Merge branch 'master' of http://192.168.1.20:10010/r/Project_SG_scripts

yyl

2025-10-31 39001a600fcae2bcf27c225df8752d75fb92fef4

 Main/System/HeroUI/HeroUIManager.OnTeam.cs

@@ -6,7 +6,7 @@

public partial class HeroUIManager : GameSystemManager<HeroUIManager>
{
    


    #region 布阵界面
    public List<string> heroOnTeamSortList { get; private set; } = new List<string>();    //不同上阵的列表排序
@@ -171,12 +171,43 @@

        var team = TeamManager.Instance.GetTeam(teamType);
        if (team == null)
        { 
        {
            return heroCountryCount;
        }
        TeamHero[] teamHeroes = isPreview ? team.tempHeroes : team.serverHeroes;

        for (int i = 0; i < teamHeroes.Length; i++)
        {
            if (teamHeroes[i] == null)
                continue;
            var country = teamHeroes[i].Country;

            if (!heroCountryCount.ContainsKey(country))
            {
                heroCountryCount.Add(country, 1);
            }
            else
            {
                heroCountryCount[country] += 1;
            }

        }


        return heroCountryCount;
    }

    /// <summary>
    /// 获得自定义队伍中各个国家的武将数量
    /// </summary>
    public Dictionary<HeroCountry, int> GetCountryHeroCountByTeamHeroList(List<TeamHero> teamHeroes)
    {
        Dictionary<HeroCountry, int> heroCountryCount = new Dictionary<HeroCountry, int>();
        if (teamHeroes == null)
        {
            return heroCountryCount;
        }
        for (int i = 0; i < teamHeroes.Count; i++)
        {
            if (teamHeroes[i] == null)
                continue;
@@ -220,6 +251,26 @@
        return new Int2((int)country, maxValue);
    }

    /// <summary>
    /// 获得自定义队伍中武将数量最大的国家和数量
    /// </summary>
    public Int2 GetMaxCountHeroCountry(List<TeamHero> teamType)
    {
        var countryCountDict = GetCountryHeroCountByTeamHeroList(teamType);
        //找到最大的国家和数量
        HeroCountry country = HeroCountry.None;
        int maxValue = 0;
        foreach (var data in countryCountDict)
        {
            if (data.Value > maxValue)
            {
                country = data.Key;
                maxValue = data.Value;
            }
        }
        return new Int2((int)country, maxValue);
    }

    //在不同页签下选AttackType 0 攻击阵容 1 防守阵容
    public int GetSelectTeamTypeByAttackType(int AttackType)
    {
@@ -241,12 +292,8 @@
    //推荐阵容
    public List<string> SelectRecommend()
    {
        //推荐阵容的算法逻辑
        //自动选择优先级：武将等级＞突破等级＞武将觉醒阶级＞武将品质＞武将吞噬星级＞武将ID
        var tmpList = HeroManager.Instance.GetHeroGuidList();
        tmpList.Sort(CmpHeroRecommend);


        //推荐最多6个，存在相同heroid，则跳过
        List<string> selectHeroList = new List<string>();
        List<int> selectHeroIDList = new List<int>();
@@ -258,6 +305,7 @@
            string guid = tmpList[i];
            HeroInfo heroInfo = HeroManager.Instance.GetHero(guid);
            if (selectHeroIDList.Contains(heroInfo.heroId))
                //重复英雄
                continue;
            //如果重复了,跳过
            if (selectHeroList.Contains(guid))
@@ -265,10 +313,16 @@
            selectHeroList.Add(guid);
            selectHeroIDList.Add(heroInfo.heroId);
        }

        // 再按 肉盾>控制>输出>辅助
        selectHeroList.Sort(CmpByJob);

        return selectHeroList;
    }


    //！！！新排序规则
    //若在新手引导（引导ID）中，如果5号位为空，则优先放置5号位
    //按战力排序 
    int CmpHeroRecommend(string guidA, string guidB)
    {
        HeroInfo heroA = HeroManager.Instance.GetHero(guidA);
@@ -278,34 +332,204 @@
            return 0;
        }

        // 排序规则：武将等级＞突破等级＞武将觉醒阶级＞武将品质＞武将吞噬星级＞武将ID
        if (heroA.heroLevel != heroB.heroLevel)
        {
            return heroA.heroLevel > heroB.heroLevel ? -1 : 1;
        }
        if (heroA.breakLevel != heroB.breakLevel)
        {
            return heroA.breakLevel > heroB.breakLevel ? -1 : 1;
        }
        if (heroA.awakeLevel != heroB.awakeLevel)
        {
            return heroA.awakeLevel > heroB.awakeLevel ? -1 : 1;
        }
        if (heroA.Quality != heroB.Quality)
        {
            return heroA.Quality > heroB.Quality ? -1 : 1;
        }
        if (heroA.heroStar != heroB.heroStar)
        {
            return heroA.heroStar > heroB.heroStar ? -1 : 1;
        }
        // // 排序规则：武将等级＞突破等级＞武将觉醒阶级＞武将品质＞武将吞噬星级＞武将ID
        // if (heroA.heroLevel != heroB.heroLevel)
        // {
        //     return heroA.heroLevel > heroB.heroLevel ? -1 : 1;
        // }
        // if (heroA.breakLevel != heroB.breakLevel)
        // {
        //     return heroA.breakLevel > heroB.breakLevel ? -1 : 1;
        // }
        // if (heroA.awakeLevel != heroB.awakeLevel)
        // {
        //     return heroA.awakeLevel > heroB.awakeLevel ? -1 : 1;
        // }
        // if (heroA.Quality != heroB.Quality)
        // {
        //     return heroA.Quality > heroB.Quality ? -1 : 1;
        // }
        // if (heroA.heroStar != heroB.heroStar)
        // {
        //     return heroA.heroStar > heroB.heroStar ? -1 : 1;
        // }

        return heroA.heroId.CompareTo(heroB.heroId);


        return heroB.CalculateFightPower(false).CompareTo(heroA.CalculateFightPower(false));
    }

