422 子 【内政】命格系统 / 【内政】命格系统-客户端

hch

2026-01-26 aa84cb62bebb9c8a4e586bcc1ec28eb7a16a8860

 Main/System/Hero/HeroManager.cs

@@ -1,81 +1,161 @@
using System.Collections.Generic;
using UnityEngine;
using System;
using System.Linq;

public class HeroManager : GameSystemManager<HeroManager>
{
    //武将和图鉴的关系
    //同一个武将图鉴，可能有多个武将（物品）数据，或者没有武将，但是有图鉴信息
    //初始创建（0725），后续跟随背包事件增加删除  key = guid
    protected Dictionary<string, HeroInfo> heroInfoDict = new Dictionary<string, HeroInfo>();

    public Action<HeroInfo> onNewHeroEvent;

    public Action<HeroInfo> onHeroChangeEvent;

    public Action<int> onHeroDeleteEvent;

    public override void Init()
    {
        base.Init();

        //  注册一点事件
        PackManager.Instance.refrechPackEvent += refrechPackEvent;
        PackManager.Instance.ChangeItemEvent += ChangeHero;
        PackManager.Instance.DeleteItemEvent += DeleteHero;
        DTC0102_tagCDBPlayer.beforePlayerDataInitializeEventOnRelogin += OnBeforePlayerDataInitialize;
    }

    public override void Release()
    {
        base.Release();
        PackManager.Instance.refrechPackEvent -= refrechPackEvent;
        PackManager.Instance.ChangeItemEvent -= ChangeHero;
        PackManager.Instance.DeleteItemEvent -= DeleteHero;
        DTC0102_tagCDBPlayer.beforePlayerDataInitializeEventOnRelogin -= OnBeforePlayerDataInitialize;
    }

    public override void RequestNessaryData()
    void OnBeforePlayerDataInitialize()
    {
        base.RequestNessaryData();

        
        heroInfoDict.Clear();
    }

    public void refrechPackEvent(PackType packType)

    // isCreate bool：true代表创建 false 刷新触发
    void ChangeHero(PackType packType, string guid, bool isCreate)
    {
        if (packType == PackType.Hero)
        {
            // bool change = false;
            bool isNew = false;
            //  如果有分批次初始化可能还要麻烦一点?先看看
            bool isInit = heroInfoDict.Count >= 0;

            SinglePack heroPack = PackManager.Instance.GetSinglePack(packType);

            Dictionary<int, ItemModel> heroes = heroPack.GetAllItems();

            foreach (ItemModel hero in heroes.Values)
            HeroInfo heroInfo = null;
            if (!heroInfoDict.TryGetValue(guid, out heroInfo))
            {
                HeroInfo heroInfo = null;
                if (!heroInfoDict.TryGetValue(hero.guid, out heroInfo))
                {
                    heroInfo = new HeroInfo(hero);
                    heroInfoDict.Add(hero.guid, heroInfo);
                    if (!isInit)
                    {
                        isNew = true;
                        onNewHeroEvent?.Invoke(heroInfo);
                    }
                }
                else
                {
                    heroInfo.UpdateHero(hero);
                    //  也有可能不是change
                    // change = true;
                    // onHeroChangeEvent?.Invoke(heroInfo);
                }
                heroInfo = new HeroInfo(PackManager.Instance.GetItemByGuid(guid));
                heroInfoDict.Add(guid, heroInfo);
            }
            else
            {
                heroInfo.UpdateHero(PackManager.Instance.GetItemByGuid(guid));
            }

            onHeroChangeEvent?.Invoke(heroInfo);
        }
    }

    void DeleteHero(PackType packType, string guid, int itemID, int index, int clearType)
    {
        if (packType == PackType.Hero)
        {
            HeroInfo heroInfo = null;
            heroInfoDict.TryGetValue(guid, out heroInfo);

            heroInfoDict.Remove(guid);

            onHeroDeleteEvent?.Invoke(itemID);
        }
    }

    public HeroInfo GetHero(string guid)
    {
        if (heroInfoDict == null || guid == null)
        {
            Debug.LogError("HeroManager GetHero guid is null");
            return null;
        }
        if (!heroInfoDict.ContainsKey(guid))
            return null;
        return heroInfoDict[guid];
    }

