public CK2Province(int id, CK2World world, PdxSublist historyData)
{
World = world;
ID = id;
county = historyData.KeyValuePairs["title"];
_cultureHistory = new List <Dated <CK2Culture> >();
_religionHistory = new List <Dated <CK2Religion> >();
if (historyData.KeyValuePairs.ContainsKey("culture"))
{
_cultureHistory.Add(new Dated <CK2Culture>(new DateTime(769, 1, 1), world.CK2Cultures[historyData.KeyValuePairs["culture"]]));
}
if (historyData.KeyValuePairs.ContainsKey("religion"))
{
_religionHistory.Add(new Dated <CK2Religion>(new DateTime(769, 1, 1), world.CK2Religions[historyData.KeyValuePairs["religion"]]));
}
historyData.ForEachSublist((sub) =>
{
var date = PdxSublist.ParseDate(sub.Key);
if (sub.Value.KeyValuePairs.ContainsKey("religion"))
{
_religionHistory.Add(new Dated <CK2Religion>(date, world.CK2Religions[sub.Value.KeyValuePairs["religion"]]));
}
if (sub.Value.KeyValuePairs.ContainsKey("culture"))
{
_cultureHistory.Add(new Dated <CK2Culture>(date, world.CK2Cultures[sub.Value.KeyValuePairs["culture"]]));
}
});
}
private PdxSublist GetCharacterData(string type, CK2CharacterBase character)
{
var rulerData = new PdxSublist(null, character.BirthDate.ToString("yyyy.MM.dd"));
var monarchData = new PdxSublist(null, type);
monarchData.AddValue("name", character.Name);
if (character.DynastyID == 0)
{ //todo: better support for lowborn rulers
//monarchData.AddValue("dynasty", "Lowborn");
}
else
{
monarchData.AddValue("dynasty", character.World.CK2Dynasties[character.DynastyID].Name);
}
if (CountryTag == "SCA")
{
Console.WriteLine();
}
monarchData.AddValue("birth_date", rulerData.Key);
monarchData.AddValue("adm", ((character.Attribites.Stewardship + character.Attribites.Learning) / 6).ToString());
monarchData.AddValue("dip", ((character.Attribites.Diplomacy + character.Attribites.Learning) / 6).ToString());
monarchData.AddValue("mil", ((character.Attribites.Martial + character.Attribites.Learning) / 6).ToString());
if (type == "heir")
{
monarchData.AddValue("claim", "95");
monarchData.AddValue("monarch_name", character.Name);
monarchData.AddValue("death_date", "1821.5.5");
}
rulerData.AddSublist(monarchData.Key, monarchData);
return(rulerData);
}
private void LoadEffects()
{
Console.WriteLine("Loading countryEffects.txt...");
CountryEffects = PdxSublist.ReadFile("countryEffects.txt");
Console.WriteLine("Loading provinceEffects.txt...");
ProvinceEffects = PdxSublist.ReadFile("provinceEffects.txt");
}
public Eu4Religion AddReligion(PdxSublist value, Eu4WorldBase world)
{
var religion = new Eu4Religion(value, this, world);
Religions.Add(religion);
return(religion);
}
private void CreatePopFiles()
{
Console.WriteLine("Creating pop files...");
var histDir = Directory.CreateDirectory(Path.Combine(OUTPUT, @"history\pops"));
var startDir = Directory.CreateDirectory(Path.Combine(OUTPUT, @"history\pops\1836.1.1"));
var vanillaFiles = Directory.GetFiles(Path.Combine(VIC2_DIR, @"history\pops\1836.1.1"));
foreach (var file in vanillaFiles)
{
using (File.CreateText(Path.Combine(startDir.FullName, Path.GetFileName(file)))) { }
}
var pops = new PdxSublist(null);
foreach (var province in Vic2Provinces)
{
var pop = province.GetPopData();
if (pop != null)
{
pops.AddSublist(province.ProvID.ToString(), pop);
}
}
using (var file = File.CreateText(Path.Combine(startDir.FullName, "1836.txt")))
{
pops.WriteToFile(file);
}
}
public void ValueEffect(PdxSublist effects, Action <Dictionary <string, float> > callback, string key, float value)
{
if (effects.Sublists.ContainsKey("values") && effects.GetSublist("values").Sublists.ContainsKey(key))
{
effects.GetSublist("values").Sublists.ForEach(key, (sub) =>
{
var average = 0f;
if (sub.FloatValues.ContainsKey("average"))
{
average = sub.GetFloat("average");
}
var min = float.MinValue;
if (sub.FloatValues.ContainsKey("minimum"))
{
min = sub.GetFloat("minimum");
}
var max = float.MaxValue;
if (sub.FloatValues.ContainsKey("maximum"))
{
max = sub.GetFloat("maximum");
}
callback(sub.FloatValues.ToDictionary(effect => effect.Key, effect => Math.Min(max, Math.Max(min, (value - average))) * effect.Value.Sum()));
});
}
}
//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.");
// }
//
}
public PdxSublist GetProvinceData()
{
var file = new PdxSublist(null);
if (Owner != null)
{
file.AddValue("owner", Owner.CountryTag);
file.AddValue("controller", Owner.CountryTag);
}
if (Cores != null)
{
foreach (var core in Cores)
{
file.AddValue("add_core", core.CountryTag);
}
}
file.AddValue("trade_goods", TradeGoods);
file.AddValue("fort", FortLevel.ToString());
file.AddValue("railroad", RailroadLevel.ToString());
foreach (var factory in Factories)
{
var factoryData = new PdxSublist();
factoryData.AddValue("level", "1");
factoryData.AddValue("building", factory);
factoryData.AddValue("upgrade", "yes");
file.AddSublist("state_building", factoryData);
}
return(file);
}
private void CreateDiplomacyFiles()
{
Console.WriteLine("Creating diplomacy files...");
var alliances = new PdxSublist();
foreach (var alliance in Alliances)
{
alliances.AddSublist("alliance", alliance.GetData());
}
var puppets = new PdxSublist();
foreach (var vassal in Puppets)
{
puppets.AddSublist("vassal", vassal.GetData());
}
var histDir = Directory.CreateDirectory(Path.Combine(OUTPUT, @"history\diplomacy"));
using (var file = File.CreateText(Path.Combine(histDir.FullName, "Alliances.txt")))
{
alliances.WriteToFile(file);
}
using (var file = File.CreateText(Path.Combine(histDir.FullName, "PuppetStates.txt")))
{
puppets.WriteToFile(file);
}
}
public Eu4Culture AddCulture(PdxSublist data, Eu4WorldBase world)
{
var culture = new Eu4Culture(data, this, world);
Cultures.Add(culture);
return(culture);
}
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 Dictionary <DateTime, string> AddHistory(PdxSublist history, string type)
{
var storedHistory = new Dictionary <DateTime, string>();
if (!history.KeyValuePairs.ContainsKey(type))
{
return(storedHistory);
}
var startDate = new DateTime(1444, 11, 11);
history.KeyValuePairs.ForEach(type, (h =>
{
storedHistory[startDate] = h;
}));
foreach (var entry in history.Sublists)
{
var sub = entry.Value;
if (sub.KeyValuePairs.ContainsKey(type))
{
var date = PdxSublist.ParseDate(sub.Key);
sub.KeyValuePairs.ForEach(type, v =>
{
storedHistory[date] = v;
});
}
}
return(storedHistory);
}
internal void AddData(PdxSublist data)
{
foreach (var reform in typeof(Reforms).GetProperties())
{
data.AddValue(reform.Name, Enum.GetName(reform.PropertyType, reform.GetValue(this)));
}
}
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 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);
}
});
});
}
}
public Eu4Province(Eu4World world, int ID, PdxSublist history)
{
this.World = world;
this.ProvinceID = ID;
Cores = new List <Eu4CountryBase>();
Modifiers = new List <string>();
LatentTradeGoods = new List <string>();
if (history.KeyValuePairs.ContainsKey("trade_goods"))
{
TradeGood = history.KeyValuePairs["trade_goods"];
}
history.Sublists.ForEach("latent_trade_goods", (sub =>
{
LatentTradeGoods.AddRange(sub.Values);
}));
if (history.FloatValues.ContainsKey("center_of_trade"))
{
CentreOfTradeWeight += 0.25f * history.GetFloat("center_of_trade");
}
history.Sublists.ForEach("add_permanent_province_modifier", (sub) =>
{
var mod = sub.KeyValuePairs["name"];
if (mod.Contains("estuary_modifier"))
{
CentreOfTradeWeight += 0.25f;
}
Modifiers.Add(mod);
});
}
public Estate(PdxSublist estate)
{
Type = estate.GetString("type");
Loyalty = estate.GetFloat("loyalty");
Influence = estate.GetFloat("influence");
Territory = estate.FloatValues.ContainsKey("territory") ? estate.GetFloat("territory") : 0;
}
public Vic2ReligionGroup(PdxSublist data) : this(data.Key)
{
foreach (var sub in data.Sublists)
{
Religions.Add(new Vic2Religion(sub.Value));
}
}
private float GetFloatEffect(PdxSublist effects, string key)
{
if (!effects.FloatValues.ContainsKey(key))
{
return(0);
}
return(effects.FloatValues[key].Sum());
}
public CK2Culture(PdxSublist data, CK2World world, CK2CultureGroup group) : this(data.Key, world)
{
Group = group;
if (data.BoolValues.ContainsKey("dynasty_title_names"))
{
DynastyTitleNames = data.BoolValues["dynasty_title_names"].Single();
}
}
private void CalcEffects(PdxSublist effects, float multiplier)
{
baseTax += GetFloatEffect(effects, "base_tax", multiplier);
baseProduction += GetFloatEffect(effects, "base_production", multiplier);
baseManpower += GetFloatEffect(effects, "base_manpower", multiplier);
fortLevel += GetFloatEffect(effects, "fort_level", multiplier);
CentreOfTradeWeight += GetFloatEffect(effects, "centre_of_trade_weight", multiplier);
}
private float LoadFloat(PdxSublist country, string key, float deflt = 0)
{
if (!country.FloatValues.ContainsKey(key))
{
return(deflt);
}
return(country.GetFloat(key));
}
public CK2Religion initFromSave(PdxSublist data, CK2World world)
{
HolySites = data.Sublists["holy_sites"].Values.Select(v => world.CK2Titles[v]).ToList();
if (data.Sublists.ContainsKey("features"))
{
Features = data.Sublists["features"].Values;
}
return(this);
}
public NationalIdeaGroup(PdxSublist data)
{
Name = data.Key;
Ideas = new List <NationalIdea>();
data.ForEachSublist(sub =>
{
Ideas.Add(new NationalIdea(sub.Value, this));
});
}
private PdxSublist GetNameData(List <string> names)
{
var nameData = new PdxSublist();
foreach (var name in names)
{
nameData.AddValue(string.Empty, name);
}
return(nameData);
}
public void ReadData(PdxSublist data)
{
var rgx = new Regex(@"\d+$");
foreach (var pop in data.Sublists)
{
var key = rgx.Replace(pop.Key, string.Empty);
AddPop((PopType)Enum.Parse(typeof(PopType), key), (int)pop.Value.GetFloat("size"), pop.Value.KeyValuePairs["culture"], pop.Value.KeyValuePairs["religion"]);
}
}
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 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 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);
}
}
public override PdxSublist GetHistoryFile()
{
var data = new PdxSublist(null, (FileName == CountryTag ? CountryTag : (CountryTag + " - " + FileName)) + ".txt");
data.AddValue("government", Government);
foreach (var reform in Reforms)
{
data.AddValue("add_government_reform", reform);
}
data.AddValue("government_rank", GovernmentRank.ToString());
data.AddValue("mercantilism", Mercantilism.ToString());
//TODO: tech groups
data.AddValue("technology_group", TechGroup);
data.AddValue("religion", Religion);
data.AddValue("primary_culture", PrimaryCulture);
foreach (var culture in AcceptedCultures)
{
data.AddValue("add_accepted_culture", culture);
}
if (IsElector)
{
data.AddValue("elector", "yes");
}
if (Capital != 0)
{
data.AddValue("capital", Capital.ToString());
}
if (holder != null)
{
var rulerData = GetCharacterData("monarch", holder);
//rulerData.AddValue("clear_scripted_personalities", "yes");
data.AddSublist(rulerData.Key, rulerData);
if (title.Name == "k_dyn_8040718")
{
Console.WriteLine();
}
var heir = holder.Heir;
if (heir != null)
{
var heirData = GetCharacterData("heir", heir);
data.AddSublist(heirData.Key, heirData);
}
//TODO: heirs
//if(holder.PrimaryTitle.Succession == "succ_primogeniture")
//{
//}
}
//TODO: heirs & spouses
return(data);
}
