test/Assets/PerfectWorld/Scripts/ModelFiles/CECComboSkillState.cs

using BrewMonster.Scripts.Skills;
using NUnit.Framework;
using System;
using System.Collections.Generic;
using UnityEngine;

namespace BrewMonster
{
    public class CECComboSkillState : Singleton<CECComboSkillState>
    {
        public static CECComboSkillState instance;
        public static CECComboSkillState Instance
        {
            get
            {
                if (instance == null)
                {
                    instance = new CECComboSkillState();
                }
                return instance;
            }

            set => instance = value;
        }
        private readonly Dictionary<uint, CECSkill> m_inherentSkillMap = new Dictionary<uint, CECSkill>();
        private readonly List<uint> m_activeSkills = new();
        private readonly List<uint> m_skillStayTime = new();
        private readonly List<bool> m_skillTimeOut = new();
        List<uint> m_preSkillSet = new List<uint>();			// 所有是其它技能前提的技能

        uint m_dwStartTime;							// 技能激活开始时间

        public ComboSkillState m_comboSkillState { get; private set; }
        public DateTime? ComboStateStartTime { get; private set; }
        public IReadOnlyList<uint> ActiveComboSkills => m_activeSkills;
        public IReadOnlyList<uint> SkillStayTimes => m_skillStayTime;
        public IReadOnlyList<bool> SkillTimeouts => m_skillTimeOut;

        public CECSkill GetInherentSkillByID(uint skillID)
        {
            if (m_inherentSkillMap.TryGetValue(skillID, out CECSkill skill))
            {
                return skill;
            }
            else
            {
                return null;
            }
        }

        public void SetComboSkillState(Dictionary<uint, int> skillDic, ref ComboSkillState state)
        {
            //BMLogger.LogError($"SetComboSkillState: skillid={state.skillid}, arg0={state.arg[0]}, arg1={state.arg[1]}, arg2={state.arg[2]}");
            m_comboSkillState = state;
            if (state.skillid != 0)
            {
                m_dwStartTime = (uint)Time.realtimeSinceStartup * 1000;
                SetActiveComboSkills(skillDic);
                /* CECComboSkillChange change(CECComboSkillChange::COMBOSKILL_ACTIVE);
                 NotifyObservers(&change);*/
            }
            else
            {
                m_dwStartTime = 0;
                m_activeSkills.Clear();
                m_skillStayTime.Clear();
                m_skillTimeOut.Clear();
                /*CECComboSkillChange change(CECComboSkillChange::COMBOSKILL_STOP);
                NotifyObservers(&change);*/
            }
        }
        public ComboSkillState GetComboSkillState()
        {
            return m_comboSkillState;
        }
        void SetActiveComboSkills(Dictionary<uint, int> dic)
        {
            Dictionary<uint, int> newList = new Dictionary<uint, int>();
            FilterComboSkills(dic, newList);

            m_activeSkills.Clear();
            m_skillStayTime.Clear();
            m_skillTimeOut.Clear();
            List<uint> juniorSkills = new List<uint>();
            int i;
            foreach (var skill in newList)
            {
                int skillID = (int)skill.Key;
                int skillTime = skill.Value;
                m_activeSkills.Add((uint)skillID);
                m_skillStayTime.Add((uint)skillTime);
                m_skillTimeOut.Add(false);
                if (m_inherentSkillMap.ContainsKey((uint)skillID))
                {
                    juniorSkills.Add((uint)GetFirstChildRecursively(skillID));
                }
                else
                {
                    juniorSkills.Add((uint)skillID);
                }

            }
            // 冒泡排序：有后续技能的放在前面；最原始的初级技能id小的放在前面
            int j;
            for (i = m_activeSkills.Count - 1; i > 0; i--)
            {
                for (j = 0; j < i; j++)
                {
                    bool bPreSkill1 = IsComboPreSkill(juniorSkills[j]);
                    bool bPreSkill2 = IsComboPreSkill(juniorSkills[j + 1]);
                    if ((!bPreSkill1 && bPreSkill2) || (bPreSkill1 == bPreSkill2 && juniorSkills[j] > juniorSkills[j + 1]))
                    {
                        EC_Utility.Swap(m_activeSkills, j, j + 1);
                        EC_Utility.Swap(m_skillStayTime, j, j + 1);
                        EC_Utility.Swap(juniorSkills, j, j + 1);
                    }
                }
            }
        }
        public bool IsActiveComboSkill(uint skillID)
        {
            for (int i = 0; i < m_activeSkills.Count; i++)
            {
                if (m_activeSkills[i] == skillID && m_skillTimeOut[i] == false)
                {
                    return true;
                }
            }
            return false;
        }

        public bool IsComboPreSkill(uint skillID)
        {
            return m_preSkillSet.Contains(skillID);
        }
        int GetFirstChildRecursively(int iSkillID)
        {
            Dictionary<uint, int> vecJuniors = CECHostSkillModel.Instance.GetJunior(iSkillID);
            if (vecJuniors.Count == 0)
            {
                return iSkillID;
            }
            else
            {
                foreach (var skill in vecJuniors)
                {
                    int iComboPreSkill = ElementSkill.GetComboSkPreSkill(skill.Key);
                    if (iComboPreSkill != 0)
                    {
                        return GetFirstChildRecursively((int)skill.Key);
                    }
                }
                return iSkillID;
            }
        }
        void FilterComboSkills(Dictionary<uint, int> inDic, Dictionary<uint, int> outDic)
        {
            outDic.Clear();
            CECTaoistRank pCurTaoistRank = CECTaoistRank.GetTaoistRank(CECGameRun.Instance.GetHostPlayer().GetBasicProps().iLevel2);
            CECHostSkillModel hostSkillModel = CECHostSkillModel.Instance;
            uint i;
            foreach (var skill in inDic)
            {
                uint uiSkillID = skill.Key;
                if (!m_inherentSkillMap.ContainsKey(uiSkillID))
                {
                    // 如果不是天生技能，则执行过滤
                    enumEvilGod skillEvilGod = hostSkillModel.GetSkillEvilGod((int)uiSkillID);
                    enumSkillLearnedState skillLearnState = hostSkillModel.GetSkillLearnedState((int)uiSkillID);
                    // 如果该技能已被覆盖，则去掉
                    if (enumSkillLearnedState.SKILL_OVERRIDDEN == skillLearnState)
                    {
                        continue;
                    }
                    // 如果是魔技能且人物修真为普通或仙，则去掉
                    if (enumEvilGod.SKILL_EVIL == skillEvilGod)
                    {
                        if (pCurTaoistRank.IsBaseRank() || pCurTaoistRank.IsGodRank())
                        {
                            continue;
                        }
                    }
                    // 如果是仙技能且人物修真为普通或魔，则去掉
                    if (enumEvilGod.SKILL_GOD == skillEvilGod)
                    {
                        if (pCurTaoistRank.IsBaseRank() || pCurTaoistRank.IsEvilRank())
                        {
                            continue;
                        }
                    }
                    // 如果是仙魔技能且未学习，则去掉
                    if (enumEvilGod.SKILL_GOD == skillEvilGod || skillEvilGod == enumEvilGod.SKILL_EVIL)
                    {
                        if (enumSkillLearnedState.SKILL_NOT_LEARNED == skillLearnState)
                        {
                            continue;
                        }
                    }
                }
                outDic[skill.Key] = skill.Value;
            }

        }
    }
}