[骑砍2]战斗改动:突破格挡,代码解读与修改(附赠减伤功能)

路过的罗格

  最近摸了一遍战斗系统,东西比较多,所以教程一点一点来写.

  首先是游戏源码,机制的入口是 TaleWorlds.MountAndBlade.Mission.GetDefendCollisionResults,防御相关的回调函数.这里的东西不多,主要是继续调用MissionCombatMechanicsHelper.GetDefendCollisionResults方法去处理数据.在MissionCombatMechanicsHelper.GetDefendCollisionResults处理完数据后,将算好的数据返回这个函数,然后继续往后续的攻击处理过程去传递数据

（点击展开 / 收起）

internal void GetDefendCollisionResults(Agent attackerAgent, Agent defenderAgent, CombatCollisionResult collisionResult, int attackerWeaponSlotIndex, bool isAlternativeAttack, StrikeType strikeType, Agent.UsageDirection attackDirection, float collisionDistanceOnWeapon, float attackProgress, bool attackIsParried, bool isPassiveUsageHit, bool isHeavyAttack, ref float defenderStunPeriod, ref float attackerStunPeriod, ref bool crushedThrough)                 {                         bool flag = false;                         MissionCombatMechanicsHelper.GetDefendCollisionResults(attackerAgent, defenderAgent, collisionResult, attackerWeaponSlotIndex, isAlternativeAttack, strikeType, attackDirection, collisionDistanceOnWeapon, attackProgress, attackIsParried, isPassiveUsageHit, isHeavyAttack, ref defenderStunPeriod, ref attackerStunPeriod, ref crushedThrough, ref flag);                         if ((crushedThrough || flag) && (attackerAgent.CanLogCombatFor || defenderAgent.CanLogCombatFor))                         {                                 CombatLogData combatLog = new CombatLogData(false, attackerAgent.IsHuman, attackerAgent.IsMine, attackerAgent.RiderAgent != null, attackerAgent.RiderAgent != null && attackerAgent.RiderAgent.IsMine, attackerAgent.IsMount, defenderAgent.IsHuman, defenderAgent.IsMine, defenderAgent.Health <= 0f, defenderAgent.HasMount, defenderAgent.RiderAgent != null && defenderAgent.RiderAgent.IsMine, defenderAgent.IsMount, false, defenderAgent.RiderAgent == attackerAgent, crushedThrough, flag, 0f);                                 this.AddCombatLogSafe(attackerAgent, defenderAgent, null, combatLog);                         }                 } 复制代码

  然后进TaleWorlds.MountAndBlade.MissionCombatMechanicsHelper.GetDefendCollisionResults,简单扫一眼它的输入输出,其中包含ref bool crushedThrough,一个是否突破格挡的判定值将被返回.然后进函数里面看这个变量怎么获取的.可以在最后一句看到

1.    crushedThrough = !chamber && MissionGameModels.Current.AgentApplyDamageModel.DecideCrushedThrough(attackerAgent, defenderAgent, num, attackDirection, strikeType, weaponComponentData2, isPassiveUsageHit);

复制代码

在没有触发挡反(大师反)的时候,调用AgentApplyDamageModel.DecideCrushedThrough函数,进行下一步计算.这个函数需要传入的大多数数据,都是直接从MissionCombatMechanicsHelper.GetDefendCollisionResults的传入数据里获取的,只有两个新的变量num和weaponComponentData2.其中weaponComponentData2是受击方使用的防御物品,由以下语句获取

1.             //获取防御方左手武器的索引
   
2.             EquipmentIndex wieldedItemIndex = defenderAgent.GetWieldedItemIndex(Agent.HandIndex.OffHand);
   
3.             //如果左手物品为空
   
4.             if (wieldedItemIndex == EquipmentIndex.None)
   
5.             {
   
6.                 //则获取右手武器的索引
   
7.                 wieldedItemIndex = defenderAgent.GetWieldedItemIndex(Agent.HandIndex.MainHand);
   
8.             }
   
9.             //获取该索引值对应的物品数据
   
10.             WeaponComponentData weaponComponentData2 = ((wieldedItemIndex != EquipmentIndex.None) ? defenderAgent.Equipment[wieldedItemIndex].CurrentUsageItem : null);

复制代码

num是"总攻击能量",基本可以理解为不计算武器配件伤害倍率,不计算perk加成,但是吃速度加成的伤害计算.

1.             //基础值为10
   
2.             float num = 10f;
   
3.             //当攻击方武器不为空时
   
4.             if (!missionWeapon.IsEmpty)
   
5.             {
   
6.                 //获取攻击方的当前武器偏移值
   
7.                 float z = attackerAgent.GetCurWeaponOffset().z;
   
8.                 //获取攻击方武器真实长度
   
9.                 float realWeaponLength = weaponComponentData.GetRealWeaponLength();
   
10.                 //当前武器偏移值+武器真实长度
    
11.                 float num2 = realWeaponLength + z;
    
12.                 //计算一个武器上的碰撞点位,等于(0.2+传入的武器碰撞距离)/(当前武器偏移值+武器真实长度),并且限制这个数介于10%~98%
    
13.                 float impactPoint = MBMath.ClampFloat((0.2f + collisionDistanceOnWeapon) / num2, 0.1f, 0.98f);
    
14.                 //获取这次攻击的额外速度加成
    
15.                 float exraLinearSpeed = MissionCombatMechanicsHelper.ComputeRelativeSpeedDiffOfAgents(attackerAgent, defenderAgent);
    
16.                 float num3;
    
17.                 //如果这次的攻击时戳刺动作
    
18.                 if (strikeType == StrikeType.Thrust)
    
19.                 {
    
20.                     //进行一次不吃skill/perk伤害加成的伤害计算流程.
    
21.                     num3 = CombatStatCalculator.CalculateBaseBlowMagnitudeForThrust((float)missionWeapon.GetModifiedThrustSpeedForCurrentUsage() / 11.764706f * MissionCombatMechanicsHelper.SpeedGraphFunction(attackProgress, strikeType, attackDirection), missionWeapon.Item.Weight, exraLinearSpeed);
    
22.                 }
    
23.                 //对挥砍类型的动作同理
    
24.                 else
    
25.                 {
    
26.                     num3 = CombatStatCalculator.CalculateBaseBlowMagnitudeForSwing((float)missionWeapon.GetModifiedSwingSpeedForCurrentUsage() / 4.5454545f * MissionCombatMechanicsHelper.SpeedGraphFunction(attackProgress, strikeType, attackDirection), realWeaponLength, missionWeapon.Item.Weight, weaponComponentData.Inertia, weaponComponentData.CenterOfMass, impactPoint, exraLinearSpeed);
    
27.                 }
    
28.                 //如果这次的攻击时戳刺动作
    
29.                 if (strikeType == StrikeType.Thrust)
    
30.                 {
    
31.                     //刚才计算的伤害值吃一个80%的减益
    
32.                     num3 *= 0.8f;
    
33.                 }
    
34.                 //如果这次攻击的方向是上打
    
35.                 else if (attackDirection == Agent.UsageDirection.AttackUp)
    
36.                 {
    
37.                     //刚才计算的伤害值吃一个125%的增益
    
38.                     num3 *= 1.25f;
    
39.                 }
    
40.                 //如果这次攻击是一个重击(完整的进行完攻击的准备动作后,本次攻击是为重击)
    
41.                 else if (isHeavyAttack)
    
42.                 {
    
43.                     //获取一个配置xml里的数值作为增益
    
44.                     num3 *= ManagedParameters.Instance.GetManagedParameter(ManagedParametersEnum.HeavyAttackMomentumMultiplier);
    
45.                 }
    
46.                 //基础值加上这个吃完增减益的攻击值
    
47.                 num += num3;
    
48.             }

复制代码

（点击展开 / 收起）

internal static void GetDefendCollisionResults(Agent attackerAgent, Agent defenderAgent, CombatCollisionResult collisionResult, int attackerWeaponSlotIndex, bool isAlternativeAttack, StrikeType strikeType, Agent.UsageDirection attackDirection, float collisionDistanceOnWeapon, float attackProgress, bool attackIsParried, bool isPassiveUsageHit, bool isHeavyAttack, ref float defenderStunPeriod, ref float attackerStunPeriod, ref bool crushedThrough, ref bool chamber)                 {                         MissionWeapon missionWeapon = ((attackerWeaponSlotIndex >= 0) ? attackerAgent.Equipment[attackerWeaponSlotIndex] : MissionWeapon.Invalid);                         WeaponComponentData weaponComponentData = (missionWeapon.IsEmpty ? null : missionWeapon.CurrentUsageItem);                         EquipmentIndex wieldedItemIndex = defenderAgent.GetWieldedItemIndex(Agent.HandIndex.OffHand);                         if (wieldedItemIndex == EquipmentIndex.None)                         {                                 wieldedItemIndex = defenderAgent.GetWieldedItemIndex(Agent.HandIndex.MainHand);                         }                         ItemObject itemObject = ((wieldedItemIndex != EquipmentIndex.None) ? defenderAgent.Equipment[wieldedItemIndex].Item : null);                         WeaponComponentData weaponComponentData2 = ((wieldedItemIndex != EquipmentIndex.None) ? defenderAgent.Equipment[wieldedItemIndex].CurrentUsageItem : null);                         float num = 10f;                         attackerStunPeriod = ((strikeType == StrikeType.Thrust) ? ManagedParameters.Instance.GetManagedParameter(ManagedParametersEnum.StunPeriodAttackerThrust) : ManagedParameters.Instance.GetManagedParameter(ManagedParametersEnum.StunPeriodAttackerSwing));                         chamber = false;                         if (!missionWeapon.IsEmpty)                         {                                 float z = attackerAgent.GetCurWeaponOffset().z;                                 float realWeaponLength = weaponComponentData.GetRealWeaponLength();                                 float num2 = realWeaponLength + z;                                 float impactPoint = MBMath.ClampFloat((0.2f + collisionDistanceOnWeapon) / num2, 0.1f, 0.98f);                                 float exraLinearSpeed = MissionCombatMechanicsHelper.ComputeRelativeSpeedDiffOfAgents(attackerAgent, defenderAgent);                                 float num3;                                 if (strikeType == StrikeType.Thrust)                                 {                                         num3 = CombatStatCalculator.CalculateBaseBlowMagnitudeForThrust((float)missionWeapon.GetModifiedThrustSpeedForCurrentUsage() / 11.764706f * MissionCombatMechanicsHelper.SpeedGraphFunction(attackProgress, strikeType, attackDirection), missionWeapon.Item.Weight, exraLinearSpeed);                                 }                                 else                                 {                                         num3 = CombatStatCalculator.CalculateBaseBlowMagnitudeForSwing((float)missionWeapon.GetModifiedSwingSpeedForCurrentUsage() / 4.5454545f * MissionCombatMechanicsHelper.SpeedGraphFunction(attackProgress, strikeType, attackDirection), realWeaponLength, missionWeapon.Item.Weight, weaponComponentData.Inertia, weaponComponentData.CenterOfMass, impactPoint, exraLinearSpeed);                                 }                                 if (strikeType == StrikeType.Thrust)                                 {                                         num3 *= 0.8f;                                 }                                 else if (attackDirection == Agent.UsageDirection.AttackUp)                                 {                                         num3 *= 1.25f;                                 }                                 else if (isHeavyAttack)                                 {                                         num3 *= ManagedParameters.Instance.GetManagedParameter(ManagedParametersEnum.HeavyAttackMomentumMultiplier);                                 }                                 num += num3;                         }                         float num4 = 1f;                         defenderStunPeriod = num * ManagedParameters.Instance.GetManagedParameter(ManagedParametersEnum.StunMomentumTransferFactor);                         if (weaponComponentData2 != null)                         {                                 if (weaponComponentData2.IsShield)                                 {                                         float managedParameter = ManagedParameters.Instance.GetManagedParameter(ManagedParametersEnum.StunDefendWeaponWeightOffsetShield);                                         num4 += managedParameter * itemObject.Weight;                                 }                                 else                                 {                                         num4 = 0.9f;                                         float managedParameter2 = ManagedParameters.Instance.GetManagedParameter(ManagedParametersEnum.StunDefendWeaponWeightMultiplierWeaponWeight);                                         num4 += managedParameter2 * itemObject.Weight;                                         ItemObject.ItemTypeEnum itemType = itemObject.ItemType;                                         if (itemType == ItemObject.ItemTypeEnum.TwoHandedWeapon)                                         {                                                 managedParameter2 = ManagedParameters.Instance.GetManagedParameter(ManagedParametersEnum.StunDefendWeaponWeightBonusTwoHanded);                                         }                                         else if (itemType == ItemObject.ItemTypeEnum.Polearm)                                         {                                                 num4 += ManagedParameters.Instance.GetManagedParameter(ManagedParametersEnum.StunDefendWeaponWeightBonusPolearm);                                         }                                 }                                 if (collisionResult == CombatCollisionResult.Parried)                                 {                                         attackerStunPeriod += MathF.Min(0.15f, 0.12f * num4);                                         num4 += ManagedParameters.Instance.GetManagedParameter(ManagedParametersEnum.StunDefendWeaponWeightBonusActiveBlocked);                                 }                                 else if (collisionResult == CombatCollisionResult.ChamberBlocked)                                 {                                         attackerStunPeriod += MathF.Min(0.25f, 0.25f * num4);                                         num4 += ManagedParameters.Instance.GetManagedParameter(ManagedParametersEnum.StunDefendWeaponWeightBonusChamberBlocked);                                         chamber = true;                                 }                         }                         if (!defenderAgent.GetIsLeftStance())                         {                                 num4 += ManagedParameters.Instance.GetManagedParameter(ManagedParametersEnum.StunDefendWeaponWeightBonusRightStance);                         }                         defenderStunPeriod /= num4;                         float num5;                         float num6;                         MissionGameModels.Current.AgentApplyDamageModel.CalculateDefendedBlowStunMultipliers(attackerAgent, defenderAgent, collisionResult, weaponComponentData, weaponComponentData2, out num5, out num6);                         attackerStunPeriod *= num5;                         defenderStunPeriod *= num6;                         float managedParameter3 = ManagedParameters.Instance.GetManagedParameter(ManagedParametersEnum.StunPeriodMax);                         attackerStunPeriod = MathF.Min(attackerStunPeriod, managedParameter3);                         defenderStunPeriod = MathF.Min(defenderStunPeriod, managedParameter3);                         crushedThrough = !chamber && MissionGameModels.Current.AgentApplyDamageModel.DecideCrushedThrough(attackerAgent, defenderAgent, num, attackDirection, strikeType, weaponComponentData2, isPassiveUsageHit);                 } 复制代码

  有了这些数据,就可以继续看AgentApplyDamageModel.DecideCrushedThrough怎么处理这些数据了.
  这里稍微注意一下,对于沙盒/战役模式,与自定义战斗/多人游戏的代码是不一样的,虽然差别不大就是了.对于沙盒战役模式中,我这边用的1.28版本的代码,已经取消掉了物品的突破格挡标签,也就意味着随便一把武器都可以参与突破格挡的判定.而自定义战斗和多人,依旧有这个标签的判定,需要使用有这个标签的武器,才能触发.以判定较多的自定义战斗/多人游戏的代码为准,这边的代码不多,直接每行都过一遍(同时也能看到一些抽象的逻辑):

1.         public override bool DecideCrushedThrough(Agent attackerAgent, Agent defenderAgent, float totalAttackEnergy, Agent.UsageDirection attackDirection, StrikeType strikeType, WeaponComponentData defendItem, bool isPassiveUsage)
   
2.         {
   
3.             //获取攻击方的左手物品索引
   
4.             EquipmentIndex wieldedItemIndex = attackerAgent.GetWieldedItemIndex(Agent.HandIndex.OffHand);
   
5.             //如果左手物品为空
   
6.             if (wieldedItemIndex == EquipmentIndex.None)
   
7.             {
   
8.                 //则取获取右手的物品
   
9.                 //这里注意一下,这里只有你左手没有物品时,才会获取右手物品.如果你左手有个盾牌,那么会拿着你的盾去看有没有突破格挡属性
   
10.                 wieldedItemIndex = attackerAgent.GetWieldedItemIndex(Agent.HandIndex.MainHand);
    
11.             }
    
12.             //获取索引对应物品的物品数据,在索引不为空的前提下
    
13.             WeaponComponentData weaponComponentData = ((wieldedItemIndex != EquipmentIndex.None) ? attackerAgent.Equipment[wieldedItemIndex].CurrentUsageItem : null);
    
14.             //如果:物品数据不为空,或者是被动攻击(骑枪突刺/长矛反骑),或者没有突破格挡属性,或者攻击类型不为挥砍,或者攻击方向不是上打
    
15.             if (weaponComponentData == null || isPassiveUsage || !weaponComponentData.WeaponFlags.HasAnyFlag(WeaponFlags.CanCrushThrough) || strikeType != StrikeType.Swing || attackDirection != Agent.UsageDirection.AttackUp)
    
16.             {
    
17.                 //就直接判定无法突破格挡
    
18.                 //这里面坑就很多,每一个判定都抽象.首先是骑枪突刺直接判定无法突破格挡,然后是你左手有物品时会判定你左手物品有没有突破格挡的属性.还限制了只有挥砍的上劈才能突破格挡,突刺直接没戏.
    
19.                 return false;
    
20.             }
    
21.             //如果没有被前面的一堆条件直接给判定为无法突破格挡
    
22.             //初始化一个数值为58
    
23.             float num = 58f;
    
24.             //如果受击方的防御武器不为空且为盾牌
    
25.             if (defendItem != null && defendItem.IsShield)
    
26.             {
    
27.                 //数值乘1.2倍,为69.6
    
28.                 num *= 1.2f;
    
29.             }
    
30.             //直接进行判定,传递进来的那个num,有没有大于这个函数里的num,如果传进来的那个数值,大于58(用盾为69.6),则判定为突破格挡
    
31.             return totalAttackEnergy > num;
    
32.         }

复制代码

  可以看到这个判定非常简单,就是在没有被直接判定为无法突破格挡的前提下,不计算武器配件伤害倍率和技能加成的前提下伤害够高,就能完成突破格挡.
  然后再回去看一下刚才的那个伤害计算是怎么算的.因为原本只有挥砍能突破格挡,所以只看挥砍的.
  首先看一眼输入的变量名:浮点型角速度，浮点型武器长度，浮点型武器重量，浮点型武器惯性，浮点型武器质心，浮点型冲击点，浮点型速度加成

1. public static float CalculateBaseBlowMagnitudeForSwing(float angularSpeed, float weaponReach, float weaponWeight, float weaponInertia, float weaponCoM, float impactPoint, float exraLinearSpeed)

复制代码

  然后输入的东西,除了角速度要稍微计算一下外,其他的都等于是从武器属性上获取的,或者是之前这个函数传入的
  角速度=获取当前武器实际挥砍速度(这个数值可以吃到武器前缀的额外速度)/4.5454545*动作完成度影响的数值,这个数值最大为1

1. CombatStatCalculator.CalculateBaseBlowMagnitudeForSwing((float)missionWeapon.GetModifiedSwingSpeedForCurrentUsage() / 4.5454545f * MissionCombatMechanicsHelper.SpeedGraphFunction(attackProgress, strikeType, attackDirection), realWeaponLength, missionWeapon.Item.Weight, weaponComponentData.Inertia, weaponComponentData.CenterOfMass, impactPoint, exraLinearSpeed);

复制代码

  

  再来看CalculateBaseBlowMagnitudeForSwing,这里跳过了一层过度的代码,那个代码里会多次计算碰撞点,来获取一个最大是伤害值,实际的伤害计算在这里

（点击展开 / 收起）

public static float CalculateStrikeMagnitudeForSwing(float swingSpeed, float impactPointAsPercent, float weaponWeight, float weaponLength, float weaponInertia, float weaponCoM, float extraLinearSpeed)                 {                         float num = weaponLength * impactPointAsPercent - weaponCoM;                         float num2 = swingSpeed * (0.5f + weaponCoM) + extraLinearSpeed;                         float num3 = 0.5f * weaponWeight * num2 * num2;                         float num4 = 0.5f * weaponInertia * swingSpeed * swingSpeed;                         float num5 = num3 + num4;                         float num6 = (num2 + swingSpeed * num) / (1f / weaponWeight + num * num / weaponInertia);                         float num7 = num2 - num6 / weaponWeight;                         float num8 = swingSpeed - num6 * num / weaponInertia;                         float num9 = 0.5f * weaponWeight * num7 * num7;                         float num10 = 0.5f * weaponInertia * num8 * num8;                         float num11 = num9 + num10;                         float num12 = num5 - num11 + 0.5f;                         return 0.067f * num12;                 } 复制代码

反编译源码丢gpt里过一遍,稍微能看一点的逻辑是这样

1. public static float CalculateStrikeMagnitudeForSwing(float swingSpeed, float impactPointAsPercent, float weaponWeight, float weaponLength, float weaponInertia, float weaponCoM, float extraLinearSpeed)
   
2. {
   
3.     // 计算击中点距离武器重心的距离
   
4.     float impactPointDistance = weaponLength * impactPointAsPercent - weaponCoM;
   
5.    
   
6.     // 计算武器在击中瞬间的初始线速度
   
7.     float initialVelocity = swingSpeed * (0.5f + weaponCoM) + extraLinearSpeed;
   
8. 
   
9.     // 计算击中之前的动能，包括线动能和角动能
   
10.     float kineticEnergyBeforeImpact = 0.5f * weaponWeight * initialVelocity * initialVelocity +
    
11.                                        0.5f * weaponInertia * swingSpeed * swingSpeed;
    
12. 
    
13.     // 计算击中后的最终线速度
    
14.     float finalLinearVelocity = initialVelocity - (initialVelocity + swingSpeed * impactPointDistance) / (1f / weaponWeight + impactPointDistance * impactPointDistance / weaponInertia) / weaponWeight;
    
15.    
    
16.     // 计算击中后的最终角速度
    
17.     float finalAngularVelocity = swingSpeed - (initialVelocity + swingSpeed * impactPointDistance) * impactPointDistance / weaponInertia;
    
18. 
    
19.     // 计算击中后的动能，包括线动能和角动能
    
20.     float kineticEnergyAfterImpact = 0.5f * weaponWeight * finalLinearVelocity * finalLinearVelocity +
    
21.                                      0.5f * weaponInertia * finalAngularVelocity * finalAngularVelocity;
    
22. 
    
23.     // 返回冲击力的大小，基于动能的改变量，并乘以一个系数0.067，再加上一个常数0.5的一半
    
24.     return 0.067f * (kineticEnergyBeforeImpact - kineticEnergyAfterImpact + 0.5f);
    
25. }

复制代码

到这一步我脑子已经不够用了,直接复制一下gpt的回复

（点击展开 / 收起）

