Merge branch 'dev1.2' into techbranch

Author: IExploitableMan

src/Loader.cs

@@ -273,7 +273,7 @@ public static void LoadLocalizationFile(Mod mod, Mod.File file)
 		{
 			Loc.BuildAndLoadLocalization(JsonSerializer
 				.Deserialize<Dictionary<string, Dictionary<string, string>>>(file.bytes)!);
-			Plugin.logger.LogInfo($"Registried localization from {mod.id} mod");
+			Plugin.logger.LogInfo($"Registered localization from {mod.id} mod");
 		}
 		catch (Exception e)
 		{
@@ -441,8 +441,34 @@ public static void LoadGameLogicDataPatch(Mod mod, JObject gld, JObject patch)
 					Registry.tribePreviews[Util.GetJTokenName(token)] = preview;
 				}
 			}
+			foreach (JToken jtoken in patch.SelectTokens("$.unitData.*").ToArray())
+			{
+				JObject token = jtoken.Cast<JObject>();
+				if (token["embarksTo"] != null)
+				{
+					string unitId = Util.GetJTokenName(token);
+					string embarkUnitId = token["embarksTo"].ToString();
+					Main.embarkNames[unitId] = embarkUnitId;
+				}
+			}
+			foreach (JToken jtoken in patch.SelectTokens("$.improvementData.*").ToArray())
+			{
+				JObject token = jtoken.Cast<JObject>();
+				if (token["attractsResource"] != null)
+				{
+					string improvementId = Util.GetJTokenName(token);
+					string attractsId = token["attractsResource"].ToString();
+					Main.attractsResourceNames[improvementId] = attractsId;
+				}
+				if (token["attractsToTerrain"] != null)
+				{
+					string improvementId = Util.GetJTokenName(token);
+					string attractsId = token["attractsToTerrain"].ToString();
+					Main.attractsTerrainNames[improvementId] = attractsId;
+				}
+			}
 			gld.Merge(patch, new() { MergeArrayHandling = MergeArrayHandling.Replace, MergeNullValueHandling = MergeNullValueHandling.Merge });
-			Plugin.logger.LogInfo($"Registried patch from {mod.id} mod");
+			Plugin.logger.LogInfo($"Registered patch from {mod.id} mod");
 		}
 		catch (Exception e)
 		{

src/Managers/Main.cs

@@ -16,7 +16,13 @@ public static class Main
 	internal static readonly Stopwatch stopwatch = new();
 	internal static bool fullyInitialized;
 	internal static bool dependencyCycle;
-
+	internal static Dictionary<string, string> embarkNames = new();
+	internal static Dictionary<UnitData.Type, UnitData.Type> embarkOverrides = new();
+	internal static bool currentlyEmbarking = false;
+	internal static Dictionary<string, string> attractsResourceNames = new();
+	internal static Dictionary<string, string> attractsTerrainNames = new();
+	internal static Dictionary<ImprovementData.Type, ResourceData.Type> attractsResourceOverrides = new();
+	internal static Dictionary<ImprovementData.Type, Polytopia.Data.TerrainData.Type> attractsTerrainOverrides = new();
 
 	[HarmonyPrefix]
 	[HarmonyPatch(typeof(GameLogicData), nameof(GameLogicData.AddGameLogicPlaceholders))]
@@ -30,6 +36,48 @@ private static void GameLogicData_Parse(GameLogicData __instance, JObject rootOb
 				if (skin.skinData != null)
 					__instance.skinData[(SkinType)skin.idx] = skin.skinData;
 			}
+			foreach (KeyValuePair<string, string> entry in embarkNames)
+			{
+				try
+				{
+					UnitData.Type unit = EnumCache<UnitData.Type>.GetType(entry.Key);
+					UnitData.Type newUnit = EnumCache<UnitData.Type>.GetType(entry.Value);
+					embarkOverrides[unit] = newUnit;
+					Plugin.logger.LogInfo($"Embark unit type for {entry.Key} is now {entry.Value}");
+				}
+				catch
+				{
+					Plugin.logger.LogError($"Embark unit type for {entry.Key} is not valid: {entry.Value}");
+				}
+			}
+			foreach (KeyValuePair<string, string> entry in attractsResourceNames)
+			{
+				try
+				{
+					ImprovementData.Type improvement = EnumCache<ImprovementData.Type>.GetType(entry.Key);
+					ResourceData.Type resource = EnumCache<ResourceData.Type>.GetType(entry.Value);
+					attractsResourceOverrides[improvement] = resource;
+					Plugin.logger.LogInfo($"Improvement {entry.Key} now attracts {entry.Value}");
+				}
+				catch
+				{
+					Plugin.logger.LogError($"Improvement {entry.Key} resource type is not valid: {entry.Value}");
+				}
+			}
+			foreach (KeyValuePair<string, string> entry in attractsTerrainNames)
+			{
+				try
+				{
+					ImprovementData.Type improvement = EnumCache<ImprovementData.Type>.GetType(entry.Key);
+					Polytopia.Data.TerrainData.Type terrain = EnumCache<Polytopia.Data.TerrainData.Type>.GetType(entry.Value);
+					attractsTerrainOverrides[improvement] = terrain;
+					Plugin.logger.LogInfo($"Improvement {entry.Key} now attracts on {entry.Value}");
+				}
+				catch
+				{
+					Plugin.logger.LogError($"Improvement {entry.Key} terrain type is not valid: {entry.Value}");
+				}
+			}
 			fullyInitialized = true;
 		}
 	}
