public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
SessionDataPacket sessionDataPacket = (SessionDataPacket)packet;
ClientProcessorContext processorContext = (ClientProcessorContext)context;
processorContext.Client.OnSessionDataReceived(sessionDataPacket.SessionData);
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
UpdateDisasterPacket updateDisasterPacket = (UpdateDisasterPacket)packet;
ClientProcessorContext processorContext = (ClientProcessorContext)context;
processorContext.Client.DisasterManager.OnUpdateDisaster(updateDisasterPacket.CurrentTime);
}
public override void ProcessAction(ulong currentTick, ClientProcessorContext context)
{
Player?simulationOwner = context.Client.SimulationManager.GetSimulationOwner();
if (simulationOwner == null || simulationOwner.Value != context.Client.LocalPlayer)
{
return;
}
Planetbase.EnvironmentManager environmentManager = Planetbase.EnvironmentManager.getInstance();
Type environmentManagerType = environmentManager.GetType();
FieldInfo mTimeIndicator = Reflection.GetPrivateFieldOrThrow(environmentManagerType, "mTimeIndicator", true);
FieldInfo mWindIndicator = Reflection.GetPrivateFieldOrThrow(environmentManagerType, "mWindIndicator", true);
FieldInfo mWindDirection = Reflection.GetPrivateFieldOrThrow(environmentManagerType, "mWindDirection", true);
Indicator timeIndicator = (Indicator)Reflection.GetInstanceFieldValue(environmentManager, mTimeIndicator);
Indicator windIndicator = (Indicator)Reflection.GetInstanceFieldValue(environmentManager, mWindIndicator);
float time = timeIndicator.getValue();
float windLevel = windIndicator.getValue();
Vector3 windDirection = (Vector3)Reflection.GetInstanceFieldValue(environmentManager, mWindDirection);
context.Client.EnvironmentManager.UpdateEnvironmentData(time, windLevel, windDirection);
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
TimeScaleUpdatePacket timeScaleUpdatedPacket = (TimeScaleUpdatePacket)packet;
ClientProcessorContext processorContext = (ClientProcessorContext)context;
processorContext.Client.TimeManager.OnTimeScaleUpdated(timeScaleUpdatedPacket.TimeScale, timeScaleUpdatedPacket.IsPaused);
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
CreateDisasterPacket createDisasterPacket = (CreateDisasterPacket)packet;
ClientProcessorContext processorContext = (ClientProcessorContext)context;
processorContext.Client.DisasterManager.OnCreateDisaster(createDisasterPacket.Disaster);
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
PlayerDisconnectedPacket playerDisconnectedPacket = (PlayerDisconnectedPacket)packet;
ClientProcessorContext processorContext = (ClientProcessorContext)context;
if (processorContext.Client.LocalPlayer.HasValue)
{
if (processorContext.Client.LocalPlayer.Value.Id != playerDisconnectedPacket.PlayerId)
{
Player player = processorContext.Client.PlayerManager.GetPlayer(playerDisconnectedPacket.PlayerId);
string reason = DisconnectReasonUtils.ReasonToString(playerDisconnectedPacket.Reason);
MessageLog.Show($"Player {player.Name} left the game: {reason}", null, MessageLogFlags.MessageSoundNormal);
}
if (processorContext.Client.LocalPlayer.Value.Id == playerDisconnectedPacket.PlayerId)
{
// The server has freed up resources associated with our player
// This may mean that we requested a disconnect
// or we're in for a big surprise
processorContext.Client.LocalPlayer = null;
}
}
processorContext.Client.PlayerManager.OnPlayerRemoved(playerDisconnectedPacket.PlayerId);
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
UpdateEnvironmentDataPacket updateEnvironmentDataPacket = (UpdateEnvironmentDataPacket)packet;
ClientProcessorContext processorContext = (ClientProcessorContext)context;
processorContext.Client.EnvironmentManager.OnUpdateEnvironmentData(updateEnvironmentDataPacket.Time, updateEnvironmentDataPacket.WindLevel, updateEnvironmentDataPacket.WindDirection);
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
WorldDataPacket worldDataPacket = (WorldDataPacket)packet;
ClientProcessorContext processorContext = (ClientProcessorContext)context;
processorContext.Client.WorldStateManager.UpdateWorldData(worldDataPacket.World);
Debug.Log("Informing the server that we've started loading the world data");
ClientLoadingStartedPacket clientLoadingStartedPacket = new ClientLoadingStartedPacket();
processorContext.Client.SendPacket(clientLoadingStartedPacket);
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
PlayerDataUpdatedPacket playerDataUpdatedPacket = (PlayerDataUpdatedPacket)packet;
ClientProcessorContext processorContext = (ClientProcessorContext)context;
processorContext.Client.PlayerManager.OnPlayerUpdated(playerDataUpdatedPacket.PlayerId, playerDataUpdatedPacket.Player);
if (playerDataUpdatedPacket.Player == processorContext.Client.LocalPlayer)
{
// Update the local client data
processorContext.Client.LocalPlayer = playerDataUpdatedPacket.Player;
}
}
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)
{
ClientProcessorContext processorContext = (ClientProcessorContext)context;
DisconnectRequestPacket disconnectRequestPacket = (DisconnectRequestPacket)packet;
void OnExitConfirm(object parameter)
{
GameManager.getInstance().setGameStateTitle();
processorContext.Client.Disconnect();
}
GuiDefinitions.Callback callback = new GuiDefinitions.Callback(OnExitConfirm);
switch (disconnectRequestPacket.Reason)
{
case DisconnectReason.DisconnectRequestResponse:
Debug.Log("Graceful disconnect response received, disconnecting.");
OnExitConfirm(null);
break;
case DisconnectReason.KickedOut:
if (!MessageBoxOk.Show(callback, "Disconnected from server", "You have been kicked out of the game."))
{
OnExitConfirm(null); // Failed to show window
}
break;
case DisconnectReason.ServerClosing:
if (!MessageBoxOk.Show(callback, "Disconnected from server", "Server is shutting down."))
{
OnExitConfirm(null); // Failed to show window
}
break;
default:
if (!MessageBoxOk.Show(callback, "Disconnected from server", "Unknown reason."))
{
OnExitConfirm(null); // Failed to show window
}
break;
}
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
PlayerJoinedPacket playerJoinedPacket = (PlayerJoinedPacket)packet;
ClientProcessorContext processorContext = (ClientProcessorContext)context;
processorContext.Client.PlayerManager.OnPlayerAdded(playerJoinedPacket.Player);
MessageLogFlags flags;
if (playerJoinedPacket.Player.Name.ToLower() == "freddy")
{
flags = MessageLogFlags.MessageSoundPowerDown;
}
else
{
flags = MessageLogFlags.MessageSoundNormal;
}
MessageLog.Show($"Player is joining game: {playerJoinedPacket.Player.Name}", null, flags);
}
public override void ProcessAction(ulong currentTick, ClientProcessorContext context)
{
Player?simulationOwner = context.Client.SimulationManager.GetSimulationOwner();
if (simulationOwner == null || simulationOwner.Value != context.Client.LocalPlayer)
{
return;
}
DisasterManager disasterManager = context.Client.DisasterManager;
if (!disasterManager.AnyDisasterInProgress())
{
return;
}
// Pull the current time from our disaster proxy
IDisasterProxy disasterProxy = disasterManager.GetCurrentDisasterProxy();
disasterManager.UpdateDisaster(disasterProxy.Time);
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
SimulationOwnerChangedPacket simulationOwnerChangedPacket = (SimulationOwnerChangedPacket)packet;
ClientProcessorContext processorContext = (ClientProcessorContext)context;
PlayerManager playerManager = processorContext.Client.PlayerManager;
SimulationManager simulationManager = processorContext.Client.SimulationManager;
if (simulationOwnerChangedPacket.PlayerId != null)
{
Debug.Log($"Setting new simulation owner to {simulationOwnerChangedPacket.PlayerId.Value}");
Player player = playerManager.GetPlayer(simulationOwnerChangedPacket.PlayerId.Value);
simulationManager.OnSimulationOwnerUpdated(player);
MessageLog.Show($"New simulation owner: {player.Name}", null, MessageLogFlags.MessageSoundNormal);
}
else
{
// No simulation owner
simulationManager.OnSimulationOwnerUpdated(null);
Debug.Log("Setting new simulation owner to none");
}
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
ClientProcessorContext processorContext = (ClientProcessorContext)context;
AuthenticatePacket authenticatePacket = (AuthenticatePacket)packet;
PlayerManager playerManager = processorContext.Client.PlayerManager;
if (!authenticatePacket.AuthenticationSuccessful)
{
switch (authenticatePacket.ErrorReason.Value)
{
case AuthenticationErrorReason.UsernameTaken:
MessageBoxOk.Show(null, "Failed to join game", "Failed to connect to the server: Username is already taken");
break;
case AuthenticationErrorReason.IncorrectPassword:
MessageBoxOk.Show(null, "Failed to join game", "Failed to connect to the server: Incorrect password");
break;
case AuthenticationErrorReason.IllegalUsername:
MessageBoxOk.Show(null, "Failed to join game", "Failed to connect to the server: Username contains disallowed characters");
break;
}
processorContext.Client.RequestDisconnect();
return;
}
processorContext.Client.LocalPlayer = authenticatePacket.LocalPlayer.Value;
processorContext.Client.SimulationManager.OnSimulationOwnerUpdated(authenticatePacket.SimulationOwner);
foreach (Player player in authenticatePacket.Players)
{
playerManager.OnPlayerAdded(player); // Sync players
}
Debug.Log("Sending world data request");
WorldDataRequestPacket worldDataRequestPacket = new WorldDataRequestPacket();
processorContext.Client.SendPacket(worldDataRequestPacket);
}
public override void ProcessAction(ulong currentTick, ClientProcessorContext context)
{
context.Client.ProcessPackets();
}
public TimerActionManager(ClientProcessorContext processorContext)
{
this.processorContext = processorContext;
timerActions = new Dictionary <TimerAction, uint>();
}
public override void ProcessPacket(Guid sourcePlayerId, Packet packet, IProcessorContext context)
{
ClientProcessorContext processorContext = (ClientProcessorContext)context;
processorContext.Client.DisasterManager.OnEndDisaster();
}
public abstract void ProcessAction(ulong currentTick, ClientProcessorContext context);
