private static bool HasSiegeEngineJustBeenConstructed(ISiegeEventSide playerSiegeEvent, int deployedSiegeEngineCount, int reservedSiegeEngineCount)
 {
     if (playerSiegeEvent.SiegeEngines.DeployedSiegeEngines.Count <= deployedSiegeEngineCount)
     {
         return(false);
     }
     return(playerSiegeEvent.SiegeEngines.ReservedSiegeEngines.Count == reservedSiegeEngineCount);
 }
Beispiel #2
0
 public static void BombardPrefix(ISiegeEventSide siegeEventSide, SiegeEngineType attackerEngineType, SiegeEvent.SiegeEngineConstructionProgress damagedEngine)
 {
     if (!IsCatapult(attackerEngineType))
     {
         return;
     }
     CalculateBonusDamageAndRates(attackerEngineType, siegeEventSide, out _, out var bonusDamage);
     damagedEngine.SetHitpoints(damagedEngine.Hitpoints - bonusDamage);
 }
        private static void CalculateBonusFlatHpAndRateFromPerk(SiegeEvent.SiegeEngineConstructionProgress justDeployedEngine,
                                                                ISiegeEventSide sideSiegeEvent, out float bonusFlatHp, out float bonusHpRate)
        {
            var perk = ActivePatch._perk;
            var partyMemberHealth = new ExplainedNumber(justDeployedEngine.SiegeEngine.MaxHitPoints);
            var partyMemberRate   = new ExplainedNumber(100);

            foreach (var siegeParty in sideSiegeEvent.SiegeParties.Where(x => x.MobileParty != null))
            {
                PerkHelper.AddPerkBonusForParty(perk, siegeParty.MobileParty, ref partyMemberHealth);
                PerkHelper.AddPerkBonusForParty(perk, siegeParty.MobileParty, ref partyMemberRate);
            }

            bonusFlatHp = partyMemberHealth.ResultNumber - partyMemberHealth.BaseNumber;
            bonusHpRate = partyMemberRate.ResultNumber - partyMemberRate.BaseNumber;
        }
Beispiel #4
0
        private static void CalculateBonusDamageAndRates(
            SiegeEngineType siegeEngineType,
            ISiegeEventSide siegeEventSide, out float bonusRateOnly, out float bonusDamageOnly)
        {
            var perk              = ActivePatch._perk;
            var baseDamage        = siegeEngineType.Damage;
            var partyMemberDamage = new ExplainedNumber(baseDamage);
            var partyMemberRate   = new ExplainedNumber(100f);
            var parties           = siegeEventSide.SiegeParties.Where(x => x.MobileParty != null);

            foreach (var party in parties)
            {
                PerkHelper.AddPerkBonusForParty(perk, party.MobileParty, ref partyMemberRate);
                PerkHelper.AddPerkBonusForParty(perk, party.MobileParty, ref partyMemberDamage);
            }

            bonusRateOnly   = partyMemberRate.ResultNumber - 100;
            bonusDamageOnly = partyMemberDamage.ResultNumber - baseDamage;
        }
        public static void GetConstructionProgressPerHour(SiegeEngineType type, SiegeEvent siegeEvent, ISiegeEventSide side, StatExplainer explanation, ref float __result)
        {
            BattleSideEnum otherSide;

            switch (side.BattleSide)
            {
            case BattleSideEnum.Attacker:
                otherSide = BattleSideEnum.Defender;
                break;

            case BattleSideEnum.Defender:
                otherSide = BattleSideEnum.Attacker;
                break;

            default:
                return;
            }

            if ((siegeEvent.GetSiegeEventSide(otherSide)?.SiegeParties.Any(x => x.Leader?.IsPlayerCharacter ?? false) ?? false) &&
                BannerlordCheatsSettings.Instance.EnemySiegeBuildingSpeedPercentage < 100)
            {
                var factor = BannerlordCheatsSettings.Instance.EnemySiegeBuildingSpeedPercentage / 100f;

                var newValue = factor * __result;

                __result = newValue;
            }
        }
 private static void ApplyPerkToSiegeEngine(SiegeEvent.SiegeEngineConstructionProgress justDeployedEngine, ISiegeEventSide sideSiegeEvent)
 {
     CalculateBonusFlatHpAndRateFromPerk(justDeployedEngine, sideSiegeEvent, out var bonusFlatHp, out _);
     justDeployedEngine.SetHitpoints(justDeployedEngine.Hitpoints + bonusFlatHp);
     SiegeEngineConstructionExtraDataManager.SetMaxHitPoints(justDeployedEngine, justDeployedEngine.Hitpoints);
 }
 public static bool IsPlayerSide(this ISiegeEventSide side)
 {
     return(side?.SiegeParties?.Any(x => x.IsPlayerParty()) ?? false);
 }
