public void EntityDataTest()
{
for (int serializerIndex = 0; serializerIndex < worldsDataAfter.Length; serializerIndex++)
{
PersistedWorldData worldDataAfter = worldsDataAfter[serializerIndex];
for (int index = 0; index < worldData.EntityData.Entities.Count; index++)
{
Entity entity = worldData.EntityData.Entities[index];
Entity entityAfter = worldDataAfter.EntityData.Entities[index];
Assert.AreEqual(entity.Transform.LocalPosition, entityAfter.Transform.LocalPosition, $"EntityData.Entities.Transform.LocalPosition is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(entity.Transform.LocalRotation, entityAfter.Transform.LocalRotation, $"EntityData.Entities.Transform.LocalRotation is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(entity.Transform.LocalScale, entityAfter.Transform.LocalScale, $"EntityData.Entities.Transform.LocalPosition is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(entity.TechType, entityAfter.TechType, $"EntityData.Entities.TechType is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(entity.Id, entityAfter.Id, $"EntityData.Entities.Id is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(entity.Level, entityAfter.Level, $"EntityData.Entities.Level is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(entity.ClassId, entityAfter.ClassId, $"EntityData.Entities.ClassId is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(entity.SpawnedByServer, entityAfter.SpawnedByServer, $"EntityData.Entities.SpawnedByServer is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(entity.WaterParkId, entityAfter.WaterParkId, $"EntityData.Entities.WaterParkId is not equal while using {serverSerializers[serializerIndex]}.");
Assert.IsTrue(entity.SerializedGameObject.SequenceEqual(entityAfter.SerializedGameObject), $"EntityData.Entities.SerializedGameObject is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(entity.ExistsInGlobalRoot, entityAfter.ExistsInGlobalRoot, $"EntityData.Entities.ExistsInGlobalRoot is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(entity.ParentId, entityAfter.ParentId, $"EntityData.Entities.ParentId is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(entity.Metadata, entityAfter.Metadata, $"EntityData.Entities.Metadata is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(entity.ExistingGameObjectChildIndex, entityAfter.ExistingGameObjectChildIndex, "EntityData.Entities.ExistingGameObjectChildIndex is not equal while using {serverSerializers[serializerIndex]}.");
}
}
}
public static void ClassInitialize(TestContext context)
{
NitroxServiceLocator.InitializeDependencyContainer(new SubnauticaServerAutoFacRegistrar(), new TestAutoFacRegistrar());
NitroxServiceLocator.BeginNewLifetimeScope();
WorldPersistence worldPersistence = NitroxServiceLocator.LocateService <WorldPersistence>();
serverSerializers = NitroxServiceLocator.LocateService <IServerSerializer[]>();
worldsDataAfter = new PersistedWorldData[serverSerializers.Length];
tempSaveFilePath = Path.Combine(Path.GetTempPath(), "NitroxTestTempDir");
worldData = GeneratePersistedWorldData();
World world = worldPersistence.CreateWorld(worldData, ServerGameMode.CREATIVE);
world.EventTriggerer.ResetWorldTime();
for (int index = 0; index < serverSerializers.Length; index++)
{
//Checking saving
worldPersistence.UpdateSerializer(serverSerializers[index]);
Assert.IsTrue(worldPersistence.Save(world, tempSaveFilePath), $"Saving normal world failed while using {serverSerializers[index]}.");
Assert.IsFalse(worldPersistence.Save(null, tempSaveFilePath), $"Saving null world worked while using {serverSerializers[index]}.");
//Checking loading
Optional <World> worldAfter = worldPersistence.LoadFromFile(tempSaveFilePath);
Assert.IsTrue(worldAfter.HasValue, $"Loading saved world failed while using {serverSerializers[index]}.");
worldAfter.Value.EventTriggerer.ResetWorldTime();
worldsDataAfter[index] = PersistedWorldData.From(worldAfter.Value);
}
}
public void SaveBackup(World world)
{
//Log.Info("Saving world state.");
try
{
PersistedWorldData persistedData = new PersistedWorldData();
persistedData.ParsedBatchCells = world.BatchEntitySpawner.SerializableParsedBatches;
persistedData.ServerStartTime = world.TimeKeeper.ServerStartTime;
persistedData.EntityData = world.EntityData;
persistedData.BaseData = world.BaseData;
persistedData.VehicleData = world.VehicleData;
persistedData.InventoryData = world.InventoryData;
persistedData.PlayerData = world.PlayerData;
persistedData.GameData = world.GameData;
persistedData.EscapePodData = world.EscapePodData;
using (Stream stream = File.OpenWrite(fileName_backup))
{
serializer.Serialize(stream, persistedData);
}
Log.Info("World state saved.");
}
catch (Exception ex)
{
Log.Info("Could not save world: " + ex);
}
}
public void Setup()
{
NitroxServiceLocator.InitializeDependencyContainer(new SubnauticaServerAutoFacRegistrar(), new TestAutoFacRegistrar());
NitroxServiceLocator.BeginNewLifetimeScope();
tempSaveFilePath = Path.Combine(Path.GetTempPath(), "NitroxTestTempDir");
serverSerializers = NitroxServiceLocator.LocateService <IServerSerializer[]>();
worldPersistence = NitroxServiceLocator.LocateService <WorldPersistence>();
serverConfig = NitroxServiceLocator.LocateService <ServerConfig>();
worldData = GeneratePersistedWorldData();
world = worldPersistence.CreateWorld(worldData, serverConfig.GameMode);
worldsDataAfter = new PersistedWorldData[serverSerializers.Length];
for (int index = 0; index < serverSerializers.Length; index++)
{
worldPersistence.UpdateSerializer(serverSerializers[index]);
Assert.IsTrue(worldPersistence.Save(world, tempSaveFilePath));
Assert.IsFalse(worldPersistence.Save(null, tempSaveFilePath));
worldPersistence.UpdateSerializer(serverSerializers[index]);
Optional <World> worldAfter = worldPersistence.LoadFromFile(tempSaveFilePath);
Assert.IsTrue(worldAfter.HasValue);
worldsDataAfter[index] = PersistedWorldData.From(worldAfter.Value);
}
}
public void WorldDataTest()
{
for (int serializerIndex = 0; serializerIndex < worldsDataAfter.Length; serializerIndex++)
{
PersistedWorldData worldDataAfter = worldsDataAfter[serializerIndex];
Assert.IsTrue(worldData.WorldData.ParsedBatchCells.SequenceEqual(worldDataAfter.WorldData.ParsedBatchCells), $"WorldData.ParsedBatchCells is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(worldData.WorldData.Seed, worldDataAfter.WorldData.Seed, $"WorldData.Seed is not equal while using {serverSerializers[serializerIndex]}.");
}
}
public void PlayerDataTest()
{
for (int serializerIndex = 0; serializerIndex < worldsDataAfter.Length; serializerIndex++)
{
PersistedWorldData worldDataAfter = worldsDataAfter[serializerIndex];
for (int playerIndex = 0; playerIndex < worldData.PlayerData.Players.Count; playerIndex++)
{
PersistedPlayerData playerData = worldData.PlayerData.Players[playerIndex];
PersistedPlayerData playerDataAfter = worldDataAfter.PlayerData.Players[playerIndex];
Assert.AreEqual(playerData.Name, playerDataAfter.Name, $"PlayerData.Players.Name is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(playerData.EquippedItems.Count, playerDataAfter.EquippedItems.Count, $"PlayerData.Players.EquippedItems.Count is not equal while using {serverSerializers[serializerIndex]}.");
for (int index = 0; index < playerData.EquippedItems.Count; index++)
{
Assert.AreEqual(playerData.EquippedItems[index].Slot, playerDataAfter.EquippedItems[index].Slot, $"PlayerData.Players.EquippedItems.Slot is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(playerData.EquippedItems[index].TechType, playerDataAfter.EquippedItems[index].TechType, $"PlayerData.Players.EquippedItems.TechType is not equal while using {serverSerializers[serializerIndex]}.");
}
Assert.AreEqual(playerData.Modules.Count, playerDataAfter.Modules.Count, $"PlayerData.Players.Modules.Count is not equal while using {serverSerializers[serializerIndex]}.");
for (int index = 0; index < playerData.Modules.Count; index++)
{
Assert.AreEqual(playerData.Modules[index].Slot, playerDataAfter.Modules[index].Slot, $"PlayerData.Players.Modules.Slot is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(playerData.Modules[index].TechType, playerDataAfter.Modules[index].TechType, $"PlayerData.Players.Modules.TechType is not equal while using {serverSerializers[serializerIndex]}.");
}
Assert.AreEqual(playerData.UsedItems.Count, playerDataAfter.UsedItems.Count, $"PlayerData.Players.UsedItems.Count is not equal while using {serverSerializers[serializerIndex]}.");
for (int index = 0; index < playerData.UsedItems.Count; index++)
{
Assert.AreEqual(playerData.UsedItems[index].Name, playerDataAfter.UsedItems[index].Name, $"PlayerData.Players.UsedItems.Name is not equal while using {serverSerializers[serializerIndex]}.");
}
Assert.IsTrue(playerData.QuickSlotsBinding.SequenceEqual(playerDataAfter.QuickSlotsBinding), $"PlayerData.Players.QuickSlotsBinding is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(playerData.Id, playerDataAfter.Id, $"PlayerData.Players.Id is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(playerData.SpawnPosition, playerDataAfter.SpawnPosition, $"PlayerData.Players.SpawnPosition is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(playerData.CurrentStats.Oxygen, playerDataAfter.CurrentStats.Oxygen, $"PlayerData.Players.CurrentStats.Oxygen is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(playerData.CurrentStats.MaxOxygen, playerDataAfter.CurrentStats.MaxOxygen, $"PlayerData.Players.CurrentStats.MaxOxygen is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(playerData.CurrentStats.Health, playerDataAfter.CurrentStats.Health, $"PlayerData.Players.CurrentStats.Health is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(playerData.CurrentStats.Food, playerDataAfter.CurrentStats.Food, $"PlayerData.Players.CurrentStats.Food is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(playerData.CurrentStats.Water, playerDataAfter.CurrentStats.Water, $"PlayerData.Players.CurrentStats.Water is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(playerData.CurrentStats.InfectionAmount, playerDataAfter.CurrentStats.InfectionAmount, $"PlayerData.Players.CurrentStats.InfectionAmount is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(playerData.SubRootId, playerDataAfter.SubRootId, $"PlayerData.Players.SubRootId is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(playerData.Permissions, playerDataAfter.Permissions, $"PlayerData.Players.Permissions is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(playerData.NitroxId, playerDataAfter.NitroxId, $"PlayerData.Players.NitroxId is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(playerData.IsPermaDeath, playerDataAfter.IsPermaDeath, $"PlayerData.Players.IsFurniture is not equal while using {serverSerializers[serializerIndex]}.");
}
}
}
public void GameDataTest()
{
for (int serializerIndex = 0; serializerIndex < worldsDataAfter.Length; serializerIndex++)
{
PersistedWorldData worldDataAfter = worldsDataAfter[serializerIndex];
Assert.IsTrue(worldData.WorldData.GameData.PDAState.UnlockedTechTypes.SequenceEqual(worldDataAfter.WorldData.GameData.PDAState.UnlockedTechTypes), $"WorldData.GameData.PDAState.UnlockedTechTypes is not equal while using {serverSerializers[serializerIndex]}.");
Assert.IsTrue(worldData.WorldData.GameData.PDAState.KnownTechTypes.SequenceEqual(worldDataAfter.WorldData.GameData.PDAState.KnownTechTypes), $"WorldData.GameData.PDAState.KnownTechTypes is not equal while using {serverSerializers[serializerIndex]}.");
Assert.IsTrue(worldData.WorldData.GameData.PDAState.EncyclopediaEntries.SequenceEqual(worldDataAfter.WorldData.GameData.PDAState.EncyclopediaEntries), $"WorldData.GameData.PDAState.EncyclopediaEntries is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(worldData.WorldData.GameData.PDAState.PartiallyUnlockedByTechType.Count, worldDataAfter.WorldData.GameData.PDAState.PartiallyUnlockedByTechType.Count, $"WorldData.GameData.PDAState.PartiallyUnlockedByTechType.Count is not equal while using {serverSerializers[serializerIndex]}.");
for (int index = 0; index < worldData.WorldData.GameData.PDAState.PartiallyUnlockedByTechType.Count; index++)
{
KeyValuePair <NitroxTechType, PDAEntry> entry = worldData.WorldData.GameData.PDAState.PartiallyUnlockedByTechType.ElementAt(index);
KeyValuePair <NitroxTechType, PDAEntry> entryAfter = worldData.WorldData.GameData.PDAState.PartiallyUnlockedByTechType.ElementAt(index);
Assert.AreEqual(entry.Key, entryAfter.Key, $"WorldData.GameData.PDAState.PartiallyUnlockedByTechType.Key is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(entry.Value.Progress, entryAfter.Value.Progress, $"WorldData.GameData.PDAState.PartiallyUnlockedByTechType.Value.Progress is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(entry.Value.TechType, entryAfter.Value.TechType, $"WorldData.GameData.PDAState.PartiallyUnlockedByTechType.Value.TechType is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(entry.Value.Unlocked, entryAfter.Value.Unlocked, $"WorldData.GameData.PDAState.PartiallyUnlockedByTechType.Value.Unlocked is not equal while using {serverSerializers[serializerIndex]}.");
}
Assert.AreEqual(worldData.WorldData.GameData.PDAState.PdaLog.Count, worldDataAfter.WorldData.GameData.PDAState.PdaLog.Count, $"WorldData.GameData.PDAState.PdaLog.Count is not equal while using {serverSerializers[serializerIndex]}.");
for (int index = 0; index < worldData.WorldData.GameData.PDAState.PdaLog.Count; index++)
{
PDALogEntry logEntry = worldData.WorldData.GameData.PDAState.PdaLog[index];
PDALogEntry logEntryAfter = worldDataAfter.WorldData.GameData.PDAState.PdaLog[index];
Assert.AreEqual(logEntry.Key, logEntryAfter.Key, $"WorldData.GameData.PDAState.PdaLog.Key is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(logEntry.Timestamp, logEntryAfter.Timestamp, $"WorldData.GameData.PDAState.PdaLog.Timestamp is not equal while using {serverSerializers[serializerIndex]}.");
}
Assert.IsTrue(worldData.WorldData.GameData.StoryGoals.CompletedGoals.SequenceEqual(worldDataAfter.WorldData.GameData.StoryGoals.CompletedGoals), $"WorldData.GameData.StoryGoals.CompletedGoals is not equal while using {serverSerializers[serializerIndex]}.");
Assert.IsTrue(worldData.WorldData.GameData.StoryGoals.RadioQueue.SequenceEqual(worldDataAfter.WorldData.GameData.StoryGoals.RadioQueue), $"WorldData.GameData.StoryGoals.RadioQueue is not equal while using {serverSerializers[serializerIndex]}.");
Assert.IsTrue(worldData.WorldData.GameData.StoryGoals.GoalUnlocks.SequenceEqual(worldDataAfter.WorldData.GameData.StoryGoals.GoalUnlocks), $"WorldData.GameData.StoryGoals.GoalUnlocks is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(worldData.WorldData.GameData.StoryTiming.ElapsedTime, worldDataAfter.WorldData.GameData.StoryTiming.ElapsedTime, $"WorldData.GameData.StoryTiming.ElapsedTime is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(worldData.WorldData.GameData.StoryTiming.AuroraExplosionTime, worldDataAfter.WorldData.GameData.StoryTiming.AuroraExplosionTime, $"WorldData.GameData.StoryTiming.AuroraExplosionTime is not equal while using {serverSerializers[serializerIndex]}.");
}
}
public void InventoryDataTest()
{
for (int serializerIndex = 0; serializerIndex < worldsDataAfter.Length; serializerIndex++)
{
PersistedWorldData worldDataAfter = worldsDataAfter[serializerIndex];
Assert.AreEqual(worldData.WorldData.InventoryData.InventoryItems.Count, worldDataAfter.WorldData.InventoryData.InventoryItems.Count, $"WorldData.InventoryData.InventoryItems.Count is not equal while using {serverSerializers[serializerIndex]}.");
for (int index = 0; index < worldData.WorldData.InventoryData.InventoryItems.Count; index++)
{
ItemData itemData = worldData.WorldData.InventoryData.InventoryItems[index];
ItemData itemDataAfter = worldDataAfter.WorldData.InventoryData.InventoryItems[index];
Assert.AreEqual(itemData.ContainerId, itemDataAfter.ContainerId, $"WorldData.InventoryData.InventoryItems.ContainerId is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(itemData.ItemId, itemDataAfter.ItemId, $"WorldData.InventoryData.InventoryItems.ItemId is not equal while using {serverSerializers[serializerIndex]}.");
Assert.IsTrue(itemData.SerializedData.SequenceEqual(itemDataAfter.SerializedData), $"WorldData.InventoryData.InventoryItems.SerializedData is not equal while using {serverSerializers[serializerIndex]}.");
}
Assert.AreEqual(worldData.WorldData.InventoryData.StorageSlotItems.Count, worldDataAfter.WorldData.InventoryData.StorageSlotItems.Count, $"WorldData.InventoryData.StorageSlotItems.Count is not equal while using {serverSerializers[serializerIndex]}.");
for (int index = 0; index < worldData.WorldData.InventoryData.StorageSlotItems.Count; index++)
{
ItemData itemData = worldData.WorldData.InventoryData.StorageSlotItems[index];
ItemData itemDataAfter = worldDataAfter.WorldData.InventoryData.StorageSlotItems[index];
Assert.AreEqual(itemData.ContainerId, itemDataAfter.ContainerId, $"WorldData.InventoryData.StorageSlotItems.ContainerId is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(itemData.ItemId, itemDataAfter.ItemId, $"WorldData.InventoryData.StorageSlotItems.ItemId is not equal while using {serverSerializers[serializerIndex]}.");
Assert.IsTrue(itemData.SerializedData.SequenceEqual(itemDataAfter.SerializedData), $"WorldData.InventoryData.StorageSlotItems.SerializedData is not equal while using {serverSerializers[serializerIndex]}.");
}
Assert.AreEqual(worldData.WorldData.InventoryData.Modules.Count, worldDataAfter.WorldData.InventoryData.Modules.Count, $"WorldData.InventoryData.Modules.Count is not equal while using {serverSerializers[serializerIndex]}.");
for (int index = 0; index < worldData.WorldData.InventoryData.Modules.Count; index++)
{
EquippedItemData equippedItemData = worldData.WorldData.InventoryData.Modules[index];
EquippedItemData equippedItemDataAfter = worldDataAfter.WorldData.InventoryData.Modules[index];
Assert.AreEqual(equippedItemData.ContainerId, equippedItemDataAfter.ContainerId, $"WorldData.InventoryData.Modules.ContainerId is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(equippedItemData.ItemId, equippedItemDataAfter.ItemId, $"WorldData.InventoryData.Modules.ItemId is not equal while using {serverSerializers[serializerIndex]}.");
Assert.IsTrue(equippedItemData.SerializedData.SequenceEqual(equippedItemDataAfter.SerializedData), $"WorldData.InventoryData.Modules.SerializedData is not equal while using {serverSerializers[serializerIndex]}.");
}
}
}
public void VehicleDataTest()
{
for (int serializerIndex = 0; serializerIndex < worldsDataAfter.Length; serializerIndex++)
{
PersistedWorldData worldDataAfter = worldsDataAfter[serializerIndex];
Assert.AreEqual(worldData.WorldData.VehicleData.Vehicles.Count, worldDataAfter.WorldData.VehicleData.Vehicles.Count, $"WorldData.VehicleData.Vehicles.Count is not equal while using {serverSerializers[serializerIndex]}.");
for (int index = 0; index < worldData.WorldData.VehicleData.Vehicles.Count; index++)
{
VehicleModel vehicleModel = worldData.WorldData.VehicleData.Vehicles[index];
VehicleModel vehicleModelAfter = worldDataAfter.WorldData.VehicleData.Vehicles[index];
Assert.AreEqual(vehicleModel.TechType, vehicleModelAfter.TechType, $"WorldData.VehicleData.Vehicles.TechType is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(vehicleModel.Id, vehicleModelAfter.Id, $"WorldData.VehicleData.Vehicles.Id is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(vehicleModel.Position, vehicleModelAfter.Position, $"WorldData.VehicleData.Vehicles.Position is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(vehicleModel.Rotation, vehicleModelAfter.Rotation, $"WorldData.VehicleData.Vehicles.Rotation is not equal while using {serverSerializers[serializerIndex]}.");
Assert.IsTrue(vehicleModel.InteractiveChildIdentifiers.SequenceEqual(vehicleModelAfter.InteractiveChildIdentifiers), $"WorldData.VehicleData.Vehicles.InteractiveChildIdentifiers is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(vehicleModel.DockingBayId, vehicleModelAfter.DockingBayId, $"WorldData.VehicleData.Vehicles.DockingBayId is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(vehicleModel.Name, vehicleModelAfter.Name, $"WorldData.VehicleData.Vehicles.Name is not equal while using {serverSerializers[serializerIndex]}.");
Assert.IsTrue(vehicleModel.HSB.SequenceEqual(vehicleModelAfter.HSB), $"WorldData.VehicleData.Vehicles.HSB is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(vehicleModel.Health, vehicleModelAfter.Health, $"WorldData.VehicleData.Vehicles.Health is not equal while using {serverSerializers[serializerIndex]}.");
}
}
}
public void EscapePodDataTest()
{
for (int serializerIndex = 0; serializerIndex < worldsDataAfter.Length; serializerIndex++)
{
PersistedWorldData worldDataAfter = worldsDataAfter[serializerIndex];
Assert.AreEqual(worldData.WorldData.EscapePodData.EscapePods.Count, worldDataAfter.WorldData.EscapePodData.EscapePods.Count, $"WorldData.EscapePodData.EscapePods.Count is not equal while using {serverSerializers[serializerIndex]}.");
for (int index = 0; index < worldData.WorldData.EscapePodData.EscapePods.Count; index++)
{
EscapePodModel escapePod = worldData.WorldData.EscapePodData.EscapePods[index];
EscapePodModel escapePodAfter = worldDataAfter.WorldData.EscapePodData.EscapePods[index];
Assert.AreEqual(escapePod.Id, escapePodAfter.Id, $"WorldData.EscapePodData.EscapePods.Id is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(escapePod.Location, escapePodAfter.Location, $"WorldData.EscapePodData.EscapePods.Location is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(escapePod.FabricatorId, escapePodAfter.FabricatorId, $"WorldData.EscapePodData.EscapePods.FabricatorId is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(escapePod.MedicalFabricatorId, escapePodAfter.MedicalFabricatorId, $"WorldData.EscapePodData.EscapePods.MedicalFabricatorId is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(escapePod.StorageContainerId, escapePodAfter.StorageContainerId, $"WorldData.EscapePodData.EscapePods.StorageContainerId is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(escapePod.RadioId, escapePodAfter.RadioId, $"WorldData.EscapePodData.EscapePods.RadioId is not equal while using {serverSerializers[serializerIndex]}.");
Assert.IsTrue(escapePod.AssignedPlayers.SequenceEqual(escapePodAfter.AssignedPlayers), $"WorldData.EscapePodData.EscapePods.AssignedPlayers is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(escapePod.Damaged, escapePodAfter.Damaged, $"WorldData.EscapePodData.EscapePods.Damaged is not equal while using {serverSerializers[serializerIndex]}.");
Assert.AreEqual(escapePod.RadioDamaged, escapePodAfter.RadioDamaged, $"WorldData.EscapePodData.EscapePods.RadioDamaged is not equal while using {serverSerializers[serializerIndex]}.");
}
}
}
