3982596437

Build Type

github

Committed by GitHub

Commit Message

<a href="https://github.com/ParadoxGameConverters/ImperatorToCK3/commit/<a class=hub.com/ParadoxGameConverters/ImperatorToCK3/commit/07b1a5ef17597c9c5a07f909aaf3e4970318cf68">07b1a5ef1<a href="https://github.com/ParadoxGameConverters/ImperatorToCK3/commit/07b1a5ef17597c9c5a07f909aaf3e4970318cf68">">Merge </a><a class="double-link" href="https://github.com/ParadoxGameConverters/ImperatorToCK3/commit/<a class="double-link" href="https://github.com/ParadoxGameConverters/ImperatorToCK3/commit/15defdfd4646e3e8e625f662f1a79416c0f22cb6">15defdfd4</a>">15defdfd4</a><a href="https://github.com/ParadoxGameConverters/ImperatorToCK3/commit/07b1a5ef17597c9c5a07f909aaf3e4970318cf68"> into c42948fef">c42948fef</a>

Pull Request Pull Request #1196: Spelling Fixes

Run Details

1389 of 2537 branches covered (54.75%)

Branch coverage included in aggregate %.

13 of 13 new or added lines in 9 files covered. (100.0%)

5279 of 8243 relevant lines covered (64.04%)

482.82 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

6.86

/ImperatorToCK3/Imperator/World.cs

using commonItems;
using commonItems.Colors;
using commonItems.Localization;
using commonItems.Mods;
using ImperatorToCK3.CommonUtils;
using ImperatorToCK3.Imperator.Diplomacy;
using ImperatorToCK3.Imperator.Armies;
using ImperatorToCK3.Imperator.Characters;
using ImperatorToCK3.Imperator.Countries;
using ImperatorToCK3.Imperator.Cultures;
using ImperatorToCK3.Imperator.Families;
using ImperatorToCK3.Imperator.Genes;
using ImperatorToCK3.Imperator.Geography;
using ImperatorToCK3.Imperator.Pops;
using ImperatorToCK3.Imperator.Provinces;
using ImperatorToCK3.Imperator.Religions;
using ImperatorToCK3.Imperator.States;
using System;
using System.Collections.Generic;
using System.Collections.Immutable;
using System.IO;
using System.Linq;
using Mods = System.Collections.Generic.List<commonItems.Mods.Mod>;
using Parser = commonItems.Parser;

namespace ImperatorToCK3.Imperator;

public class World : Parser {
        private readonly Date startDate = new("450.10.1", AUC: true);
        public Date EndDate { get; private set; } = new Date("727.2.17", AUC: true);
        public ModFilesystem ModFS { get; private set; }
        private readonly SortedSet<string> dlcs = new();
        public IReadOnlySet<string> GlobalFlags { get; private set; } = ImmutableHashSet<string>.Empty;
        private readonly ScriptValueCollection scriptValues = new();
        public Defines Defines { get; } = new();
        public LocDB LocDB { get; } = new("english", "french", "german", "korean", "russian", "simp_chinese", "spanish");

        public NamedColorCollection NamedColors { get; } = new();
        public FamilyCollection Families { get; private set; } = new();
        public CharacterCollection Characters { get; private set; } = new();
        private PopCollection pops = new();
        public ProvinceCollection Provinces { get; private set; } = new();
        public CountryCollection Countries { get; private set; } = new();
        public AreaCollection Areas { get; } = new();
        public StateCollection States { get; } = new();
        public List<War> Wars { get; private set; } = new();
        public Jobs.Jobs Jobs { get; private set; } = new();
        public UnitCollection Units { get; private set; } = new();
        public CulturesDB CulturesDB { get; } = new();
        public ReligionCollection Religions { get; private set; }
        private GenesDB genesDB = new();

        private enum SaveType { Invalid, Plaintext, CompressedEncoded }
        private SaveType saveType = SaveType.Invalid;

