public static bool HasPrimaryDecisionCooldown(KingdomDecision decision, out float elapsedDaysUntilNow)
{
elapsedDaysUntilNow = default;
return(SupportedDecisionTypes.Contains(decision.GetType()) &&
KingdomDecisionHistory.TryGetValue(decision, out KingdomDecisionConclusion decisionConclusion) &&
(elapsedDaysUntilNow = decisionConclusion.ConclusionTime.ElapsedDaysUntilNow) < GetRequiredDecisionCooldown(decision));
}
private void RegisterKingdomDecisionConcluded(KingdomDecision decision, DecisionOutcome chosenOutcome, bool isPlayerInvolved)
{
if (AOCooldownManager.SupportedDecisionTypes.Contains(decision.GetType()))
{
_cooldownManager.UpdateKingdomDecisionHistory(decision, chosenOutcome, CampaignTime.Now);
}
}
public void UpdateKingdomDecisionHistory(KingdomDecision decision, DecisionOutcome chosenOutcome, CampaignTime conclusionTime)
{
if (SupportedDecisionTypes.Contains(decision.GetType()))
{
if (_KingdomDecisionHistory.ContainsKey(decision))
{
_KingdomDecisionHistory.Remove(decision);
}
_KingdomDecisionHistory[decision] = new KingdomDecisionConclusion(chosenOutcome, conclusionTime);
}
else
{
throw new ArgumentException(string.Format("{0} is not supported KingdomDecision type", decision.GetType().FullName), nameof(decision));
}
}
public static int GetRequiredDecisionCooldown(KingdomDecision decision)
{
switch (decision)
{
case MakePeaceKingdomDecision _:
return(Settings.Instance.MakePeaceDecisionCooldown);
case DeclareWarDecision _:
return(Settings.Instance.DeclareWarDecisionCooldown);
case ExpelClanFromKingdomDecision _:
return(Settings.Instance.ExpelClanDecisionCooldown);
case KingdomPolicyDecision _:
return(Settings.Instance.KingdomPolicyDecisionCooldown);
case SettlementClaimantPreliminaryDecision _:
return(Settings.Instance.AnnexationDecisionCooldown);
default:
throw new ArgumentException(string.Format("{0} is not supported KingdomDecision type", decision.GetType().FullName), nameof(decision));
}
}
/*
* 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)),
});
protected override double GetSupportScoreOfDecisionMaker(DecisionMaker decisionMaker, KingdomDecision decision, DecisionOutcome possibleOutcome)
{
switch (decision)
{
case MakePeaceKingdomDecision makePeaceDecision: return(GetSupportScoreOfDecisionMaker(decisionMaker, makePeaceDecision, possibleOutcome) * decisionMaker.DecisionWeight);
case DeclareWarDecision declareWarDecision: return(GetSupportScoreOfDecisionMaker(decisionMaker, declareWarDecision, possibleOutcome) * decisionMaker.DecisionWeight);
case SettlementClaimantDecision claimantDecision: return(GetSupportScoreOfDecisionMaker(decisionMaker, claimantDecision, possibleOutcome) * decisionMaker.DecisionWeight);
case SettlementClaimantPreliminaryDecision annexationDecision: return(GetSupportScoreOfDecisionMaker(decisionMaker, annexationDecision, possibleOutcome) * decisionMaker.DecisionWeight);
default:
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)),
});