使函数 CalculateStrikeMagnitudeForSwing 的输出值变大，即增加冲击力的大小，你可以通过调整输入参数来实现。下面是一些可能的方法： 增加挥动速度（swingSpeed）： 增加挥动速度会直接增加击中前的动能，因为动能与速度的平方成正比。这通常会导致更大的冲击力。 增加武器长度（weaponLength）并调整冲击点： 增加武器长度并适当调整击中点（impactPointAsPercent），使其更接近武器末端，但不是太远以至于超过武器的有效范围，可以增加杠杆效应，从而增加冲击力。 增加额外的线速度（extraLinearSpeed）： 增加额外的线速度会直接增加击中前的线动能，从而可能增加冲击力。 减少武器重量（weaponWeight）： 虽然减少武器重量会减少击中前的线动能，但它也会使得武器更容易加速，从而可能在某些情况下增加冲击力。这需要与其他因素（如速度）的增加相结合来实现最佳效果。 调整武器质心（weaponCoM）： 将质心适当向武器末端移动可以增加杠杆效应，但需要注意的是，这也可能使得武器更难以控制。找到最佳质心位置需要平衡冲击力和操控性。 减少武器惯性（weaponInertia）： 减少武器惯性可以使得武器在旋转时更容易加速，从而可能增加冲击力。但这也取决于其他因素，如挥动速度和击中点的位置。 复制代码

路过的罗格

  继续来写怎么修改突破格挡的判定,这部分很简单,关键是你怎么去设计突破格挡
  在上面说过了,沙盒模式与多人游戏的突破格挡代码是不一样的,因为突破格挡的核心函数AgentApplyDamageModel.DecideCrushedThrough是一个可以复写的虚构类,同时复写后的代码可以提交给引擎,让引擎去调用.
  所以呢,我们开始完成函数的复习以及提交给引擎的代码.首先新建两个类,分别继承沙盒的和自定义战斗的源码,当然,如果你不需要在自定义模式里测试的话,只处理沙盒的也行.

1.     public class WOW_SandboxAgentApplyDamageModel : SandboxAgentApplyDamageModel

复制代码

1.     public class WOW_CustomAgentApplyDamageModel : CustomAgentApplyDamageModel

复制代码

建好类后,直接把沙盒代码里DecideCrushedThrough方法的代码全部复制过来,并且对自定义战斗那边也做同样的处理.比如现在是这样:

1. public class WOW_SandboxAgentApplyDamageModel : SandboxAgentApplyDamageModel
   
2. {
   
3.     public override bool DecideCrushedThrough(Agent attackerAgent, Agent defenderAgent, float totalAttackEnergy, Agent.UsageDirection attackDirection, StrikeType strikeType, WeaponComponentData defendItem, bool isPassiveUsage)
   
4.     {
   
5.         EquipmentIndex wieldedItemIndex = attackerAgent.GetWieldedItemIndex(Agent.HandIndex.OffHand);
   
6.         if (wieldedItemIndex == EquipmentIndex.None)
   
7.         {
   
8.             wieldedItemIndex = attackerAgent.GetWieldedItemIndex(Agent.HandIndex.MainHand);
   
9.         }
   
10.         if (((wieldedItemIndex != EquipmentIndex.None) ? attackerAgent.Equipment[wieldedItemIndex].CurrentUsageItem : null) == null || isPassiveUsage || strikeType != StrikeType.Swing || attackDirection != Agent.UsageDirection.AttackUp)
    
11.         {
    
12.             return false;
    
13.         }
    
14.         float num = 58f;
    
15.         if (defendItem != null && defendItem.IsShield)
    
16.         {
    
17.             num *= 1.2f;
    
18.         }
    
19.         return totalAttackEnergy > num;
    
20.     }
    
21. }

复制代码

然后先不着急编写这些条件,直接先去你mod的SubModule里,添加一下这个类的引用,告诉引擎突破格挡判定用这里的,比如在这个函数里添加:(其他没有的函数不用管,删了)

1.         protected override void InitializeGameStarter(Game game, IGameStarter gameStarterObject)
   
2.         {
   
3. 
   
4.             ExtendedData extendedData = new ExtendedData();
   
5.             //默认使用的代码   
   
6. 
   
7.             extendedData.CreateOrRetrieveDataForGun();
   
8.             gameStarterObject.AddModel(new WOW_DefaultStrikeMagnitudeModel());
   
9.             gameStarterObject.AddModel(new WOW_CustomBattleAgentStatCalculateModel());
   
10.             gameStarterObject.AddModel(new WOW_CustomAgentApplyDamageModel());//刚才写的突破格挡的代码
    
11.             gameStarterObject.AddModel(new WOW_DefaultRidingModel());
    
12.             if (game.GameType is Campaign)
    
13.             {
    
14.                 //战役里使用的代码
    
15. 
    
16.                 gameStarterObject.AddModel(new WOW_SandboxAgentApplyDamageModel());
    
17.                 gameStarterObject.AddModel(new WOW_SandboxStrikeMagnitudeModel());
    
18.                 gameStarterObject.AddModel(new WOW_SandboxAgentStatCalculateModel());//刚才写的突破格挡的代码
    
19.                 gameStarterObject.AddModel(new WOW_DefaultPartySpeedCalculatingModel());
    
20. 
    
21.             }
    
22.         }

复制代码

现在,突破格挡的判定就已经归你来控制了,随便加点东西

1.        public override bool DecideCrushedThrough(Agent attackerAgent, Agent defenderAgent, float totalAttackEnergy, Agent.UsageDirection attackDirection, StrikeType strikeType, WeaponComponentData defendItem, bool isPassiveUsage)
   
2.        {
   
3.            Random random = new Random();
   
4.            /*获取攻击方武器数据*/
   
5.            EquipmentIndex attackerAgentwieldedOffHandItemIndex = attackerAgent.GetWieldedItemIndex(Agent.HandIndex.OffHand);
   
6.            EquipmentIndex attackerAgentwieldedMainHandItemIndex = attackerAgent.GetWieldedItemIndex(Agent.HandIndex.MainHand);
   
7.            WeaponComponentData attackerAgentweaponComponentData = ((attackerAgentwieldedMainHandItemIndex != EquipmentIndex.None) ? attackerAgent.Equipment[attackerAgentwieldedMainHandItemIndex].CurrentUsageItem : null);
   
8.            if (attackerAgentweaponComponentData == null)
   
9.            {
   
10.                return false;//如果没有攻击方武器，直接无法突破格挡
    
11.            }
    
12.            //获取防御方武器数据
    
13.            EquipmentIndex defenderAgentwieldedItemIndex = attackerAgent.GetWieldedItemIndex(Agent.HandIndex.MainHand);
    
14.            WeaponComponentData defenderAgentweaponComponentData = ((defenderAgentwieldedItemIndex != EquipmentIndex.None) ? attackerAgent.Equipment[defenderAgentwieldedItemIndex].CurrentUsageItem : null);
    
15.            if (defenderAgentweaponComponentData == null)
    
16.            {
    
17.                return true;//如果没有武器，默认突破格挡
    
18.            }
    
19.            //一些额外的直接突破格挡的设定
    
20.            if (WoW_MissionSetting.WoW_Agents.TryGetValue(attackerAgent.Index, out var WoW_agent))
    
21.            {
    
22.                if (WoW_agent.primarySkill == "menglihuiji" && WoW_agent.primarySkillDur > 0)
    
23.                {
    
24.                    return true;
    
25.                }
    
26.            }
    
27.            if (defendItem != null && !defendItem.IsShield && strikeType == StrikeType.Thrust)//武器防御突刺时
    
28.            {
    
29.                return true;//一定被突破格挡
    
30.            }
    
31. 
    
32.            //获取攻守双方的武器熟练度（对应武器的技能等级）
    
33.            int attacckAgentWeaponProficiency = attackerAgent.Character.GetSkillValue(attackerAgentweaponComponentData.RelevantSkill);
    
34.            int defenderAgentWeaponProficiency = defenderAgent.Character.GetSkillValue(defenderAgentweaponComponentData.RelevantSkill);
    
35.            int ProficiencyCrush = attacckAgentWeaponProficiency - defenderAgentWeaponProficiency;//熟练度差值，可以为负数，负数表示攻击方熟练度低于防御方
    
36.            //获取双方跑动或骑术的技能等级，根据是否有马来判断
    
37.            int attacckAgentDefSkillValue = 0;
    
38.            int defenderAgentDefSkillValue = 0;
    
39.            if (defenderAgent.Mount != null)
    
40.                defenderAgentDefSkillValue = defenderAgent.Character.GetSkillValue(DefaultSkills.Riding);
    
41.            else
    
42.                defenderAgentDefSkillValue = defenderAgent.Character.GetSkillValue(DefaultSkills.Athletics);
    
43.            if (attackerAgent.Mount != null)
    
44.                attacckAgentDefSkillValue = attackerAgent.Character.GetSkillValue(DefaultSkills.Riding);
    
45.            else
    
46.                attacckAgentDefSkillValue = attackerAgent.Character.GetSkillValue(DefaultSkills.Athletics);
    
47. 
    
48.            //突破格挡需要超过的能量数
    
49.            float num = 58f;
    
50. 
    
51.            //攻击方使用双手武器或者双手使用长杆，更容易突破格挡
    
52.            if (attackerAgentweaponComponentData.RelevantSkill == DefaultSkills.TwoHanded | (attackerAgentwieldedOffHandItemIndex == null && attackerAgentweaponComponentData.RelevantSkill == DefaultSkills.Polearm))
    
53.            {
    
54.                totalAttackEnergy *= 1.2f;//只要用双手武器，就强化20%输入能量
    
55.                if (ProficiencyCrush > 0)
    
56.                    totalAttackEnergy = totalAttackEnergy * (1 + ProficiencyCrush / 500f);//如果熟练度高于对方的武器熟练度，则额外加乘，每多100点熟练度，强化20%
    
57.            }
    
58.            //双方都处于步战时，如果防御方使用武器防御，则会根据步战技能差值，调整破防难度
    
59.            if (defendItem != null && !defendItem.IsShield && defenderAgent.Mount == null && attackerAgent.Mount == null)
    
60.            {
    
61.                num -= ((attacckAgentDefSkillValue - defenderAgentDefSkillValue) * 0.05f);
    
62.            }
    
63.            //处于任意状态，根据双方武器熟练差值，调整破防难度
    
64.            num -= (ProficiencyCrush * 0.05f);
    
65.            if (isPassiveUsage)//如果是骑枪冲刺或者长矛反骑
    
66.            {
    
67.                num /= 2;//更容易突破格挡
    
68.            }
    
69.            if (defendItem != null && defendItem.IsShield)//如果防御方使用盾牌防御，更难突破格挡
    
70.            {
    
71.                num *= 1.2f;
    
72.            }
    
73. 
    
74.            //如果使用斧类武器攻击，根据双方武器和步战熟练度差值，有概率缴械对方的防御物品
    
75.            //需要额外增加设定,基础概率增加一点,然后可以根据对方格挡的方向,额外降低一下缴械概率
    
76.            //注意一下缴械的时候检测一下是不是空手了
    
77.            if (attackerAgentweaponComponentData.WeaponClass == WeaponClass.OneHandedAxe || attackerAgentweaponComponentData.WeaponClass == WeaponClass.TwoHandedAxe)
    
78.            {
    
79. 
    
80.                //缴械概率=熟练度差值/500*（1+步战差值/1000）.300熟练打100熟练，破防时缴械概率为0.2+0.4*1.2=0.68
    
81.                float disarm = 0.2f + ProficiencyCrush / 500 * (1 + (attacckAgentDefSkillValue - defenderAgentDefSkillValue) / 1000);
    
82.                float r = random.NextFloat();
    
83.                if (disarm > r)
    
84.                {
    
85.                    EquipmentIndex wieldedItemIndex = defenderAgent.GetWieldedItemIndex(Agent.HandIndex.OffHand);
    
86.                    if (wieldedItemIndex == EquipmentIndex.None)
    
87.                    {
    
88.                        wieldedItemIndex = defenderAgent.GetWieldedItemIndex(Agent.HandIndex.MainHand);
    
89.                    }
    
90.                    if (wieldedItemIndex == EquipmentIndex.None)
    
91.                        defenderAgent.RemoveEquippedWeapon(wieldedItemIndex);
    
92.                }
    
93. 
    
94. 
    
95.            }
    
96.            return totalAttackEnergy > num;
    
97.        }

复制代码

路过的罗格

顺便附赠一个同样在这个类里处理的功能:根据受伤部位的护甲值,提供固定数值的减伤

1.         public override float CalculateDamage(in AttackInformation attackInformation, in AttackCollisionData collisionData, in MissionWeapon weapon, float baseDamage)
   
2.         {
   
3.             //做一下护甲的固定数值减伤，最终的伤害，减少护甲15%防御值的伤害。60甲-12的最终伤害，避免重甲被劫匪石头砸死
   
4.             int def = (int)(attackInformation.ArmorAmountFloat * 0.1f);
   
5.             return base.CalculateDamage(attackInformation, collisionData, weapon, baseDamage) - def;
   
6.         }

复制代码

恶猪

如果我想档反的时候使用呢？

路过的罗格

恶猪 发表于 2024-3-21 19:22
如果我想档反的时候使用呢？

不用四前置的话肯定很麻烦，这段是已经写死没有给接口的代码

1. crushedThrough = !chamber && MissionGameModels.Current.AgentApplyDamageModel.DecideCrushedThrough(attackerAgent, defenderAgent, num, attackDirection, strikeType, weaponComponentData2, isPassiveUsageHit);

复制代码

可能可以在判定好大师反也就是确定chamber 变量之前做点手脚，不过印象里之前找这堆东西都没没有找到源头的 。十有八九是由引擎算完丢出来的。