        public World(Configuration config) {
                ModFS = new ModFilesystem(Path.Combine(config.ImperatorPath, "game"), new Mod[] { });
                Religions = new ReligionCollection(new ScriptValueCollection());
        }
        public World(Configuration config, ConverterVersion converterVersion): this(config) {
                Logger.Info("*** Hello Imperator, Roma Invicta! ***");

                var imperatorRoot = Path.Combine(config.ImperatorPath, "game");

                // Parse the save.
                RegisterRegex(@"\bSAV\w*\b", _ => { });
                RegisterKeyword("version", reader => {
                        var imperatorVersion = new GameVersion(reader.GetString());
                        Logger.Info($"Save game version: {imperatorVersion}");

                        if (converterVersion.MinSource > imperatorVersion) {
                                Logger.Error(
                                        $"Converter requires a minimum save from v{converterVersion.MinSource.ToShortString()}");
                                throw new FormatException("Save game vs converter version mismatch!");
                        }
                        if (!converterVersion.MaxSource.IsLargerishThan(imperatorVersion)) {
                                Logger.Error(
                                        $"Converter requires a maximum save from v{converterVersion.MaxSource.ToShortString()}");
                                throw new FormatException("Save game vs converter version mismatch!");
                        }
                });
                RegisterKeyword("date", reader => {
                        var dateString = reader.GetString();
                        EndDate = new Date(dateString, AUC: true);  // converted to AD
                        Logger.Info($"Date: {dateString} AUC ({EndDate} AD)");

                        if (EndDate > config.CK3BookmarkDate) {
                                config.CK3BookmarkDate = new Date(EndDate);
                                Logger.Warn($"CK3 bookmark date can't be earlier than save date. Changed to {config.CK3BookmarkDate}.");
                        }
                });
                RegisterKeyword("enabled_dlcs", reader => {
                        dlcs.UnionWith(reader.GetStrings());
                        foreach (var dlc in dlcs) {
                                Logger.Info($"Enabled DLC: {dlc}");
                        }
                        Logger.IncrementProgress();
                });
                RegisterKeyword("enabled_mods", reader => {
                        Logger.Info("Detecting used mods...");
                        var modsList = reader.GetStrings();
                        Logger.Info($"Save game claims {modsList.Count} mods used:");
                        Mods incomingMods = new();
                        foreach (var modPath in modsList) {
                                Logger.Info($"Used mod: {modPath}");
                                incomingMods.Add(new Mod(string.Empty, modPath));
                        }
                        Logger.IncrementProgress();

                        // Let's locate, verify and potentially update those mods immediately.
                        ModLoader modLoader = new();
                        modLoader.LoadMods(config.ImperatorDocPath, incomingMods);
                        ModFS = new ModFilesystem(imperatorRoot, modLoader.UsableMods);

                        // Now that we have the list of mods used, we can load data from Imperator mod filesystem
                        LoadModFilesystemDependentData();
                });
                RegisterKeyword("variables", reader => {
                        Logger.Info("Reading global variables...");

                        var variables = new HashSet<string>();
                        var variablesParser = new Parser();
                        variablesParser.RegisterKeyword("data", dataReader => {
                                var blobParser = new Parser();
                                blobParser.RegisterKeyword("flag", blobReader => variables.Add(blobReader.GetString()));
                                blobParser.IgnoreUnregisteredItems();
                                foreach (var blob in new BlobList(dataReader).Blobs) {
                                        var blobReader = new BufferedReader(blob);
                                        blobParser.ParseStream(blobReader);
                                }
                        });
                        variablesParser.IgnoreAndLogUnregisteredItems();
                        variablesParser.ParseStream(reader);
                        GlobalFlags = variables.ToImmutableHashSet();

                        Logger.IncrementProgress();
                });
                RegisterKeyword("family", reader => {
                        Logger.Info("Loading families...");
                        Families.LoadFamiliesFromBloc(reader);
                        Logger.Info($"Loaded {Families.Count} families.");
                        Logger.IncrementProgress();
                });
                RegisterKeyword("character", reader => {
                        Logger.Info("Loading characters...");
                        Characters.GenesDB = genesDB;
                        Characters.LoadCharactersFromBloc(reader);
                        Logger.Info($"Loaded {Characters.Count} characters.");
                        Logger.IncrementProgress();
                });
                RegisterKeyword("state", reader => {
                        Logger.Info("Loading states...");
                        var statesBlocParser = new Parser();
                        statesBlocParser.RegisterKeyword("state_database", statesReader => States.LoadStates(statesReader, Areas, Countries));
                        statesBlocParser.IgnoreAndLogUnregisteredItems();
                        statesBlocParser.ParseStream(reader);
                        Logger.Debug($"Ignored state keywords: {State.IgnoredKeywords}");
                        Logger.Info($"Loaded {States.Count} states.");
                        Logger.IncrementProgress();
                });
                RegisterKeyword("provinces", reader => {
                        Logger.Info("Loading provinces...");
                        Provinces.LoadProvinces(reader, States, Countries);
                        Logger.Debug($"Ignored Province tokens: {Province.IgnoredTokens}");
                        Logger.Info($"Loaded {Provinces.Count} provinces.");

                        Logger.IncrementProgress();
                });
                RegisterKeyword("armies", reader => {
                        Logger.Info("Loading armies...");
                        var armiesParser = new Parser();
                        armiesParser.RegisterKeyword("subunit_database", subunitsReader => Units.LoadSubunits(subunitsReader));
                        armiesParser.RegisterKeyword("units_database", unitsReader => Units.LoadUnits(unitsReader, LocDB, Defines));

                        armiesParser.ParseStream(reader);
                });
                RegisterKeyword("country", reader => {
                        Logger.Info("Loading countries...");
                        Countries.LoadCountriesFromBloc(reader);
                        Logger.Info($"Loaded {Countries.Count} countries.");
                        Logger.IncrementProgress();
                });
                RegisterKeyword("population", reader => {
                        Logger.Info("Loading pops...");
                        pops.LoadPopsFromBloc(reader);
                        Logger.Info($"Loaded {pops.Count} pops.");
                        Logger.IncrementProgress();
                });
                RegisterKeyword("diplomacy", reader => {
                        Logger.Info("Loading diplomacy...");
                        var diplomacy = new Diplomacy.Diplomacy(reader);
                        Wars = diplomacy.Wars;
                        Logger.IncrementProgress();
                });
                RegisterKeyword("jobs", reader => {
                        Logger.Info("Loading Jobs...");
                        Jobs = new Jobs.Jobs(reader);
                        Logger.Info($"Loaded {Jobs.Governorships.Capacity} governorships.");
                        Logger.IncrementProgress();
                });
                RegisterKeyword("deity_manager", reader => {
                        Religions.LoadHolySiteDatabase(reader);
                });
                var playerCountriesToLog = new List<string>();
                RegisterKeyword("played_country", reader => {
                        var playedCountryBlocParser = new Parser();
                        playedCountryBlocParser.RegisterKeyword("country", reader => {
                                var countryId = reader.GetULong();
                                var country = Countries[countryId];
                                country.PlayerCountry = true;
                                playerCountriesToLog.Add(country.Tag);
                        });
                        playedCountryBlocParser.IgnoreUnregisteredItems();
                        playedCountryBlocParser.ParseStream(reader);
                });
                this.IgnoreAndStoreUnregisteredItems(ignoredTokens);

                Logger.Info("Verifying Imperator save...");
                VerifySave(config.SaveGamePath);
                Logger.IncrementProgress();

                ParseStream(ProcessSave(config.SaveGamePath));
                ClearRegisteredRules();
                Logger.Debug($"Ignored World tokens: {ignoredTokens}");
                Logger.Info($"Player countries: {string.Join(", ", playerCountriesToLog)}");
                Logger.IncrementProgress();

                Logger.Info("*** Building World ***");

                // Link all the intertwining references
                Logger.Info("Linking Characters with Families...");
                Characters.LinkFamilies(Families);
                Families.RemoveUnlinkedMembers(Characters);
                Families.MergeDividedFamilies(Characters);
                Logger.Info("Linking Characters with Countries...");
                Characters.LinkCountries(Countries);
                Logger.Info("Linking Provinces with Pops...");
                Provinces.LinkPops(pops);
                Logger.Info("Linking Countries with Families...");
                Countries.LinkFamilies(Families);

                LoadPreImperatorRulers();

                Logger.Info("*** Good-bye Imperator, rest in peace. ***");
        }
        private void ParseGenes() {
                var genesFileLocation = ModFS.GetActualFileLocation("common/genes/00_genes.txt");
                if (genesFileLocation is null) {
                        Logger.Warn("I:R genes file not found!");
                } else {
                        genesDB = new GenesDB(genesFileLocation);
                }
        }
        private void LoadPreImperatorRulers() {
                const string filePath = "configurables/characters_prehistory.txt";
                const string noRulerWarning = "Pre-Imperator ruler term has no pre-Imperator ruler!";
                const string noCountryIdWarning = "Pre-Imperator ruler term has no country ID!";

                var preImperatorRulerTerms = new Dictionary<ulong, List<RulerTerm>>(); // <country id, list of terms>
                var parser = new Parser();
                parser.RegisterKeyword("ruler", reader => {
                        var rulerTerm = new RulerTerm(reader, Countries);
                        if (rulerTerm.PreImperatorRuler is null) {
                                Logger.Warn(noRulerWarning);
                                return;
                        }
                        if (rulerTerm.PreImperatorRuler.Country is null) {
                                Logger.Warn(noCountryIdWarning);
                                return;
                        }
                        var countryId = rulerTerm.PreImperatorRuler.Country.Id;
                        Countries[countryId].RulerTerms.Add(rulerTerm);
                        if (preImperatorRulerTerms.TryGetValue(countryId, out var list)) {
                                list.Add(rulerTerm);
                        } else {
                                preImperatorRulerTerms[countryId] = new List<RulerTerm> { rulerTerm };
                        }
                });
                parser.RegisterRegex(CommonRegexes.Catchall, ParserHelpers.IgnoreAndLogItem);
                parser.ParseFile(filePath);

                foreach (var country in Countries) {
                        country.RulerTerms = country.RulerTerms.OrderBy(t => t.StartDate).ToList();
                }

                // verify with data from historical_regnal_numbers
                var regnalNameCounts = new Dictionary<ulong, Dictionary<string, int>>(); // <country id, <name, count>>
                foreach (var country in Countries) {
                        if (!preImperatorRulerTerms.ContainsKey(country.Id)) {
                                continue;
                        }

                        regnalNameCounts.Add(country.Id, new());
                        var countryRulerTerms = regnalNameCounts[country.Id];

                        foreach (var term in preImperatorRulerTerms[country.Id]) {
                                if (term.PreImperatorRuler is null) {
                                        Logger.Warn(noRulerWarning);
                                        continue;
                                }
                                var name = term.PreImperatorRuler.Name;
                                if (name is null) {
                                        Logger.Warn("Pre-Imperator ruler has no country name!");
                                        continue;
                                }
                                if (countryRulerTerms.ContainsKey(name)) {
                                        ++countryRulerTerms[name];
                                } else {
                                        countryRulerTerms[name] = 1;
                                }
                        }
                }
                foreach (var country in Countries) {
                        bool equal;
                        if (!regnalNameCounts.ContainsKey(country.Id)) {
                                equal = country.HistoricalRegnalNumbers.Count == 0;
                        } else {
                                equal = country.HistoricalRegnalNumbers.OrderBy(kvp => kvp.Key)
                                        .SequenceEqual(regnalNameCounts[country.Id].OrderBy(kvp => kvp.Key)
                                        );
                        }

                        if (!equal) {
                                Logger.Debug($"List of pre-Imperator rulers of {country.Tag} doesn't match data from save!");
                        }
                }
        }