@@ -160,6 +208,83 @@ public static bool TechView_CreateNode(TechView __instance, TechData data, TechI
 		return false;
 	}
 
+	[HarmonyPrefix]
+	[HarmonyPatch(typeof(EmbarkAction), nameof(EmbarkAction.Execute))]
+	private static bool EmbarkAction_Execute_Prefix(EmbarkAction __instance, GameState gameState)
+	{
+		currentlyEmbarking = true;
+		return true;
+	}
+
+	[HarmonyPrefix]
+	[HarmonyPatch(typeof(ActionUtils), nameof(ActionUtils.TrainUnit))]
+	private static bool ActionUtils_TrainUnit(ref UnitState __result, GameState gameState, PlayerState playerState, TileData tile, ref UnitData unitData)
+	{
+		if (tile == null)
+		{
+			return true;
+		}
+		if (tile.unit == null)
+		{
+			return true;
+		}
+		if (currentlyEmbarking)
+		{
+			if (embarkOverrides.TryGetValue(tile.unit.type, out UnitData.Type newType))
+			{
+				gameState.GameLogicData.TryGetData(newType, out unitData);
+			}
+			currentlyEmbarking = false;
+		}
+		return true;
+	}
+
+	[HarmonyPostfix]
+	[HarmonyPatch(typeof(StartTurnAction), nameof(StartTurnAction.Execute))]
+	private static void StartTurnAction_Execute(StartTurnAction __instance, GameState state)
+	{
+		for (int i = state.ActionStack.Count - 1; i >= 0; i--)
+		{
+			if (state.ActionStack[i].GetActionType() == ActionType.CreateResource)
+			{
+				state.ActionStack.RemoveAt(i);
+			}
+		}
+		for (int i = 0; i < state.Map.Tiles.Length; i++)
+		{
+			TileData tileData = state.Map.Tiles[i];
+			if (tileData.owner == __instance.PlayerId && tileData.improvement != null && state.CurrentTurn > 0U)
+			{
+				ImprovementData improvementData;
+				state.GameLogicData.TryGetData(tileData.improvement.type, out improvementData);
+				if (improvementData != null)
+				{
+					if (improvementData.HasAbility(ImprovementAbility.Type.Attract) && tileData.improvement.GetAge(state) % improvementData.growthRate == 0)
+					{
+						ResourceData.Type resourceType = ResourceData.Type.Game;
+						if (attractsResourceOverrides.TryGetValue(tileData.improvement.type, out ResourceData.Type newType))
+						{
+							resourceType = newType;
+						}
+						Polytopia.Data.TerrainData.Type targetTerrain = Polytopia.Data.TerrainData.Type.Forest;
+						if (attractsTerrainOverrides.TryGetValue(tileData.improvement.type, out Polytopia.Data.TerrainData.Type newTerrain))
+						{
+							targetTerrain = newTerrain;
+						}
+						foreach (TileData tileData2 in state.Map.GetArea(tileData.coordinates, 1, true, false))
+						{
+							if (tileData2.owner == __instance.PlayerId && tileData2.improvement == null && tileData2.resource == null && tileData2.terrain == targetTerrain)
+							{
+								state.ActionStack.Add(new CreateResourceAction(__instance.PlayerId, resourceType, tileData2.coordinates, CreateResourceAction.CreateReason.Attract));
+								break;
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
 	internal static void Init()
 	{
 		stopwatch.Start();