Beispiel #8
0
 public static void GetConstructionProgressPerHour(ref SiegeEngineType type, ref SiegeEvent siegeEvent, ref ISiegeEventSide side, ref float __result)
 {
     try
     {
         if (side.IsPlayerSide() &&
             BannerlordCheatsSettings.Instance?.SiegeBuildingSpeedMultiplier > 1f)
         {
             __result *= BannerlordCheatsSettings.Instance.SiegeBuildingSpeedMultiplier;
         }
     }
     catch (Exception e)
     {
         SubModule.LogError(e, typeof(SiegeBuildingSpeedMultiplier));
     }
 }
Beispiel #9
0
 public override float GetConstructionProgressPerHour(SiegeEngineType type, SiegeEvent siegeEvent, ISiegeEventSide side, StatExplainer explanation = null)
 {
     if (Settings.Instance.SiegeConstructionProgressPerDayMultiplierEnabled)
     {
         return(base.GetConstructionProgressPerHour(type, siegeEvent, side, explanation) * Settings.Instance.SiegeConstructionProgressPerDayMultiplier);
     }
     else
     {
         return(base.GetConstructionProgressPerHour(type, siegeEvent, side, explanation));
     }
 }
Beispiel #10
0
 public static void Prefix(ISiegeEventSide siegeEventSide, SiegeEngineType attackerEngineType, SiegeEvent.SiegeEngineConstructionProgress damagedEngine)
 {
     CalculateBonusDamageAndRates(attackerEngineType, siegeEventSide, out _, out var bonusDamageOnly);
     damagedEngine.SetHitpoints(damagedEngine.Hitpoints - bonusDamageOnly);
 }
Beispiel #11
0
 public static void GetConstructionProgressPerHour(SiegeEngineType type, SiegeEvent siegeEvent, ISiegeEventSide side, StatExplainer explanation, ref float __result)
 {
     if (side?.SiegeParties?.Any(x => x.Leader?.IsPlayerCharacter ?? false) ?? false)
     {
         __result *= BannerlordCheatsSettings.Instance.SiegeBuildingSpeedMultiplier;
     }
 }
Beispiel #12
0
        public static void GetConstructionProgressPerHour(ref SiegeEngineType type, ref SiegeEvent siegeEvent, ref ISiegeEventSide side, ref float __result)
        {
            try
            {
                BattleSideEnum otherSide;
                switch (side.BattleSide)
                {
                case BattleSideEnum.Attacker:
                    otherSide = BattleSideEnum.Defender;
                    break;

                case BattleSideEnum.Defender:
                    otherSide = BattleSideEnum.Attacker;
                    break;

                default:
                    return;
                }

                if ((siegeEvent.GetSiegeEventSide(otherSide)?.SiegeParties.Any(x => x.IsPlayerParty()) ?? false) &&
                    BannerlordCheatsSettings.Instance?.EnemySiegeBuildingSpeedPercentage < 100f)
                {
                    var factor = BannerlordCheatsSettings.Instance.EnemySiegeBuildingSpeedPercentage / 100f;

                    var newValue = factor * __result;

                    __result = newValue;
                }
            }
            catch (Exception e)
            {
                SubModule.LogError(e, typeof(EnemySiegeBuildingSpeedPercentage));
            }
        }
 public override float GetConstructionProgressPerHour(SiegeEngineType type, SiegeEvent siegeEvent, ISiegeEventSide side)
 {
     if (BannerlordTweaksSettings.Instance is { } settings)
     {
         return(base.GetConstructionProgressPerHour(type, siegeEvent, side) * settings.SiegeConstructionProgressPerDayMultiplier);
     }