        private void LoadModFilesystemDependentData() {
                scriptValues.LoadScriptValues(ModFS);
                Logger.IncrementProgress();

                Defines.LoadDefines(ModFS);

                Logger.Info("Loading named colors...");
                NamedColors.LoadNamedColors("common/named_colors", ModFS);
                Logger.IncrementProgress();

                ParseGenes();

                Areas.LoadAreas(ModFS, Provinces);
                Country.LoadGovernments(ModFS);

                CulturesDB.Load(ModFS);

                Religions = new ReligionCollection(scriptValues);
                Religions.LoadDeities(ModFS);
                Religions.LoadReligions(ModFS);

                LocDB.ScrapeLocalizations(ModFS);
                Logger.IncrementProgress();
        }

        private BufferedReader ProcessSave(string saveGamePath) {
                switch (saveType) {
                        case SaveType.Plaintext:
                                Logger.Info("Importing debug_mode Imperator save.");
                                return ProcessDebugModeSave(saveGamePath);
                        case SaveType.CompressedEncoded:
                                Logger.Info("Importing regular Imperator save.");
                                return ProcessCompressedEncodedSave(saveGamePath);
                        case SaveType.Invalid:
                        default:
                                throw new InvalidDataException("Unknown save type.");
                }
        }
        private void VerifySave(string saveGamePath) {
                using var saveStream = File.Open(saveGamePath, FileMode.Open);
                var buffer = new byte[10];
                var bytesRead = saveStream.Read(buffer, 0, 4);
                if (bytesRead < 4) {
                        throw new InvalidDataException("Failed to read 4 bytes from save.");
                }
                if (buffer[0] != 'S' || buffer[1] != 'A' || buffer[2] != 'V') {
                        throw new InvalidDataException("Save game of unknown type!");
                }

                char ch;
                do { // skip until newline
                        ch = (char)saveStream.ReadByte();
                } while (ch != '\n' && ch != '\r');

                var length = saveStream.Length;
                if (length < 65536) {
                        throw new InvalidDataException("Save game seems a bit too small.");
                }

                saveStream.Position = 0;
                var bigBuf = new byte[65536];
                var bytesReadCount = saveStream.Read(bigBuf);
                if (bytesReadCount < 65536) {
                        throw new InvalidDataException($"Read only {bytesReadCount}bytes.");
                }
                saveType = SaveType.Plaintext;
                for (var i = 0; i < 65533; ++i) {
                        if (BitConverter.ToUInt32(bigBuf, i) == 0x04034B50 && BitConverter.ToUInt16(bigBuf, i - 2) == 4) {
                                saveType = SaveType.CompressedEncoded;
                        }
                }
        }
        private static BufferedReader ProcessDebugModeSave(string saveGamePath) {
                return new BufferedReader(File.Open(saveGamePath, FileMode.Open));
        }
        private static BufferedReader ProcessCompressedEncodedSave(string saveGamePath) {
                Helpers.RakalyCaller.MeltSave(saveGamePath);
                return new BufferedReader(File.Open("temp/melted_save.rome", FileMode.Open));
        }

