531 lines
22 KiB
C#
531 lines
22 KiB
C#
using Assets.Code;
|
|
using Riptide;
|
|
using Riptide.Transports;
|
|
using Steamworks;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using System.Reflection;
|
|
using System.Text;
|
|
using System.Threading.Tasks;
|
|
|
|
namespace KCM.LoadSaveOverrides
|
|
{
|
|
[Serializable]
|
|
public class MultiplayerSaveContainer : LoadSaveContainer
|
|
{
|
|
public Dictionary<string, Player.PlayerSaveData> players = new Dictionary<string, Player.PlayerSaveData>();
|
|
public Dictionary<string, string> kingdomNames = new Dictionary<string, string>();
|
|
|
|
public new MultiplayerSaveContainer Pack(object obj)
|
|
{
|
|
this.CameraSaveData = new Cam.CamSaveData().Pack(Cam.inst);
|
|
this.TownNameSaveData = new TownNameUI.TownNameSaveData().Pack(TownNameUI.inst);
|
|
|
|
Main.helper.Log($"Saving data for {Main.kCPlayers.Count} ({KCServer.server.ClientCount}) players.");
|
|
|
|
//this.PlayerSaveData = new PlayerSaveDataOverride().Pack(Player.inst);
|
|
foreach (var player in Main.kCPlayers.Values)
|
|
{
|
|
try
|
|
{
|
|
if (player == null)
|
|
continue;
|
|
|
|
if (string.IsNullOrWhiteSpace(player.steamId))
|
|
{
|
|
Main.helper.Log($"Skipping save for player with missing steamId (name={player.name ?? string.Empty})");
|
|
continue;
|
|
}
|
|
|
|
if (player.inst == null)
|
|
{
|
|
Main.helper.Log($"Skipping save for player {player.name ?? string.Empty} ({player.steamId}) because Player.inst is null");
|
|
continue;
|
|
}
|
|
|
|
Main.helper.Log($"Attempting to pack data for: {player.name} ({player.steamId})");
|
|
string playerGoName = (player.inst.gameObject != null) ? player.inst.gameObject.name : string.Empty;
|
|
Main.helper.Log($"Player object: {player.inst} {playerGoName}");
|
|
|
|
this.players[player.steamId] = new Player.PlayerSaveData().Pack(player.inst);
|
|
kingdomNames[player.steamId] = player.kingdomName ?? " ";
|
|
|
|
Main.helper.Log($"{players[player.steamId] == null}");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
string steamId = (player != null && player.steamId != null) ? player.steamId : string.Empty;
|
|
string name = (player != null && player.name != null) ? player.name : string.Empty;
|
|
Main.helper.Log($"Error packing player data for save (steamId={steamId}, name={name})");
|
|
Main.helper.Log(ex.ToString());
|
|
}
|
|
}
|
|
|
|
this.WorldSaveData = new World.WorldSaveData().Pack(World.inst);
|
|
this.FishSystemSaveData = new FishSystem.FishSystemSaveData().Pack(FishSystem.inst);
|
|
this.JobSystemSaveData = new JobSystem.JobSystemSaveData().Pack(JobSystem.inst);
|
|
this.FreeResourceManagerSaveData = new FreeResourceManager.FreeResourceManagerSaveData().Pack(FreeResourceManager.inst);
|
|
this.WeatherSaveData = new Weather.WeatherSaveData().Pack(Weather.inst);
|
|
this.FireManagerSaveData = new FireManager.FireManagerSaveData().Pack(FireManager.inst);
|
|
this.DragonSpawnSaveData = new DragonSpawn.DragonSpawnSaveData().Pack(DragonSpawn.inst);
|
|
this.UnitSystemSaveData = new UnitSystem.UnitSystemSaveData().Pack(UnitSystem.inst);
|
|
this.RaidSystemSaveData2 = new RaiderSystem.RaiderSystemSaveData2().Pack(RaiderSystem.inst);
|
|
|
|
if (ShipSystem.inst != null)
|
|
{
|
|
try
|
|
{
|
|
this.ShipSystemSaveData = new ShipSystem.ShipSystemSaveData().Pack(ShipSystem.inst);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Main.helper.Log("Error packing ShipSystem for save; skipping ShipSystemSaveData.");
|
|
Main.helper.Log(ex.ToString());
|
|
this.ShipSystemSaveData = null;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
this.ShipSystemSaveData = null;
|
|
}
|
|
|
|
this.AIBrainsSaveData = new AIBrainsContainer.SaveData().Pack(AIBrainsContainer.inst);
|
|
this.SiegeMonsterSaveData = new SiegeMonster.SiegeMonsterSaveData().Pack(null);
|
|
this.CartSystemSaveData = new CartSystem.CartSystemSaveData().Pack(CartSystem.inst);
|
|
this.SiegeCatapultSystemSaveData = new SiegeCatapultSystem.SiegeCatapultSystemSaveData().Pack(SiegeCatapultSystem.inst);
|
|
this.OrdersManagerSaveData = new OrdersManager.OrdersManagerSaveData().Pack(OrdersManager.inst);
|
|
this.CustomSaveData = LoadSave.CustomSaveData_DontAccessDirectly;
|
|
|
|
return this;
|
|
}
|
|
|
|
public override object Unpack(object obj)
|
|
{
|
|
//original Player reset was up here
|
|
foreach (var kvp in players)
|
|
{
|
|
|
|
KCPlayer player;
|
|
|
|
if (!Main.kCPlayers.TryGetValue(kvp.Key, out player))
|
|
{
|
|
player = new KCPlayer("", 50, kvp.Key);
|
|
player.kingdomName = kingdomNames[kvp.Key];
|
|
|
|
Main.kCPlayers.Add(kvp.Key, player);
|
|
}
|
|
}
|
|
|
|
foreach (var player in Main.kCPlayers.Values)
|
|
player.inst.Reset();
|
|
|
|
|
|
AIBrainsContainer.inst.ClearAIs();
|
|
this.CameraSaveData.Unpack(Cam.inst);
|
|
this.WorldSaveData.Unpack(World.inst);
|
|
|
|
bool flag = this.FishSystemSaveData != null;
|
|
if (flag)
|
|
{
|
|
this.FishSystemSaveData.Unpack(FishSystem.inst);
|
|
}
|
|
this.TownNameSaveData.Unpack(TownNameUI.inst);
|
|
|
|
|
|
//TownNameUI.inst.townName = kingdomNames[Main.PlayerSteamID];
|
|
TownNameUI.inst.SetTownName(kingdomNames[Main.PlayerSteamID]);
|
|
|
|
Main.helper.Log("Unpacking player data");
|
|
|
|
Player.PlayerSaveData clientPlayerData = null;
|
|
|
|
foreach (var kvp in players)
|
|
{
|
|
if (kvp.Key == SteamUser.GetSteamID().ToString())
|
|
{
|
|
Main.helper.Log("Found current client player data. ID: " + SteamUser.GetSteamID().ToString());
|
|
|
|
clientPlayerData = kvp.Value;
|
|
}
|
|
else
|
|
{ // Maybe ??
|
|
Main.helper.Log("Loading player data: " + kvp.Key);
|
|
|
|
|
|
KCPlayer player;
|
|
|
|
if (!Main.kCPlayers.TryGetValue(kvp.Key, out player))
|
|
{
|
|
player = new KCPlayer("", 50, kvp.Key);
|
|
Main.kCPlayers.Add(kvp.Key, player);
|
|
}
|
|
|
|
Player oldPlayer = Player.inst;
|
|
Player.inst = player.inst;
|
|
Main.helper.Log($"Number of landmasses: {World.inst.NumLandMasses}");
|
|
|
|
//Reset was here before unpack
|
|
kvp.Value.Unpack(player.inst);
|
|
|
|
Player.inst = oldPlayer;
|
|
|
|
|
|
player.banner = player.inst.PlayerLandmassOwner.bannerIdx;
|
|
player.kingdomName = TownNameUI.inst.townName;
|
|
}
|
|
}
|
|
|
|
clientPlayerData.Unpack(Player.inst); // Unpack the current client player last so that loading of villagers works correctly.
|
|
|
|
Main.helper.Log("unpacked player data");
|
|
Main.helper.Log("Setting banner and name");
|
|
|
|
var client = Main.kCPlayers[SteamUser.GetSteamID().ToString()];
|
|
|
|
|
|
client.banner = Player.inst.PlayerLandmassOwner.bannerIdx;
|
|
client.kingdomName = TownNameUI.inst.townName;
|
|
|
|
Main.helper.Log("Finished unpacking player data");
|
|
|
|
// Fix AI brains save/load system to restore villager AI state
|
|
bool flag2 = this.AIBrainsSaveData != null;
|
|
if (flag2)
|
|
{
|
|
try
|
|
{
|
|
Main.helper.Log("Unpacking AI brains before player data");
|
|
this.AIBrainsSaveData.UnpackPrePlayer(AIBrainsContainer.inst);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Main.helper.Log("Error unpacking AI brains pre-player: " + e.Message);
|
|
}
|
|
}
|
|
|
|
Main.helper.Log("Unpacking free resource manager");
|
|
this.FreeResourceManagerSaveData.Unpack(FreeResourceManager.inst);
|
|
Main.helper.Log("Unpacking job system");
|
|
this.JobSystemSaveData.Unpack(JobSystem.inst);
|
|
Main.helper.Log("Unpacking weather");
|
|
this.WeatherSaveData.Unpack(Weather.inst);
|
|
Main.helper.Log("Unpacking fire manager");
|
|
this.FireManagerSaveData.Unpack(FireManager.inst);
|
|
Main.helper.Log("Unpacking dragon spawn");
|
|
this.DragonSpawnSaveData.Unpack(DragonSpawn.inst);
|
|
Main.helper.Log("Unpacking unit system");
|
|
bool flag3 = this.UnitSystemSaveData != null;
|
|
if (flag3)
|
|
{
|
|
this.UnitSystemSaveData.Unpack(UnitSystem.inst);
|
|
}
|
|
Main.helper.Log("Unpacking siege monster");
|
|
bool flag4 = this.SiegeMonsterSaveData != null;
|
|
if (flag4)
|
|
{
|
|
this.SiegeMonsterSaveData.Unpack(null);
|
|
}
|
|
Main.helper.Log("Unpacking siege catapult system");
|
|
bool flag5 = this.SiegeCatapultSystemSaveData != null;
|
|
if (flag5)
|
|
{
|
|
this.SiegeCatapultSystemSaveData.Unpack(SiegeCatapultSystem.inst);
|
|
}
|
|
Main.helper.Log("Unpacking ship system");
|
|
bool flag6 = this.ShipSystemSaveData != null;
|
|
if (flag6)
|
|
{
|
|
this.ShipSystemSaveData.Unpack(ShipSystem.inst);
|
|
}
|
|
Main.helper.Log("Unpacking cart system");
|
|
bool flag7 = this.CartSystemSaveData != null;
|
|
if (flag7)
|
|
{
|
|
this.CartSystemSaveData.Unpack(CartSystem.inst);
|
|
}
|
|
Main.helper.Log("Unpacking raid system");
|
|
bool flag8 = this.RaidSystemSaveData2 != null;
|
|
if (flag8)
|
|
{
|
|
this.RaidSystemSaveData2.Unpack(RaiderSystem.inst);
|
|
}
|
|
Main.helper.Log("Unpacking orders manager");
|
|
bool flag9 = this.OrdersManagerSaveData != null;
|
|
if (flag9)
|
|
{
|
|
this.OrdersManagerSaveData.Unpack(OrdersManager.inst);
|
|
}
|
|
Main.helper.Log("Unpacking AI brains");
|
|
bool flag10 = this.AIBrainsSaveData != null;
|
|
if (flag10)
|
|
{
|
|
try
|
|
{
|
|
this.AIBrainsSaveData.Unpack(AIBrainsContainer.inst);
|
|
Main.helper.Log("AI brains unpacked successfully");
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Main.helper.Log("Error unpacking AI brains: " + e.Message);
|
|
Main.helper.Log("Attempting to reinitialize AI systems");
|
|
try
|
|
{
|
|
AIBrainsContainer.inst.ClearAIs();
|
|
// Force reinitialize AI for all villagers
|
|
for (int i = 0; i < Villager.villagers.Count; i++)
|
|
{
|
|
Villager v = Villager.villagers.data[i];
|
|
if (v != null && v.brain != null)
|
|
{
|
|
v.brain.Restart();
|
|
}
|
|
}
|
|
Main.helper.Log("AI systems reinitialized");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Main.helper.Log("Failed to reinitialize AI systems: " + ex.Message);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Main.helper.Log("No AI brains save data found, initializing fresh AI");
|
|
try
|
|
{
|
|
// Initialize AI for all villagers if no save data
|
|
for (int i = 0; i < Villager.villagers.Count; i++)
|
|
{
|
|
Villager v = Villager.villagers.data[i];
|
|
if (v != null && v.brain != null)
|
|
{
|
|
v.brain.Restart();
|
|
}
|
|
}
|
|
Main.helper.Log("Fresh AI initialization completed");
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Main.helper.Log("Failed fresh AI initialization: " + e.Message);
|
|
}
|
|
}
|
|
Main.helper.Log("Unpacking custom save data");
|
|
bool flag11 = this.CustomSaveData != null;
|
|
if (flag11)
|
|
{
|
|
LoadSave.CustomSaveData_DontAccessDirectly = this.CustomSaveData;
|
|
}
|
|
Main.helper.Log("Unpacking done");
|
|
|
|
try
|
|
{
|
|
Main.helper.Log("Post-load: rebuilding path costs + villager grid");
|
|
try { World.inst.SetupInitialPathCosts(); } catch (Exception e) { Main.helper.Log(e.ToString()); }
|
|
try { World.inst.RebuildVillagerGrid(); } catch (Exception e) { Main.helper.Log(e.ToString()); }
|
|
try { Player.inst.irrigation.UpdateIrrigation(); } catch (Exception e) { Main.helper.Log(e.ToString()); }
|
|
try { Player.inst.CalcMaxResources(null, -1); } catch (Exception e) { Main.helper.Log(e.ToString()); }
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Main.helper.Log("Post-load rebuild failed");
|
|
Main.helper.Log(e.ToString());
|
|
}
|
|
|
|
|
|
World.inst.UpscaleFeatures();
|
|
Player.inst.RefreshVisibility(true);
|
|
for (int i = 0; i < Player.inst.Buildings.Count; i++)
|
|
{
|
|
Player.inst.Buildings.data[i].UpdateMaterialSelection();
|
|
}
|
|
|
|
// Increase loadTickDelay values to ensure proper initialization
|
|
Type playerType = typeof(Player);
|
|
FieldInfo loadTickDelayField = playerType.GetField("loadTickDelay", BindingFlags.Instance | BindingFlags.NonPublic);
|
|
if (loadTickDelayField != null)
|
|
{
|
|
loadTickDelayField.SetValue(Player.inst, 3);
|
|
}
|
|
|
|
// UnitSystem.inst.loadTickDelay = 3;
|
|
Type unitSystemType = typeof(UnitSystem);
|
|
loadTickDelayField = unitSystemType.GetField("loadTickDelay", BindingFlags.Instance | BindingFlags.NonPublic);
|
|
if (loadTickDelayField != null)
|
|
{
|
|
loadTickDelayField.SetValue(UnitSystem.inst, 3);
|
|
}
|
|
|
|
// JobSystem.inst.loadTickDelay = 3;
|
|
Type jobSystemType = typeof(JobSystem);
|
|
loadTickDelayField = jobSystemType.GetField("loadTickDelay", BindingFlags.Instance | BindingFlags.NonPublic);
|
|
if (loadTickDelayField != null)
|
|
{
|
|
loadTickDelayField.SetValue(JobSystem.inst, 3);
|
|
}
|
|
|
|
// VillagerSystem.inst.loadTickDelay = 3;
|
|
Type villagerSystemType = typeof(VillagerSystem);
|
|
loadTickDelayField = villagerSystemType.GetField("loadTickDelay", BindingFlags.Instance | BindingFlags.NonPublic);
|
|
if (loadTickDelayField != null)
|
|
{
|
|
loadTickDelayField.SetValue(VillagerSystem.inst, 3);
|
|
}
|
|
|
|
// Force AI system restart after load
|
|
try
|
|
{
|
|
Main.helper.Log("Forcing AI system restart after load");
|
|
|
|
// Restart all villager AI brains
|
|
for (int i = 0; i < Villager.villagers.Count; i++)
|
|
{
|
|
Villager v = Villager.villagers.data[i];
|
|
if (v != null && v.brain != null)
|
|
{
|
|
try
|
|
{
|
|
v.brain.Restart();
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Main.helper.Log($"Failed to restart villager AI: {e.Message}");
|
|
}
|
|
}
|
|
}
|
|
|
|
// Force job system refresh
|
|
if (JobSystem.inst != null)
|
|
{
|
|
try
|
|
{
|
|
// Use reflection to call any refresh/rebuild methods
|
|
var jobSystemType = typeof(JobSystem);
|
|
var refreshMethods = jobSystemType.GetMethods(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance)
|
|
.Where(m => m.Name.Contains("Refresh") || m.Name.Contains("Rebuild") || m.Name.Contains("Update"));
|
|
|
|
foreach (var method in refreshMethods)
|
|
{
|
|
if (method.GetParameters().Length == 0)
|
|
{
|
|
try
|
|
{
|
|
method.Invoke(JobSystem.inst, null);
|
|
Main.helper.Log($"Called JobSystem.{method.Name}()");
|
|
}
|
|
catch { }
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Main.helper.Log($"Error refreshing job system: {e.Message}");
|
|
}
|
|
}
|
|
|
|
Main.helper.Log("AI system restart completed");
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Main.helper.Log($"Error during AI system restart: {e.Message}");
|
|
}
|
|
|
|
Main.helper.Log($"Setting kingdom name to: {kingdomNames[Main.PlayerSteamID]}");
|
|
TownNameUI.inst.SetTownName(kingdomNames[Main.PlayerSteamID]);
|
|
|
|
// Perform villager state resync after loading completes
|
|
try
|
|
{
|
|
Main.helper.Log("Starting villager state resync after load");
|
|
|
|
// Wait a frame for all systems to initialize
|
|
System.Threading.Tasks.Task.Delay(100).ContinueWith(_ =>
|
|
{
|
|
try
|
|
{
|
|
Main.helper.Log("Performing delayed villager resync");
|
|
|
|
// Resync all villager positions and states
|
|
for (int i = 0; i < Villager.villagers.Count; i++)
|
|
{
|
|
Villager v = Villager.villagers.data[i];
|
|
if (v != null)
|
|
{
|
|
try
|
|
{
|
|
// Force position update
|
|
Vector3 currentPos = v.Pos;
|
|
v.TeleportTo(currentPos);
|
|
|
|
// Restart AI brain if it exists
|
|
if (v.brain != null)
|
|
{
|
|
v.brain.Restart();
|
|
}
|
|
|
|
// Ensure villager is in correct system lists
|
|
if (v.workerJob != null && Player.inst != null)
|
|
{
|
|
if (!Player.inst.Workers.Contains(v))
|
|
{
|
|
Player.inst.Workers.Add(v);
|
|
}
|
|
}
|
|
else if (v.workerJob == null && Player.inst != null)
|
|
{
|
|
if (!Player.inst.Homeless.Contains(v))
|
|
{
|
|
Player.inst.Homeless.Add(v);
|
|
}
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Main.helper.Log($"Error resyncing villager {i}: {e.Message}");
|
|
}
|
|
}
|
|
}
|
|
|
|
// Force job system to re-evaluate all jobs
|
|
if (JobSystem.inst != null)
|
|
{
|
|
try
|
|
{
|
|
var jobSystemType = typeof(JobSystem);
|
|
var updateMethods = jobSystemType.GetMethods(System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Instance)
|
|
.Where(m => (m.Name.Contains("Update") || m.Name.Contains("Refresh")) && m.GetParameters().Length == 0);
|
|
|
|
foreach (var method in updateMethods)
|
|
{
|
|
try
|
|
{
|
|
method.Invoke(JobSystem.inst, null);
|
|
Main.helper.Log($"Called JobSystem.{method.Name} for resync");
|
|
}
|
|
catch { }
|
|
}
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Main.helper.Log($"Error updating job system: {e.Message}");
|
|
}
|
|
}
|
|
|
|
Main.helper.Log("Villager state resync completed");
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Main.helper.Log($"Error in delayed villager resync: {e.Message}");
|
|
}
|
|
});
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Main.helper.Log($"Error starting villager resync: {e.Message}");
|
|
}
|
|
|
|
return obj;
|
|
}
|
|
}
|
|
}
|