private void OnPostRoundEnd()
{
if (!this.UseGold() || this.RoundController.IsMatchEnding)
{
return;
}
foreach (NetworkCommunicator networkPeer in GameNetwork.NetworkPeers)
{
MissionPeer component = networkPeer.GetComponent <MissionPeer>();
if (component != null && this.RoundController.RoundCount > 0)
{
int num1 = 300;
int num2 = this.GetCurrentGoldForPeer(component);
if (num2 < 0)
{
num2 = 80;
}
else if (component.Team != null && component.Team.Side != BattleSideEnum.None && (this.RoundController.RoundWinner == component.Team.Side && component.GetComponent <FlagDominationMissionRepresentative>().CheckIfSurvivedLastRoundAndReset()))
{
num2 += 30;
}
int newAmount = num1 + MBMath.ClampInt(num2, 0, 80);
if (newAmount > 300)
{
this.NotificationsComponent.GoldCarriedFromPreviousRound(newAmount - 300, component.GetNetworkPeer());
}
this.ChangeCurrentGoldForPeer(component, newAmount);
}
}
}
private void RespecHero(Hero hero)
{
InformationManager.DisplayMessage(new InformationMessage($"{hero.Name} will be demolished."));
InformationManager.DisplayMessage(new InformationMessage($"Clearing Perks..."));
hero.ClearPerks();
// re-initialize skills to activate perks
foreach (SkillObject skill in DefaultSkills.GetAllSkills())
{
int skill_level = hero.GetSkillValue(skill);
hero.HeroDeveloper.SetInitialSkillLevel(skill, skill_level);
}
int statpoints = hero.HeroDeveloper.UnspentAttributePoints;
int focuspoints = hero.HeroDeveloper.UnspentFocusPoints;
int focus_to_add = 0;
int statpoints_to_add = 0;
InformationManager.DisplayMessage(new InformationMessage($"Unspent: {statpoints} stat | {focuspoints} focus"));
InformationManager.DisplayMessage(new InformationMessage($"Demolishing focus..."));
foreach (SkillObject skill in DefaultSkills.GetAllSkills())
{
int focus_in_skill = hero.HeroDeveloper.GetFocus(skill);
if (focus_in_skill > 0)
{
InformationManager.DisplayMessage(new InformationMessage($"{skill.Name}; {focus_in_skill}"));
focus_to_add += focus_in_skill;
}
}
InformationManager.DisplayMessage(new InformationMessage($"{focus_to_add} focus points reclaimed"));
hero.HeroDeveloper.UnspentFocusPoints += MBMath.ClampInt(focus_to_add, 0, 999);
hero.HeroDeveloper.ClearFocuses();
InformationManager.DisplayMessage(new InformationMessage($"Demolishing stats..."));
for (CharacterAttributesEnum statEnum = CharacterAttributesEnum.Vigor; statEnum < CharacterAttributesEnum.NumCharacterAttributes; statEnum++)
{
int attributeValue = hero.GetAttributeValue(statEnum);
InformationManager.DisplayMessage(new InformationMessage($"{statEnum} {attributeValue} --> 0"));
statpoints_to_add += attributeValue;
hero.SetAttributeValue(statEnum, 0);
}
InformationManager.DisplayMessage(new InformationMessage($"{statpoints_to_add} stat points reclaimed"));
hero.HeroDeveloper.UnspentAttributePoints += MBMath.ClampInt(statpoints_to_add, 0, 999);
InformationManager.DisplayMessage(new InformationMessage($"Unspent: {hero.HeroDeveloper.UnspentAttributePoints} stat | {hero.HeroDeveloper.UnspentFocusPoints} focus"));
}
private void ApplyAIWithholdDecision(bool decisionIsWithhold)
{
if (!decisionIsWithhold || WithholdCost is null)
{
return;
}
LeavingClan.Kingdom.RulingClan.Influence = MBMath.ClampFloat(LeavingClan.Kingdom.RulingClan.Influence - WithholdCost.InfluenceCost, 0f, float.MaxValue);
LeavingClan.Kingdom.Ruler.Gold = MBMath.ClampInt(LeavingClan.Kingdom.Ruler.Gold - WithholdCost.GoldCost, 0, int.MaxValue);
}
public static void ResetAttrs([NotNull] this Hero hero)
{
int attrValues = 0;
for (var i = CharacterAttributesEnum.First; i < CharacterAttributesEnum.End; i++)
{
var currentAttrValue = hero.GetAttributeValue(i);
attrValues += currentAttrValue - 1;
hero.SetAttributeValue(i, 1);
}
hero.HeroDeveloper.UnspentAttributePoints += MBMath.ClampInt(attrValues, 0, 999);
}
public void ReAttHero(Hero hero)
{
int num = 0;
for (CharacterAttributesEnum characterAttributesEnum = CharacterAttributesEnum.Vigor; characterAttributesEnum < CharacterAttributesEnum.NumCharacterAttributes; characterAttributesEnum++)
{
int attributeValue = hero.GetAttributeValue(characterAttributesEnum);
num += attributeValue;
hero.SetAttributeValue(characterAttributesEnum, 0);
}
hero.HeroDeveloper.UnspentAttributePoints += MBMath.ClampInt(num, 0, 999);
}
public static void Postfix(ref int __result)
{
bool learningPatch = Settings.Instance.HeroSkillExperienceMultiplierEnabled;
if (learningPatch)
{
float learningLimitMultiplier = 20;
int minimumLearningLimit = 200;
int num = __result;
__result = MBMath.ClampInt((int)Math.Ceiling((float)num * learningLimitMultiplier), minimumLearningLimit, 99999);
}
}
public static void ResetFocus([NotNull] this Hero hero)
{
//var focus = DefaultSkills.GetAllSkills().Sum(skill => hero.HeroDeveloper.GetFocus(skill));
//hero.HeroDeveloper.UnspentFocusPoints += MBMath.ClampInt(focus, 0, 999);
//hero.HeroDeveloper.ClearFocuses();
int count = 0;
foreach (var item in DefaultSkills.GetAllSkills())
{
var focus = hero.HeroDeveloper.GetFocus(item);
hero.HeroDeveloper.AddFocus(item, 0 - focus, false);
count += focus;
}
hero.HeroDeveloper.UnspentFocusPoints += MBMath.ClampInt(count, 0, 999);
}
public void RefocusHero(Hero hero)
{
int num = 0;
int num2 = 0;
foreach (SkillObject skill in DefaultSkills.GetAllSkills())
{
int focus = hero.HeroDeveloper.GetFocus(skill);
if (focus > 0)
{
num += focus;
hero.HeroDeveloper.AddFocus(skill, num2 - focus, false);
}
}
hero.HeroDeveloper.UnspentFocusPoints += MBMath.ClampInt(num, 0, 999);
}
public void ChangeTeamScore(Team team, int scoreChange)
{
this._sides[(int)team.Side].SideScore += scoreChange;
this._sides[(int)team.Side].SideScore = MBMath.ClampInt(this._sides[(int)team.Side].SideScore, -120000, 120000);
if (GameNetwork.IsServer)
{
GameNetwork.BeginBroadcastModuleEvent();
GameNetwork.WriteMessage((GameNetworkMessage) new NetworkMessages.FromServer.UpdateRoundScores(this.GetRoundScore(BattleSideEnum.Attacker), this.GetRoundScore(BattleSideEnum.Defender)));
GameNetwork.EndBroadcastModuleEvent(GameNetwork.EventBroadcastFlags.None);
}
if (this.OnRoundPropertiesChanged == null)
{
return;
}
this.OnRoundPropertiesChanged();
}
public void ChangeCurrentGoldForPeer(MissionPeer peer, int newAmount)
{
if (newAmount >= 0)
{
newAmount = MBMath.ClampInt(newAmount, 0, 2000);
}
if (peer.Peer.Communicator.IsConnectionActive)
{
GameNetwork.BeginBroadcastModuleEvent();
GameNetwork.WriteMessage((GameNetworkMessage) new SyncGoldsForSkirmish(peer.Peer, newAmount));
GameNetwork.EndBroadcastModuleEvent(GameNetwork.EventBroadcastFlags.None);
}
if (this.GameModeBaseClient == null)
{
return;
}
this.GameModeBaseClient.OnGoldAmountChangedForRepresentative(peer.Representative, newAmount);
}
public static void RespecHero(Hero hero)
{
if (hero == default)
{
return;
}
int num1 = 0;
int num2 = 0;
DisplayMessage(string.Format("{0}", hero));
RespecPerks(hero);
DisplayMessage("Clearing focus...");
using (IEnumerator <SkillObject> enumerator = DefaultSkills.GetAllSkills().GetEnumerator())
{
while (enumerator.MoveNext())
{
var current = enumerator.Current;
int focus = hero.HeroDeveloper.GetFocus(current);
if (focus > 0)
{
num1 += focus;
}
}
}
hero.HeroDeveloper.UnspentFocusPoints += MBMath.ClampInt(num1, 0, 999);
hero.HeroDeveloper.ClearFocuses();
DisplayMessage("Clearing stats...");
for (CharacterAttributesEnum characterAttributesEnum = 0; characterAttributesEnum < CharacterAttributesEnum.End; characterAttributesEnum += 1)
{
int attributeValue = hero.GetAttributeValue(characterAttributesEnum);
if (hero == Hero.MainHero)
{
num2 += attributeValue - 2;
hero.SetAttributeValue(characterAttributesEnum, 2);
}
else
{
num2 += attributeValue - 1;
hero.SetAttributeValue(characterAttributesEnum, 1);
}
}
hero.HeroDeveloper.UnspentAttributePoints += MBMath.ClampInt(num2, 0, 999);
DisplayMessage(string.Format("Unspent: {0} stat | {1} focus", hero.HeroDeveloper.UnspentAttributePoints, hero.HeroDeveloper.UnspentFocusPoints));
}
//CalculateNativeForSettlementClaimantDecision
private double CalculateNativeForSettlementClaimantDecision(DecisionMaker decisionMaker, SettlementClaimantDecision claimantDecision, DecisionOutcome possibleOutcome)
{
float initialMeritScore = possibleOutcome.InitialMerit * MathF.Clamp(1f + decisionMaker.Hero.GetTraitLevel(DefaultTraits.Honor), 0f, 2f);
float basicScoreForOutcome;
int calculatingTraitLevel = MBMath.ClampInt(decisionMaker.Hero.GetTraitLevel(DefaultTraits.Calculating), -2, 2);
bool outcomeIsClanOfDM = FieldAccessHelper.ClanAsDecisionOutcomeByRef(possibleOutcome) == decisionMaker.Hero.Clan;
if (outcomeIsClanOfDM)
{
float settlementValueForFaction = claimantDecision.Settlement.GetSettlementValueForFaction(decisionMaker.Hero.Clan);
basicScoreForOutcome = initialMeritScore + 0.2f * settlementValueForFaction * Campaign.Current.Models.DiplomacyModel.DenarsToInfluence();
}
else
{
float relationBetweenClans = !outcomeIsClanOfDM?FactionManager.GetRelationBetweenClans(FieldAccessHelper.ClanAsDecisionOutcomeByRef(possibleOutcome), decisionMaker.Hero.Clan) : 100f;
basicScoreForOutcome = initialMeritScore * MathF.Clamp(1f + calculatingTraitLevel, 0f, 2f) + relationBetweenClans * 0.2f * calculatingTraitLevel;
}
double calculatingModifier = (1.0 - (calculatingTraitLevel > 0 ? 0.4 - Math.Min(2f, calculatingTraitLevel) * 0.1 : 0.4 + Math.Min(2f, Math.Abs(calculatingTraitLevel)) * 0.1) * 1.5);
return(basicScoreForOutcome * calculatingModifier * (outcomeIsClanOfDM ? 2f : 1f));
}
public void SetGenderAndAdjustParams(int gender, int curAge)
{
this._currentGender = gender;
int hairNum = 0;
int beardNum = 0;
int faceTextureNum = 0;
int mouthTextureNum = 0;
int eyebrowNum = 0;
int soundNum = 0;
int faceTattooNum = 0;
float scale = 0.0f;
MBBodyProperties.GetParamsMax(gender, curAge, ref hairNum, ref beardNum, ref faceTextureNum, ref mouthTextureNum, ref faceTattooNum, ref soundNum, ref eyebrowNum, ref scale);
this._currentHair = MBMath.ClampInt(this._currentHair, 0, hairNum - 1);
this._curBeard = MBMath.ClampInt(this._curBeard, 0, beardNum - 1);
this._curFaceTexture = MBMath.ClampInt(this._curFaceTexture, 0, faceTextureNum - 1);
this._curMouthTexture = MBMath.ClampInt(this._curMouthTexture, 0, mouthTextureNum - 1);
this._curFaceTattoo = MBMath.ClampInt(this._curFaceTattoo, 0, faceTattooNum - 1);
this._currentVoice = MBMath.ClampInt(this._currentVoice, 0, soundNum - 1);
this._voicePitch = MBMath.ClampFloat(this._voicePitch, 0.0f, 1f);
this._curEyebrow = MBMath.ClampInt(this._curEyebrow, 0, eyebrowNum - 1);
}
private Clan CreateRebellionClan(SettlementInfo info)
{
Clan clan = MBObjectManager.Instance.CreateObject <Clan>(info.Settlement.Name.ToString() + "_rebels_" + MBRandom.RandomInt(100000).ToString());
Hero hero = HeroCreator.CreateSpecialHero(CreateLordCharacter(info.OriginalCulture), info.Settlement, clan, clan, 30);
TextObject name = new TextObject(hero.Name.ToString());
int value = MBMath.ClampInt(1, DefaultTraits.Commander.MinValue, DefaultTraits.Commander.MaxValue);
hero.SetTraitLevel(DefaultTraits.Commander, value);
hero.ChangeState(Hero.CharacterStates.Active);
hero.Initialize();
clan.InitializeClan(name, name, info.OriginalCulture, Banner.CreateRandomClanBanner(MBRandom.RandomInt(100000)));
hero.Clan = clan;
clan.SetLeader(hero);
clan.IsUnderMercenaryService = false;
var kingdom = FormRebelKingdom(clan, info.Settlement, info.CurrentFaction);
kingdom.ReactivateKingdom();
DeclareWarAction.Apply(kingdom, info.CurrentFaction);
clan.ClanJoinFaction(kingdom);
kingdom.RulingClan = clan;
return(clan);
}
private void UpdatePersonalRelation(Hero baseHero, Hero otherHero, int relationChange)
{
int newValue = MBMath.ClampInt(CharacterRelationManager.GetHeroRelation(baseHero, otherHero) + relationChange, -100, 100);
CharacterRelationManager.SetHeroRelation(baseHero, otherHero, newValue);
}
public static void GetAttackCollisionResults(Mission.Missile missile, bool isHorseArcher, float armorAmountFloat, WeaponComponentData shieldOnBack, AgentFlag victimAgentFlag, float victimAgentAbsorbedDamageRatio, float damageMultiplierOfBone, float combatDifficultyMultiplier, MissionWeapon victimShield, bool canGiveDamageToAgentShield, bool isVictimAgentLeftStance, bool isFriendlyFire, bool doesAttackerHaveMountAgent, bool doesVictimHaveMountAgent, Vec2 attackerAgentMovementVelocity, Vec3 attackerAgentMountMovementDirection, float attackerMovementDirectionAsAngle, Vec2 victimAgentMovementVelocity, Vec3 victimAgentMountMovementDirection, float victimMovementDirectionAsAngle, bool isVictimAgentSameWithAttackerAgent, bool isAttackerAgentMine, bool isAttackerAgentHasRiderAgent, bool isAttackerAgentRiderAgentIsMine, bool isAttackerAgentMount, bool isVictimAgentMine, bool isVictimAgentHasRiderAgent, bool isVictimAgentRiderAgentIsMine, bool isVictimAgentMount, bool isAttackerAgentNull, bool isAttackerAIControlled, BasicCharacterObject attackerAgentCharacter, BasicCharacterObject victimAgentCharacter, Vec3 attackerAgentMovementDirection, Vec3 attackerAgentVelocity, float attackerAgentMountChargeDamageProperty, Vec3 attackerAgentCurrentWeaponOffset, bool isAttackerAgentHuman, bool isAttackerAgentActive, bool isAttackerAgentCharging, bool isVictimAgentNull, float victimAgentScale, float victimAgentWeight, float victimAgentTotalEncumbrance, bool isVictimAgentHuman, Vec3 victimAgentVelocity, Vec3 victimAgentPosition, int weaponAttachBoneIndex, MissionWeapon offHandItem, bool isHeadShot, bool crushedThrough, bool IsVictimRiderAgentSameAsAttackerAgent, float momentumRemaining, ref AttackCollisionData attackCollisionData, bool cancelDamage, string victimAgentName, out CombatLogData combatLog)
{
float distance = 0f;
if (attackCollisionData.IsMissile)
{
distance = (attackCollisionData.MissileStartingPosition - attackCollisionData.CollisionGlobalPosition).Length;
}
combatLog = new CombatLogData(isVictimAgentSameWithAttackerAgent, isAttackerAgentHuman, isAttackerAgentMine, isAttackerAgentHasRiderAgent, isAttackerAgentRiderAgentIsMine, isAttackerAgentMount, isVictimAgentHuman, isVictimAgentMine, false, isVictimAgentHasRiderAgent, isVictimAgentRiderAgentIsMine, isVictimAgentMount, false, IsVictimRiderAgentSameAsAttackerAgent, false, false, distance);
ItemObject itemFromWeaponKind = ItemObject.GetItemFromWeaponKind(attackCollisionData.AffectorWeaponKind);
WeaponComponentData weaponComponentData = (itemFromWeaponKind != null) ? itemFromWeaponKind.GetWeaponWithUsageIndex(attackCollisionData.CurrentUsageIndex) : null;
bool flag = Extensions.HitWithAnotherBone(ref attackCollisionData, weaponAttachBoneIndex);
Vec3 agentVelocityContribution = Extensions.GetAgentVelocityContribution(doesAttackerHaveMountAgent, attackerAgentMovementVelocity, attackerAgentMountMovementDirection, attackerMovementDirectionAsAngle);
Vec3 agentVelocityContribution2 = Extensions.GetAgentVelocityContribution(doesVictimHaveMountAgent, victimAgentMovementVelocity, victimAgentMountMovementDirection, victimMovementDirectionAsAngle);
if (attackCollisionData.IsColliderAgent)
{
combatLog.IsRangedAttack = attackCollisionData.IsMissile;
combatLog.HitSpeed = (attackCollisionData.IsMissile ? (agentVelocityContribution2 - attackCollisionData.MissileVelocity).Length : (agentVelocityContribution - agentVelocityContribution2).Length);
}
float baseMagnitude;
int speedBonus;
Mission.ComputeBlowMagnitude(ref attackCollisionData, doesVictimHaveMountAgent, weaponComponentData, isAttackerAgentNull, attackerAgentCharacter, attackerAgentMovementDirection, attackerAgentVelocity, attackerAgentMountChargeDamageProperty, attackerAgentCurrentWeaponOffset, isAttackerAgentHuman, isAttackerAgentActive, isAttackerAgentCharging, isVictimAgentNull, victimAgentScale, victimAgentWeight, victimAgentTotalEncumbrance, isVictimAgentHuman, victimAgentVelocity, victimAgentPosition, momentumRemaining, cancelDamage, flag, attackCollisionData.MissileTotalDamage, agentVelocityContribution, agentVelocityContribution2, out attackCollisionData.BaseMagnitude, out baseMagnitude, out attackCollisionData.MovementSpeedDamageModifier, out speedBonus);
DamageTypes damageType = (itemFromWeaponKind == null || flag || attackCollisionData.IsAlternativeAttack || attackCollisionData.IsFallDamage || attackCollisionData.IsHorseCharge) ? DamageTypes.Blunt : ((DamageTypes)attackCollisionData.DamageType);
combatLog.DamageType = damageType;
if (!attackCollisionData.IsColliderAgent && attackCollisionData.EntityExists)
{
string name = PhysicsMaterial.GetFromIndex(attackCollisionData.PhysicsMaterialIndex).Name;
bool isWoodenBody = name == "wood" || name == "wood_weapon" || name == "wood_shield";
attackCollisionData.BaseMagnitude *= Extensions.GetEntityDamageMultiplier(isAttackerAgentCharging, weaponComponentData, damageType, isWoodenBody);
attackCollisionData.InflictedDamage = MBMath.ClampInt((int)attackCollisionData.BaseMagnitude, 0, 2000);
combatLog.InflictedDamage = attackCollisionData.InflictedDamage;
}
int num = 0;
if (attackCollisionData.IsColliderAgent && !isVictimAgentNull)
{
if (attackCollisionData.IsAlternativeAttack)
{
baseMagnitude = attackCollisionData.BaseMagnitude;
}
if (attackCollisionData.AttackBlockedWithShield)
{
Mission.ComputeBlowDamageOnShield(isAttackerAgentNull, isAttackerAgentActive, isAttackerAgentCharging, canGiveDamageToAgentShield, isVictimAgentLeftStance, victimShield, ref attackCollisionData, weaponComponentData, attackCollisionData.BaseMagnitude);
attackCollisionData.AbsorbedByArmor = attackCollisionData.InflictedDamage;
}
else
{
Mission.ComputeBlowDamage(armorAmountFloat, shieldOnBack, victimAgentFlag, victimAgentAbsorbedDamageRatio, damageMultiplierOfBone, combatDifficultyMultiplier, damageType, baseMagnitude, attackCollisionData.CollisionGlobalPosition, itemFromWeaponKind, attackCollisionData.AttackBlockedWithShield, attackCollisionData.CollidedWithShieldOnBack, speedBonus, cancelDamage, attackCollisionData.IsFallDamage, out attackCollisionData.InflictedDamage, out attackCollisionData.AbsorbedByArmor, out num);
}
GCOToolbox.GCOToolbox.ProjectileBalance.ApplyProjectileArmorResistance(armorAmountFloat, ref attackCollisionData, missile, isHorseArcher);
combatLog.InflictedDamage = attackCollisionData.InflictedDamage;
combatLog.AbsorbedDamage = attackCollisionData.AbsorbedByArmor;
//combatLog.AttackProgress = attackCollisionData.AttackProgress;
//issionGameModels.Current.AgentApplyDamageModel.CalculateDamage(attackerAgentCharacter, victimAgentCharacter, offHandItem, isHeadShot, isVictimAgentMount, isVictimAgentHuman, doesAttackerHaveMountAgent, isVictimAgentNull, isAttackerAgentHuman, attackCollisionData, weaponComponentData);
//combatLog.ExtraDamage = attackCollisionData.InflictedDamage - combatLog.InflictedDamage;
}
if (!attackCollisionData.IsFallDamage && isFriendlyFire && !isAttackerAIControlled && GameNetwork.IsSessionActive)
{
int num2 = attackCollisionData.IsMissile ? MultiplayerOptions.OptionType.FriendlyFireDamageRangedSelfPercent.GetIntValue(MultiplayerOptions.MultiplayerOptionsAccessMode.CurrentMapOptions) : MultiplayerOptions.OptionType.FriendlyFireDamageMeleeSelfPercent.GetIntValue(MultiplayerOptions.MultiplayerOptionsAccessMode.CurrentMapOptions);
attackCollisionData.SelfInflictedDamage = MBMath.Round((float)attackCollisionData.InflictedDamage * ((float)num2 * 0.01f));
int num3 = attackCollisionData.IsMissile ? MultiplayerOptions.OptionType.FriendlyFireDamageRangedFriendPercent.GetIntValue(MultiplayerOptions.MultiplayerOptionsAccessMode.CurrentMapOptions) : MultiplayerOptions.OptionType.FriendlyFireDamageMeleeFriendPercent.GetIntValue(MultiplayerOptions.MultiplayerOptionsAccessMode.CurrentMapOptions);
attackCollisionData.InflictedDamage = MBMath.Round((float)attackCollisionData.InflictedDamage * ((float)num3 * 0.01f));
if (isVictimAgentMount && !doesAttackerHaveMountAgent)
{
attackCollisionData.InflictedDamage = MBMath.Round((float)attackCollisionData.InflictedDamage * 0.1f);
}
combatLog.InflictedDamage = attackCollisionData.InflictedDamage;
combatLog.IsFriendlyFire = true;
}
if (attackCollisionData.AttackBlockedWithShield && attackCollisionData.InflictedDamage > 0 && (int)victimShield.HitPoints - attackCollisionData.InflictedDamage <= 0)
{
attackCollisionData.IsShieldBroken = true;
}
}
public void ChangeGold(int amount) => Capital = MBMath.ClampInt(Capital + amount, 1, 10000);