//private void LoadCountryTags()
//{
// Console.WriteLine("Loading list of countries...");
// var countryTagFiles = GetFilesFor(@"common\country_tags");
// CountryTags = new List<string>();
// foreach (var ctf in countryTagFiles)
// {
// var file = new StreamReader(ctf);
// string line;
// while ((line = file.ReadLine()) != null)
// {
// if (line.First() !='#' && line.Contains('='))
// {
// var tag = line.Substring(0, line.IndexOf('=')).Trim();
// CountryTags.Add(tag);
// }
// }
// }
//
// var dynCountries = RootList.Sublists["dynamic_countries"].Values.Select(s => s.Substring(1, 3));
// CountryTags.AddRange(dynCountries);
// Console.WriteLine(CountryTags[0]);
//}
private void ReadSave(string filePath)
{
Console.WriteLine("Reading save file...");
RootList = PdxSublist.ReadFile(filePath, "EU4txt");
Console.WriteLine("Save reading complete.");
//
// var file = new StreamReader(filePath);
// var line = file.ReadLine();
// if (line != "EU4txt")
// {
// throw new Exception("Not an EU4 file");
// }
// RootList = new PdxSublist(null);
// var currentList = RootList;
// //var lineNumber = 0;
// while ((line = file.ReadLine()) != null)
// {
// //lineNumber++;
// currentList = PdxSublist.RunLine(line, currentList);
// }
// if(currentList != RootList)
// {
// throw new Exception("An unknown error occurred.");
// }
//
}
private void LoadCultureData()
{
Cultures = new Dictionary <string, Eu4Culture>();
CultureGroups = new Dictionary <string, Eu4CultureGroup>();
var relFiles = GetFilesFor(@"common\cultures");
var ignores = new string[] { "male_names", "female_names", "dynasty_names" };
foreach (var relFile in relFiles)
{
var cultures = PdxSublist.ReadFile(relFile);
cultures.ForEachSublist(culGroup =>
{
if (!CultureGroups.ContainsKey(culGroup.Key))
{
CultureGroups[culGroup.Key] = new Eu4CultureGroup(culGroup.Value, this);
}
culGroup.Value.ForEachSublist(cul =>
{
if (!Cultures.ContainsKey(cul.Key) && ignores.All(ign => ign != cul.Key))
{
Cultures[cul.Key] = CultureGroups[culGroup.Key].AddCulture(cul.Value, this);
}
});
});
}
}
private void LoadEffects()
{
Console.WriteLine("Loading countryEffects.txt...");
CountryEffects = PdxSublist.ReadFile("countryEffects.txt");
Console.WriteLine("Loading provinceEffects.txt...");
ProvinceEffects = PdxSublist.ReadFile("provinceEffects.txt");
}
private void LoadReligion()
{
Console.WriteLine("Loading CK2 religions...");
CK2Religions = new Dictionary <string, CK2Religion>();
var religionFiles = GetFilesFor(@"common\religions");
foreach (var file in religionFiles)
{
var religionGroups = PdxSublist.ReadFile(file);
religionGroups.ForEachSublist(relGroup =>
{
if (relGroup.Key == "secret_religion_visibility_trigger")
{
return;
}
relGroup.Value.ForEachSublist(rel =>
{
if (!(rel.Key == "color" || rel.Key == "male_names" || rel.Key == "female_names"))
{
CK2Religions[rel.Key] = new CK2Religion(rel.Key);
}
});
});
}
}
private void LoadReligionData()
{
Religions = new Dictionary <string, Eu4Religion>();
ReligiousGroups = new Dictionary <string, Eu4ReligionGroup>();
var relFiles = GetFilesFor(@"common\religions");
var rgx = new Regex(@"\d+$");
foreach (var relFile in relFiles)
{
var religions = PdxSublist.ReadFile(relFile);
religions.ForEachSublist(relGroup =>
{
var key = rgx.Replace(relGroup.Key, string.Empty);
if (!ReligiousGroups.ContainsKey(key))
{
ReligiousGroups[relGroup.Key] = new Eu4ReligionGroup(key, this);
}
relGroup.Value.ForEachSublist(rel =>
{
if (!Religions.ContainsKey(rel.Key) && rel.Key != "flag_emblem_index_range")
{
Religions[rel.Key] = ReligiousGroups[key].AddReligion(rel.Value, this);
}
});
});
}
}
private void LoadVicReligion()
{
ReligiousGroups = new Dictionary <string, Vic2ReligionGroup>();
var religions = PdxSublist.ReadFile(Path.Combine(VIC2_DIR, @"common\religion.txt"));
foreach (var relGroup in religions.Sublists)
{
ReligiousGroups[relGroup.Key] = new Vic2ReligionGroup(relGroup.Value);
}
}
private void LoadExistingCountries()
{
ExistingCountries = new HashSet <string>();
var countries = PdxSublist.ReadFile(Path.Combine(VIC2_DIR, @"common\countries.txt"));
foreach (var c in countries.KeyValuePairs.Keys)
{
ExistingCountries.Add(c);
}
}
private void LoadBuildingData()
{
Buildings = new List <string>();
var buildFiles = GetFilesFor(@"common\buildings");
foreach (var buildFile in buildFiles)
{
var buildings = PdxSublist.ReadFile(buildFile);
Buildings.AddRange(buildings.Sublists.Keys);
}
}
private void LoadRegions()
{
Console.WriteLine("Loading EU4 areas..");
var files = GetFilesFor("map");
var areaFile = files.Find(f => Path.GetFileName(f) == "area.txt");
var areas = PdxSublist.ReadFile(areaFile);
Areas = new Dictionary <string, Eu4Area>();
foreach (var ar in areas.Sublists)
{
//Areas[ar.Key] = new HashSet<int>(ar.Value.FloatValues.Values.SelectMany(f => f.Select(e => (int)e)));
Areas[ar.Key] = new Eu4Area(ar.Key, ar.Value);
}
Console.WriteLine("Loading EU4 regions...");
var regionFile = files.Find(f => Path.GetFileName(f) == "region.txt");
var regions = PdxSublist.ReadFile(regionFile);
Regions = new Dictionary <string, Eu4Region>();
foreach (var reg in regions.Sublists)
{
Regions[reg.Key] = new Eu4Region(reg.Key, reg.Value, this);
}
Console.WriteLine("Loading EU4 super regions...");
var superRegionFile = files.Find(f => Path.GetFileName(f) == "superregion.txt");
var superRegions = PdxSublist.ReadFile(superRegionFile);
SuperRegions = new Dictionary <string, Eu4SuperRegion>();
foreach (var sr in superRegions.Sublists)
{
SuperRegions[sr.Key] = new Eu4SuperRegion(sr.Key, sr.Value, this);
}
Console.WriteLine("Loading EU4 continents..");
var continentFile = files.Find(f => Path.GetFileName(f) == "continent.txt");
var continents = PdxSublist.ReadFile(continentFile);
Continents = new Dictionary <string, Eu4Continent>();
foreach (var con in continents.Sublists)
{
//Areas[ar.Key] = new HashSet<int>(ar.Value.FloatValues.Values.SelectMany(f => f.Select(e => (int)e)));
if (con.Key != "island_check_provinces")
{
Continents[con.Key] = new Eu4Continent(con.Key, con.Value);
}
}
}
private void LoadVicPopData()
{
PopData = new PdxSublist();
var files = Directory.GetFiles(Path.Combine(VIC2_DIR, @"history\pops\1836.1.1"));
foreach (var file in files)
{
var data = PdxSublist.ReadFile(file);
foreach (var sub in data.Sublists)
{
PopData.Sublists[sub.Key] = sub.Value;
}
}
}
private void LoadGovernmentTypes()
{
GovernmentTypes = new List <string>();
var govFiles = GetFilesFor(@"common\governments");
foreach (var govFile in govFiles)
{
var govs = PdxSublist.ReadFile(govFile);
govs.ForEachSublist(gov =>
{
GovernmentTypes.Add(gov.Key);
});
}
}
private void LoadDynasties()
{
Console.WriteLine("Loading static CK2 dynasties...");
CK2Dynasties = new Dictionary <int, CK2Dynasty>();
var dynFiles = GetFilesFor(@"common\dynasties");
foreach (var dynFile in dynFiles)
{
var data = PdxSublist.ReadFile(dynFile);
data.ForEachSublist(sub =>
{
CK2Dynasties[int.Parse(sub.Key)] = new CK2Dynasty(this, sub.Value);
});
}
}
private void LoadVanillaTitleData()
{
Console.WriteLine("Loading CK2 title data...");
var titles = GetFilesFor(@"common\landed_titles");
foreach (var title in titles)
{
if (Path.GetExtension(title) != ".txt")
{
continue;
}
var data = PdxSublist.ReadFile(title);
RecursiveTitleSearch(data);
}
}
private PdxSublist FindProvinceFile(int key)
{
var provinces = Path.Combine(VIC2_DIR, @"history\provinces");
var provDir = Directory.GetDirectories(provinces);
foreach (var dir in provDir)
{
var files = Directory.GetFiles(dir);
var provFile = files.FirstOrDefault(f => Path.GetFileName(f).StartsWith(key + " "));
if (provFile != default(string))
{
return(PdxSublist.ReadFile(provFile));
}
}
return(null);
}
private void LoadTraits()
{
Console.WriteLine("Loading CK2 traits...");
CK2Traits = new List <CK2Traits>();
CK2Traits.Add(null);
var traitFiles = GetFilesFor(@"common\traits");
traitFiles.Sort();
foreach (var file in traitFiles)
{
var traits = PdxSublist.ReadFile(file);
traits.ForEachSublist(trait =>
{
CK2Traits.Add(new CK2Traits(trait));
});
}
}
private void LoadVicCulture()
{
Console.WriteLine("Loading Vic2 Cultures...");
CultureGroups = new Dictionary <string, Vic2CultureGroup>();
Cultures = new Dictionary <string, Vic2Culture>();
var cultures = PdxSublist.ReadFile(Path.Combine(VIC2_DIR, @"common\cultures.txt"));
foreach (var culGroup in cultures.Sublists)
{
var nextGroup = new Vic2CultureGroup(this, culGroup.Value);
CultureGroups[culGroup.Key] = nextGroup;
nextGroup.Cultures.ForEach(c => Cultures.Add(c.Name, c));
}
Console.WriteLine("Loading cultureNations.txt");
CultureNations = PdxSublist.ReadFile("cultureNations.txt");
}
private void LoadHistory()
{
Console.WriteLine("Loading history..");
CountryHistory = new Dictionary <string, PdxSublist>();
var ctryHistory = GetFilesFor(@"history\countries");
foreach (var ctry in ctryHistory)
{
CountryHistory.Add(Path.GetFileName(ctry).Substring(0, 3), PdxSublist.ReadFile(ctry));
}
//ProvinceHistory = new Dictionary<string, PdxSublist>();
//var provHistory = GetFilesFor(@"history\provinces");
//foreach (var prov in provHistory)
//{
// ProvinceHistory.Add(Path.GetFileName(prov).Substring(0, 3), PdxSublist.ReadFile(prov));
//}
}
private void LoadBuildings()
{
Console.WriteLine("Loading CK2 buildings...");
CK2Buildings = new Dictionary <string, CK2Building>();
var buildingFiles = GetFilesFor("common\\buildings");
foreach (var file in buildingFiles)
{
var data = PdxSublist.ReadFile(file);
data.ForEachSublist(sub =>
{
sub.Value.ForEachSublist(building =>
{
CK2Buildings.Add(building.Key, new CK2Building(building.Value));
});
});
}
}
public CK2Save(string filePath, string modPath, bool keepStartDate) : base(modPath)
{
FilePath = filePath;
KeepStartDate = keepStartDate;
Console.WriteLine("Reading CK2 save file...");
RootList = PdxSublist.ReadFile(filePath, "CK2txt");
Date = RootList.KeyValuePairs["date"];
Console.WriteLine(RootList.Sublists.ContainsKey("artifacts"));
LoadDynasties();
LoadCharacters();
LoadArtifacts();
LoadDynamicReligions();
LoadTitles();
LoadProvinces();
LoadPostCharacters();
LoadCultureCentres();
//LoadWars();
LoadChina();
LoadVanillaTitleData();
LoadReligiousData();
}
private void FixTechnologies()
{
// adjust the year for tech
Directory.CreateDirectory(Path.Combine(OUTPUT, "technologies"));
var techFiles = Directory.GetFiles(Path.Combine(VIC2_DIR, "technologies"));
foreach (var techFile in techFiles)
{
var data = PdxSublist.ReadFile(techFile);
data.ForEachSublist(sub =>
{
var year = (int)sub.Value.FloatValues["year"].Single() - 1836 + StartYear;
sub.Value.FloatValues["year"].Clear();
sub.Value.FloatValues["year"].Add(year);
});
using (var outFile = new StreamWriter(Path.Combine(OUTPUT, "technologies", Path.GetFileName(techFile))))
{
data.WriteToFile(outFile);
}
}
}
// do not look in here, it's an ugly mess
private void LoadVicTech()
{
Console.WriteLine("Loading vic2 technologies...");
var techs = PdxSublist.ReadFile(Path.Combine(VIC2_DIR, @"common\technology.txt"));
var techTypes = techs.Sublists["folders"];
TechOrder = new Dictionary <string, List <string> >();
foreach (var techType in techTypes.Sublists)
{
TechOrder.Add(techType.Key, new List <string>());
var techTypeFile = PdxSublist.ReadFile(Path.Combine(VIC2_DIR, $@"technologies\{techType.Key}.txt"));
//list instead of dictionary to retain order
var subTypes = new List <KeyValuePair <string, Queue <string> > >();
foreach (var tech in techTypeFile.Sublists)
{
if (!subTypes.Exists(p => p.Key == tech.Value.KeyValuePairs["area"]))
{
subTypes.Add(new KeyValuePair <string, Queue <string> >(tech.Value.KeyValuePairs["area"], new Queue <string>()));
}
// a big mess
subTypes.Find(kv => kv.Key == tech.Value.KeyValuePairs["area"]).Value.Enqueue(tech.Key);
}
var subTypesList = subTypes.ConvertAll(st => st.Value);
while (subTypesList.Count > 0)
{
for (var i = 0; i < subTypesList.Count; i++)
{
TechOrder[techType.Key].Add(subTypesList[i].Dequeue());
if (subTypesList[i].Count == 0)
{
subTypesList.RemoveAt(i--);
}
}
}
}
}
private void LoadPoliticalParties()
{
Console.WriteLine("Loading party ideologies...");
IdeologyModifiers = new Dictionary <Ideology, IdeologyModifier>();
var parties = PdxSublist.ReadFile("political_parties.txt");
foreach (var ideology in (Ideology[])Enum.GetValues(typeof(Ideology)))
{
var name = Enum.GetName(typeof(Ideology), ideology);
if (parties.Sublists.ContainsKey(name))
{
var party = new IdeologyModifier();
foreach (var policy in Policies.policyTypes)
{
if (parties.Sublists[name].FloatValues.ContainsKey(policy.Name))
{
party.AddModifier(policy, parties.Sublists[name].FloatValues[policy.Name].Sum());
}
}
IdeologyModifiers.Add(ideology, party);
}
}
}
private void LoadCulture()
{
Console.WriteLine("Loading CK2 cultures...");
CK2Cultures = new Dictionary <string, CK2Culture>();
CK2CultureGroups = new Dictionary <string, CK2CultureGroup>();
var cultureFiles = GetFilesFor(@"common\cultures");
foreach (var file in cultureFiles)
{
var cultureGroups = PdxSublist.ReadFile(file);
cultureGroups.ForEachSublist(culGroup =>
{
var group = new CK2CultureGroup(culGroup.Key);
CK2CultureGroups[culGroup.Key] = group;
culGroup.Value.ForEachSublist(rel =>
{
if (rel.Key != "graphical_cultures")
{
CK2Cultures[rel.Key] = new CK2Culture(rel.Value, this, group);
}
});
});
}
}
private PdxSublist MappingsFile(string filePath)
{
Console.WriteLine($"Loading {filePath}...");
return(PdxSublist.ReadFile(filePath));
}
private void LoadLocalisationHelper()
{
LocalisationHelper = PdxSublist.ReadFile("localisation.txt");
}
private void CreateCountryFiles()
{
//common
Console.WriteLine("Creating country files...");
var vanillaCtry = PdxSublist.ReadFile(Path.Combine(VIC2_DIR, @"common\countries.txt"));
var txt = Path.Combine(OUTPUT, @"common\countries.txt");
using (var txtFile = File.CreateText(txt))
{
foreach (var country in Vic2Countries)
{
txtFile.WriteLine($"{country.CountryTag} = \"countries/{country.CountryTag}.txt\"");
}
txtFile.WriteLine("# From vanilla");
foreach (var ctry in vanillaCtry.KeyValuePairs)
{
var genCtry = Vic2Countries.Find(c => c.CountryTag == ctry.Key);
if (genCtry == null)
{
txtFile.WriteLine($"{ctry.Key} = \"{ctry.Value}\"");
}
}
}
var dir = Directory.CreateDirectory(Path.Combine(OUTPUT, @"common\countries"));
var histDir = Directory.CreateDirectory(Path.Combine(OUTPUT, @"history\countries"));
var flagDir = Directory.CreateDirectory(Path.Combine(OUTPUT, @"gfx\flags"));
var eu4Flags = Eu4Save.GetFilesFor(@"gfx\flags");
var vic2Flags = Directory.GetFiles(Path.Combine(VIC2_DIR, @"gfx\flags"));
var suffixes = new string[] { "", "communist", "fascist", "monarchy", "republic" };
foreach (var country in Vic2Countries)
{
//common\countries
using (var file = File.CreateText(Path.Combine(dir.FullName, $"{country.CountryTag}.txt")))
{
country.GetCommonCountryFile().WriteToFile(file);
}
//history\countries
using (var file = File.CreateText(Path.Combine(histDir.FullName, $"{country.CountryTag}.txt")))
{
country.GetHistoryCountryFile(this).WriteToFile(file);
}
if (country.CountryTag == "GRA")
{
Console.WriteLine();
}
if (vic2Flags.FirstOrDefault(f => Path.GetFileName(f).StartsWith(country.CountryTag)) == null)
{
var eu4Flag = eu4Flags.Find(f => Path.GetFileName(f).StartsWith(country.Eu4Country?.CountryTag ?? "!"));
foreach (var suff in suffixes)
{
var name = country.CountryTag + (suff == string.Empty ? string.Empty : $"_{suff}");
if (eu4Flag == null)
{
country.CreateFlag(Path.Combine(flagDir.FullName, $"{name}.tga"), suff);
}
else
{
File.Copy(eu4Flag, Path.Combine(flagDir.FullName, $"{name}.tga"));
}
}
}
}
}
private void LoadFactories()
{
Factories = PdxSublist.ReadFile("factory.txt");
}
public ProvinceMapper(string mappingPath)
{
//instance = this;
Console.WriteLine("Loading province mappings...");
Mappings = PdxSublist.ReadFile(mappingPath);
}
private void LoadProvCounties()
{
Console.WriteLine("Loading CK2 provinces...");
// CK2ProvCounties = new Dictionary<string, string>();
// CK2DupeProvCounties = new Dictionary<string, string>();
CK2Provinces = new Dictionary <int, CK2Province>();
CK2ProvinceDupes = new Dictionary <int, CK2Province>();
var provFiles = GetFilesFor("history\\provinces");
foreach (var provFile in provFiles)
{
var data = PdxSublist.ReadFile(provFile);
var provID = int.Parse(new Regex("[0-9]+").Match(Path.GetFileName(provFile)).Value);
var prov = new CK2Province(provID, this, data);
if (CK2Provinces.ContainsKey(provID))
{
CK2ProvinceDupes.Add(provID, prov);
}
else
{
CK2Provinces.Add(provID, prov);
}
// if (CK2ProvCounties.ContainsKey(provID))
// {
// CK2DupeProvCounties.Add(provID, data.KeyValuePairs["title"]);
// }
// else
// {
// CK2ProvCounties.Add(provID, data.KeyValuePairs["title"]);
// }
}
var mapFiles = GetFilesFor("map");
var provMapFile = mapFiles.Single(m => Path.GetFileName(m) == "provinces.bmp");
ProvinceMap = new Bitmap(provMapFile);
CK2ProvColours = new Dictionary <int, string>();
var defFile = mapFiles.Single(m => Path.GetFileName(m) == "definition.csv");
using (TextFieldParser parser = new TextFieldParser(defFile))
{
parser.TextFieldType = FieldType.Delimited;
parser.SetDelimiters(";");
parser.ReadFields();
while (!parser.EndOfData)
{
//Process row
string[] fields = parser.ReadFields();
var col = Color.FromArgb(int.Parse(fields[1]), int.Parse(fields[2]), int.Parse(fields[3]));
CK2ProvColours[col.ToArgb()] = fields[0];
}
}
Console.WriteLine("Loading province map...");
CK2ProvPositions = new Dictionary <string, List <Point> >();
var bmp = ProvinceMap;
for (int y = 0; y < bmp.Height; y++)
{
for (int x = 0; x < bmp.Width; x++)
{
var pxColour = bmp.GetPixel(x, y).ToArgb();
if (CK2ProvColours.ContainsKey(pxColour))
{
var provID = CK2ProvColours[pxColour];
if (!CK2ProvPositions.ContainsKey(provID))
{
CK2ProvPositions[provID] = new List <Point>();
}
CK2ProvPositions[provID].Add(new Point(x, y));
}
}
}
}
