public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
ServerProcessorContext processorContext = (ServerProcessorContext)context;
PlayerManager playerManager = processorContext.Server.PlayerManager;
ServerSettings serverSettings = processorContext.Server.Settings;
SessionData sessionData = new SessionData(serverSettings.Name, serverSettings.PasswordProtected, playerManager.GetPlayerCount());
SessionDataPacket sessionDataPacket = new SessionDataPacket(sessionData);
processorContext.Server.SendPacketToPlayer(sessionDataPacket, sourcePlayerId);
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
ServerProcessorContext processorContext = (ServerProcessorContext)context;
PlayerManager playerManager = processorContext.Server.PlayerManager;
if (!playerManager.PlayerExists(sourcePlayerId))
{
return; // what
}
Player player = playerManager.GetPlayer(sourcePlayerId);
player.State = PlayerState.ConnectedLoadingData;
playerManager.UpdatePlayer(player);
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
ServerProcessorContext processorContext = (ServerProcessorContext)context;
WorldDataPacket worldDataPacket = (WorldDataPacket)packet;
Player?simulationOwner = processorContext.Server.SimulationManager.GetSimulationOwner();
if (simulationOwner == null || sourcePlayerId != simulationOwner.Value.Id)
{
//Deny request if client isn't the simulation owner
return;
}
processorContext.Server.WorldStateManager.OnWorldDataReceived(worldDataPacket.World);
}
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)
{
ServerProcessorContext processorContext = (ServerProcessorContext)context;
PlayerManager playerManager = processorContext.Server.PlayerManager;
TimeManager timeManager = processorContext.Server.TimeManager;
if (!playerManager.PlayerExists(sourcePlayerId))
{
return; // what
}
Player player = playerManager.GetPlayer(sourcePlayerId);
player.State = PlayerState.ConnectedReady;
playerManager.UpdatePlayer(player);
if (playerManager.GetPlayers().Count(p => p.State == PlayerState.ConnectedLoadingData) == 0)
{
timeManager.UnfreezeTime();
}
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
ServerProcessorContext processorContext = (ServerProcessorContext)context;
PlayerManager playerManager = processorContext.Server.PlayerManager;
TimeManager timeManager = processorContext.Server.TimeManager;
Console.WriteLine($"Player {sourcePlayerId} requested a graceful disconnect");
playerManager.DestroyPlayer(sourcePlayerId, DisconnectReason.DisconnectRequest);
// We reply with another disconnect request to let the client know that we're ready for a graceful disconnect
DisconnectRequestPacket disconnectReply = new DisconnectRequestPacket(DisconnectReason.DisconnectRequestResponse);
processorContext.Server.SendPacketToPlayer(disconnectReply, sourcePlayerId);
processorContext.Server.playerConnections.Remove(sourcePlayerId);
if (playerManager.GetPlayers().Count(p => p.State == PlayerState.ConnectedLoadingData) == 0)
{
timeManager.UnfreezeTime();
}
}
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);
}
