public void SendGameStateUpdate(bool force = false, bool forceFullState = false)
{
//Obey the updates per second limit
TimeSpan elapsed = Time - _lastStateTime;
if (force || elapsed.TotalMilliseconds > (1000 / updateRate))
{
//Save last state time
_lastStateTime = Time;
//Create a new GameState object
var stateManager = IoCManager.Resolve <IGameStateManager>();
var state = new GameState(++_lastState);
if (EntityManager != null)
{
state.EntityStates = EntityManager.GetEntityStates();
}
state.PlayerStates = IoCManager.Resolve <IPlayerManager>().GetPlayerStates();
stateManager.Add(state.Sequence, state);
//LogManager.Log("Update " + _lastState + " sent.");
List <NetConnection> connections = IoCManager.Resolve <ISS13NetServer>().Connections;
if (connections.Count == 0)
{
//No clients -- don't send state
_oldestAckedState = _lastState;
stateManager.Clear();
}
else
{
foreach (
NetConnection c in
IoCManager.Resolve <ISS13NetServer>().Connections.Where(
c => c.Status == NetConnectionStatus.Connected))
{
IPlayerSession session = IoCManager.Resolve <IPlayerManager>().GetSessionByConnection(c);
if (session == null || (session.status != SessionStatus.InGame && session.status != SessionStatus.InLobby))
{
continue;
}
NetOutgoingMessage stateMessage = IoCManager.Resolve <ISS13NetServer>().CreateMessage();
uint lastStateAcked = stateManager.GetLastStateAcked(c);
if (lastStateAcked == 0)// || forceFullState)
{
int length = state.WriteStateMessage(stateMessage);
//LogManager.Log("Full state of size " + length + " sent to " + c.RemoteUniqueIdentifier);
}
else
{
stateMessage.Write((byte)NetMessage.StateUpdate);
GameStateDelta delta = stateManager.GetDelta(c, _lastState);
delta.WriteDelta(stateMessage);
//LogManager.Log("Delta of size " + delta.Size + " sent to " + c.RemoteUniqueIdentifier);
}
IoCManager.Resolve <ISS13NetServer>().SendMessage(stateMessage, c, NetDeliveryMethod.Unreliable);
}
}
stateManager.Cull();
}
}
public void Update(float frameTime)
{
if (Runlevel == RunLevel.Game)
{
EntityManager.ComponentManager.Update(frameTime);
EntityManager.Update(frameTime);
var start = stopWatch.ElapsedTicks;
((AtmosManager)IoCManager.Resolve <IAtmosManager>()).Update(frameTime);
var end = stopWatch.ElapsedTicks;
var atmosTime = (end - start) / (float)Stopwatch.Frequency * 1000;
IoCManager.Resolve <IRoundManager>().CurrentGameMode.Update();
IoCManager.Resolve <ICraftingManager>().Update();
GC.KeepAlive(atmosTime);
}
else if (Runlevel == RunLevel.Lobby)
{
TimeSpan countdown = _startAt.Subtract(DateTime.Now);
if (_lastAnnounced != countdown.Seconds)
{
_lastAnnounced = countdown.Seconds;
IoCManager.Resolve <IChatManager>().SendChatMessage(ChatChannel.Server,
"Starting in " + _lastAnnounced + " seconds...",
"", 0);
}
if (countdown.Seconds <= 0)
{
StartGame();
}
}
LastUpdate = Time;
SendGameStateUpdate();
}
public void DisposeForRestart()
{
IoCManager.Resolve <IPlayerManager>().DetachAll();
EntityManager.Shutdown();
EntityManager = null;
IoCManager.Resolve <IMapManager>().Shutdown();
GC.Collect();
}
/// <summary>
/// Controls what modules are running.
/// </summary>
/// <param name="runlevel"></param>
public void InitModules(RunLevel runlevel = RunLevel.Lobby)
{
if (runlevel == Runlevel)
{
return;
}
Runlevel = runlevel;
if (Runlevel == RunLevel.Lobby)
{
_startAt = DateTime.Now.AddSeconds(GameCountdown);
}
else if (Runlevel == RunLevel.Game)
{
IoCManager.Resolve <IMapManager>().InitMap(_serverMapName);
IoCManager.Resolve <IAtmosManager>().InitializeGasCells();
EntityManager = new EntityManager(IoCManager.Resolve <ISS13NetServer>());
IoCManager.Resolve <IRoundManager>().CurrentGameMode.StartGame();
}
}
public void HandleAdminMessage(NetMessage adminMsgType, NetIncomingMessage messageBody)
{
switch (adminMsgType)
{
case NetMessage.RequestEntityDeletion:
int entId = messageBody.ReadInt32();
if (
IoCManager.Resolve <IPlayerManager>().GetSessionByConnection(messageBody.SenderConnection).
adminPermissions.isAdmin || true)
//TEMPORARY. REMOVE THE 'TRUE' LATER ON. !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
{
Entity delEnt = EntityManager.GetEntity(entId);
if (delEnt != null)
{
EntityManager.DeleteEntity(delEnt);
}
}
break;
case NetMessage.RequestAdminLogin:
string password = messageBody.ReadString();
if (password == IoCManager.Resolve <IConfigurationManager>().AdminPassword)
{
LogManager.Log("Admin login: "******"Failed Admin login: "******" -> ' " + password + " '");
}
break;
case NetMessage.RequestAdminPlayerlist:
if (
IoCManager.Resolve <IPlayerManager>().GetSessionByConnection(messageBody.SenderConnection).
adminPermissions.isAdmin)
{
NetOutgoingMessage adminPlayerListMessage = IoCManager.Resolve <ISS13NetServer>().CreateMessage();
adminPlayerListMessage.Write((byte)NetMessage.RequestAdminPlayerlist);
adminPlayerListMessage.Write((byte)ClientList.Count);
foreach (
IPlayerSession plrSession in
ClientList.Keys.Select(
conn => IoCManager.Resolve <IPlayerManager>().GetSessionByConnection(conn)))
{
adminPlayerListMessage.Write(plrSession.name);
adminPlayerListMessage.Write((byte)plrSession.status);
adminPlayerListMessage.Write(plrSession.assignedJob.Name);
adminPlayerListMessage.Write(plrSession.connectedClient.RemoteEndPoint.Address.ToString());
adminPlayerListMessage.Write(plrSession.adminPermissions.isAdmin);
}
IoCManager.Resolve <ISS13NetServer>().SendMessage(adminPlayerListMessage,
messageBody.SenderConnection,
NetDeliveryMethod.ReliableOrdered);
}
else
{
NetOutgoingMessage loginMessage = IoCManager.Resolve <ISS13NetServer>().CreateMessage();
loginMessage.Write((byte)NetMessage.RequestAdminLogin);
IoCManager.Resolve <ISS13NetServer>().SendMessage(loginMessage, messageBody.SenderConnection,
NetDeliveryMethod.ReliableOrdered);
}
break;
case NetMessage.RequestAdminKick:
if (
IoCManager.Resolve <IPlayerManager>().GetSessionByConnection(messageBody.SenderConnection).
adminPermissions.isAdmin)
{
string ipKick = messageBody.ReadString();
IPlayerSession kickSession = IoCManager.Resolve <IPlayerManager>().GetSessionByIp(ipKick);
if (kickSession != null)
{
IoCManager.Resolve <IPlayerManager>().EndSession(kickSession.connectedClient);
kickSession.connectedClient.Disconnect("Kicked by Administrator.");
}
}
break;
case NetMessage.RequestAdminBan:
if (
IoCManager.Resolve <IPlayerManager>().GetSessionByConnection(messageBody.SenderConnection).
adminPermissions.isAdmin)
{
string ipBan = messageBody.ReadString();
IPlayerSession banSession = IoCManager.Resolve <IPlayerManager>().GetSessionByIp(ipBan);
if (banSession != null)
{
if (BanlistMgr.Singleton.IsBanned(ipBan))
{
return;
}
BanlistMgr.Singleton.AddBan(ipBan, "No reason specified.");
IoCManager.Resolve <IPlayerManager>().EndSession(banSession.connectedClient);
banSession.connectedClient.Disconnect("Banned by Administrator.");
}
}
break;
case NetMessage.RequestBanList:
if (
IoCManager.Resolve <IPlayerManager>().GetSessionByConnection(messageBody.SenderConnection).
adminPermissions.isAdmin)
{
NetOutgoingMessage banListMessage = IoCManager.Resolve <ISS13NetServer>().CreateMessage();
banListMessage.Write((byte)NetMessage.RequestBanList);
banListMessage.Write(BanlistMgr.Singleton.banlist.List.Count);
foreach (BanEntry t in BanlistMgr.Singleton.banlist.List)
{
banListMessage.Write(t.ip);
banListMessage.Write(t.reason);
banListMessage.Write(t.tempBan);
int compare = t.expiresAt.CompareTo(DateTime.Now);
TimeSpan timeLeft = compare < 0 ? new TimeSpan(0) : t.expiresAt.Subtract(DateTime.Now);
var minutesLeft = (uint)Math.Truncate(timeLeft.TotalMinutes);
banListMessage.Write(minutesLeft);
}
IoCManager.Resolve <ISS13NetServer>().SendMessage(banListMessage, messageBody.SenderConnection,
NetDeliveryMethod.ReliableOrdered);
}
break;
case NetMessage.RequestAdminUnBan:
if (
IoCManager.Resolve <IPlayerManager>().GetSessionByConnection(messageBody.SenderConnection).
adminPermissions.isAdmin)
{
string ip = messageBody.ReadString();
BanlistMgr.Singleton.RemoveBanByIp(ip);
}
break;
}
}
/// <summary>
/// Main method for routing incoming application network messages
/// </summary>
/// <param name="msg"></param>
public void HandleData(NetIncomingMessage msg)
{
var messageType = (NetMessage)msg.ReadByte();
switch (messageType)
{
case NetMessage.CraftMessage:
IoCManager.Resolve <ICraftingManager>().HandleNetMessage(msg);
break;
case NetMessage.WelcomeMessage:
SendWelcomeInfo(msg.SenderConnection);
break;
case NetMessage.RequestJob:
HandleJobRequest(msg);
break;
case NetMessage.ForceRestart:
Restart();
break;
case NetMessage.RequestMap:
SendMap(msg.SenderConnection);
break;
case NetMessage.PlayerList:
SendPlayerList(msg.SenderConnection);
break;
case NetMessage.ClientName:
HandleClientName(msg);
break;
case NetMessage.ChatMessage:
IoCManager.Resolve <IChatManager>().HandleNetMessage(msg);
break;
case NetMessage.PlayerSessionMessage:
IoCManager.Resolve <IPlayerManager>().HandleNetworkMessage(msg);
break;
case NetMessage.MapMessage:
IoCManager.Resolve <IMapManager>().HandleNetworkMessage(msg);
break;
case NetMessage.JobList:
HandleJobListRequest(msg);
break;
case NetMessage.PlacementManagerMessage:
IoCManager.Resolve <IPlacementManager>().HandleNetMessage(msg);
break;
case NetMessage.EntityMessage:
EntityManager.HandleEntityNetworkMessage(msg);
break;
case NetMessage.RequestAdminLogin:
HandleAdminMessage(messageType, msg);
break;
case NetMessage.RequestAdminPlayerlist:
HandleAdminMessage(messageType, msg);
break;
case NetMessage.RequestAdminKick:
HandleAdminMessage(messageType, msg);
break;
case NetMessage.RequestAdminBan:
HandleAdminMessage(messageType, msg);
break;
case NetMessage.RequestAdminUnBan:
HandleAdminMessage(messageType, msg);
break;
case NetMessage.RequestBanList:
HandleAdminMessage(messageType, msg);
break;
case NetMessage.RequestEntityDeletion:
HandleAdminMessage(messageType, msg);
break;
case NetMessage.StateAck:
HandleStateAck(msg);
break;
case NetMessage.ConsoleCommand:
IoCManager.Resolve <IClientConsoleHost>().ProcessCommand(msg.ReadString(), msg.SenderConnection);
break;
}
}
public void SaveEntities()
{
EntityManager.SaveEntities();
}
/// <summary>
/// Controls what modules are running.
/// </summary>
/// <param name="runlevel"></param>
public void InitModules(RunLevel runlevel = RunLevel.Lobby)
{
if (runlevel == Runlevel)
return;
Runlevel = runlevel;
if (Runlevel == RunLevel.Lobby)
{
_startAt = DateTime.Now.AddSeconds(GameCountdown);
}
else if (Runlevel == RunLevel.Game)
{
IoCManager.Resolve<IMapManager>().InitMap(_serverMapName);
IoCManager.Resolve<IAtmosManager>().InitializeGasCells();
EntityManager = new EntityManager(IoCManager.Resolve<ISS13NetServer>());
IoCManager.Resolve<IRoundManager>().CurrentGameMode.StartGame();
}
}