    int CmpByJob(string guidA, string guidB)
    {
        HeroInfo heroA = HeroManager.Instance.GetHero(guidA);
        HeroInfo heroB = HeroManager.Instance.GetHero(guidB);
        if (heroA == null || heroB == null)
        {
            return 0;
        }
        
        int indexA = Array.IndexOf(teamSortByJob, heroA.heroConfig.Class);
        int indexB = Array.IndexOf(teamSortByJob, heroB.heroConfig.Class);

        return indexA.CompareTo(indexB);
    }


    #endregion

    
    #region 主界面上的武将上阵解锁显示 和 解锁规则

    public int[][] lockHeroCountLimit;
    public List<int> lockIndexList = new List<int>();

    public int[] teamSortByJob;
    public int onekeyGuideID;
    public int[] onekeyGuidePosList; //一键上阵在引导下的顺序

    public Action OnUnLockHeroCountEvent;
    public int lockState
    {
        get
        {
            return QuickSetting.Instance.GetQuickSettingValue<int>(QuickSettingType.HeroCountLock, 0);
        }
        set
        {
            QuickSetting.Instance.SetQuickSetting(QuickSettingType.HeroCountLock, value, 0);
            QuickSetting.Instance.SendPackage();
            RefreshServerLockIndex();
        }
    }

    //解锁上阵英雄的数量限制, 解锁条件在界面上是按顺序排序的，但是锁定的位置是动态变化的
    //比如 第4，5，6格子锁住了，但第6个的锁先完成了解锁条件，解锁后锁住的位置往后顺推
    //则 第4的位置显示为解锁状态，5和6是锁住状态，5的解锁条件按配置列表的顺序解锁（即为原4的解锁条件）

    // 模拟服务端 这里的index 对应的是配表的
    public bool IsUnLock(int configIndex)
    {
        //按lockState的位判断
        return (lockState & (1 << configIndex)) != 0;
    }

    public bool SetUnLock(int configIndex)
    {
        if (!CanUnLock(configIndex, true))
        {
            return false;
        }
        lockState |= 1 << configIndex;
        return true;
    }

    // 解锁类型
    // 1.主公等级达X级开启；
    // 2.通关主线X-X开启；同任务配法
    // 3.开服时间达到X天开启；
    public bool CanUnLock(int configIndex, bool notify = false)
    {
        int type = lockHeroCountLimit[configIndex][0];
        int value = lockHeroCountLimit[configIndex][1];
        if (type == 1)
        {
            if (PlayerDatas.Instance.baseData.LV < value)
            {
                if (notify)
                    SysNotifyMgr.Instance.ShowTip("HeroCountUnLock1", value);
                return false;
            }
        }
        else if (type == 2)
        {
            //如ExAttr1值为20103代表当前已经过了第2章第1关第3波； value为201
            if (PlayerDatas.Instance.baseData.ExAttr1 / 100 <= value)
            {
                if (notify)
                    SysNotifyMgr.Instance.ShowTip("HeroCountUnLock2", value / 100, value % 100);
                return false;
            }
        }
        else if (type == 3)
        {
            if (TimeUtility.OpenDay < value - 1)
            {
                if (notify)
                    SysNotifyMgr.Instance.ShowTip("HeroCountUnLock3", value);
                return false;
            }
        }

        return true;
    }


    public void ShowUnLockTip(int configIndex)
    {
        int type = lockHeroCountLimit[configIndex][0];
        int value = lockHeroCountLimit[configIndex][1];
        if (type == 1)
        {
            if (PlayerDatas.Instance.baseData.LV < value)
            {
                SysNotifyMgr.Instance.ShowTip("HeroCountUnLock1", value);
                return;
            }
        }
        else if (type == 2)
        {
            //如ExAttr1值为20103代表当前已经过了第2章第1关第3波； value为201
            if (PlayerDatas.Instance.baseData.ExAttr1 / 100 <= value)
            {
                SysNotifyMgr.Instance.ShowTip("HeroCountUnLock2", value / 100, value % 100);
                return;
            }
        }
        else if (type == 3)
        {
            if (TimeUtility.OpenDay < value - 1)
            {
                SysNotifyMgr.Instance.ShowTip("HeroCountUnLock3", value);
                return;
            }
        }

        //可以解锁，但未解锁
        if (!IsUnLock(configIndex))
        {
            SysNotifyMgr.Instance.ShowTip("HeroCountUnLock4");
        }
    }


    // 刷新未解锁武将上限的配置索引列表
    public void RefreshServerLockIndex()
    {
        lockIndexList.Clear();
        for (int i = 0; i < lockHeroCountLimit.Length; i++)
        {
            if (!IsUnLock(i))
            {
                lockIndexList.Add(i);
            }
        }
    }

    public bool UnLockHeroCnt(int lockIndex)
    {
        if (lockIndex < 0 || lockIndex >= lockIndexList.Count)
        {
            return false;
        }

        return SetUnLock(lockIndexList[lockIndex]);

    }

    void OnQuickSettingUpdate()
    {
        RefreshServerLockIndex();
    }
    #endregion

}