    public List<HeroInfo> GetHeroList()
    {
        return heroInfoDict.Values.ToList();
    }

    public List<string> GetHeroGuidList()
    {
        return heroInfoDict.Keys.ToList();
    }

    /// 参数： 职业，国家，伤害类型，6大战斗属性，特殊属性
    public List<string> GetHeroGuidList(List<int> selectList = null)
    {
        if (selectList.IsNullOrEmpty())
            return heroInfoDict.Keys.ToList();

        int job = selectList[0];
        int country = selectList[1];
        int hurtType = selectList[2];
        int fightAttrType = selectList[3];
        int specialAttrType = selectList[4];

        List<string> retGuidList = new List<string>();
        foreach (string guid in heroInfoDict.Keys)
        {
            HeroInfo heroInfo = heroInfoDict[guid];

            //0代表全部, 同级别是可复选，不同级别为且的关系
            bool isMatch = true;
            if (job != 0)
            {
                isMatch = isMatch && (job & (1 << heroInfo.heroConfig.Class)) > 0;
            }
            if (country != 0)
            {
                isMatch = isMatch && (country & (1 << heroInfo.heroConfig.Country)) > 0;
            }
            if (hurtType != 0)
            {
                isMatch = isMatch && (hurtType & (1 << heroInfo.heroConfig.HurtType)) > 0;
            }
            if (fightAttrType != 0)
            {
                isMatch = isMatch && (fightAttrType & (1 << heroInfo.heroConfig.Specialty)) > 0;
            }
            if (specialAttrType != 0)
            {
                bool isMatch2 = false;
                for (int i = 0; i < heroInfo.heroConfig.Specialty2.Length; i++)
                {
                    isMatch2 = (specialAttrType & (1 << heroInfo.heroConfig.Specialty2[i])) > 0;
                    if (isMatch2)
                        break;
                }
                isMatch = isMatch && isMatch2;
            }
            if (isMatch)
            {
                retGuidList.Add(guid);
            }

        }
        return retGuidList;
    }

    public List<HeroInfo> GetPowerfulHeroList()
    {
        List<HeroInfo> heroList = new List<HeroInfo>(heroInfoDict.Values);

        heroList.Sort((a, b) => 
        heroList.Sort((a, b) =>
        {
            int power1 = a.CalculatePower();
            int power2 = b.CalculatePower();
            long power1 = a.CalculateFightPower(false);
            long power2 = b.CalculateFightPower(false);

            if (power1 == power2)
            {
@@ -95,9 +175,74 @@
        return retList;
    }

    // public override bool IsNessaryDataReady()
    // {
    //     return true;
    // }

    public int GetHeroCount()
    {
        return heroInfoDict.Count;
    }

    public bool HasHero(int heroID)
    {
        return PackManager.Instance.GetSinglePack(PackType.Hero).HasItem(heroID);
    }

    public int GetHeroCountByID(int heroID)
    {
        return (int)PackManager.Instance.GetSinglePack(PackType.Hero).GetCountById(heroID);
    }

    //获得生效的武将数量
    public int GetAttrActiveHeroCount()
    {
        int count = 0;
        foreach (HeroInfo heroInfo in heroInfoDict.Values)
        {
            if (heroInfo.isAttrActive)
            {
                count++;
            }
        }
        return count;
    }

    //获得未生效的武将数量
    public int GetNotActiveHeroCount()
    {
        int count = 0;
        foreach (HeroInfo heroInfo in heroInfoDict.Values)
        {
            if (!heroInfo.isAttrActive)
            {
                count++;
            }
        }
        return count;
    }

    //获得指定ID且属性生效的武将
    public HeroInfo GetHeroByID(int heroID)
    {
        foreach (HeroInfo heroInfo in heroInfoDict.Values)
        {
            if (heroInfo.heroId == heroID && heroInfo.isAttrActive)
            {
                return heroInfo;
            }
        }
        return null;
    }

    public List<HeroInfo> GetHeroListByID(int heroID)
    {
        List<HeroInfo> heroList = new List<HeroInfo>();
        foreach (HeroInfo heroInfo in heroInfoDict.Values)
        {
            if (heroInfo.heroId == heroID)
            {
                heroList.Add(heroInfo);
            }
        }
        return heroList;
    }

}