        private readonly IgnoredKeywordsSet ignoredTokens = new();
}

1	using commonItems;
2	using commonItems.Colors;
3	using commonItems.Localization;
4	using commonItems.Mods;
5	using ImperatorToCK3.CommonUtils;
6	using ImperatorToCK3.Imperator.Diplomacy;
7	using ImperatorToCK3.Imperator.Armies;
8	using ImperatorToCK3.Imperator.Characters;
9	using ImperatorToCK3.Imperator.Countries;
10	using ImperatorToCK3.Imperator.Cultures;
11	using ImperatorToCK3.Imperator.Families;
12	using ImperatorToCK3.Imperator.Genes;
13	using ImperatorToCK3.Imperator.Geography;
14	using ImperatorToCK3.Imperator.Pops;
15	using ImperatorToCK3.Imperator.Provinces;
16	using ImperatorToCK3.Imperator.Religions;
17	using ImperatorToCK3.Imperator.States;
18	using System;
19	using System.Collections.Generic;
20	using System.Collections.Immutable;
21	using System.IO;
22	using System.Linq;
23	using Mods = System.Collections.Generic.List<commonItems.Mods.Mod>;
24	using Parser = commonItems.Parser;
25
26	namespace ImperatorToCK3.Imperator;
27
28	public class World : Parser {
29	private readonly Date startDate = new("450.10.1", AUC: true);	8✔
30	public Date EndDate { get; private set; } = new Date("727.2.17", AUC: true);	8✔
31	public ModFilesystem ModFS { get; private set; }	12✔
32	private readonly SortedSet<string> dlcs = new();	8✔
33	public IReadOnlySet<string> GlobalFlags { get; private set; } = ImmutableHashSet<string>.Empty;	8✔
34	private readonly ScriptValueCollection scriptValues = new();	8✔
35	public Defines Defines { get; } = new();	8✔
36	public LocDB LocDB { get; } = new("english", "french", "german", "korean", "russian", "simp_chinese", "spanish");	8✔
37
38	public NamedColorCollection NamedColors { get; } = new();	8✔
39	public FamilyCollection Families { get; private set; } = new();	8✔
40	public CharacterCollection Characters { get; private set; } = new();	35✔
41	private PopCollection pops = new();	8✔
42	public ProvinceCollection Provinces { get; private set; } = new();	53✔
43	public CountryCollection Countries { get; private set; } = new();	15✔
44	public AreaCollection Areas { get; } = new();	10✔
45	public StateCollection States { get; } = new();	8✔
46	public List<War> Wars { get; private set; } = new();	8✔
47	public Jobs.Jobs Jobs { get; private set; } = new();	13✔
48	public UnitCollection Units { get; private set; } = new();	8✔
49	public CulturesDB CulturesDB { get; } = new();	8✔
50	public ReligionCollection Religions { get; private set; }	8✔
51	private GenesDB genesDB = new();	8✔
52
53	private enum SaveType { Invalid, Plaintext, CompressedEncoded }
54	private SaveType saveType = SaveType.Invalid;	8✔
55
56	public World(Configuration config) {	16✔
57	ModFS = new ModFilesystem(Path.Combine(config.ImperatorPath, "game"), new Mod[] { });	8✔
58	Religions = new ReligionCollection(new ScriptValueCollection());	8✔
59	}	8✔
60	public World(Configuration config, ConverterVersion converterVersion): this(config) {	×
61	Logger.Info("* Hello Imperator, Roma Invicta! *");	×
62
63	var imperatorRoot = Path.Combine(config.ImperatorPath, "game");	×
64
65	// Parse the save.
66	RegisterRegex(@"\bSAV\w*\b", _ => { });	×
67	RegisterKeyword("version", reader => {	×
68	var imperatorVersion = new GameVersion(reader.GetString());	×
69	Logger.Info($"Save game version: {imperatorVersion}");	×
70		×
71	if (converterVersion.MinSource > imperatorVersion) {	×
72	Logger.Error(	×
73	$"Converter requires a minimum save from v{converterVersion.MinSource.ToShortString()}");	×
74	throw new FormatException("Save game vs converter version mismatch!");	×
75	}	×
76	if (!converterVersion.MaxSource.IsLargerishThan(imperatorVersion)) {	×
77	Logger.Error(	×
78	$"Converter requires a maximum save from v{converterVersion.MaxSource.ToShortString()}");	×
79	throw new FormatException("Save game vs converter version mismatch!");	×
80	}	×
81	});	×
82	RegisterKeyword("date", reader => {	×
83	var dateString = reader.GetString();	×
84	EndDate = new Date(dateString, AUC: true); // converted to AD	×
85	Logger.Info($"Date: {dateString} AUC ({EndDate} AD)");	×
86		×
87	if (EndDate > config.CK3BookmarkDate) {	×
88	config.CK3BookmarkDate = new Date(EndDate);	×
89	Logger.Warn($"CK3 bookmark date can't be earlier than save date. Changed to {config.CK3BookmarkDate}.");	×
90	}	×
91	});	×
92	RegisterKeyword("enabled_dlcs", reader => {	×
93	dlcs.UnionWith(reader.GetStrings());	×
94	foreach (var dlc in dlcs) {	×
95	Logger.Info($"Enabled DLC: {dlc}");	×
96	}	×
97	Logger.IncrementProgress();	×
98	});	×
99	RegisterKeyword("enabled_mods", reader => {	×
100	Logger.Info("Detecting used mods...");	×
101	var modsList = reader.GetStrings();	×
102	Logger.Info($"Save game claims {modsList.Count} mods used:");	×
103	Mods incomingMods = new();	×
104	foreach (var modPath in modsList) {	×
105	Logger.Info($"Used mod: {modPath}");	×
106	incomingMods.Add(new Mod(string.Empty, modPath));	×
107	}	×
108	Logger.IncrementProgress();	×
109		×
110	// Let's locate, verify and potentially update those mods immediately.	×
111	ModLoader modLoader = new();	×
112	modLoader.LoadMods(config.ImperatorDocPath, incomingMods);	×
113	ModFS = new ModFilesystem(imperatorRoot, modLoader.UsableMods);	×
114		×
115	// Now that we have the list of mods used, we can load data from Imperator mod filesystem	×
116	LoadModFilesystemDependentData();	×
117	});	×
118	RegisterKeyword("variables", reader => {	×
119	Logger.Info("Reading global variables...");	×
120		×
121	var variables = new HashSet<string>();	×
122	var variablesParser = new Parser();	×
123	variablesParser.RegisterKeyword("data", dataReader => {	×
124	var blobParser = new Parser();	×
125	blobParser.RegisterKeyword("flag", blobReader => variables.Add(blobReader.GetString()));	×
126	blobParser.IgnoreUnregisteredItems();	×
127	foreach (var blob in new BlobList(dataReader).Blobs) {	×
128	var blobReader = new BufferedReader(blob);	×
129	blobParser.ParseStream(blobReader);	×
130	}	×
131	});	×
132	variablesParser.IgnoreAndLogUnregisteredItems();	×
133	variablesParser.ParseStream(reader);	×
134	GlobalFlags = variables.ToImmutableHashSet();	×
135		×
136	Logger.IncrementProgress();	×
137	});	×
138	RegisterKeyword("family", reader => {	×
139	Logger.Info("Loading families...");	×
140	Families.LoadFamiliesFromBloc(reader);	×
141	Logger.Info($"Loaded {Families.Count} families.");	×
142	Logger.IncrementProgress();	×
143	});	×
144	RegisterKeyword("character", reader => {	×
145	Logger.Info("Loading characters...");	×
146	Characters.GenesDB = genesDB;	×
147	Characters.LoadCharactersFromBloc(reader);	×
148	Logger.Info($"Loaded {Characters.Count} characters.");	×
149	Logger.IncrementProgress();	×
150	});	×
151	RegisterKeyword("state", reader => {	×
152	Logger.Info("Loading states...");	×
153	var statesBlocParser = new Parser();	×
154	statesBlocParser.RegisterKeyword("state_database", statesReader => States.LoadStates(statesReader, Areas, Countries));	×
155	statesBlocParser.IgnoreAndLogUnregisteredItems();	×
156	statesBlocParser.ParseStream(reader);	×
157	Logger.Debug($"Ignored state keywords: {State.IgnoredKeywords}");	×
158	Logger.Info($"Loaded {States.Count} states.");	×
159	Logger.IncrementProgress();	×
160	});	×
161	RegisterKeyword("provinces", reader => {	×
162	Logger.Info("Loading provinces...");	×
163	Provinces.LoadProvinces(reader, States, Countries);	×
164	Logger.Debug($"Ignored Province tokens: {Province.IgnoredTokens}");	×
165	Logger.Info($"Loaded {Provinces.Count} provinces.");	×
166		×
167	Logger.IncrementProgress();	×
168	});	×
169	RegisterKeyword("armies", reader => {	×
170	Logger.Info("Loading armies...");	×
171	var armiesParser = new Parser();	×
172	armiesParser.RegisterKeyword("subunit_database", subunitsReader => Units.LoadSubunits(subunitsReader));	×
173	armiesParser.RegisterKeyword("units_database", unitsReader => Units.LoadUnits(unitsReader, LocDB, Defines));	×
174		×
175	armiesParser.ParseStream(reader);	×
176	});	×
177	RegisterKeyword("country", reader => {	×
178	Logger.Info("Loading countries...");	×
179	Countries.LoadCountriesFromBloc(reader);	×
180	Logger.Info($"Loaded {Countries.Count} countries.");	×
181	Logger.IncrementProgress();	×
182	});	×
183	RegisterKeyword("population", reader => {	×
184	Logger.Info("Loading pops...");	×
185	pops.LoadPopsFromBloc(reader);	×
186	Logger.Info($"Loaded {pops.Count} pops.");	×
187	Logger.IncrementProgress();	×
188	});	×
189	RegisterKeyword("diplomacy", reader => {	×
190	Logger.Info("Loading diplomacy...");	×
191	var diplomacy = new Diplomacy.Diplomacy(reader);	×
192	Wars = diplomacy.Wars;	×
193	Logger.IncrementProgress();	×
194	});	×
195	RegisterKeyword("jobs", reader => {	×
196	Logger.Info("Loading Jobs...");	×
197	Jobs = new Jobs.Jobs(reader);	×
198	Logger.Info($"Loaded {Jobs.Governorships.Capacity} governorships.");	×
199	Logger.IncrementProgress();	×
200	});	×
201	RegisterKeyword("deity_manager", reader => {	×
202	Religions.LoadHolySiteDatabase(reader);	×
203	});	×
204	var playerCountriesToLog = new List<string>();	×
205	RegisterKeyword("played_country", reader => {	×
206	var playedCountryBlocParser = new Parser();	×
207	playedCountryBlocParser.RegisterKeyword("country", reader => {	×
208	var countryId = reader.GetULong();	×
209	var country = Countries[countryId];	×
210	country.PlayerCountry = true;	×
211	playerCountriesToLog.Add(country.Tag);	×
212	});	×
213	playedCountryBlocParser.IgnoreUnregisteredItems();	×
214	playedCountryBlocParser.ParseStream(reader);	×
215	});	×
216	this.IgnoreAndStoreUnregisteredItems(ignoredTokens);	×
217
218	Logger.Info("Verifying Imperator save...");	×
219	VerifySave(config.SaveGamePath);	×
220	Logger.IncrementProgress();	×
221
222	ParseStream(ProcessSave(config.SaveGamePath));	×
223	ClearRegisteredRules();	×
224	Logger.Debug($"Ignored World tokens: {ignoredTokens}");	×
225	Logger.Info($"Player countries: {string.Join(", ", playerCountriesToLog)}");	×
226	Logger.IncrementProgress();	×
227
228	Logger.Info("* Building World *");	×
229
230	// Link all the intertwining references
231	Logger.Info("Linking Characters with Families...");	×
232	Characters.LinkFamilies(Families);	×
233	Families.RemoveUnlinkedMembers(Characters);	×
234	Families.MergeDividedFamilies(Characters);	×
235	Logger.Info("Linking Characters with Countries...");	×
236	Characters.LinkCountries(Countries);	×
237	Logger.Info("Linking Provinces with Pops...");	×
238	Provinces.LinkPops(pops);	×
239	Logger.Info("Linking Countries with Families...");	×
240	Countries.LinkFamilies(Families);	×
241
242	LoadPreImperatorRulers();	×
243
244	Logger.Info("* Good-bye Imperator, rest in peace. *");	×
245	}	×
246	private void ParseGenes() {	×
247	var genesFileLocation = ModFS.GetActualFileLocation("common/genes/00_genes.txt");	×
248	if (genesFileLocation is null) {	×
249	Logger.Warn("I:R genes file not found!");	×
250	} else {	×
251	genesDB = new GenesDB(genesFileLocation);	×
252	}	×
253	}	×
254	private void LoadPreImperatorRulers() {	×
255	const string filePath = "configurables/characters_prehistory.txt";
256	const string noRulerWarning = "Pre-Imperator ruler term has no pre-Imperator ruler!";
257	const string noCountryIdWarning = "Pre-Imperator ruler term has no country ID!";
258
259	var preImperatorRulerTerms = new Dictionary<ulong, List<RulerTerm>>(); // <country id, list of terms>	×
260	var parser = new Parser();	×
261	parser.RegisterKeyword("ruler", reader => {	×
262	var rulerTerm = new RulerTerm(reader, Countries);	×
263	if (rulerTerm.PreImperatorRuler is null) {	×
264	Logger.Warn(noRulerWarning);	×
265	return;	×
266	}	×
267	if (rulerTerm.PreImperatorRuler.Country is null) {	×
268	Logger.Warn(noCountryIdWarning);	×
269	return;	×
270	}	×
271	var countryId = rulerTerm.PreImperatorRuler.Country.Id;	×
272	Countries[countryId].RulerTerms.Add(rulerTerm);	×
273	if (preImperatorRulerTerms.TryGetValue(countryId, out var list)) {	×
274	list.Add(rulerTerm);	×
275	} else {	×
276	preImperatorRulerTerms[countryId] = new List<RulerTerm> { rulerTerm };	×
277	}	×
278	});	×
279	parser.RegisterRegex(CommonRegexes.Catchall, ParserHelpers.IgnoreAndLogItem);	×
280	parser.ParseFile(filePath);	×
281
282	foreach (var country in Countries) {	×
283	country.RulerTerms = country.RulerTerms.OrderBy(t => t.StartDate).ToList();	×
284	}	×
285
286	// verify with data from historical_regnal_numbers
287	var regnalNameCounts = new Dictionary<ulong, Dictionary<string, int>>(); // <country id, <name, count>>	×
288	foreach (var country in Countries) {	×
289	if (!preImperatorRulerTerms.ContainsKey(country.Id)) {	×
290	continue;	×
291	}
292
293	regnalNameCounts.Add(country.Id, new());	×
294	var countryRulerTerms = regnalNameCounts[country.Id];	×
295
296	foreach (var term in preImperatorRulerTerms[country.Id]) {	×
297	if (term.PreImperatorRuler is null) {	×
298	Logger.Warn(noRulerWarning);	×
299	continue;	×
300	}
301	var name = term.PreImperatorRuler.Name;	×
302	if (name is null) {	×
303	Logger.Warn("Pre-Imperator ruler has no country name!");	×
304	continue;	×
305	}
306	if (countryRulerTerms.ContainsKey(name)) {	×
307	++countryRulerTerms[name];	×
308	} else {	×
309	countryRulerTerms[name] = 1;	×
310	}	×
311	}	×
312	}	×
313	foreach (var country in Countries) {	×
314	bool equal;
315	if (!regnalNameCounts.ContainsKey(country.Id)) {	×
316	equal = country.HistoricalRegnalNumbers.Count == 0;	×
317	} else {	×
318	equal = country.HistoricalRegnalNumbers.OrderBy(kvp => kvp.Key)	×
319	.SequenceEqual(regnalNameCounts[country.Id].OrderBy(kvp => kvp.Key)	×
320	);	×
321	}	×
322
323	if (!equal) {	×
324	Logger.Debug($"List of pre-Imperator rulers of {country.Tag} doesn't match data from save!");	×
325	}	×
326	}	×
327	}	×
328
329	private void LoadModFilesystemDependentData() {	×
330	scriptValues.LoadScriptValues(ModFS);	×
331	Logger.IncrementProgress();	×
332
333	Defines.LoadDefines(ModFS);	×
334
335	Logger.Info("Loading named colors...");	×
336	NamedColors.LoadNamedColors("common/named_colors", ModFS);	×
337	Logger.IncrementProgress();	×
338
339	ParseGenes();	×
340
341	Areas.LoadAreas(ModFS, Provinces);	×
342	Country.LoadGovernments(ModFS);	×
343
344	CulturesDB.Load(ModFS);	×
345
346	Religions = new ReligionCollection(scriptValues);	×
347	Religions.LoadDeities(ModFS);	×
348	Religions.LoadReligions(ModFS);	×
349
350	LocDB.ScrapeLocalizations(ModFS);	×
351	Logger.IncrementProgress();	×
352	}	×
353
354	private BufferedReader ProcessSave(string saveGamePath) {	×
355	switch (saveType) {	×
356	case SaveType.Plaintext:
357	Logger.Info("Importing debug_mode Imperator save.");	×
358	return ProcessDebugModeSave(saveGamePath);	×
359	case SaveType.CompressedEncoded:
360	Logger.Info("Importing regular Imperator save.");	×
361	return ProcessCompressedEncodedSave(saveGamePath);	×
362	case SaveType.Invalid:
363	default:
364	throw new InvalidDataException("Unknown save type.");	×
365	}
366	}	×
367	private void VerifySave(string saveGamePath) {	×
368	using var saveStream = File.Open(saveGamePath, FileMode.Open);	×
369	var buffer = new byte[10];	×
370	var bytesRead = saveStream.Read(buffer, 0, 4);	×
371	if (bytesRead < 4) {	×
372	throw new InvalidDataException("Failed to read 4 bytes from save.");	×
373	}
374	if (buffer[0] != 'S' \|\| buffer[1] != 'A' \|\| buffer[2] != 'V') {	×
375	throw new InvalidDataException("Save game of unknown type!");	×
376	}
377
378	char ch;
379	do { // skip until newline	×
380	ch = (char)saveStream.ReadByte();	×
381	} while (ch != '\n' && ch != '\r');	×
382
383	var length = saveStream.Length;	×
384	if (length < 65536) {	×
385	throw new InvalidDataException("Save game seems a bit too small.");	×
386	}
387
388	saveStream.Position = 0;	×
389	var bigBuf = new byte[65536];	×
390	var bytesReadCount = saveStream.Read(bigBuf);	×
391	if (bytesReadCount < 65536) {	×
392	throw new InvalidDataException($"Read only {bytesReadCount}bytes.");	×
393	}
394	saveType = SaveType.Plaintext;	×
395	for (var i = 0; i < 65533; ++i) {	×
396	if (BitConverter.ToUInt32(bigBuf, i) == 0x04034B50 && BitConverter.ToUInt16(bigBuf, i - 2) == 4) {	×
397	saveType = SaveType.CompressedEncoded;	×
398	}	×
399	}	×
400	}	×
401	private static BufferedReader ProcessDebugModeSave(string saveGamePath) {	×
402	return new BufferedReader(File.Open(saveGamePath, FileMode.Open));	×
403	}	×
404	private static BufferedReader ProcessCompressedEncodedSave(string saveGamePath) {	×
405	Helpers.RakalyCaller.MeltSave(saveGamePath);	×
406	return new BufferedReader(File.Open("temp/melted_save.rome", FileMode.Open));	×
407	}	×
408
409	private readonly IgnoredKeywordsSet ignoredTokens = new();	8✔
410	}

ParadoxGameConverters / ImperatorToCK3 / 3982596437

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous