void CheckIfShouldPause()
{
if (!Program.Server)
{
return;
}
bool ShouldPause = false;
foreach (var client in Server.Clients)
{
if (!client.HasLeft && client.RequestingPause)
{
ShouldPause = true;
}
}
if (ShouldPause && !ServerPaused)
{
Networking.ToClients(new Message(MessageType.Pause));
}
else if (!ShouldPause && ServerPaused)
{
Networking.ToClients(new Message(MessageType.Unpause));
}
}
public static void LeaveGameNetwork()
{
if (Program.Server)
{
Networking.ToClients(new Message(MessageType.ServerLeft));
}
else
{
Networking.ToServer(new Message(MessageType.LeaveGame));
}
Networking.FinalSend();
}
public void SynchronizeNetwork()
{
if (GameOver)
{
return;
}
GameClass.Game.Send("setScreen", "desync");
SaveCurrentStateInBuffer();
Networking.ToClients(new Message(MessageType.NetworkDesync));
Networking.ToClients(new MessageGameState(SimStep, WorldBytes));
}
void PreGame()
{
if (Program.GameStarted)
{
return;
}
Message message;
while (Networking.Inbox.TryDequeue(out message))
{
if (Log.Processing)
{
Console.WriteLine(" -Pre Game Processing {0}", message);
}
if (message.Type == MessageType.Start || message.Type == MessageType.NetworkDesync)
{
Program.GameStarted = true;
break;
}
if (Program.Server)
{
if (message.Type == MessageType.DoneLoading)
{
message.Source.HasLoaded = true;
if (!Program.GameStarted && Server.Clients.Count(client => client.HasLoaded && !client.Spectator) == Program.NumPlayers)
{
Networking.ToClients(new Message(MessageType.Start));
}
}
}
}
}
public void Draw()
{
ProcessInbox();
DrawCount++;
Render.StandardRenderSetup();
double PreviousSecondsSinceLastUpdate = SecondsSinceLastUpdate;
if (!DesyncPause)
{
CheckIfShouldPause();
CheckIfShouldShowWaiting();
}
if (GameClass.GameActive && !ServerPaused && !DesyncPause)
{
if (NotPaused_SimulationUpdate)
{
double Elapsed = GameClass.DeltaT; //GameClass.ElapsedSeconds;
if (SimStep + SecondsSinceLastUpdate / DelayBetweenUpdates < ServerSimStep - .25f)
{
Elapsed *= 1.15f;
if (Log.SpeedMods)
{
Console.WriteLine(" -- Speed up please, Elasped = {3} # {0}/{1} :{2}", Elapsed, SimStep, ServerSimStep, SecondsSinceLastUpdate / DelayBetweenUpdates);
}
}
SecondsSinceLastUpdate += Elapsed;
T += (float)Elapsed;
}
else
{
DataGroup.PausedSimulationUpdate();
if (MapEditorActive)
{
SecondsSinceLastUpdate += DelayBetweenUpdates;
T += (float)DelayBetweenUpdates;
}
}
if (GameClass.HasFocus)
{
switch (CurUserMode)
{
case UserMode.PlaceBuilding:
if (UnselectAll)
{
SelectionUpdate(SelectSize);
UnselectAll = false;
}
Update_BuildingPlacing();
break;
case UserMode.Painting:
if (UnselectAll || MapEditorActive)
{
SelectionUpdate(SelectSize);
UnselectAll = false;
}
Update_Painting();
break;
case UserMode.Select:
SelectionUpdate(SelectSize, LineSelect: LineSelect);
break;
case UserMode.CastSpell:
if (LeftMousePressed && MyPlayerInfo != null)
{
if (!MyPlayerInfo.DragonLordAlive)
{
Message_NoDragonLordMagic();
}
else if (MyPlayerInfo.CanAffordSpell(CurSpell))
{
CastSpell(CurSpell);
}
else
{
Message_InsufficientJade();
}
}
break;
}
}
SkipNextSelectionUpdate = false;
if (Program.Server)
{
if (SecondsSinceLastUpdate / DelayBetweenUpdates > .75f && SimStep == ServerSimStep && !SentBookend)
{
if (Log.UpdateSim)
{
Console.WriteLine("Ready for bookend. {0}/{1} : {2}", SimStep, ServerSimStep, SecondsSinceLastUpdate / DelayBetweenUpdates);
}
SentBookend = true;
AckSimStep = ServerSimStep + 2;
Networking.ToClients(new MessageBookend(ServerSimStep + 1));
}
}
// Check if post-upate calculation still need to be done
if (!PostUpdateFinished)
{
PostSimulationUpdate();
}
// Check if we need to do a simulation update
//if (true)
//Console.WriteLine(ServerSimStep);
if (GameClass.UnlimitedSpeed || SecondsSinceLastUpdate > DelayBetweenUpdates || SimStep + 2 < ServerSimStep)
{
if (SimStep < ServerSimStep && !(Program.Server && MinClientSimStep + 2 < ServerSimStep))
{
WaitingTime = 0;
if (!PostUpdateFinished)
{
PostSimulationUpdate(); // If we are behind do another post-sim update to help catchup.
}
else
{
SecondsSinceLastUpdate -= DelayBetweenUpdates;
if (SecondsSinceLastUpdate < 0)
{
SecondsSinceLastUpdate = 0;
}
HashCheck();
DeququeActions(SimStep + 1);
HashCheck();
SimulationUpdate();
if (!Program.Spectate || Program.Spectate && SimStep % 15 == 0)
{
HashCheck(Send: true);
}
SentBookend = false;
Networking.ToServer(new MessageStartingStep(SimStep));
if (Log.UpdateSim)
{
Console.WriteLine("Just updated sim # {0}/{1} : {2} min={3}", SimStep, ServerSimStep, SecondsSinceLastUpdate / DelayBetweenUpdates, MinClientSimStep);
}
}
}
else
{
WaitingTime += GameClass.ElapsedSeconds;
if (Log.Delays)
{
Console.WriteLine("-Reverting from # {0}/{1} : {2}", SimStep, ServerSimStep, SecondsSinceLastUpdate / DelayBetweenUpdates);
}
SecondsSinceLastUpdate = DelayBetweenUpdates;
T -= (float)GameClass.ElapsedSeconds;
if (Log.Delays)
{
Console.WriteLine("-Reverting to # {0}/{1} : {2}", SimStep, ServerSimStep, SecondsSinceLastUpdate / DelayBetweenUpdates);
}
}
}
else
{
if (Program.Server)
{
if (Log.Draws)
{
Console.WriteLine("Draw step {0}, {1}", DrawCount, SecondsSinceLastUpdate / DelayBetweenUpdates);
}
}
}
}
BenchmarkTests.Run(DataGroup.CurrentData, DataGroup.PreviousData);
if (!Program.Headless)
{
try
{
DrawWorld();
}
catch (Exception e)
{
}
}
else
{
GridHelper.GraphicsDevice.SetRenderTarget(null);
}
}
public void ProcessInbox()
{
Message message;
while (Networking.Inbox.TryDequeue(out message))
{
if (Log.Processing)
{
Console.WriteLine(" -In Game Processing {0}", message);
}
if (Program.Server)
{
if (message.Type == MessageType.PlayerAction)
{
var ack = new MessagePlayerActionAck(AckSimStep, message);
var chat = message.Innermost as MessageChat;
if (null != chat)
{
if (chat.Global)
{
Networking.ToClients(ack);
}
else
{
var chat_team = message.Source.Team;
if (chat_team < 0)
{
continue;
}
foreach (var client in Server.Clients)
{
if (client.Team == chat_team)
{
Networking.ToClient(client, ack);
}
}
}
}
else
{
if (message.Source.Index > 4)
{
Console.WriteLine("Warning! Action message from spectator, possibly malicious.");
continue;
}
Networking.ToClients(ack);
}
}
if (message.Type == MessageType.LeaveGame)
{
message.Source.HasLeft = true;
}
if (message.Type == MessageType.RequestPause)
{
message.Source.RequestingPause = true;
}
if (message.Type == MessageType.RequestUnpause)
{
message.Source.RequestingPause = false;
// Cancel everyone's pause request.
foreach (var client in Server.Clients)
{
client.RequestingPause = false;
}
}
}
// Messages from players
if (message != null)
{
if (message.Type == MessageType.StartingStep ||
message.Type == MessageType.Hash ||
message.Type == MessageType.StringHash)
{
message.Innermost.Do();
}
}
// Messages from the server
if (message.Source.IsServer)
{
if (message.Type == MessageType.Bookend)
{
message.Innermost.Do();
}
if (message.Type == MessageType.PlayerActionAck)
{
message.Inner.Do();
}
if (message.Type == MessageType.Pause)
{
if (!ServerPaused)
{
ServerPaused = true;
GameClass.Game.Send("setScreen", "game-paused", new { canUnpause = true });
}
}
if (message.Type == MessageType.Unpause)
{
if (ServerPaused)
{
ServerPaused = false;
GameClass.Game.Send("back");
}
}
if (message.Type == MessageType.ServerLeft)
{
if (!Program.Server && !GameOver)
{
GameClass.Game.Send("setScreen", "disconnected", new { message = "The server has quit. Tell them they suck." });
}
}
if (message.Type == MessageType.NetworkDesync)
{
DesyncPause = true;
if (!Program.Server)
{
// The server has already put up its desync UI,
// so only do this for clients.
GameClass.Game.Send("setScreen", "desync");
}
}
if (message.Type == MessageType.GameState)
{
message.Innermost.Do();
}
}
}
}
