public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
ServerProcessorContext processorContext = (ServerProcessorContext)context;
SimulationManager simulationManager = processorContext.Server.SimulationManager;
DisasterManager disasterManager = processorContext.Server.DisasterManager;
Player?simulationOwner = simulationManager.GetSimulationOwner();
if (simulationOwner == null || sourcePlayerId != simulationOwner.Value.Id)
{
//Deny request if client isn't the simulation owner
return;
}
disasterManager.EndDisaster();
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
UpdateEnvironmentDataPacket updateEnvironmentDataPacket = (UpdateEnvironmentDataPacket)packet;
ServerProcessorContext processorContext = (ServerProcessorContext)context;
SimulationManager simulationManager = processorContext.Server.SimulationManager;
EnvironmentManager environmentManager = processorContext.Server.EnvironmentManager;
Player?simulationOwner = simulationManager.GetSimulationOwner();
if (simulationOwner == null || sourcePlayerId != simulationOwner.Value.Id)
{
//Deny request if client isn't the simulation owner
return;
}
environmentManager.UpdateEnvironmentData(updateEnvironmentDataPacket.Time, updateEnvironmentDataPacket.WindLevel, updateEnvironmentDataPacket.WindDirection);
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
ServerProcessorContext processorContext = (ServerProcessorContext)context;
AuthenticateRequestPacket authenticateRequestPacket = (AuthenticateRequestPacket)packet;
ServerSettings serverSettings = processorContext.Server.Settings;
PlayerManager playerManager = processorContext.Server.PlayerManager;
SimulationManager simulationManager = processorContext.Server.SimulationManager;
AuthenticatePacket authenticateResponsePacket;
if (playerManager.PlayerExists(sourcePlayerId))
{
return; // Player already authenticated
}
// Will fail if the requested username contains disallowed characters/does not meet length requirements/etc.
if (!playerManager.IsUsernameAllowed(authenticateRequestPacket.Username))
{
authenticateResponsePacket = new AuthenticatePacket(false, AuthenticationErrorReason.IllegalUsername, null, null, null);
Console.WriteLine($"Player {sourcePlayerId} attempted joining with an illegal username");
}
// Will fail if a player with the same nickname is already connected.
else if (playerManager.IsUsernameTaken(authenticateRequestPacket.Username))
{
authenticateResponsePacket = new AuthenticatePacket(false, AuthenticationErrorReason.UsernameTaken, null, null, null);
Console.WriteLine($"Player {sourcePlayerId} attempted joining with an already taken username: {authenticateRequestPacket.Username}");
}
// Will fail if the authenticating client provided an incorrect server password.
else if (serverSettings.PasswordProtected && serverSettings.Password != authenticateRequestPacket.Password)
{
authenticateResponsePacket = new AuthenticatePacket(false, AuthenticationErrorReason.IncorrectPassword, null, null, null);
Console.WriteLine($"Player {sourcePlayerId} attempted joining with an incorrect password");
}
// Approve authentication request and let other players know that a player joined.
else
{
Player client = playerManager.CreatePlayer(sourcePlayerId, authenticateRequestPacket.Username, state: PlayerState.ConnectedMainMenu);
Player[] players = playerManager.GetPlayers().ToArray();
Player? simulationOwner = simulationManager.GetSimulationOwner();
authenticateResponsePacket = new AuthenticatePacket(true, null, client, players, simulationOwner);
Console.WriteLine($"Player {sourcePlayerId} successfully authenticated!");
}
processorContext.Server.SendPacketToPlayer(authenticateResponsePacket, sourcePlayerId);
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
WorldDataRequestPacket worldDataRequestPacket = (WorldDataRequestPacket)packet;
ServerProcessorContext processorContext = (ServerProcessorContext)context;
PlayerManager playerManager = processorContext.Server.PlayerManager;
SimulationManager simulationManager = processorContext.Server.SimulationManager;
TimeManager timeManager = processorContext.Server.TimeManager;
WorldRequestQueueManager worldRequestQueueManager = processorContext.Server.WorldRequestQueueManager;
WorldStateManager worldStateManager = processorContext.Server.WorldStateManager;
if (!playerManager.PlayerExists(sourcePlayerId))
{
// Players can not ask for a copy of the world before they authenticate
return;
}
Player sourcePlayer = playerManager.GetPlayer(sourcePlayerId);
if (sourcePlayer.State != PlayerState.ConnectedMainMenu)
{
// Invalid state
return;
}
// We pause the game and lock time management until everyone has finished loading
timeManager.FreezeTime();
Player?simulationOwner = simulationManager.GetSimulationOwner();
if (simulationOwner != null && simulationOwner.Value != sourcePlayer && worldStateManager.RequestWorldData())
{
// The server can get a newer world state
// add the client to the queue and wait
worldRequestQueueManager.EnqueuePlayer(sourcePlayer);
}
else
{
// The state we have is already the newest
WorldStateData worldStateData = worldStateManager.GetWorldData();
WorldDataPacket worldDataPacket = new WorldDataPacket(worldStateData);
processorContext.Server.SendPacketToPlayer(worldDataPacket, sourcePlayerId);
}
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
ClientProcessorContext clientProcessor = (ClientProcessorContext)context;
SimulationManager simulationManager = clientProcessor.Client.SimulationManager;
Player?player = simulationManager.GetSimulationOwner();
if (player.HasValue && clientProcessor.Client.LocalPlayer.HasValue && clientProcessor.Client.LocalPlayer.Value != player.Value)
{
return; // Not the simulation owner
}
GameStateGame gameStateGame = GameManager.getInstance().getGameState() as GameStateGame;
string xmlData = WorldSerializer.Serialize(gameStateGame);
WorldStateData worldStateData = new WorldStateData(xmlData);
WorldDataPacket worldDataPacket = new WorldDataPacket(worldStateData);
clientProcessor.Client.SendPacket(worldDataPacket);
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
TimeScaleUpdatePacket timeScaleUpdatePacket = (TimeScaleUpdatePacket)packet;
ServerProcessorContext processorContext = (ServerProcessorContext)context;
SimulationManager simulationManager = processorContext.Server.SimulationManager;
TimeManager timeManager = processorContext.Server.TimeManager;
Player?simulationOwner = simulationManager.GetSimulationOwner();
if (simulationOwner == null || sourcePlayerId != simulationOwner.Value.Id)
{
//Deny request if client isn't the simulation owner
return;
}
if (timeManager.IsTimeLocked())
{
// The server is holding onto the current timescale
// Inform the client, maybe?
return;
}
timeManager.SetTimescale(timeScaleUpdatePacket.TimeScale, timeScaleUpdatePacket.IsPaused);
}
