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

yyl

2025-12-24 e6269ae16fea2462c32705ce0fbe7e4f3bf364a4

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

 Main/System/Battle/BaseBattleWin.cs

@@ -1,4 +1,5 @@
using UnityEngine;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

/// <summary>
@@ -185,8 +186,6 @@
        battleField.OnRoundChange += OnRoundChange;
        OnRoundChange(battleField.round, battleField.turnMax); // 立即执行一次以显示初始回合
    }


    /// <summary>
    /// 跳过战斗
    /// </summary>
@@ -201,87 +200,132 @@
    {
        if (null == battleField)
            return true;
        // 检查是否为永久特权卡玩家

        bool hasForeverPrivilege = InvestModel.Instance.IsInvested(InvestModel.foreverCardType);

        string battleFieldName = battleField.ToString();
        if (!hasForeverPrivilege && !FuncOpen.Instance.IsFuncOpen(BattleManager.Instance.passFuncId))
        {
            if (battleFieldName != BattleConst.StoryBossBattleField)
            {
                //等级达到20级后解锁或开通终身特权解锁
                SysNotifyMgr.Instance.ShowTip("BattlePass2");
            }
            else
            {
                FuncOpen.Instance.ProcessorFuncErrorTip(BattleManager.Instance.passFuncId);
            }

        // 检查功能开启状态
        if (!IsPassOpen(hasForeverPrivilege, battleFieldName))
            return false;
        }

        int passRound = BattleManager.Instance.defaultPassRound;
        var name = battleField.ToString();


        if (hasForeverPrivilege)
        // 获取配置的回合限制
        int configRoundLimit = GetRequiredPassRound(hasForeverPrivilege, battleFieldName);
        int nowRound = battleField.round > 0 ? battleField.round : 1;
        if (nowRound >= configRoundLimit + 1)
        {
            // 永久特权卡玩家逻辑
            if (BattleConst.FieldNameToIndex.ContainsKey(name))
            return true;
        }
        ShowSkipWaitTip(configRoundLimit, battleFieldName, hasForeverPrivilege);
        return false;
    }

    private bool IsPassOpen(bool hasForeverPrivilege, string battleFieldName)
    {
        // 拥有永久特权卡，无视功能开启限制
        if (hasForeverPrivilege)
            return true;

        int passFuncId = BattleManager.Instance.passFuncId;
        // 检查功能ID是否开启
        if (FuncOpen.Instance.IsFuncOpen(passFuncId))
            return true;

        if (!FuncOpenLVConfig.HasKey(passFuncId))
            return true;
        int lv = FuncOpenLVConfig.Get(passFuncId).LimitLV;
        SysNotifyMgr.Instance.ShowTip("BattlePass2", lv);
        return false;
    }

    private int GetRequiredPassRound(bool hasForeverPrivilege, string battleFieldName)
    {
        // 初始化默认值
        int resultRound = BattleManager.Instance.defaultPassRound;

        // 尝试获取普通配置（覆盖默认值）
        if (BattleConst.FieldNameToIndex.TryGetValue(battleFieldName, out int index))
        {
            if (BattleManager.Instance.passDict.TryGetValue(index, out int normalRound))
            {
                int index = BattleConst.FieldNameToIndex[name];
                if (BattleManager.Instance.foreverPrivilegePassDict.ContainsKey(index))
                {
                    passRound = BattleManager.Instance.foreverPrivilegePassDict[index];
                }
                else
                {
                    // 未配置的战场类型，使用普通玩家规则
                    if (BattleManager.Instance.passDict.ContainsKey(index))
                    {
                        passRound = BattleManager.Instance.passDict[index];
                    }
                    // 否则使用默认配置
                }
                resultRound = normalRound;
            }
            // 如果战场类型不在 FieldNameToIndex 中，使用默认配置
        }
        else
        {
            // 普通玩家逻辑
            if (BattleConst.FieldNameToIndex.ContainsKey(name))
            {
                int index = BattleConst.FieldNameToIndex[name];
                if (BattleManager.Instance.passDict.ContainsKey(index))
                {
                    passRound = BattleManager.Instance.passDict[index];
                }
                // 否则使用默认配置
            }
            // 如果战场类型不在 FieldNameToIndex 中，使用默认配置
            // 如果连索引都找不到，直接返回默认值，无需后续判断
            return resultRound;
        }

        if (passRound != 0)
        // 如果没有特权，直接返回普通配置
        if (!hasForeverPrivilege)
            return resultRound;

        // 判断特权是否生效
        bool isPrivilegeEffective = true;

        // 特殊规则：主线BOSS需要达到指定章节，特权才生效
        if (battleFieldName == BattleConst.StoryBossBattleField)
        {
            int nowRound = battleField.round;
            int realPassRound = passRound + 1;  // 配置是超过x回合可以跳,意味着x+1回合可以跳
            if (nowRound < realPassRound)
            if (IsStoryBossChapterLimited())
            {
                if (battleFieldName != BattleConst.StoryBossBattleField)
                {
                    //%s0回合后可跳过，开通终身特权立即跳过
                    SysNotifyMgr.Instance.ShowTip("BattlePass1", realPassRound - nowRound);
                }
                else
                {
                    SysNotifyMgr.Instance.ShowTip("BattlePass", realPassRound - nowRound);
                }

                return false;
                isPrivilegeEffective = false;
            }
        }
        return true;

        if (isPrivilegeEffective)
        {
            var vipDict = BattleManager.Instance.foreverPrivilegePassDict;
            // 只有当特权表里显式配置了该战场，才进行覆盖
            if (vipDict.TryGetValue(index, out int vipRound))
            {
                resultRound = vipRound;
            }
        }

        return resultRound;
    }

    private void ShowSkipWaitTip(int configRoundLimit, string battleFieldName, bool hasForeverPrivilege)
    {
        int waitRound = Mathf.Max(configRoundLimit - battleField.round + 1, 0);

        // 主线BOSS战场特殊提示
        if (battleFieldName == BattleConst.StoryBossBattleField)
        {
            if (!hasForeverPrivilege || IsStoryBossChapterLimited())
            {
                SysNotifyMgr.Instance.ShowTip("BattlePass3", waitRound, BattleManager.Instance.passChapterID);
            }
            else
            {
                SysNotifyMgr.Instance.ShowTip("BattlePass", waitRound);
            }
        }
        // 其他战场提示
        else
        {
            if (hasForeverPrivilege)
            {
                SysNotifyMgr.Instance.ShowTip("BattlePass", waitRound);
            }
            else
            {
                SysNotifyMgr.Instance.ShowTip("BattlePass1", waitRound);
            }

        }
    }

    /// <summary>
    /// 检查主线BOSS是否受到章节限制
    /// </summary>
    private bool IsStoryBossChapterLimited()
    {
        long currentProgress = PlayerDatas.Instance.baseData.ExAttr2;
        int nowChapterID = (int)(currentProgress / 10000);

        return nowChapterID <= BattleManager.Instance.passChapterID;
    }

    /// <summary>
    /// 改变速度

 Main/System/Battle/BattleManager.cs

