Ejemplo n.º 1
0
        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);
        }
Ejemplo n.º 2
0
        public void InitializeFromGovernorship(
            Imperator.Countries.Country country,
            Imperator.Jobs.Governorship governorship,
            Dictionary <ulong, Imperator.Characters.Character> imperatorCharacters,
            LocalizationMapper localizationMapper,
            LandedTitles landedTitles,
            ProvinceMapper provinceMapper,
            CoaMapper coaMapper,
            TagTitleMapper tagTitleMapper,
            DefiniteFormMapper definiteFormMapper,
            Mappers.Region.ImperatorRegionMapper imperatorRegionMapper
            )
        {
            IsImportedOrUpdatedFromImperator = true;

            // ------------------ determine CK3 title

            if (country.CK3Title is null)
            {
                throw new ArgumentException($"{country.Tag} governorship of {governorship.RegionName} could not be mapped to CK3 title: liege doesn't exist!");
            }

            HasDefiniteForm = definiteFormMapper.IsDefiniteForm(governorship.RegionName);

            string?title = null;

            title        = tagTitleMapper.GetTitleForGovernorship(governorship.RegionName, country.Tag, country.CK3Title.Name);
            DeJureLiege  = country.CK3Title;
            DeFactoLiege = country.CK3Title;
            if (title is null)
            {
                throw new ArgumentException($"{country.Tag} governorship of {governorship.RegionName} could not be mapped to CK3 title!");
            }

            Name = title;

            SetRank();

            PlayerCountry = false;

            var impGovernor         = imperatorCharacters[governorship.CharacterID];
            var normalizedStartDate = governorship.StartDate.Year > 0 ? governorship.StartDate : new Date(1, 1, 1);

            // ------------------ determine holder
            history.InternalHistory.AddSimpleFieldValue("holder", $"imperator{impGovernor.ID}", normalizedStartDate);

            // ------------------ determine government
            var ck3LiegeGov = country.CK3Title.GetGovernment(governorship.StartDate);

            if (ck3LiegeGov is not null)
            {
                history.InternalHistory.AddSimpleFieldValue("government", ck3LiegeGov, normalizedStartDate);
            }

            // ------------------ determine color
            var color1Opt = country.Color1;

            if (color1Opt is not null)
            {
                Color1 = color1Opt;
            }
            var color2Opt = country.Color2;

            if (color2Opt is not null)
            {
                Color2 = color2Opt;
            }

            // determine successions laws
            // https://github.com/ParadoxGameConverters/ImperatorToCK3/issues/90#issuecomment-817178552
            SuccessionLaws = new() { "high_partition_succession_law" };

            // ------------------ determine CoA
            CoA = null;             // using game-randomized CoA

            // ------------------ determine capital
            var governorProvince = impGovernor.ProvinceID;

            if (imperatorRegionMapper.ProvinceIsInRegion(governorProvince, governorship.RegionName))
            {
                foreach (var ck3Prov in provinceMapper.GetCK3ProvinceNumbers(governorProvince))
                {
                    var foundCounty = landedTitles.GetCountyForProvince(ck3Prov);
                    if (foundCounty is not null)
                    {
                        CapitalCounty = new(foundCounty.Name, foundCounty);
                        break;
                    }
                }
            }

            // ------------------ Country Name Locs
            var      nameSet                  = false;
            LocBlock?regionLocBlock           = localizationMapper.GetLocBlockForKey(governorship.RegionName);
            var      countryAdjectiveLocBlock = country.CK3Title.Localizations[country.CK3Title.Name + "_adj"];

            if (regionLocBlock is not null && countryAdjectiveLocBlock is not null)
            {
                var nameLocBlock = new LocBlock(regionLocBlock);
                nameLocBlock.ModifyForEveryLanguage(countryAdjectiveLocBlock,
                                                    (ref string orig, string adj) => orig = $"{adj} {orig}"
                                                    );
                Localizations.Add(Name, nameLocBlock);
                nameSet = true;
            }
            if (!nameSet && regionLocBlock is not null)
            {
                var nameLocBlock = new LocBlock(regionLocBlock);
                Localizations.Add(Name, nameLocBlock);
                nameSet = true;
            }
            if (!nameSet)
            {
                Logger.Warn($"{Name} needs help with localization!");
            }

            // --------------- Adjective Locs
            var adjSet = false;

            if (countryAdjectiveLocBlock is not null)
            {
                var adjLocBlock = new LocBlock(countryAdjectiveLocBlock);
                Localizations.Add(Name + "_adj", adjLocBlock);
                adjSet = true;
            }
            if (!adjSet)
            {
                Logger.Warn($"{Name} needs help with adjective localization!");
            }
        }