Implement most of the difficulty factors

 - AI players now get cheaper production on higher difficulties
 - AI players get extra units on turn 1
 - AI players get extra unit support

I also fixed a bug where the combat AI wouldn't pursue empty barbarian camps (no enemy players, no enemy cities). This was causing the extra units to just sit in the starting city.

Author: TomWerner

C7/UIElements/NewGame/PlayerSetup.cs

@@ -272,6 +272,8 @@ private void DoWorldGenerationAndstartGame(SaveGame save, GlobalSingleton Global
 					  isHuman: false);
 		}
 
+		save.GameDifficulty = difficulty;
+
 		log.Information("saving generated map");
 		save.Save(Global.DefaultGeneratedGamePath);
 		Global.LoadGamePath = Global.DefaultGeneratedGamePath;

C7Engine/AI/PlayerAI.cs

@@ -156,7 +156,6 @@ public static UnitAI GetAIForUnit(MapUnit unit, Player player) {
 			} else if (unit.location.cityAtTile != null && unit.CanDefendOnLand() && unit.location.unitsOnTile.Count(u => u.CanDefendOnLand() && u != unit) == 0) {
 				return new DefenderAI(DefenderAI.MakeAiDataForDefendInPlace(unit, player));
 			} else if (GetCombatAIIfUnitCanAttackNearbyBarbCamp(unit, player) is UnitAI unitAI && unitAI != null) {
-				log.Information("Set unit " + unit + " to take out barb camp");
 				return unitAI;
 			} else if (unit.unitType.name == "Catapult") {
 				//For now tell catapults to sit tight.  It's getting really annoying watching them pointlessly bombard barb camps forever
@@ -262,6 +261,7 @@ private static UnitAI GetCombatAIIfUnitCanAttackNearbyBarbCamp(MapUnit unit, Pla
 
 				PathingAlgorithm algorithm = PathingAlgorithmChooser.GetAlgorithm(unit);
 				caid.path = algorithm.PathFrom(unit.location, closestBarbCamp);
+				log.Information($"Set unit {unit} to take out barb camp at {closestBarbCamp}");
 				return new CombatAI(caid);
 			}
 			return null;

C7Engine/AI/UnitAI/CombatAI.cs

@@ -51,8 +51,9 @@ public C7GameData.UnitAI.Result PlayTurnImpl(Player player, MapUnit unit) {
 				&& !dest.unitsOnTile[0].owner.IsAtPeaceWith(unit.owner);
 			bool destinationHasEnemyCity = dest.cityAtTile != null
 				&& !data.destination.cityAtTile.owner.IsAtPeaceWith(unit.owner);
+			bool destinationHasBarbCamp = dest.hasBarbarianCamp;
 
-			if (!destinationHasEnemyCity && !destinationHasEnemyUnits) {
+			if (!destinationHasEnemyCity && !destinationHasEnemyUnits && !destinationHasBarbCamp) {
 				return C7GameData.UnitAI.Result.Done;
 			}
 
@@ -63,8 +64,9 @@ public C7GameData.UnitAI.Result PlayTurnImpl(Player player, MapUnit unit) {
 				foreach (Tile t in unit.location.neighbors.Values) {
 					bool nextToEnemyCity = t.cityAtTile != null && !t.cityAtTile.owner.IsAtPeaceWith(unit.owner);
 					bool nextToEnemyUnit = t.unitsOnTile.Count > 0 && !t.unitsOnTile[0].owner.IsAtPeaceWith(unit.owner);
+					bool nextToBarbCamp = t.hasBarbarianCamp;
 
-					if (!nextToEnemyCity && !nextToEnemyUnit) {
+					if (!nextToEnemyCity && !nextToEnemyUnit && !nextToBarbCamp) {
 						continue;
 					}
 

C7Engine/C7GameData/Building.cs

@@ -228,13 +228,13 @@ public bool CanProduce(City city, HashSet<Resource> accessibleResources) {
 			return true;
 		}
 
-		public int ShieldCost(HashSet<Civilization.Trait> civTraits) {
+		public int ShieldCost(HashSet<Civilization.Trait> civTraits, float costFactor) {
 			foreach (Civilization.Trait trait in dataSource.traits) {
 				if (civTraits.Contains(trait)) {
-					return (int)(shieldCost * EngineStorage.gameData.rules.BuildingDiscountForCivTraits);
+					return (int)(shieldCost * EngineStorage.gameData.rules.BuildingDiscountForCivTraits * costFactor);
 				}
 			}
-			return shieldCost;
+			return (int)(shieldCost * costFactor);
 		}
 
 		public bool isGreatWonderObsolete(Player owner) {

C7Engine/C7GameData/IProducible.cs

@@ -11,7 +11,7 @@ public interface IProducible {
 		Tech requiredTech { get; set; }
 		HashSet<Resource> requiredResources { get; set; }
 
-		int ShieldCost(HashSet<Civilization.Trait> civTraits);
+		int ShieldCost(HashSet<Civilization.Trait> civTraits, float costFactor);
 
 		bool CanProduce(City city, HashSet<Resource> accessibleResources);
 	}

C7Engine/C7GameData/ImportCiv3.cs

@@ -1312,9 +1312,15 @@ private void ImportRules() {
 			save.Rules.CitizenValueInShields = rule.CitizenValueInShields;
 			save.Rules.TurnPenaltyForEachHurrySacrifice = rule.TurnPenaltyForEachHurrySacrifice;
 			save.GameDifficulty = save.Difficulties[rule.DefaultDifficultyLevel];
-			save.Rules.StartUnitType1 = theBiq.Prto[rule.StartUnitType1].Name;
-			save.Rules.StartUnitType2 = theBiq.Prto[rule.StartUnitType2].Name;
-			save.Rules.ScoutUnitType = theBiq.Prto[rule.Scout].Name;
+			if (rule.StartUnitType1 >= 0) {
+				save.Rules.StartUnitType1 = theBiq.Prto[rule.StartUnitType1].Name;
+			}
+			if (rule.StartUnitType2 >= 0) {
+				save.Rules.StartUnitType2 = theBiq.Prto[rule.StartUnitType2].Name;
+			}
+			if (rule.Scout >= 0) {
+				save.Rules.ScoutUnitType = theBiq.Prto[rule.Scout].Name;
+			}
 		}
 
 		private static void SetWorldWrap(SavData civ3Save, SaveGame save) {

C7Engine/C7GameData/Player.cs

@@ -459,7 +459,9 @@ public int GetAdjustedOptimalCityNumber(GameData gameData) {
 		//    civilizations, the formula is: 1 (2 for Conquests) + random number
 		//    between 1-4 + number between 0-3 depending on size of your empire.
 		public int GetTurnsOfAnarchyForTransition(GameData gameData) {
-			// TODO: if religious, return 2.
+			if (civilization.traits.Contains(Civilization.Trait.Religious)) {
+				return 2;
+			}
 
 			// We add Next(3)+Next(3) to roughly approximate a normal 
 			// distribution. With the base of 2, this gets us a random value 
@@ -617,12 +619,19 @@ private bool CanAdvanceToNextEra(GameData gameData) {
 		public (int, int, int) TotalUnitsAllowedUnitsAndSupportCost() {
 			int freeUnits = 0;
 
+			Difficulty difficulty = EngineStorage.gameData.gameDifficulty;
+			if (!isHuman) {
+				freeUnits += difficulty.AdditionalFreeUnitSupport;
+			}
+
 			foreach (City city in cities) {
-				// TODO: Import these sizes from Rule.cs in the biq. Maybe have
-				// them live in the city class?
-				if (city.residents.Count <= 6) {
+				if (!isHuman) {
+					freeUnits += difficulty.UnitSupportBonusForEachSettlement;
+				}
+
+				if (city.residents.Count <= rules.MaximumLevel1CitySize) {
 					freeUnits += government.freeUnitsPerTown;
-				} else if (city.residents.Count <= 12) {
+				} else if (city.residents.Count <= rules.MaximumLevel2CitySize) {
 					freeUnits += government.freeUnitsPerCity;
 				} else {
 					freeUnits += government.freeUnitsPerMetropolis;
@@ -745,6 +754,43 @@ public List<Tuple<City, CityBuilding>> GetActiveWonders() {
 			return result;
 		}
 
+		public void MaybeSpawnBonusUnits(GameData gD) {
+			// Bonus units only spawn on the first turn, if we have a city and
+			// are a non-barbarian AI player.
+			if (gD.turn != 1 || cities.Count != 1 || isHuman || isBarbarians) {
+				return;
+			}
+
+			for (int i = 0; i < gD.gameDifficulty.ExtraStartUnit1; ++i) {
+				cities[0].AddUnit(gD.unitPrototypes.Find(x => x.name == gD.rules.StartUnitType1), gD);
+			}
+			for (int i = 0; i < gD.gameDifficulty.ExtraStartUnit2; ++i) {
+				cities[0].AddUnit(gD.unitPrototypes.Find(x => x.name == gD.rules.StartUnitType2), gD);
+			}
+			for (int i = 0; i < gD.gameDifficulty.NumberOfAIDefensiveStartingUnits; ++i) {
+				UnitPrototype unit = (UnitPrototype)cities[0].ListProductionOptions(gD).MaxBy(
+					x => {
+						if (x is UnitPrototype u) {
+							return u.defense;
+						}
+						return -1;
+					}
+				);
+				cities[0].AddUnit(unit, gD);
+			}
+			for (int i = 0; i < gD.gameDifficulty.NumberOfAIOffensiveStartingUnits; ++i) {
+				UnitPrototype unit = (UnitPrototype)cities[0].ListProductionOptions(gD).MaxBy(
+					x => {
+						if (x is UnitPrototype u) {
+							return u.attack;
+						}
+						return -1;
+					}
+				);
+				cities[0].AddUnit(unit, gD);
+			}
+		}
+
 		public void UpdateResourcesInBorders(IEnumerable<Tile> ownedTiles) {
 			resourcesInBorders = ownedTiles
 								.Where(t => t.Resource != Resource.NONE)
@@ -758,7 +804,11 @@ public bool HasRequiredTechnology(IProducible producible) {
 		}
 
 		public int ShieldCost(IProducible producible) {
-			return producible.ShieldCost(civilization.traits);
+			// At higher difficulties, AI players get a cost discount.
+			Difficulty difficulty = EngineStorage.gameData.gameDifficulty;
+			float costFactor = isHuman ? 1.0f : difficulty.AiCostFactor / (float)(difficulty.HumanCostFactor);
+
+			return producible.ShieldCost(civilization.traits, costFactor);
 		}
 	}
 

C7Engine/C7GameData/Terraform.cs

@@ -55,6 +55,10 @@ public Terraform(SaveTerraform saveTerraform, GameData gameData) {
 		SetRules();
 	}
 
+	public string ToString() {
+		return Name;
+	}
+
 	private void SetRules() {
 		if (TerraformRules.ActionEffects.TryGetValue(Action, out var onComplete)) {
 			OnComplete = onComplete;

C7Engine/C7GameData/Tile.cs

@@ -220,7 +220,7 @@ public bool IsWater() {
 		}
 
 		public bool IsAllowCities() {
-			return overlayTerrainType.allowCities;
+			return overlayTerrainType.allowCities && !hasBarbarianCamp;
 		}
 
 		public bool IsVolcano() {

C7Engine/C7GameData/UnitPrototype.cs

@@ -104,8 +104,8 @@ public bool CanProduce(City city, HashSet<Resource> accessibleResources) {
 			return MeetsProductionRequirements(city, accessibleResources) && !IsUnitObsolete(city, accessibleResources);
 		}
 
-		public int ShieldCost(HashSet<Civilization.Trait> civTraits) {
-			return shieldCost;
+		public int ShieldCost(HashSet<Civilization.Trait> civTraits, float costFactor) {
+			return (int)(shieldCost * costFactor);
 		}
 
 		// TODO: Consider golden ages when determining whether a unit is obsolete.