153 【武将】招募系统 - 抽奖立绘增加背景图

hch

2025-09-17 f306d23e461ab236ed88173f7b4a5bc35a3e9bc9

 Main/System/Battle/SkillEffect/BulletSkillEffect.cs

@@ -13,14 +13,17 @@

    protected List<BulletCurve> bulletCurves = new List<BulletCurve>();


    public BulletSkillEffect(SkillConfig _skillConfig, BattleObject _caster, HB427_tagSCUseSkill _tagUseSkillAttack)
        : base(_skillConfig, _caster, _tagUseSkillAttack)
    {

    }

    public override void OnMiddleFrameStart(int times)

    public override void OnMiddleFrameEnd(int times, int index)
    {
        base.OnMiddleFrameEnd(times, index);
        //  弹射 另外的做法了
        if (skillConfig.effectType == SkillEffectType.Bullet && skillConfig.BulletPath == 4)
        {
@@ -28,148 +31,336 @@
            BattleObject targetObject = caster.battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
            if (targetObject == null)
            {
                BattleDebug.LogError("目标为空 target == null ObjId : " + hurt.ObjID);
                Debug.LogError("目标为空 target == null ObjId : " + hurt.ObjID);
                return;
            }
            ShotToTarget(targetObject);
            ShotToTarget(targetObject, index);
        }
        //  普通的做法 区分打向阵营或者打向个体
        else
        {
            Action<int, List<HB427_tagSCUseSkill.tagSCUseSkillHurt>> onHitFormation = (_hitIndex, _hurtList) =>
            //  区分散射跟范围攻击
            if (skillConfig.Scattering == 1)
            {
                onHit?.Invoke(_hitIndex, tagUseSkillAttack.HurtList.ToList());
            };
            switch (skillConfig.castMode)
                //  散射
                ShotEachTargets(index);
            }
            else
            {
                case SkillCastMode.Self:
                    onHitFormation?.Invoke(0, tagUseSkillAttack.HurtList.ToList());
                    BattleDebug.LogError("子弹的目标是自己，暂时不支持 协商程序完成");
                    break;
                case SkillCastMode.Enemy:
                    var targetNode = caster.battleField.GetTeamNode(caster.GetEnemyCamp(), skillConfig);
                    ShotToFormation(targetNode, onHitFormation);
                    break;
                case SkillCastMode.Target:
                    for (int i = 0; i < tagUseSkillAttack.HurtList.Length; i++)
                    {
                        var hurt = tagUseSkillAttack.HurtList[i];
                        BattleObject target = caster.battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
                        if (target == null)
                        {
                            BattleDebug.LogError("特效目标为空 target == null ObjId : " + hurt.ObjID);
                            continue;
                        }

                        ShotToTarget(target);
                    }
                    break;
                case SkillCastMode.Allies:
                    var healNode = caster.battleField.GetTeamNode(caster.Camp, skillConfig);
                    ShotToFormation(healNode, onHitFormation);
                    break;
                default:
                    BattleDebug.LogError("暂时不支持其他的方式释放 有需求请联系程序 " + skillConfig.SkillID);
                    break;
                switch (skillConfig.TagAim)
                {
                    case 0:
                        AllAreaShoting(index);
                        break;
                    case 1:
                        OneTargetShoting(index);
                        break;
                    case 2:
                        FrontRowShoting(index);
                        break;
                    case 3:
                        BackRowShoting(index);
                        break;
                    case 4:
                        VerticalRowShoting(index);
                        break;
                    case 5:
                        SelfShoting(index);
                        break;
                    default:
                        Debug.LogError("子弹特效没有配置正确的TagAim，强制结束子弹特效 TagAim: " + skillConfig.TagAim);
                        ForceFinished();
                        break;
                }
            }
        }
    }


    public override void Play(Action<int, List<HB427_tagSCUseSkill.tagSCUseSkillHurt>> _onHit)
    // 0   全部范围：
    private void AllAreaShoting(int index)
    {
        base.Play(_onHit);
        if (skillConfig.TagCount == 0 || skillConfig.TagCount >= 6)
        {
            // 若TagCount目标个数为0或6，根据TagFriendly敌我配置，代表作用于敌方全体或我方全体，此时主目标为敌我站位中的2号位置
            BattleCamp battleCamp = skillConfig.TagFriendly != 0 ? caster.Camp : caster.GetEnemyCamp();
            ShotToIndex(battleCamp, 1, index);
        }
        else
        {
            // 若TagCount目标个数为1~5个，代表随机作用于敌方或我方x个武将，此时所有被随机到的对象都为主目标（施法位置会用客户端配置）
            ShotEachTargets(index);
        }   
    }

    // 1    对位：
    private void OneTargetShoting(int index)
    {
        // 默认只选1个，对位规则为A1优先打B1，A2优先打B2，A3优先打B3，对位目标死亡时，优先前排，
        // 比如B2已经死亡，那么A2将优先打B1，前排1、2、3号位置全部死亡之后才开始选择后排4、5、6号位置，
        // 对位只可选1个目标，即主目标

        if (tagUseSkillAttack.HurtList.Length > 1)
        {
            Debug.LogError("服务器 对位攻击目标数量错误，应该只有一个目标 技能id" + skillConfig.SkillID);
        }

        var hurt = tagUseSkillAttack.HurtList[0];
        BattleObject targetObject = caster.battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
        if (targetObject == null)
        {
            Debug.LogError("目标为空 target == null ObjId : " + hurt.ObjID);
            return;
        }
        ShotToTarget(targetObject, index);
    }

    // 2    前排：
    private void FrontRowShoting(int index)
    {
        // 1、2、3号位为前排，默认2号位置为主目标，当1、2、3号位置角色全部死亡，前排将替换成后排，5号位置变更为主目标，
        // 若配置TagAffect细分目标，且人数小于3，则所有被选择目标均为主目标（施法位置会用客户端配置）
        // （即前排默认2号位或5号位规则无效，实际作用多少人就是多少个主目标）

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

        if (skillConfig.TagAffect != 0 && skillConfig.TagAffect != 3 && skillConfig.TagCount < 3)
        {
            ShotEachTargets(index);
        }
        else
        {
            int targetIndex = int.MaxValue;
            int minimumIndex = int.MaxValue;

            foreach (var hurt in tagUseSkillAttack.HurtList)
            {
                BattleObject target = caster.battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
                if (target == null)
                {
                    Debug.LogError("特效目标为空 target == null ObjId : " + hurt.ObjID);
                    continue;
                }

                minimumIndex = Mathf.Min(target.teamHero.positionNum, minimumIndex);

                if (target.Camp == battleCamp && target.teamHero.positionNum < 3)
                {
                    targetIndex = 1;
                    break;
                }
            }

            if (targetIndex == int.MaxValue)
            {
                targetIndex = (minimumIndex >= 3) ? 4 : 1;
            }
            else
            {
                targetIndex = 1;
            }

            ShotToIndex(battleCamp, targetIndex, index);
        }

    }

    protected void ShotToFormation(RectTransform target, Action<int, List<HB427_tagSCUseSkill.tagSCUseSkillHurt>> _onHit)
    private void ShotToIndex(BattleCamp camp, int targetIndex, int bulletIndex)
    {
        BattleEffectPlayer effectPlayer = caster.battleField.battleEffectMgr.PlayEffect(caster.ObjID, skillConfig.BulletEffectId, caster.effectNode);
        RectTransform targetTransform = caster.battleField.GetTeamNode(camp, targetIndex);
        BattleEffectPlayer effectPlayer = caster.battleField.battleEffectMgr.PlayEffect(caster, skillConfig.BulletEffectId, caster.heroRectTrans, caster.Camp);

        RectTransform effectTrans = effectPlayer.transform as RectTransform;

        var bulletCurve = BulletCurveFactory.CreateBulletCurve(caster, skillConfig, effectPlayer, target, tagUseSkillAttack, (index, hitList) =>
        var bulletCurve = BulletCurveFactory.CreateBulletCurve(caster, skillConfig, effectPlayer, targetTransform, tagUseSkillAttack, bulletIndex, (index, hitList) =>
        {
            // 表现子弹飞行到目标位置
            _onHit?.Invoke(index, hitList);

            if (isFinish)
                return;
            // 击中就销毁子弹
            caster.battleField.battleEffectMgr.RemoveEffect(skillConfig.BulletEffectId, effectPlayer);
            // 播放子弹爆炸特效

            BattleCamp battleCamp = skillConfig.TagFriendly != 0 ? caster.Camp : caster.GetEnemyCamp();
            //  首先是目标身上爆炸
            PlayExplosionEffect(skillConfig.ExplosionEffectId, targetTransform, caster.Camp);
            PlayExplosionEffect(skillConfig.ExplosionEffect2, targetTransform, caster.Camp);

            foreach (var hurt in hitList)
            {
                BattleObject targetObj = caster.battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
                if (targetObj == null)
                {
                    BattleDebug.LogError("目标为空 target == null ObjId : " + hurt.ObjID);
                    Debug.LogError("目标为空 target == null ObjId : " + hurt.ObjID);
                    continue;
                }

                var effect1 = caster.battleField.battleEffectMgr.PlayEffect(targetObj.ObjID, skillConfig.ExplosionEffectId, targetObj.heroGo.transform);
                var effect2 = caster.battleField.battleEffectMgr.PlayEffect(targetObj.ObjID, skillConfig.ExplosionEffect2, targetObj.heroGo.transform);
                if (effect1 != null)
                {
                    effect1.transform.localRotation = effectTrans.localRotation;
                }
                if (effect2 != null)
                {
                    effect2.transform.localRotation = effectTrans.localRotation;
                }
                PlayExplosionEffect(skillConfig.ExplosionEffect3, targetObj.heroGo.transform, caster.Camp);
            }

        });

        bulletCurves.Add(bulletCurve);

    }

    protected void ShotToTarget(BattleObject target)
    {
        BattleDebug.LogError("发射子弹 " + skillConfig.BulletEffectId);
        BattleEffectPlayer effectPlayer = caster.battleField.battleEffectMgr.PlayEffect(caster.ObjID, skillConfig.BulletEffectId, caster.heroRectTrans);


        var bulletCurve = BulletCurveFactory.CreateBulletCurve(caster, skillConfig, effectPlayer, target.heroRectTrans, tagUseSkillAttack, (index, hitList) =>
        {
            // 表现子弹飞行到目标位置
            onHit?.Invoke(index, hitList);


            BattleDebug.LogError("回收子弹 " + skillConfig.BulletEffectId);
            // 播放子弹爆炸特效


            foreach (var hurt in hitList)
            {
                BattleObject targetObj = caster.battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
                if (targetObj == null)
                {
                    BattleDebug.LogError("目标为空 target == null ObjId : " + hurt.ObjID);
                    continue;
                }

                if (skillConfig.ExplosionEffectId > 0)
                {
                    var eft = caster.battleField.battleEffectMgr.PlayEffect(targetObj.ObjID, skillConfig.ExplosionEffectId, targetObj.heroGo.transform);
                    eft.transform.localRotation = effectPlayer.transform.localRotation;
                }

                if (skillConfig.ExplosionEffect2 > 0)
                {
                    var eft = caster.battleField.battleEffectMgr.PlayEffect(targetObj.ObjID, skillConfig.ExplosionEffect2, targetObj.heroGo.transform);
                    eft.transform.localRotation = effectPlayer.transform.localRotation;
                }
            }

            // 击中就销毁子弹
            caster.battleField.battleEffectMgr.RemoveEffect(skillConfig.BulletEffectId, effectPlayer);
            isFinish = true;
        });

        bulletCurves.Add(bulletCurve);
    }

    // 3    后排：
    private void BackRowShoting(int index)
    {
        // 4、5、6号位为后排，默认5号位置为主目标，当4、5、6号位置角色全部死亡，后排排将替换成前排，2号位置变更为主目标，
        // 若配置TagAffect细分目标，且人数小于3，则所有被选择目标均为主目标（施法位置会用客户端配置）
        // （即前排默认2号位或5号位规则无效，实际作用多少人就是多少个主目标）

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

        if (skillConfig.TagAffect != 0 && skillConfig.TagAffect != 3 && skillConfig.TagCount < 3)
        {
            ShotEachTargets(index);
        }
        else
        {
            int targetIndex = int.MaxValue;
            int maxinumIndex = int.MinValue;

            foreach (var hurt in tagUseSkillAttack.HurtList)
            {
                BattleObject target = caster.battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
                if (target == null)
                {
                    Debug.LogError("特效目标为空 target == null ObjId : " + hurt.ObjID);
                    continue;
                }

                if (target.Camp == battleCamp && target.teamHero.positionNum > 3)
                {
                    targetIndex = 4;
                    break;
                }

                maxinumIndex = Mathf.Max(target.teamHero.positionNum, maxinumIndex);
            }

            if (targetIndex == int.MaxValue)
            {
                targetIndex = (maxinumIndex < 3) ? 1 : 4;
            }
            else
            {
                targetIndex = 4;
            }

            ShotToIndex(battleCamp, targetIndex, index);
        }
    }

    // 4    纵排：
    private void VerticalRowShoting(int index)
    {
        // 纵排分别为1、4，2、5，3、6，三组纵排，按对位规则选择，默认1号、2号或3号为主目标，前排1、2、3号位置全部死完后，4号、5号或6号为主目标
        BattleCamp battleCamp = skillConfig.TagFriendly != 0 ? caster.Camp : caster.GetEnemyCamp();
        //  攻击mininumIndex目标
        int minimumIndex = int.MaxValue;
        foreach (var hurt in tagUseSkillAttack.HurtList)
        {
            BattleObject target = caster.battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
            if (target == null)
            {
                Debug.LogError("特效目标为空 target == null ObjId : " + hurt.ObjID);
                continue;
            }

            minimumIndex = Mathf.Min(target.teamHero.positionNum, minimumIndex);
        }

        if (minimumIndex != int.MaxValue)
        {
            ShotToIndex(battleCamp, minimumIndex, index);
        }
        else
        {
            Debug.LogError("纵排攻击没有目标 强制结束子弹特效");
            ForceFinished();
        }


    }

    // 5    自己：
    private void SelfShoting(int index)
    {
        // 默认只选自己，自己为主目标
        ShotToIndex(caster.Camp, caster.teamHero.positionNum, index);
    }

    protected void ShotToTarget(BattleObject target, int bulletIndex)
    {
        BattleEffectPlayer effectPlayer = caster.battleField.battleEffectMgr.PlayEffect(caster, skillConfig.BulletEffectId, caster.heroRectTrans, caster.Camp);

        var bulletCurve = BulletCurveFactory.CreateBulletCurve(caster, skillConfig, effectPlayer, target.heroRectTrans, tagUseSkillAttack, bulletIndex, (index, hitList) =>
        {
            if (isFinish)
                return;
            

            foreach (var hurt in hitList)
            {
                BattleObject targetObj = caster.battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
                if (targetObj == null)
                {
                    Debug.LogError("目标为空 target == null ObjId : " + hurt.ObjID);
                    continue;
                }

                PlayExplosionEffect(skillConfig.ExplosionEffectId, targetObj.heroGo.transform, caster.Camp);
                PlayExplosionEffect(skillConfig.ExplosionEffect2, targetObj.heroGo.transform, caster.Camp);
                PlayExplosionEffect(skillConfig.ExplosionEffect3, targetObj.heroGo.transform, caster.Camp);
            }

            // 表现子弹飞行到目标位置
            onHit?.Invoke(index, hitList);
            // 击中就销毁子弹
            caster.battleField.battleEffectMgr.RemoveEffect(skillConfig.BulletEffectId, effectPlayer);

            if (bulletIndex >= skillConfig.ActiveFrames.Length - 1)
            {
                isFinish = true;
            }
        });

        bulletCurves.Add(bulletCurve);
    }

    protected void PlayExplosionEffect(int effectId, Transform parent, BattleCamp camp)
    {
        if (effectId <= 0)
            return;

        var effect = caster.battleField.battleEffectMgr.PlayEffect(caster, effectId, parent, camp);
        if (effect != null)
        {
            effect.transform.localRotation = parent.localRotation;
            if (effect.transform.localScale.x < 0f)
            {
                effect.transform.localRotation *= Quaternion.Euler(0, 180, 0);
            }
        }
    }

    private void ShotEachTargets(int index)
    {
        for (int i = 0; i < tagUseSkillAttack.HurtList.Length; i++)
        {
            var hurt = tagUseSkillAttack.HurtList[i];
            BattleObject target = caster.battleField.battleObjMgr.GetBattleObject((int)hurt.ObjID);
            if (target == null)
            {
                Debug.LogError("特效目标为空 target == null ObjId : " + hurt.ObjID);
                continue;
            }
            ShotToTarget(target, index);
        }
    }


    public override void Run()
@@ -178,6 +369,15 @@
        {
            if (!bulletCurve.IsFinished)
                bulletCurve.Run();
        }
    }

    public override void ForceFinished()
    {
        base.ForceFinished();
        foreach (var bulletCurve in bulletCurves)
        {
            bulletCurve.ForceFinish();
        }
    }

@@ -190,6 +390,6 @@
            isCurveFinish |= bulletCurve.IsFinished;
        }

        return isCurveFinish && isFinish;
        return isCurveFinish && base.IsFinished();
    }
}