/*
* 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);
}
