/* * public override int GetNumberOfFiefsDesired(DecisionMaker decisionMaker) * { * int baseNumber = CalculateBaseNumberOfFiefs(decisionMaker.Hero.Clan, Settings.Instance!.DesiredFiefsBaseline.SelectedValue.EnumValue); * return baseNumber >= 0 * ? Math.Max(0, baseNumber + Settings.Instance.DesiredFiefsModifier + CalculateTraitsModifierForDesiredFiefs(decisionMaker, Settings.Instance.DesiredFiefsBaseline.SelectedValue.EnumValue)) * : baseNumber; * } * * public override int GetNumberOfFiefsDeemedFair(Clan clan) * { * int baseNumber = CalculateBaseNumberOfFiefs(clan, Settings.Instance!.FiefsDeemedFairBaseline.SelectedValue.EnumValue); * return baseNumber >= 0 * ? Math.Max(0, baseNumber + Settings.Instance.FiefsDeemedFairModifier) * : baseNumber; * } */ //Protected overrides protected override float GetGeneralSupportScore(Clan clan, KingdomDecision decision, DecisionOutcome possibleOutcome) { return(decision switch { MakePeaceKingdomDecision makePeaceDecision => GetGeneralSupportScore(clan, makePeaceDecision, possibleOutcome), DeclareWarDecision declareWarDecision => GetGeneralSupportScore(clan, declareWarDecision, possibleOutcome), SettlementClaimantDecision claimantDecision => GetGeneralSupportScore(clan, claimantDecision, possibleOutcome), SettlementClaimantPreliminaryDecision annexationDecision => GetGeneralSupportScore(clan, annexationDecision, possibleOutcome), _ => throw new ArgumentOutOfRangeException(nameof(decision), string.Format("Kingdom decision of type {0} is not supported.", decision.GetType().FullName)), });
public static int GetRequiredDecisionCooldown(KingdomDecision decision) { return(decision switch { MakePeaceKingdomDecision _ => Settings.Instance !.MakePeaceDecisionCooldown, DeclareWarDecision _ => Settings.Instance !.DeclareWarDecisionCooldown, ExpelClanFromKingdomDecision _ => Settings.Instance !.ExpelClanDecisionCooldown, KingdomPolicyDecision _ => Settings.Instance !.KingdomPolicyDecisionCooldown, SettlementClaimantPreliminaryDecision _ => Settings.Instance !.AnnexationDecisionCooldown, _ => throw new ArgumentException(string.Format("{0} is not supported KingdomDecision type", decision.GetType().FullName), nameof(decision)), });
private float GetGeneralSupportScore(Clan clan, DeclareWarDecision declareWarDecision, DecisionOutcome possibleOutcome) { int valueForClan = new DeclareWarBarterable(declareWarDecision.Kingdom, declareWarDecision.FactionToDeclareWarOn).GetValueForFaction(clan); float situationalFactorValue = 0; if (Settings.Instance.WarSupportCalculationMethod.SelectedValue.EnumValue.HasFlag(PeaceAndWarConsideration.SituationalFactor)) { situationalFactorValue = ApplySituationalFactor(declareWarDecision, ref valueForClan); } return(FieldAccessHelper.ShouldWarBeDeclaredByRef(possibleOutcome) ? valueForClan * Campaign.Current.Models.DiplomacyModel.DenarsToInfluence() + situationalFactorValue : -valueForClan *Campaign.Current.Models.DiplomacyModel.DenarsToInfluence() - situationalFactorValue); }
private bool InternalEquals(KingdomDecision decision1, KingdomDecision decision2) { if (decision1.GetType() != decision2.GetType()) { return(false); } return(decision1 switch { MakePeaceKingdomDecision peaceDecision1 => peaceDecision1.FactionToMakePeaceWith == ((MakePeaceKingdomDecision)decision2).FactionToMakePeaceWith, DeclareWarDecision warDecision1 => warDecision1.FactionToDeclareWarOn == ((DeclareWarDecision)decision2).FactionToDeclareWarOn, ExpelClanFromKingdomDecision expelDecision1 => expelDecision1.ClanToExpel == ((ExpelClanFromKingdomDecision)decision2).ClanToExpel, KingdomPolicyDecision policyDecision1 => policyDecision1.Policy == ((KingdomPolicyDecision)decision2).Policy, SettlementClaimantPreliminaryDecision annexationDecision1 => annexationDecision1.Settlement == ((SettlementClaimantPreliminaryDecision)decision2).Settlement, _ => throw new ArgumentException(string.Format("{0} is not supported KingdomDecision type", decision1.GetType().FullName), nameof(decision1)), });
private double GetSupportScoreOfDecisionMaker(DecisionMaker decisionMaker, DeclareWarDecision declareWarDecision, DecisionOutcome possibleOutcome) { double traitScore = decisionMaker.Hero.GetTraitLevel(DefaultTraits.Valor) * 20 - decisionMaker.Hero.GetTraitLevel(DefaultTraits.Mercy) * 10; double relationshipFactorValue = Settings.Instance.WarSupportCalculationMethod.SelectedValue.EnumValue.HasFlag(PeaceAndWarConsideration.RelationshipFactor) ? CalculateRelationshipFactor(decisionMaker, declareWarDecision.FactionToDeclareWarOn) * Settings.Instance.DeclareWarRelationshipFactorStrength : 0; double tributeFactorValue = Settings.Instance.WarSupportCalculationMethod.SelectedValue.EnumValue.HasFlag(PeaceAndWarConsideration.TributeFactor) ? CalculateTributeFactor(decisionMaker, declareWarDecision.FactionToDeclareWarOn) * Settings.Instance.DeclareWarTributeFactorStrength : 0; return(FieldAccessHelper.ShouldWarBeDeclaredByRef(possibleOutcome) ? traitScore - relationshipFactorValue + tributeFactorValue : -traitScore + relationshipFactorValue - tributeFactorValue); }
public static bool Prefix(Clan clan, ref KingdomDecision __result, KingdomDecisionProposalBehavior __instance) //Bool prefixes compete with each other and skip others, as well as original, if return false { try { bool SubSystemEnabled = SettingsHelper.SubSystemEnabled(SubSystemType.ElectionCooldowns, clan); bool SystemDebugEnabled = SettingsHelper.SystemDebugEnabled(AOSystems.PoliticsRebalance, DebugType.General, clan); if (!SubSystemEnabled && !SystemDebugEnabled) { return(true); } Kingdom kingdom = clan.Kingdom; __result = null; if (kingdom.UnresolvedDecisions.FirstOrDefault(x => x is DeclareWarDecision) == null) { Kingdom randomElement = Kingdom.All.Where(x => x != kingdom && !x.IsAtWarWith(kingdom) && x.GetStanceWith(kingdom).PeaceDeclarationDate.ElapsedDaysUntilNow > 20.0 && !(SubSystemEnabled && AOCooldownManager.HasDecisionCooldown(new DeclareWarDecision(clan, x))) ).ToArray().GetRandomElement(); //ConsiderWarDelegate deConsiderWar = AccessHelper.GetDelegate<ConsiderWarDelegate, KingdomDecisionProposalBehavior>(__instance, "ConsiderWar"); if (randomElement != null && deConsiderWar(__instance, clan, kingdom, randomElement)) { __result = new DeclareWarDecision(clan, randomElement); } if (SystemDebugEnabled) { PoliticsDebugHelper.PrepareConsiderationDebugMessage(ConsiderationType.DeclaringWar, clan, randomElement, __result, out TextObject debugLogMessage); MessageHelper.SimpleMessage(debugLogMessage); } } return(false); } catch (Exception ex) { MethodInfo methodInfo = MethodBase.GetCurrentMethod() as MethodInfo; DebugHelper.HandleException(ex, methodInfo, "Harmony patch for KingdomDecisionProposalBehavior. GetRandomWarDecision"); return(true); } }
public static bool ConsiderWar(Clan clan, Kingdom kingdom, IFaction otherFaction) { int num = Campaign.Current.Models.DiplomacyModel.GetInfluenceCostOfProposingWar(kingdom) / 2; if (clan.Influence < (float)num) { return(false); } DeclareWarDecision declareWarDecision = new DeclareWarDecision(clan, otherFaction); if (declareWarDecision.CalculateSupport(clan) > 50f) { float kingdomSupportForDecision = GetKingdomSupportForDecision(declareWarDecision); if ((double)MBRandom.RandomFloat < (double)kingdomSupportForDecision - 0.55) { return(true); } } return(false); }
private static bool GetRandomWarDecision(Clan clan, ref KingdomDecision __result) { if (!DiplomacySetting.Instance.EnableSmartChoseFactionToDeclareWar) { return(true); } __result = null; Kingdom kingdom = clan.Kingdom; if (kingdom.UnresolvedDecisions.FirstOrDefault((KingdomDecision x) => x is DeclareWarDecision) != null) { return(false); } IFaction DeclaredWarFaction = KingdomDecisionProposalBehaviorHelp.GetRandomPossibleDeclarWar(kingdom); if (DeclaredWarFaction != null && KingdomDecisionProposalBehaviorHelp.ConsiderWar(clan, kingdom, DeclaredWarFaction)) { // InformationManager.DisplayMessage(new InformationMessage(kingdom.Name.ToString() + ":" + DeclaredWarFaction.Name.ToString())); __result = new DeclareWarDecision(clan, DeclaredWarFaction); } return(false); }
public static void Postfix(Clan clan, DecisionOutcome possibleOutcome, ref float __result, DeclareWarDecision __instance) { try { float newResult = Campaign.Current.GetAOGameModels().DecisionSupportScoringModel.DetermineSupport(clan, __instance, possibleOutcome); if (SettingsHelper.SystemDebugEnabled(AOSystems.PoliticsRebalance, DebugType.Technical, clan)) { MessageHelper.TechnicalMessage(string.Format("Support of {0} for {1} declaring war on {2}.\nNative result = {3}. Rebalanced result = {4}", clan.Name, FieldAccessHelper.ShouldPeaceBeDeclaredByRef(possibleOutcome) ? "accepting" : "denying", __instance.FactionToDeclareWarOn, __result, newResult)); } if (SettingsHelper.SubSystemEnabled(SubSystemType.DeclareWarSupportRebalance, clan)) { __result = newResult; } } catch (Exception ex) { MethodInfo methodInfo = MethodBase.GetCurrentMethod() as MethodInfo; DebugHelper.HandleException(ex, methodInfo, "Harmony patch for DeclareWarDecision. DetermineSupport"); } }
private float ApplySituationalFactor(DeclareWarDecision declareWarDecision, ref int valueForClan) { (float value, int multiplier) = CalculateSituationalFactor(declareWarDecision.Kingdom, declareWarDecision.FactionToDeclareWarOn); valueForClan /= multiplier; return(value * Settings.Instance.DeclareWarSituationalFactorStrength); }