CTT/Server/Hotfix/Game/Helper/BattleHelper.cs

using Cal;
using System;
using System.Collections.Generic;

namespace ET
{
    public enum NumTargetType
    {
        Self,
        Target
    }
    public static class BattleHelper
    {
        public static void GetNumType(ValueCalculate valueCalculate, NumTargetType numTargetType, NumericComponent _num, NumericComponent _numTarget, out NumericComponent num, out NumericType numericType)
        {
            num = numTargetType switch
            {
                NumTargetType.Self => _num,
                NumTargetType.Target => _numTarget ?? throw new Exception("numTarget is null ,baseOriType  类型错误!"),
                _ => throw new Exception("baseOriType  类型错误!"),
            };
            numericType = valueCalculate.calculateType switch
            {
                ValueCalculateType.物理攻击力x系数 => NumericType.PhyAtk,
                ValueCalculateType.精神攻击力x系数 => NumericType.SpiAtk,
                ValueCalculateType.生命值上限x系数 => NumericType.MaxHp,
                ValueCalculateType.当前生命值x系数 => NumericType.Hp,
                _ => throw new Exception("basePercEffectType  类型错误!")
            };
        }

        /// <summary>
        /// 计算伤害
        /// </summary>
        /// <param name="damageType"></param>
        /// <param name="owner"></param>
        /// <param name="target"></param>
        /// <param name="damageCalculate_Self"></param>
        /// <param name="damageCalculate_Target"></param>
        /// <param name="data"></param>
        internal static void Calculate(SkillDamageType damageType, ISkillSender skillSender, Unit target, ValueCalculate damageCalculate_Self, ValueCalculate damageCalculate_Target, out BallisticData data)
        {
            if (damageCalculate_Self == null && damageCalculate_Target == null)
            {
                data = default;
                return;
            }
            NumericComponent num = skillSender.caster.GetComponent<NumericComponent>();
            NumericComponent numTarget = target.GetComponent<NumericComponent>();
            switch (damageType)
            {
                default:
                case SkillDamageType.None:
                    data = default;
                    break;
                case SkillDamageType.物理伤害:
                    PhyBuffDamageCalculate.Calculate(num, numTarget, damageCalculate_Self, damageCalculate_Target, skillSender.skillLogic.skillConfigId, out data);
                    break;
                case SkillDamageType.精神伤害:
                    SpiBuffDamageCalculate.Calculate(num, numTarget, damageCalculate_Self, damageCalculate_Target, skillSender.skillLogic.skillConfigId, out data);
                    break;
                case SkillDamageType.真实伤害:
                    RealBuffDamageCalculate.Calculate(num, numTarget, damageCalculate_Self, damageCalculate_Target, skillSender.skillLogic.skillConfigId, out data);
                    break;
                case SkillDamageType.护盾治疗:
                    TreatBuffDamageCalculate.Calculate(num, numTarget, damageCalculate_Self, damageCalculate_Target, skillSender.skillLogic.skillConfigId, out data);
                    break;
            }
        }