@@ -27,9 +27,10 @@
    public readonly int[] speedIndexfuncIdArr = new int[] { 34, 35, 36 };  // 战斗倍数对应的功能ID
    public readonly int passFuncId = 33;    // 跳过战斗对应的功能ID

    public int defaultPassRound;   
    public Dictionary<int, int> passDict = new Dictionary<int, int>(); 
    public int defaultPassRound;
    public Dictionary<int, int> passDict = new Dictionary<int, int>();
    public Dictionary<int, int> foreverPrivilegePassDict = new Dictionary<int, int>();
    public int passChapterID;

    public int fightBossGuideID;
    public int fightGuideMainLevelLimit;
@@ -70,6 +71,7 @@
        defaultPassRound = int.Parse(config.Numerical1);
        passDict = ConfigParse.ParseIntDict(config.Numerical2);
        foreverPrivilegePassDict = ConfigParse.ParseIntDict(config.Numerical3);
        passChapterID = int.Parse(config.Numerical4);
    }



 Main/System/HeroUI/HeroListWin.cs

@@ -45,7 +45,7 @@
        fiterManager = HeroSelectBehaviour.Create(heroSelectBehaviour);
        lineupRecommendBtn.AddListener(() =>
        {
            UIManager.Instance.OpenWindow<LineupRecommendBaseWin>();
            UIManager.Instance.OpenWindow<LineupRecommendWin>();
        });
    }


 Main/System/HeroUI/HeroPosWin.cs

@@ -110,7 +110,7 @@

        lineupRecommendBtn.AddListener(() =>
        {
            UIManager.Instance.OpenWindow<LineupRecommendBaseWin>();
            UIManager.Instance.OpenWindow<LineupRecommendWin>();
        });

        m_IsToggleOn = LocalSave.GetBool("ShowConn" + PlayerDatas.Instance.baseData.PlayerID, false);

 Main/System/LineupRecommend/LineupRecommendBaseWin.cs

