private void ImportImperatorCountry(
Country country,
CountryCollection imperatorCountries,
TagTitleMapper tagTitleMapper,
LocDB locDB,
ProvinceMapper provinceMapper,
CoaMapper coaMapper,
GovernmentMapper governmentMapper,
SuccessionLawMapper successionLawMapper,
DefiniteFormMapper definiteFormMapper,
ReligionMapper religionMapper,
CultureMapper cultureMapper,
NicknameMapper nicknameMapper,
CharacterCollection characters,
Date conversionDate
)
{
// Create a new title or update existing title
var name = DetermineName(country, imperatorCountries, tagTitleMapper, locDB);
if (TryGetValue(name, out var existingTitle))
{
existingTitle.InitializeFromTag(
country,
imperatorCountries,
locDB,
provinceMapper,
coaMapper,
governmentMapper,
successionLawMapper,
definiteFormMapper,
religionMapper,
cultureMapper,
nicknameMapper,
characters,
conversionDate
);
}
else
{
Add(
country,
imperatorCountries,
locDB,
provinceMapper,
coaMapper,
tagTitleMapper,
governmentMapper,
successionLawMapper,
definiteFormMapper,
religionMapper,
cultureMapper,
nicknameMapper,
characters,
conversionDate
);
}
}
public void NonMatchGivesEmptySet()
{
var reader = new BufferedReader("link = { imp = implaw ck3 = ck3law }");
var mapper = new SuccessionLawMapper(reader);
var ck3Laws = mapper.GetCK3LawsForImperatorLaws(new SortedSet <string> {
"madeUpLaw"
});
Assert.Empty(ck3Laws);
}
public void LinkWithNoCK3LawResultsInWarning()
{
var output = new StringWriter();
Console.SetOut(output);
var reader = new BufferedReader("link = { imp = implaw }");
var mapper = new SuccessionLawMapper(reader);
Assert.Contains("SuccessionLawMapper: link with no CK3 successions laws", output.ToString());
}
public void Ck3LawCanBeFound()
{
var reader = new BufferedReader("link = { imp = implaw ck3 = ck3law }");
var mapper = new SuccessionLawMapper(reader);
var ck3Laws = mapper.GetCK3LawsForImperatorLaws(new SortedSet <string> {
"implaw"
});
Assert.Equal(new SortedSet <string> {
"ck3law"
}, ck3Laws);
}
public void MappingsAreReadFromFile()
{
var mapper = new SuccessionLawMapper("TestFiles/configurables/succession_law_map.txt");
Assert.Equal(
new SortedSet <string> {
"ck3law1", "ck3law2"
},
mapper.GetCK3LawsForImperatorLaws(new() { "implaw1" })
);
Assert.Equal(
new SortedSet <string> {
"ck3law3"
},
mapper.GetCK3LawsForImperatorLaws(new() { "implaw2" })
);
}
public void ImportImperatorCountries(
CountryCollection imperatorCountries,
TagTitleMapper tagTitleMapper,
LocDB locDB,
ProvinceMapper provinceMapper,
CoaMapper coaMapper,
GovernmentMapper governmentMapper,
SuccessionLawMapper successionLawMapper,
DefiniteFormMapper definiteFormMapper,
ReligionMapper religionMapper,
CultureMapper cultureMapper,
NicknameMapper nicknameMapper,
CharacterCollection characters,
Date conversionDate
)
{
Logger.Info("Importing Imperator Countries...");
// landedTitles holds all titles imported from CK3. We'll now overwrite some and
// add new ones from Imperator tags.
var counter = 0;
// We don't need pirates, barbarians etc.
foreach (var country in imperatorCountries.Where(c => c.CountryType == CountryType.real))
{
ImportImperatorCountry(
country,
imperatorCountries,
tagTitleMapper,
locDB,
provinceMapper,
coaMapper,
governmentMapper,
successionLawMapper,
definiteFormMapper,
religionMapper,
cultureMapper,
nicknameMapper,
characters,
conversionDate
);
++counter;
}
Logger.Info($"Imported {counter} countries from I:R.");
}
public void MultipleLawsCanBeReturned()
{
var reader = new BufferedReader(
"link = { imp = implaw ck3 = ck3law ck3 = ck3law2 }\n" +
"link = { imp = implaw ck3 = ck3law3 }\n" +
"link = { imp = implaw2 ck3 = ck3law4 }\n" +
"link = { imp = implaw3 ck3 = ck3law5 }\n"
);
var mapper = new SuccessionLawMapper(reader);
var ck3Laws = mapper.GetCK3LawsForImperatorLaws(new SortedSet <string> {
"implaw", "implaw3"
});
var expectedReturnedLaws = new SortedSet <string> {
"ck3law", "ck3law2", "ck3law3", "ck3law5"
};
Assert.Equal(expectedReturnedLaws, ck3Laws);
}
public Title Add(
Country country,
CountryCollection imperatorCountries,
LocDB locDB,
ProvinceMapper provinceMapper,
CoaMapper coaMapper,
TagTitleMapper tagTitleMapper,
GovernmentMapper governmentMapper,
SuccessionLawMapper successionLawMapper,
DefiniteFormMapper definiteFormMapper,
ReligionMapper religionMapper,
CultureMapper cultureMapper,
NicknameMapper nicknameMapper,
CharacterCollection characters,
Date conversionDate
)
{
var newTitle = new Title(this,
country,
imperatorCountries,
locDB,
provinceMapper,
coaMapper,
tagTitleMapper,
governmentMapper,
successionLawMapper,
definiteFormMapper,
religionMapper,
cultureMapper,
nicknameMapper,
characters,
conversionDate
);
dict[newTitle.Id] = newTitle;
return(newTitle);
}
private Title(LandedTitles parentCollection,
Country country,
CountryCollection imperatorCountries,
LocDB locDB,
ProvinceMapper provinceMapper,
CoaMapper coaMapper,
TagTitleMapper tagTitleMapper,
GovernmentMapper governmentMapper,
SuccessionLawMapper successionLawMapper,
DefiniteFormMapper definiteFormMapper,
ReligionMapper religionMapper,
CultureMapper cultureMapper,
NicknameMapper nicknameMapper,
CharacterCollection characters,
Date conversionDate
)
{
this.parentCollection = parentCollection;
Id = DetermineName(country, imperatorCountries, tagTitleMapper, locDB);
SetRank();
InitializeFromTag(
country,
imperatorCountries,
locDB,
provinceMapper,
coaMapper,
governmentMapper,
successionLawMapper,
definiteFormMapper,
religionMapper,
cultureMapper,
nicknameMapper,
characters,
conversionDate
);
}
public void InitializeFromTag(
Country country,
CountryCollection imperatorCountries,
LocDB locDB,
ProvinceMapper provinceMapper,
CoaMapper coaMapper,
GovernmentMapper governmentMapper,
SuccessionLawMapper successionLawMapper,
DefiniteFormMapper definiteFormMapper,
ReligionMapper religionMapper,
CultureMapper cultureMapper,
NicknameMapper nicknameMapper,
CharacterCollection characters,
Date conversionDate
)
{
IsImportedOrUpdatedFromImperator = true;
ImperatorCountry = country;
ImperatorCountry.CK3Title = this;
LocBlock?validatedName = GetValidatedName(country, imperatorCountries, locDB);
HasDefiniteForm.Value = definiteFormMapper.IsDefiniteForm(ImperatorCountry.Name);
RulerUsesTitleName.Value = false;
PlayerCountry = ImperatorCountry.PlayerCountry;
ClearHolderSpecificHistory();
FillHolderAndGovernmentHistory();
// ------------------ determine color
var color1Opt = ImperatorCountry.Color1;
if (color1Opt is not null)
{
Color1 = color1Opt;
}
var color2Opt = ImperatorCountry.Color2;
if (color2Opt is not null)
{
Color2 = color2Opt;
}
// determine successions laws
history.InternalHistory.AddFieldValue("succession_laws",
successionLawMapper.GetCK3LawsForImperatorLaws(ImperatorCountry.GetLaws()),
conversionDate,
"succession_laws"
);
// determine CoA
CoA = coaMapper.GetCoaForFlagName(ImperatorCountry.Flag);
// determine other attributes
var srcCapital = ImperatorCountry.Capital;
if (srcCapital is not null)
{
var provMappingsForImperatorCapital = provinceMapper.GetCK3ProvinceNumbers((ulong)srcCapital);
if (provMappingsForImperatorCapital.Count > 0)
{
var foundCounty = parentCollection.GetCountyForProvince(provMappingsForImperatorCapital[0]);
if (foundCounty is not null)
{
CapitalCounty = foundCounty;
}
}
}
// determine country name localization
var nameSet = false;
if (validatedName is not null)
{
var nameLocBlock = Localizations.AddLocBlock(Id);
nameLocBlock.CopyFrom(validatedName);
nameSet = true;
}
if (!nameSet)
{
var impTagLoc = locDB.GetLocBlockForKey(ImperatorCountry.Tag);
if (impTagLoc is not null)
{
var nameLocBlock = Localizations.AddLocBlock(Id);
nameLocBlock.CopyFrom(impTagLoc);
nameSet = true;
}
}
if (!nameSet)
{
// use unlocalized name if not empty
var name = ImperatorCountry.Name;
if (!string.IsNullOrEmpty(name))
{
Logger.Warn($"Using unlocalized Imperator name {name} as name for {Id}!");
var nameLocBlock = Localizations.AddLocBlock(Id);
nameLocBlock["english"] = name;
nameLocBlock.FillMissingLocWithBaseLanguageLoc();
nameSet = true;
}
}
// giving up
if (!nameSet)
{
Logger.Warn($"{Id} needs help with localization! {ImperatorCountry.Name}?");
}
// determine adjective localization
TrySetAdjectiveLoc(locDB, imperatorCountries);
void FillHolderAndGovernmentHistory()
{
// ------------------ determine previous and current holders
// there was no 0 AD, but year 0 works in game and serves well for adding BC characters to holder history
var firstPossibleDate = new Date(0, 1, 1);
foreach (var impRulerTerm in ImperatorCountry.RulerTerms)
{
var rulerTerm = new RulerTerm(
impRulerTerm,
characters,
governmentMapper,
locDB,
religionMapper,
cultureMapper,
nicknameMapper,
provinceMapper
);
var characterId = rulerTerm.CharacterId;
var gov = rulerTerm.Government;
var startDate = new Date(rulerTerm.StartDate);
if (startDate < firstPossibleDate)
{
startDate = new Date(firstPossibleDate); // TODO: remove this workaround if CK3 supports negative dates
firstPossibleDate.ChangeByDays(1);
}
history.InternalHistory.AddFieldValue("holder", characterId, startDate, "holder");
if (gov is not null)
{
history.InternalHistory.AddFieldValue("government", gov, startDate, "government");
}
}
if (ImperatorCountry.Government is not null)
{
var lastCK3TermGov = history.GetGovernment(conversionDate);
var ck3CountryGov = governmentMapper.GetCK3GovernmentForImperatorGovernment(ImperatorCountry.Government);
if (lastCK3TermGov != ck3CountryGov && ck3CountryGov is not null)
{
history.InternalHistory.AddFieldValue("government", ck3CountryGov, conversionDate, "government");
}
}
}
}
public void InitializeFromTag(
Imperator.Countries.Country country,
Dictionary <ulong, Imperator.Countries.Country> imperatorCountries,
LocalizationMapper localizationMapper,
LandedTitles landedTitles,
ProvinceMapper provinceMapper,
CoaMapper coaMapper,
TagTitleMapper tagTitleMapper,
GovernmentMapper governmentMapper,
SuccessionLawMapper successionLawMapper,
DefiniteFormMapper definiteFormMapper
)
{
IsImportedOrUpdatedFromImperator = true;
ImperatorCountry = country;
// ------------------ determine CK3 title
LocBlock?validatedName;
// hard code for Antigonid Kingdom, Seleucid Empire and Maurya (which use customizable localization for name and adjective)
if (ImperatorCountry.Name == "PRY_DYN")
{
validatedName = localizationMapper.GetLocBlockForKey("get_pry_name_fallback");
}
else if (ImperatorCountry.Name == "SEL_DYN")
{
validatedName = localizationMapper.GetLocBlockForKey("get_sel_name_fallback");
}
else if (ImperatorCountry.Name == "MRY_DYN")
{
validatedName = localizationMapper.GetLocBlockForKey("get_mry_name_fallback");
}
// normal case
else
{
validatedName = ImperatorCountry.CountryName.GetNameLocBlock(localizationMapper, imperatorCountries);
}
HasDefiniteForm = definiteFormMapper.IsDefiniteForm(ImperatorCountry.Name);
string?title;
if (validatedName is not null)
{
title = tagTitleMapper.GetTitleForTag(ImperatorCountry.Tag, ImperatorCountry.GetCountryRank(), validatedName.english);
}
else
{
title = tagTitleMapper.GetTitleForTag(ImperatorCountry.Tag, ImperatorCountry.GetCountryRank());
}
if (title is null)
{
throw new ArgumentException("Country " + ImperatorCountry.Tag + " could not be mapped!");
}
Name = title;
SetRank();
PlayerCountry = ImperatorCountry.PlayerCountry;
// ------------------ determine previous and current holders
history.InternalHistory.SimpleFields.Remove("holder");
history.InternalHistory.SimpleFields.Remove("government");
// there was no 0 AD, but year 0 works in game and serves well for adding BC characters to holder history
var firstPossibleDate = new Date(0, 1, 1);
foreach (var impRulerTerm in ImperatorCountry.RulerTerms)
{
var rulerTerm = new RulerTerm(impRulerTerm, governmentMapper);
var characterId = rulerTerm.CharacterId;
var gov = rulerTerm.Government;
var startDate = new Date(rulerTerm.StartDate);
if (startDate < firstPossibleDate)
{
startDate = new Date(firstPossibleDate); // TODO: remove this workaround if CK3 supports negative dates
firstPossibleDate.ChangeByDays(1);
}
history.InternalHistory.AddSimpleFieldValue("holder", characterId, startDate);
if (gov is not null)
{
history.InternalHistory.AddSimpleFieldValue("government", gov, startDate);
}
}
// ------------------ determine color
var color1Opt = ImperatorCountry.Color1;
if (color1Opt is not null)
{
Color1 = color1Opt;
}
var color2Opt = ImperatorCountry.Color2;
if (color2Opt is not null)
{
Color2 = color2Opt;
}
// determine successions laws
SuccessionLaws = successionLawMapper.GetCK3LawsForImperatorLaws(ImperatorCountry.GetLaws());
// ------------------ determine CoA
CoA = coaMapper.GetCoaForFlagName(ImperatorCountry.Flag);
// ------------------ determine other attributes
var srcCapital = ImperatorCountry.Capital;
if (srcCapital is not null)
{
var provMappingsForImperatorCapital = provinceMapper.GetCK3ProvinceNumbers((ulong)srcCapital);
if (provMappingsForImperatorCapital.Count > 0)
{
var foundCounty = landedTitles.GetCountyForProvince(provMappingsForImperatorCapital[0]);
if (foundCounty is not null)
{
CapitalCounty = new(foundCounty.Name, foundCounty);
}
}
}
// ------------------ Country Name Locs
var nameSet = false;
if (validatedName is not null)
{
Localizations.Add(Name, validatedName);
nameSet = true;
}
if (!nameSet)
{
var impTagLoc = localizationMapper.GetLocBlockForKey(ImperatorCountry.Tag);
if (impTagLoc is not null)
{
Localizations.Add(Name, impTagLoc);
nameSet = true;
}
}
// giving up
if (!nameSet)
{
Logger.Warn($"{Name} needs help with localization! {ImperatorCountry.Name}?");
}
// --------------- Adjective Locs
TrySetAdjectiveLoc(localizationMapper, imperatorCountries);
}
