public Server(ServerSettings settings)
{
// Attempt to load world
if (!File.Exists(settings.SavePath))
{
throw new FileNotFoundException("Save file not found.");
}
string worldData = File.ReadAllText(settings.SavePath);
WorldStateData worldStateData = new WorldStateData(worldData);
this.settings = settings;
SynchronizationContext.SetSynchronizationContext(new SynchronizationContext());
processorContext = new ServerProcessorContext(this);
router = new PacketRouter(processorContext);
foreach (PacketProcessor packetProcessor in PacketProcessor.GetProcessors())
{
router.RegisterPacketProcessor(packetProcessor);
}
playerConnections = new Dictionary <Guid, long>();
playerManager = new PlayerManager(this);
simulationManager = new SimulationManager(this);
worldStateManager = new WorldStateManager(this, settings.SavePath, worldStateData);
worldRequestQueueManager = new WorldRequestQueueManager(this);
timeManager = new TimeManager(this);
environmentManager = new EnvironmentManager(this);
disasterManager = new DisasterManager(this);
Initialize();
}
public void UpdateWorldData(WorldStateData worldStateData)
{
this.worldStateData = worldStateData;
// Planetbase only supports loading save data from a file
// instead of rewriting a lot of game logic, we compromise
string tmpPath = Path.GetTempFileName();
File.WriteAllText(tmpPath, worldStateData.XmlData);
SaveData save = new SaveData(tmpPath, DateTime.Now);
GameManager.getInstance().setNewState(new GameStateGame(save.getPath(), save.getPlanetIndex(), null));
}
private void DeliverWorldData()
{
Console.WriteLine("Delivering world data...");
WorldStateData worldStateData = server.WorldStateManager.GetWorldData();
WorldDataPacket worldDataPacket = new WorldDataPacket(worldStateData);
foreach (KeyValuePair <Guid, Player> kvp in playerQueue)
{
server.SendPacketToPlayer(worldDataPacket, kvp.Key);
}
playerQueue.Clear();
}
public void UpdateWorldData(WorldStateData worldStateData)
{
this.worldStateData = worldStateData;
try
{
File.WriteAllText(savePath, worldStateData.XmlData);
}
catch (Exception ex)
{
Console.WriteLine($"Failed to write the world data to disk: {ex}");
}
WorldDataUpdated?.Invoke(this, new System.EventArgs());
}
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 WorldDataPacket(WorldStateData world)
{
World = world;
}
public void OnWorldDataReceived(WorldStateData worldStateData)
{
Console.WriteLine("Received world data, updating...");
dataRequestInProgress = false;
UpdateWorldData(worldStateData);
}
public WorldStateManager(Server server, string savePath, WorldStateData worldStateData)
{
this.server = server ?? throw new ArgumentNullException(nameof(server));
this.savePath = savePath ?? throw new ArgumentNullException(nameof(savePath));
this.worldStateData = worldStateData;
}