125 【战斗】战斗系统 目标选择规则&bug修复

yyl

2025-09-10 35e1332c385226a4f57c4294c19045a8aed9abe6

125 【战斗】战斗系统 目标选择规则&bug修复

 Main/System/Battle/BattleUtility.cs

@@ -176,68 +176,116 @@
        // 3    后排
        // 4    纵排，按对位规则选择纵排
        // 5    自己，默认只选自己
        // 6    继承主技能/来源技能目标
        //      一般是额外触发的技能使用，如概率附加某buff
        //      额外触发的技能如果目标与主技能不一致，则重新设定目标即可
        //      或被动触发的技能，可继承触发来源技能的攻防双方关系

        switch (skillConfig.TagAim)
        {
            case 0:
                //  全部范围
                //全部范围+敌我+目标数量为6
                //就是取敌我站位中的2号位
                returnIndex = 1;
                break;
            case 1:
                returnIndex = caster.teamHero.positionNum;
                //  寻找对位是否有人 没有的话选择最小的
                List<BattleObject> opposite = new List<BattleObject>(from bo in targetObjList where !bo.IsDead() && bo.teamHero.positionNum == returnIndex select bo);
                if (opposite.Count > 0)
                // 0   全部范围：
                // 若TagCount目标个数为0或6，根据TagFriendly敌我配置，代表作用于敌方全体或我方全体，此时主目标为敌我站位中的2号位置
                // 若TagCount目标个数为1~5个，根据TagFriendly敌我+TagAffect细分目标配置，代表随机作用于敌方或我方x个武将，第一个为主目标
                if (skillConfig.TagCount == 0 || skillConfig.TagCount == 6)
                {
                    returnIndex = opposite[0].teamHero.positionNum;
                    returnIndex = 1;
                }
                else
                {
                    opposite = new List<BattleObject>(from bo in targetObjList where !bo.IsDead() select bo);
                    opposite.Sort((a, b) => a.teamHero.positionNum.CompareTo(b.teamHero.positionNum));
                    returnIndex = opposite.Count > 0 ? opposite[0].teamHero.positionNum : returnIndex;
                    uint objId = targetList[0].ObjID;
                    BattleObject target = caster.battleField.battleObjMgr.GetBattleObject((int)objId);
                    return target.teamHero.positionNum;
                }
                break;
            case 1:
                // 1    对位：
                // 默认只选1个，对位规则为A1优先打B1，A2优先打B2，A3优先打B3，对位目标死亡时，优先前排，比如B2已经死亡，那么A2将优先打B1，前排1、2、3号位置全部死亡之后才开始选择后排4、5、6号位置，对位只可选1个目标，即主目标
                if (targetList.Count > 0)
                {
                    BattleObject battleObject = caster.battleField.battleObjMgr.GetBattleObject((int)targetList[0].ObjID);
                    if (battleObject != null)
                    {
                        returnIndex = battleObject.teamHero.positionNum;
                    }
                    else
                    {
                        Debug.LogError("GetMainTargetPositionNum 找不到目标 ObjId : " + targetList[0].ObjID);
                        returnIndex = 0;
                    }
                }
                else
                {
                    Debug.LogError("targetList 目标列表为空");
                    returnIndex = 0;
                }
                break;
            case 2:
                //  看看对面前排是否都活着
                List<BattleObject> front = new List<BattleObject>(from bo in targetObjList where !bo.IsDead() && bo.teamHero.positionNum < 3 select bo);
                if (front.Count > 0)
                //  1、2、3号位为前排，默认2号位置为主目标，当1、2、3号位置角色全部死亡，前排将替换成后排，5号位置变更为主目标，
                //  若配置TagAffect细分目标，且人数小于3，则所有被选择目标均为主目标（施法位置会用客户端配置）
                // （即前排默认2号位或5号位规则无效，实际作用多少人就是多少个主目标） (YL : TagAffect>0 && TagAffect != 3就是全体都是主目标 后排一样 )
                if (skillConfig.TagAffect != 0 && skillConfig.TagAffect != 3 && skillConfig.TagCount < 3)
                {
                    returnIndex = 1;
                    uint objId = targetList[0].ObjID;
                    BattleObject target = caster.battleField.battleObjMgr.GetBattleObject((int)objId);
                    returnIndex = target.teamHero.positionNum;
                }
                else
                {
                    returnIndex = 4;
                    //  看看对面前排是否都活着
                        List<BattleObject> front = new List<BattleObject>(from bo in targetObjList where !bo.IsDead() && bo.teamHero.positionNum < 3 select bo);
                    if (front.Count > 0)
                    {
                        returnIndex = 1;
                    }
                    else
                    {
                        returnIndex = 4;
                    }
                }
                break;
            case 3:
                //  看看对面后排是否都活着
                List<BattleObject> back = new List<BattleObject>(from bo in targetObjList where !bo.IsDead() && bo.teamHero.positionNum >= 3 select bo);
                if (back.Count > 0)
                if (skillConfig.TagAffect != 0 && skillConfig.TagAffect != 3 && skillConfig.TagCount < 3)
                {
                    returnIndex = 4;
                    uint objId = targetList[0].ObjID;
                    BattleObject target = caster.battleField.battleObjMgr.GetBattleObject((int)objId);
                    returnIndex = target.teamHero.positionNum;
                }
                else
                {
                    returnIndex = 1;
                    //  看看对面后排是否都活着
                    List<BattleObject> back = new List<BattleObject>(from bo in targetObjList where !bo.IsDead() && bo.teamHero.positionNum >= 3 select bo);
                    if (back.Count > 0)
                    {
                        returnIndex = 4;
                    }
                    else
                    {
                        returnIndex = 1;
                    }
                }
                break;
            // 4    纵排，按对位规则选择纵排
            case 4:
                List<BattleObject> vertical = new List<BattleObject>(from bo in targetObjList where !bo.IsDead() && (bo.teamHero.positionNum - caster.teamHero.positionNum) % 3 == 0 select bo);
                //  TODO YYL
                returnIndex = int.MaxValue;
                for (int i = 0; i < targetList.Count; i++)
                {
                    var hurt = targetList[i];
                    BattleObject target = caster.battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
                    if (target == null)
                    {
                        Debug.LogError("GetMainTargetPositionNum 找不到目标 ObjId : " + hurt.ObjID);
                        continue;
                    }
                    else
                    {
                        returnIndex = Mathf.Min(returnIndex, target.teamHero.positionNum);
                    }
                }
                break;
            // 5    自己，默认只选自己
            case 5:
                returnIndex = caster.teamHero.positionNum;
                break;
            default:
                Debug.LogError("暂时不支持其他的方式选择主目标 有需求请联系策划 技能id:" + skillConfig.SkillID + " TagAim " + skillConfig.TagAim);
                returnIndex = 0;
                break;
        }


 Main/System/Battle/Skill/SkillBase.cs