File was deleted

 Main/System/LineupRecommend/LineupRecommendBaseWin.cs.meta

File was deleted

 Main/System/LineupRecommend/LineupRecommendWin.cs

@@ -1,36 +1,19 @@
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;

public class LineupRecommendWin : UIBase
{
    [SerializeField] AvatarCell avatarCell;
    [SerializeField] Text txtPlayerName;
    [SerializeField] Text txtFightPoint;
    [SerializeField] OfficialTitleCell officialRankText;

    [SerializeField] ScrollerController scroller;
    LineupRecommendManager manager { get { return LineupRecommendManager.Instance; } }
    protected override void InitComponent()
    {
        base.InitComponent();
        avatarCell.redpoint.redpointId = MainRedDot.PhantasmPavilionRepoint;
        avatarCell.button.SetListener(() =>
        {
            UIManager.Instance.OpenWindow<PlayerProfileWin>();
        });
    }

    protected override void OnPreOpen()
    {
        PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefresh;
        scroller.OnRefreshCell += OnRefreshCell;
        scroller.OnGetDynamicSize += OnGetDynamicSize;
        manager.OnUpdateLineupRecommendInfoEvent += OnUpdateLineupRecommendInfoEvent;
        manager.OnUpdateSwitchOnOrOffEvent += OnUpdateSwitchOnOrOffEvent;

        manager.ClearOnList();
        UpdatePlayerInfo();
        scroller.lockType = EnhanceLockType.KeepVertical;
        CreateScoller();
        int index = 0;
@@ -41,7 +24,6 @@

    protected override void OnPreClose()
    {
        PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefresh;
        scroller.OnRefreshCell -= OnRefreshCell;
        scroller.OnGetDynamicSize -= OnGetDynamicSize;
        manager.OnUpdateLineupRecommendInfoEvent -= OnUpdateLineupRecommendInfoEvent;
@@ -77,28 +59,6 @@
        return true;
    }

    void PlayerDataRefresh(PlayerDataType type)
    {
        switch (type)
        {
            case PlayerDataType.FightPower:
                txtFightPoint.text = UIHelper.ReplaceLargeArtNum(PlayerDatas.Instance.baseData.FightPower);
                break;
            case PlayerDataType.RealmLevel:
                officialRankText.InitUI(PlayerDatas.Instance.baseData.realmLevel, PlayerDatas.Instance.baseData.TitleID);
                break;
            case PlayerDataType.Face:
            case PlayerDataType.FacePic:
                avatarCell.InitUI(AvatarHelper.GetAvatarModel((int)PlayerDatas.Instance.baseData.PlayerID,
                                                                PlayerDatas.Instance.baseData.face,
                                                                PlayerDatas.Instance.baseData.facePic));
                break;
            case PlayerDataType.ExAttr3:
                officialRankText.InitUI(PlayerDatas.Instance.baseData.realmLevel, PlayerDatas.Instance.baseData.TitleID);
                break;
        }

    }

    void RefreshScoller()
    {
@@ -118,19 +78,5 @@
        }
        scroller.Restart();
    }

    private void UpdatePlayerInfo()
    {
        // 从玩家数据中获取信息并更新UI
        avatarCell.InitUI(AvatarHelper.GetAvatarModel((int)PlayerDatas.Instance.baseData.PlayerID,
                                                        PlayerDatas.Instance.baseData.face,
                                                        PlayerDatas.Instance.baseData.facePic));

        txtPlayerName.text = PlayerDatas.Instance.baseData.PlayerName;
        txtFightPoint.text = UIHelper.ReplaceLargeArtNum(PlayerDatas.Instance.baseData.FightPower);

        officialRankText.InitUI(PlayerDatas.Instance.baseData.realmLevel, PlayerDatas.Instance.baseData.TitleID);
    }


}

 Main/System/Main/MainWin.cs

@@ -299,6 +299,13 @@
                currentSubUI = UIManager.Instance.OpenWindow<AffairBaseWin>();
                break;
            case 2:
                if (gameTip.gameObject.activeSelf)
                {
                    if (!NewBieCenter.Instance.inGuiding)
                    {
                        NewBieCenter.Instance.StartNewBieGuide(HappyXBModel.Instance.tenCallGuideID);
                    }
                }
                currentSubUI = UIManager.Instance.OpenWindow<HeroBaseWin>(0);
                break;
            // case 3: