Performance optimizations (#3124)

Author: IhateTrains

ImperatorToCK3.UnitTests/CK3/Characters/CharacterCollectionLegionTests.cs

@@ -0,0 +1,30 @@
+using commonItems;
+using commonItems.Localization;
+using AwesomeAssertions;
+using ImperatorToCK3.CK3.Characters;
+using ImperatorToCK3.Imperator;
+using ImperatorToCK3.Imperator.Armies;
+using System.Linq;
+using Xunit;
+
+namespace ImperatorToCK3.UnitTests.CK3.Characters;
+
+public class CharacterCollectionLegionTests {
+	[Fact]
+	public void LegionGroupingIndexesOnlyArmyLegionsByCountry() {
+		var unitCollection = new UnitCollection();
+		var locDB = new LocDB("english");
+		var defines = new ImperatorDefines();
+
+		unitCollection.AddOrReplace(new Unit(1, new BufferedReader("country=1 legion={} is_army=yes"), unitCollection, locDB, defines));
+		unitCollection.AddOrReplace(new Unit(2, new BufferedReader("country=1 is_army=yes"), unitCollection, locDB, defines));
+		unitCollection.AddOrReplace(new Unit(3, new BufferedReader("country=2 legion={} is_army=yes"), unitCollection, locDB, defines));
+		unitCollection.AddOrReplace(new Unit(4, new BufferedReader("country=2 legion={} is_army=no"), unitCollection, locDB, defines));
+
+		var legionsByCountry = CharacterCollection.GetLegionsByCountry(unitCollection);
+
+		legionsByCountry.Keys.Should().BeEquivalentTo(new ulong[] {1, 2});
+		legionsByCountry[1].Select(unit => unit.Id).Should().BeEquivalentTo(new ulong[] {1});
+		legionsByCountry[2].Select(unit => unit.Id).Should().BeEquivalentTo(new ulong[] {3});
+	}
+}

ImperatorToCK3.UnitTests/CK3/Titles/LandedTitlesTests.cs

@@ -30,6 +30,7 @@
 using System;
 using System.Collections.Generic;
 using System.IO;
+using System.Linq;
 using Xunit;
 using ProvinceCollection = ImperatorToCK3.CK3.Provinces.ProvinceCollection;
 
@@ -737,5 +738,28 @@ public void RemoveBreaksAllLinks() {
 		// Check if I:R country - CK3 title link is broken.
 		Assert.Null(country.CK3Title);
 	}
+
+	[Fact]
+	public void SubjectDependencyIndexKeepsFirstMatchAndSplitsCountriesCorrectly() {
+		var dependencies = new List<Dependency> {
+			new(overlordId: 10, subjectId: 2, startDate: new Date(1, 1, 1), subjectType: "tributary"),
+			new(overlordId: 11, subjectId: 2, startDate: new Date(2, 1, 1), subjectType: "vassal"),
+			new(overlordId: 12, subjectId: 4, startDate: new Date(3, 1, 1), subjectType: "client_state")
+		};
+		var countries = new[] {
+			new Country(1),
+			new Country(2),
+			new Country(3),
+			new Country(4)
+		};
+
+		var dependenciesBySubjectId = Title.LandedTitles.GetFirstDependenciesBySubjectId(dependencies);
+		var (independentCountries, subjects) = Title.LandedTitles.SplitRealCountriesBySubjectDependencies(countries, dependenciesBySubjectId);
+
+		dependenciesBySubjectId.Should().HaveCount(2);
+		dependenciesBySubjectId[2].OverlordId.Should().Be(10UL);
+		independentCountries.Select(c => c.Id).Should().Equal([1UL, 3UL]);
+		subjects.Select(c => c.Id).Should().Equal([2UL, 4UL]);
+	}
 }
 

ImperatorToCK3.UnitTests/CK3/WorldLookupTests.cs

@@ -0,0 +1,29 @@
+using AwesomeAssertions;
+using ImperatorToCK3.CK3;
+using ImperatorToCK3.Imperator.Countries;
+using ImperatorToCK3.Imperator.Diplomacy;
+using System.Collections.Generic;
+using Xunit;
+
+namespace ImperatorToCK3.UnitTests.CK3;
+
+public sealed class WorldLookupTests {
+	[Fact]
+	public void FirstValueIndexKeepsFirstCountyLevelEntryPerCountry() {
+		var country1 = new Country(1);
+		var country2 = new Country(2);
+		var firstDependency = new Dependency(10, 1, new commonItems.Date(1, 1, 1), "tributary");
+		var secondDependency = new Dependency(11, 1, new commonItems.Date(2, 1, 1), "vassal");
+		var countyLevelCountries = new List<KeyValuePair<Country, Dependency?>> {
+			new(country1, firstDependency),
+			new(country1, secondDependency),
+			new(country2, null)
+		};
+
+		var indexed = World.GetFirstValuesByKey(countyLevelCountries, entry => entry.Key.Id);
+
+		indexed.Should().HaveCount(2);
+		indexed[1].Value.Should().BeSameAs(firstDependency);
+		indexed[2].Value.Should().BeNull();
+	}
+}

ImperatorToCK3.UnitTests/Imperator/Armies/UnitTests.cs

@@ -55,4 +55,23 @@ public void UnitStrengthIsCorrectlyCalculated() {
 
 		Assert.Equal(750, unit.MenPerUnitType["archers"]); // 250 + 500
 	}
+
+	[Fact]
+	public void MissingCohortsAreIgnoredAndTypesAreGroupedCorrectly() {
+		var subunitsReader = new BufferedReader(@"
+			1 = { strength = 0.5 type=""archers"" }
+			2 = { strength = 1 type=""heavy_infantry"" }
+			3 = { strength = 0.25 type=""archers"" }
+		");
+
+		var unitCollection = new UnitCollection();
+		unitCollection.LoadSubunits(subunitsReader);
+
+		var unitReader = new BufferedReader("cohort=1 cohort=2 cohort=3 cohort=999");
+		var unit = new Unit(1, unitReader, unitCollection, new LocDB("english"), new ImperatorDefines());
+
+		Assert.Equal(375, unit.MenPerUnitType["archers"]);
+		Assert.Equal(500, unit.MenPerUnitType["heavy_infantry"]);
+		Assert.Equal(2, unit.MenPerUnitType.Count);
+	}
 }

ImperatorToCK3.UnitTests/Imperator/Jobs/GovernorshipTests.cs

@@ -5,6 +5,7 @@
 using ImperatorToCK3.Imperator.Countries;
 using ImperatorToCK3.Imperator.Geography;
 using ImperatorToCK3.Imperator.Jobs;
+using ImperatorToCK3.Imperator.Provinces;
 using ImperatorToCK3.Mappers.Region;
 using System;
 using Xunit;
@@ -63,4 +64,28 @@ public void FormatExceptionIsThrownWhenRegionIdIsMissing() {
 		);
 		Assert.Throws<FormatException>(() => new Governorship(reader, countryCollection, irRegionMapper));
 	}
+
+	[Fact]
+	public void ProvinceCountTracksOwnerChangesWithinRegion() {
+		var provinces = new ProvinceCollection {
+			new Province(1),
+			new Province(2),
+			new Province(3)
+		};
+		var areas = new AreaCollection {
+			new Area("test_area", new BufferedReader("provinces={ 1 2 }"), provinces)
+		};
+		var region = new ImperatorRegion("test_region", new BufferedReader("areas={ test_area }"), areas, new ColorFactory());
+		var country = new Country(1);
+		var governorship = new Governorship(country, characterId: 2, startDate: new Date(1, 1, 1), region);
+
+		Assert.Equal(0, governorship.GetIRProvinceCount(provinces));
+
+		provinces[1].OwnerCountry = country;
+		Assert.Equal(1, governorship.GetIRProvinceCount(provinces));
+
+		provinces[2].OwnerCountry = country;
+		provinces[3].OwnerCountry = country;
+		Assert.Equal(2, governorship.GetIRProvinceCount(provinces));
+	}
 }

ImperatorToCK3.UnitTests/Mappers/TagTitle/TagTitleMapperTests.cs

@@ -26,6 +26,7 @@
 using System.Collections.Generic;
 using System.IO;
 using Xunit;
+using CK3Province = ImperatorToCK3.CK3.Provinces.Province;
 
 namespace ImperatorToCK3.UnitTests.Mappers.TagTitle;
 
@@ -367,6 +368,49 @@ public void GetCK3TitleRankReturnsCorrectRank() {
 		Assert.Equal('h', mapper.GetTitleForTag(tag12, "Test Hegemony", maxTitleRank: TitleRank.hegemony, ck3LocDB)![0]);	
 	}
 
+	[Fact]
+	public void BuildCountyByRegionIndexGroupsCountiesByRegion() {
+		// Set up titles: two counties in region_a, one in region_b.
+		var titles = new Title.LandedTitles();
+		titles.LoadTitles(new BufferedReader(
+			"c_county1 = { b_barony1 = { province = 101 } }\n" +
+			"c_county2 = { b_barony2 = { province = 102 } }\n" +
+			"c_county_b = { b_barony3 = { province = 201 } }"),
+			ColorFactory);
+
+		// Set up CK3 provinces mapped to IR provinces.
+		var irProv11 = new ImperatorToCK3.Imperator.Provinces.Province(11);
+		var irProv12 = new ImperatorToCK3.Imperator.Provinces.Province(12);
+		var irProv21 = new ImperatorToCK3.Imperator.Provinces.Province(21);
+		var ck3Provinces = new ProvinceCollection();
+		var ck3Prov101 = new CK3Province(101) { PrimaryImperatorProvince = irProv11 };
+		var ck3Prov102 = new CK3Province(102) { PrimaryImperatorProvince = irProv12 };
+		var ck3Prov201 = new CK3Province(201) { PrimaryImperatorProvince = irProv21 };
+		ck3Provinces.Add(ck3Prov101);
+		ck3Provinces.Add(ck3Prov102);
+		ck3Provinces.Add(ck3Prov201);
+
+		// Set up IR region mapper: region_a has IR provinces 11 and 12; region_b has 21.
+		var irProvinces = new ImperatorToCK3.Imperator.Provinces.ProvinceCollection();
+		var testAreas = new AreaCollection();
+		testAreas.Add(new Area("area_a", new BufferedReader("provinces = { 11 12 }"), irProvinces));
+		testAreas.Add(new Area("area_b", new BufferedReader("provinces = { 21 }"), irProvinces));
+		var testRegionMapper = new ImperatorRegionMapper(testAreas, irMapData);
+		testRegionMapper.Regions.Add(new ImperatorRegion("region_a", new BufferedReader("areas = { area_a }"), testAreas, ColorFactory));
+		testRegionMapper.Regions.Add(new ImperatorRegion("region_b", new BufferedReader("areas = { area_b }"), testAreas, ColorFactory));
+
+		var index = TagTitleMapper.BuildCountyByRegionIndex(titles, ck3Provinces, testRegionMapper);
+
+		Assert.Equal(2, index.Count);
+		Assert.True(index.ContainsKey("region_a"));
+		Assert.True(index.ContainsKey("region_b"));
+		Assert.Equal(2, index["region_a"].Count); // c_county1 and c_county2
+		Assert.Single(index["region_b"]);
+		Assert.Contains(index["region_a"], t => t.Id == "c_county1");
+		Assert.Contains(index["region_a"], t => t.Id == "c_county2");
+		Assert.Equal("c_county_b", index["region_b"][0].Id);
+	}
+
 	[Fact]
 	public void GetTitleForTagPreventsLocKeyHashConflict() {
 		// k_IRTOCK3_ATV_adj and building_nishapur_mines_02 have a conflicting Murmur3A hash.

ImperatorToCK3.UnitTests/Outputter/LocalizationOutputterTests.cs

@@ -0,0 +1,25 @@
+using ImperatorToCK3.Outputter;
+using ImperatorToCK3.UnitTests.TestHelpers;
+using Xunit;
+
+namespace ImperatorToCK3.UnitTests.Outputter;
+
+public class LocalizationOutputterTests {
+	[Fact]
+	public void FallbackLocIsGeneratedOnlyForSecondaryLanguagesMissingPrimaryKeyLoc() {
+		var ck3LocDB = new TestCK3LocDB();
+		ck3LocDB.AddLocForLanguage("key1", "english", "English loc 1");
+		ck3LocDB.AddLocForLanguage("key1", "french", "French loc 1");
+		ck3LocDB.AddLocForLanguage("key2", "english", "English loc 2");
+		ck3LocDB.AddLocForLanguage("key3", "german", "German loc 3");
+
+		var fallbackLocByLanguage = LocalizationOutputter.GetFallbackLocLinesByLanguage(ck3LocDB);
+
+		Assert.DoesNotContain(" key1: \"English loc 1\"", fallbackLocByLanguage["french"]);
+		Assert.Contains(" key1: \"English loc 1\"", fallbackLocByLanguage["german"]);
+		Assert.Contains(" key2: \"English loc 2\"", fallbackLocByLanguage["french"]);
+		Assert.Contains(" key2: \"English loc 2\"", fallbackLocByLanguage["german"]);
+		Assert.DoesNotContain(" key3: \"\"", fallbackLocByLanguage["french"]);
+		Assert.DoesNotContain(" key3: \"\"", fallbackLocByLanguage["german"]);
+	}
+}

ImperatorToCK3/CK3/Characters/Character.cs

@@ -769,7 +769,7 @@ public bool LinkJailor(Date date) {
 	}
 
 	internal void ImportUnitsAsMenAtArms(
-		Unit[] countryUnits,
+		IEnumerable<Unit> countryUnits,
 		Date date,
 		UnitTypeMapper unitTypeMapper,
 		IdObjectCollection<string, MenAtArmsType> menAtArmsTypes,
@@ -806,7 +806,7 @@ CK3LocDB ck3LocDB
 		History.AddFieldValue(date, "effects", "effect", new StringOfItem(sb.ToString()));
 	}
 	internal void ImportUnitsAsSpecialTroops(
-		Unit[] countryUnits,
+		IEnumerable<Unit> countryUnits,
 		Imperator.Characters.CharacterCollection irCharacters,
 		CountryCollection irCountries,
 		Date date,

ImperatorToCK3/CK3/Characters/CharacterCollection.cs

@@ -753,6 +753,7 @@ Configuration config
 		Logger.Info("Importing Imperator armies...");
 
 		var ck3CountriesFromImperator = titles.GetCountriesImportedFromImperator();
+		var legionsByCountry = GetLegionsByCountry(imperatorUnits);
 		foreach (var ck3Country in ck3CountriesFromImperator) {
 			var rulerId = ck3Country.GetHolderId(date);
 			if (rulerId == "0") {
@@ -761,8 +762,7 @@ Configuration config
 			}
 
 			var imperatorCountry = ck3Country.ImperatorCountry!;
-			var countryLegions = imperatorUnits.Where(u => u.CountryId == imperatorCountry.Id && u.IsArmy && u.IsLegion).ToArray();
-			if (countryLegions.Length == 0) {
+			if (!legionsByCountry.TryGetValue(imperatorCountry.Id, out var countryLegions)) {
 				continue;
 			}
 
@@ -778,6 +778,23 @@ Configuration config
 		Logger.IncrementProgress();
 	}
 
+	internal static Dictionary<ulong, List<Unit>> GetLegionsByCountry(UnitCollection imperatorUnits) {
+		var legionsByCountry = new Dictionary<ulong, List<Unit>>();
+		foreach (var unit in imperatorUnits) {
+			if (!unit.IsArmy || !unit.IsLegion) {
+				continue;
+			}
+
+			if (!legionsByCountry.TryGetValue(unit.CountryId, out var countryLegions)) {
+				countryLegions = [];
+				legionsByCountry[unit.CountryId] = countryLegions;
+			}
+			countryLegions.Add(unit);
+		}
+
+		return legionsByCountry;
+	}
+
 	internal void GenerateSuccessorsForOldCharacters(Title.LandedTitles titles, CultureCollection cultures, Date irSaveDate, Date ck3BookmarkDate, ulong randomSeed) {
 		Logger.Info("Generating successors for old characters...");
 

ImperatorToCK3/CK3/Religions/ReligionCollection.cs

@@ -535,30 +535,35 @@ Date date
 
 	private List<Title> GetDynamicHolySiteBaroniesForFaith(Faith faith, Dictionary<string, HashSet<Province>> provincesByFaith) {
 		// Collect all Imperator territories that are mapped to this faith.
-		HashSet<Province> faithTerritories;
-		if (provincesByFaith.TryGetValue(faith.Id, out var set)) {
-			faithTerritories = set;
-		} else {
-			faithTerritories = [];
+		if (!provincesByFaith.TryGetValue(faith.Id, out var faithTerritories)) {
+			return [];
 		}
 
-		// Split the territories into 2 sets: territories that have a holy site and territories that do not.
-		// Order both sets in descending order by population.
-		var provincesWithHolySite = faithTerritories
-			.Where(p => p.ImperatorProvinces.Any(irProv => irProv.IsHolySite))
-			.OrderByDescending(p => p.PrimaryImperatorProvince!.GetPopCount())
-			.ToArray();
-		var provincesWithoutHolySite = faithTerritories.Except(provincesWithHolySite)
-			.OrderByDescending(p => p.PrimaryImperatorProvince!.GetPopCount())
-			.ToArray();
+		// Single-pass partition: split territories into holy-site and non-holy-site lists.
+		List<Province> withHolySite = [];
+		Province? bestWithout = null;
+		int bestWithoutPop = -1;
+		foreach (var p in faithTerritories) {
+			if (p.ImperatorProvinces.Any(irProv => irProv.IsHolySite)) {
+				withHolySite.Add(p);
+			} else {
+				var pop = p.PrimaryImperatorProvince!.GetPopCount();
+				if (pop > bestWithoutPop) {
+					bestWithoutPop = pop;
+					bestWithout = p;
+				}
+			}
+		}
 
-		// Take the top 4 territories with a holy site.
-		var selectedDynamicSites = provincesWithHolySite.Take(4).ToList();
+		// Take the top 4 territories with a holy site (sort only the holy-site subset).
+		var selectedDynamicSites = withHolySite
+			.OrderByDescending(p => p.PrimaryImperatorProvince!.GetPopCount())
+			.Take(4)
+			.ToList();
 
 		// Take the most populated territory without a holy site.
-		var mostPopulatedProvinceWithoutHolySite = provincesWithoutHolySite.FirstOrDefault(defaultValue: null);
-		if (mostPopulatedProvinceWithoutHolySite is not null) {
-			selectedDynamicSites.Add(mostPopulatedProvinceWithoutHolySite);
+		if (bestWithout is not null) {
+			selectedDynamicSites.Add(bestWithout);
 		}
 
 		return selectedDynamicSites