        internal static void SetTargets( BattleBase battle, IEnumerable<Unit> teamList, IEnumerable<Unit> targetTeamList)
        {
            foreach (Unit unit in teamList)
            {
                try
                {

                    unit.BattleId = battle.Id;
                    //!增加目标
                    unit.AddComponent<AttackComponent>();
                    TargetableUnitComponent targetUnits = unit.AddComponent<TargetableUnitComponent>();
                    targetUnits.AddEnermy(targetTeamList);
                    targetUnits.AddTeam(teamList);
                    targetUnits.selectedEnermy = null;

                    //!战斗开始添加技能,现在添加合适吗
                    SkillMgrComponent skillMgr = unit.GetComponent<SkillMgrComponent>();
                    UnitSkillComponent skillComponent = unit.GetComponent<UnitSkillComponent>();
                    foreach (UnitSkill unitSkill in skillComponent.GetLearnedSkills())
                    {
                        //if (unitSkill.IsPassive)
                        //    continue;
                        skillMgr.AddSkill(unit, unitSkill);
                    }
                }
                catch (Exception e)
                {
                	Log.Error(e);
                }
            }

            foreach (Unit unit in targetTeamList)
            {
                try
                {
                    unit.BattleId = battle.Id;
                    //!增加目标
                    unit.AddComponent<AttackComponent>();
                    TargetableUnitComponent targetUnits = unit.AddComponent<TargetableUnitComponent>();
                    targetUnits.AddEnermy(teamList);
                    targetUnits.AddTeam(targetTeamList);
                    targetUnits.selectedEnermy = null;

                    //!战斗开始添加技能,现在添加合适吗
                    SkillMgrComponent skillMgr = unit.GetComponent<SkillMgrComponent>();
                    UnitSkillComponent skillComponent = unit.GetComponent<UnitSkillComponent>();
                    foreach (UnitSkill unitSkill in skillComponent.GetLearnedSkills())
                    {
                        //if (unitSkill.IsPassive)
                        //    continue;
                        skillMgr.AddSkill(unit, unitSkill);
                    }
                }
                catch (Exception e)
                {
                	Log.Error(e);
                }
            }
            return;



        }
        //!玩家释放技能
        public static void PlayerSkill(Unit unit, long now)
        {
            if (!unit.IsAlive) return;
            if (unit.GetComponent<UserSetting>().IsAutoSkill)
            {
                SkillAI ai = unit.GetComponent<SkillAI>();
                ai.canSkill = true;
                ai.PlayAutoSkill(now);
            }
        }
        //!怪物释放技能
        public static void MonsterSkill(Unit unit)
        {
            if (!unit.IsAlive) return;
            SkillAI ai = unit.GetComponent<SkillAI>();
            ai.PlaySkill();
        }
        public static async ETVoid UpdateChangeMapTaskStateEvent(UnitScene unitScene, IEnumerable<Unit> teamList)
        {
            foreach (Unit u in teamList)
            {
                await Game.EventSystem.Publish(new EventType.UpdateTaskState
                {
                    unit = u,
                    type = TaskTargetType.ChangeMapTask,
                    value = unitScene.MapId
                });
            }
        }
        public static async ETVoid BrocastReword(IEnumerable<Unit> teamList, UnOrderMultiMapComponent<long, (int, int)> rewordMap)
        {
            using ListComponent<string> listComponent = ListComponent<string>.Create();
            foreach (KeyValuePair<long, List<(int, int)>> kp in rewordMap.MultiMap.GetDictionary())
            {
                long unitId = kp.Key;
                User user = await UserHelper.Query(unitId);
                foreach ((int id, int count) in kp.Value)
                {
                    listComponent.List.Add($"[color=#ffff00]【{user?.NickName}】[/color]获得了[color=#226655]{BagHelper.GetName(id)}x{count}[/color]");
                }
            }
            foreach (Unit unit in teamList)
            {
                Chat.Instance.SendSystemToTeamCaht(unit, listComponent.List);
            }
            rewordMap.Dispose();
        }

        public static async ETVoid UnitDead(BattleBase self, Unit unit)
        {
            try
            {
                if (!unit)
                    Log.Error($"unit is invalid which Id = {unit?.Id}");
                //!触发死亡事件
                if (unit.UnitType != UnitType.Player)
                {
                    UnitEnermy unitInfo = unit.GetComponent<UnitEnermy>();
                    Unit attackerUnit = unitInfo.unit;
                    int monsterId = unitInfo.MonsterId;
                    await Game.EventSystem.Publish(new EventType.UpdateTaskState
                    {
                        type = TaskTargetType.KillSpecialTask,
                        unit = attackerUnit,
                        value = monsterId
                    });
                    await Game.EventSystem.Publish(new EventType.UpdateTaskState
                    {
                        type = TaskTargetType.KillAnyTask,
                        unit = attackerUnit,
                        value = monsterId
                    });
                }
                LinkedList<Unit> teamList = self.team.GetUnits();

                if (self.team.Contains(unit.Id))
                {
                    self.targetKillInfo.UpdateAmount(1);
                    Log.Info($"【{ UserComponent.Instance.Get(unit.Id)?.NickName} ({ unit.Id})】战斗死亡了！");
                }
                else
                {
                    self.mineKillInfo.UpdateAmount(1);
                }

                //!给客户端广播怪物死亡消息
                IActorMessage deadMessage = new M2C_UnitDead()
                {
                    UnitId = unit.Id
                };

                MessageHelper.Broadcast(teamList, self.targetTeam.GetUnits(), deadMessage);
            }
            catch (Exception e)
            {
                Log.Error(e);
            }
        }