@@ -116,9 +116,9 @@
            case SkillCastMode.Allies:
                CastToAllies();
                break;
            // case SkillCastMode.DashCast:
            //     DashToTarget(() => BackToOrigin(OnSkillFinished));
            //     break;
            case SkillCastMode.DashCast:
                DashCast(OnAttackFinish);
                break;
            default:
                Debug.LogError("暂时不支持其他的方式释放 有需求请联系策划 技能id:" + skillConfig.SkillID + " cast position " + skillConfig.CastPosition);
                OnSkillFinished();
@@ -127,6 +127,29 @@

    }

    //    冲撞攻击
    protected void DashCast(Action _onComplete)
    {
        Debug.LogError("DashCast 还没实现");
        //    YYL TODO

        // var entry = caster.motionBase.PlayAnimation(skillConfig.GetMotionName(), false);
        // float animationTime = entry.AnimationTime;

        // int mainTargetPosNum = BattleUtility.GetMainTargetPositionNum(caster, tagUseSkillAttack.HurtList.ToList(), skillConfig);

        // BattleCamp battleCamp = skillConfig.TagFriendly != 0 ? caster.Camp : caster.GetEnemyCamp();

        // RectTransform targetTrans = battleField.GetTeamNode(battleCamp, mainTargetPosNum);

        // var tweener = BattleUtility.MoveToTarget(caster.heroRectTrans, targetTrans, new Vector2(skillConfig.CastDistance, 0), animationTime * 0.9f, () =>
        // {
        //     caster.motionBase.PlayAnimation(MotionName.idle, true);
        //     _onComplete?.Invoke();
        // });
        // battleField.battleTweenMgr.OnPlayTween(tweener);
    }

    protected void MoveToTarget(RectTransform target, Vector2 offset, float duration, Action onComplete = null)
    {
        //    原地释放

 Main/System/Battle/Skill/SkillCastMode.cs

@@ -17,4 +17,6 @@

    Target,

    DashCast, //释放技能冲刺到目标位置

}

 Main/System/Battle/SkillEffect/NormalSkillEffect.cs

@@ -20,6 +20,23 @@

    public override void OnMiddleFrameEnd(int times, int hitIndex)
    {

        int mainTargetIndex = BattleUtility.GetMainTargetPositionNum(caster, tagUseSkillAttack.HurtList.ToList(), skillConfig);

        BattleCamp battleCamp = skillConfig.TagFriendly == 1 ? caster.Camp : caster.GetEnemyCamp();

        RectTransform targetTransform = caster.battleField.GetTeamNode(battleCamp, mainTargetIndex);

        if (skillConfig.ExplosionEffectId > 0)
        {
            caster.battleField.battleEffectMgr.PlayEffect(0, skillConfig.ExplosionEffectId, targetTransform, battleCamp);
        }

        if (skillConfig.ExplosionEffect2 > 0)
        {
            caster.battleField.battleEffectMgr.PlayEffect(0, skillConfig.ExplosionEffect2, targetTransform, battleCamp);
        }

        for (int i = 0; i < tagUseSkillAttack.HurtList.Length; i++)
        {
            var hurt = tagUseSkillAttack.HurtList[i];
@@ -28,16 +45,6 @@
            {
                Debug.LogError("特效目标为空 target == null ObjId : " + hurt.ObjID);
                continue;
            }

            if (skillConfig.ExplosionEffectId > 0)
            {
                caster.battleField.battleEffectMgr.PlayEffect(target.ObjID, skillConfig.ExplosionEffectId, target.heroGo.transform, target.Camp);
            }

            if (skillConfig.ExplosionEffect2 > 0)
            {
                caster.battleField.battleEffectMgr.PlayEffect(target.ObjID, skillConfig.ExplosionEffect2, target.heroGo.transform, target.Camp);
            }

            if (skillConfig.ExplosionEffect3 > 0)