        public static void OnTargetVictory(this BattleBase self, Team team)
        {
            try
            {
                if (self == null)
                {
                    Log.Error($"battle == null");
                    return;
                }
                if (!self.isRunning) return;
                Execute(self, team).Coroutine();
                static async ETVoid Execute(BattleBase self, Team team)
                {
                    self.isRunning = false;

                    LinkedList<Unit> teamList = team.GetUnits();
                    await TimerComponent.Instance.WaitAsync(5500);

                    BattleHelper.EnermyClearOption(self, team);

                    Team anotherTeam = self.GetAnotherTeam(team);
                    await self.OnDefeat(anotherTeam);
                    BattleMgrCompnent.Instance.RemoveBattle(self);

                }
            }
            catch (Exception e)
            {
                Log.Error(e);
                BattleMgrCompnent.Instance.RemoveBattle(self);
            }
        }
        internal static async ETTask VictoryOption(BattleBase self, Team team,long configid = 0)
        {
            try
            {
                LinkedList<Unit> teamList = team.GetUnits();
                team.ChangeState(TeamState.None);

                //!战斗结束事件(回血，奖励) 
                UnOrderMultiMapComponent<long, (int, int)> rewordMapComponent = EntityFactory.Create<UnOrderMultiMapComponent<long, (int, int)>>(Game.Scene);
                rewordMapComponent.Dispose();
                foreach (Unit u in teamList)
                {
                    u.RemoveComponent<AttackComponent>();
                    u.RemoveComponent<TargetableUnitComponent>();

                    Game.EventSystem.Publish(new EventType.BattleEnd { unit = u ,team = team}).Coroutine();
                    Game.EventSystem.Publish(new EventType.BattleEnd_AddHp { unit = u }).Coroutine();
                    u.Live();
                    await Game.EventSystem.Publish(new EventType.BattleEnd_Reword { unit = u, rewordMap = rewordMapComponent.MultiMap, battleType = self.battleType,configid=configid });
                }
                MainStoryInteractive battleInteractiveInfo = MainStoryMap.Instance.GetBattleInteractiveInfo(team.LeaderId);
                battleInteractiveInfo.LeaderMonsterId = 0;
                //!存档
                //UnitHelper.Save(team).Coroutine();
                BattleHelper.BrocastReword(teamList, rewordMapComponent).Coroutine();
                //!移除不在线玩家
                await TeamComponent.Instance.RemoveAllOffLineId(team);
            }
            catch (Exception e)
            {
                Log.Error(e);
            }

        }
        internal static async ETTask DefeatOption(BattleBase self, Team team)
        {
            try
            {
                LinkedList<Unit> teamList = team.GetUnits();
                team.ChangeState(TeamState.None);
                foreach (Unit u in teamList)
                {
                    MessageHelper.SendActor(u, new M2C_BattleDefeat
                    {
                        BattleType = (int)self.battleType
                    });
                }
                foreach (Unit u in teamList)
                {
                    u.RemoveComponent<AttackComponent>();
                    u.RemoveComponent<TargetableUnitComponent>();


                    if (u.IsTeamLeader)
                    {
                        Game.EventSystem.Publish(new EventType.BackMainCity { unit = u,isForce =true }).Coroutine();
                    }
                    u.Live();
                    //!战斗结束事件(回血)
                    Game.EventSystem.Publish(new EventType.BattleEnd { unit = u,team = team }).Coroutine();
                    Game.EventSystem.Publish(new EventType.BattleEnd_AddHp { unit = u }).Coroutine();
                }

                //!移除不在线玩家
                await TeamComponent.Instance.RemoveAllOffLineId(team);
            }
            catch (Exception e)
            {
                Log.Error(e);
            }
        }
        internal static void EnermyClearOption(BattleBase self, Team team)
        {
            try
            {
                LinkedList<Unit> teamList = team.GetUnits();
                team.ChangeState(TeamState.None);
             
                foreach (Unit u in teamList)
                {
                    u.RemoveComponent<AttackComponent>();
                    u.RemoveComponent<TargetableUnitComponent>();
                }
            }
            catch (Exception e)
            {
                Log.Error(e);
            }
        }
        public static string SelectFixedTarget(this BattleBase self, Unit unit, long unitId, Team targetTeam, TeamType teamType)
        {
            try
            {
                AttackComponent attacker = unit.GetComponent<AttackComponent>();
                TargetableUnitComponent targetComponent = unit.GetComponent<TargetableUnitComponent>();
                switch (teamType)
                {
                    case TeamType.Self:
                        Team team = self.team;
                        Unit targetUnit = team.Get(unitId);
                        if (targetUnit == null)
                        {
                            return "系统错误";
                        }
                        targetComponent.selectedTeamMember = targetUnit;
                        break;
                    case TeamType.Target:
                        team = targetTeam;
                        targetUnit = team.Get(unitId);
                        if (targetUnit == null)
                        {
                            return "系统错误";
                        }
                        targetComponent.selectedEnermy = targetUnit;
                        break;
                    default:
                        break;
                }
            }
            catch (Exception e)
            {
                Log.Error(e);
            }
            return null;
        }
    }
}