using System.Collections; 
 | 
using System.Collections.Generic; 
 | 
using UnityEngine; 
 | 
using System; 
 | 
using System.Linq;  
 | 
  
 | 
namespace vnxbqy.UI 
 | 
{ 
 | 
    public class SkyTowerModel : Model, IPlayerLoginOk, ISwitchAccount,IBeforePlayerDataInitialize 
 | 
    { 
 | 
        public const int DATA_MAPID = 31370; 
 | 
        readonly static int REDPOINTID_01 = 21501; 
 | 
        readonly static int REDPOINTID_02 = 215; 
 | 
        readonly static int REDPOINTID_03 = 21503; 
 | 
        readonly static int FUNCTIONID = 164; 
 | 
        readonly static int REDPOINTID_04 = 21508; //天星塔挑战全服奖励外层 
 | 
        readonly static int REDPOINTID_041 = 215080; //天星塔挑战全服1奖励 
 | 
        readonly static int REDPOINTID_042 = 215081; //天星塔挑战全服5奖励 
 | 
        public static int fullServerPassNum1 = 1;  //全服通关人数指标 
 | 
        public static int fullServerPassNum2 = 5; 
 | 
        public bool allPassed { 
 | 
            get { 
 | 
                return IsTopFloor(highestPassFloor); 
 | 
            } 
 | 
        } 
 | 
  
 | 
        public int highestPassFloor { get; private set; } 
 | 
        public int currentFloor { 
 | 
            get { 
 | 
                if (IsTopFloor(highestPassFloor)) 
 | 
                { 
 | 
                    return highestPassFloor; 
 | 
                } 
 | 
                else 
 | 
                { 
 | 
                    return highestPassFloor + 1; 
 | 
                } 
 | 
            } 
 | 
        }  
 | 
  
 | 
        int m_chooseFloorIndex = 0; //全服5奖励层 
 | 
        public int chooseFloorIndex  
 | 
        {  
 | 
            get  
 | 
            {  
 | 
                return m_chooseFloorIndex;  
 | 
            }  
 | 
            set  
 | 
            {  
 | 
                m_chooseFloorIndex = value;  
 | 
                OnChooseFloorIndexChange?.Invoke();  
 | 
            }  
 | 
        } 
 | 
        public event Action OnChooseFloorIndexChange; 
 | 
  
 | 
  
 | 
        bool redpointConfirm_01 = false; 
 | 
        bool redpointConfirm_02 = false; 
 | 
        bool redpointConfirm_03 = false; 
 | 
  
 | 
        public Redpoint redpoint01 = new Redpoint(REDPOINTID_01); 
 | 
        Redpoint redpoint02 = new Redpoint(REDPOINTID_02); 
 | 
        public Redpoint redpoint03 = new Redpoint(REDPOINTID_03); 
 | 
        public Redpoint redpoint04 = new Redpoint(REDPOINTID_01, REDPOINTID_04); 
 | 
        public Redpoint redpoint041 = new Redpoint(REDPOINTID_04, REDPOINTID_041); 
 | 
        public Redpoint redpoint042 = new Redpoint(REDPOINTID_04, REDPOINTID_042); 
 | 
        List<int> sortedFloors = new List<int>(); 
 | 
        //特殊奖励楼层 
 | 
        Dictionary<int, int> rewardShowFloors = new Dictionary<int, int>(); 
 | 
        public List<int> ChallengeFloors = new List<int>(); 
 | 
        //上榜的玩家数据 玩家ID:玩家信息 
 | 
        public Dictionary<int, ChallengeInfo> ChallengeInfoFloors = new Dictionary<int, ChallengeInfo>(); 
 | 
        //排行榜数据 楼层:玩家ID列表 
 | 
        public Dictionary<int, uint[]> rankFloorPlayerIDs = new Dictionary<int, uint[]>(); 
 | 
        //全服奖励领取记录 楼层:领取状态 
 | 
        Dictionary<int,int> serverRewardRecord = new Dictionary<int, int>(); 
 | 
        public event Action OnChallengeState; 
 | 
  
 | 
        DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } } 
 | 
  
 | 
  
 | 
        public override void Init() 
 | 
        { 
 | 
            ParseConfig(); 
 | 
        } 
 | 
  
 | 
        public override void UnInit() 
 | 
        { 
 | 
             
 | 
        } 
 | 
  
 | 
        public void RequestChallenge() 
 | 
        { 
 | 
            var error = GetErrorOfChallenge(); 
 | 
            if (error == 0) 
 | 
            { 
 | 
                dungeonModel.RequestChallangeDungeon(DATA_MAPID, 0); 
 | 
            } 
 | 
            else 
 | 
            { 
 | 
                switch (error) 
 | 
                { 
 | 
                    case 1: 
 | 
                        break; 
 | 
                    case 3: 
 | 
                        SysNotifyMgr.Instance.ShowTip("FbLV", DATA_MAPID); 
 | 
                        break; 
 | 
                    default: 
 | 
                        break; 
 | 
                } 
 | 
            } 
 | 
        } 
 | 
  
 | 
        public bool IsChallengable() 
 | 
        { 
 | 
            return GetErrorOfChallenge() == 0; 
 | 
        } 
 | 
  
 | 
        private int GetErrorOfChallenge() 
 | 
        { 
 | 
            if (!FuncOpen.Instance.IsFuncOpen(FUNCTIONID)) 
 | 
            { 
 | 
                return 1; 
 | 
            } 
 | 
  
 | 
            if (allPassed) 
 | 
            { 
 | 
                return 2; 
 | 
            } 
 | 
  
 | 
            var config = SkyTowerConfig.Get(currentFloor); 
 | 
            if (PlayerDatas.Instance.baseData.LV < config.levelLimit) 
 | 
            { 
 | 
                return 3; 
 | 
            } 
 | 
  
 | 
            return 0; 
 | 
        } 
 | 
  
 | 
        public void RequestRefreshMonster() 
 | 
        { 
 | 
            var sendInfo = new CA508_tagCMDoFBAction(); 
 | 
            sendInfo.ActionType = 0; 
 | 
            sendInfo.ActionInfo = (uint)currentFloor; 
 | 
            GameNetSystem.Instance.SendInfo(sendInfo); 
 | 
        } 
 | 
  
 | 
        public List<int> GetShowFloors() 
 | 
        { 
 | 
            var currentIndex = sortedFloors.IndexOf(currentFloor); 
 | 
            var floors = new List<int>(); 
 | 
  
 | 
            if (currentIndex < 2) 
 | 
            { 
 | 
                for (var i = 0; i <= 4; i++) 
 | 
                { 
 | 
                    floors.Add(sortedFloors[i]); 
 | 
                } 
 | 
            } 
 | 
            else if (currentIndex >= sortedFloors.Count - 2) 
 | 
            { 
 | 
                for (var i = sortedFloors.Count - 3; i <= sortedFloors.Count - 1; i++) 
 | 
                { 
 | 
                    floors.Add(sortedFloors[i]); 
 | 
                } 
 | 
            } 
 | 
            else 
 | 
            { 
 | 
                for (var i = currentIndex - 2; i <= currentIndex + 2; i++) 
 | 
                { 
 | 
                    floors.Add(sortedFloors[i]); 
 | 
                } 
 | 
            } 
 | 
  
 | 
            return floors; 
 | 
        } 
 | 
  
 | 
        public bool IsTopFloor(int floor) 
 | 
        { 
 | 
            return floor == sortedFloors[sortedFloors.Count - 1]; 
 | 
        } 
 | 
  
 | 
        public bool IsBottomFloor(int floor) 
 | 
        { 
 | 
            return floor == sortedFloors[0]; 
 | 
        } 
 | 
  
 | 
        public void UpdateHighestPassFloor(HB213_tagMCSkyTowerInfo info) 
 | 
        { 
 | 
            highestPassFloor = (int)info.Floor; 
 | 
            for (int i = 0; i < info.ServerRewardList.Length; i++) 
 | 
            { 
 | 
                serverRewardRecord[(int)info.ServerRewardList[i].Floor] = (int)info.ServerRewardList[i].ServerRewardRecord; 
 | 
            } 
 | 
            UpateRedpoint(); 
 | 
            if (OnChallengeState != null) 
 | 
                OnChallengeState(); 
 | 
        } 
 | 
  
 | 
        public void ConfirmRedpoint01() 
 | 
        { 
 | 
            redpointConfirm_01 = true; 
 | 
            UpateRedpoint(); 
 | 
        } 
 | 
  
 | 
        public void ConfirmRedpoint02() 
 | 
        { 
 | 
            redpointConfirm_02 = true; 
 | 
            UpateRedpoint(); 
 | 
        } 
 | 
  
 | 
        public void ConfirmRedpoint03() 
 | 
        { 
 | 
            redpointConfirm_03 = true; 
 | 
            UpateRedpoint(); 
 | 
        } 
 | 
  
 | 
        public void OnPlayerLoginOk() 
 | 
        { 
 | 
            UpateRedpoint(); 
 | 
        } 
 | 
  
 | 
        public void OnBeforePlayerDataInitialize()  
 | 
        {  
 | 
            ChallengeInfoFloors.Clear(); 
 | 
            serverRewardRecord.Clear(); 
 | 
            rankFloorPlayerIDs.Clear(); 
 | 
        } 
 | 
  
 | 
        public void OnSwitchAccount() 
 | 
        { 
 | 
            redpointConfirm_01 = false; 
 | 
            redpointConfirm_02 = false; 
 | 
            redpointConfirm_03 = false; 
 | 
        } 
 | 
  
 | 
        private void UpateRedpoint() 
 | 
        { 
 | 
            var config = SkyTowerConfig.Get(currentFloor); 
 | 
            var challengable = IsChallengable() && PlayerDatas.Instance.baseData.FightPoint >= (ulong)NPCExConfig.Get(config.bossId).SuppressFightPower; 
 | 
  
 | 
            if (!redpointConfirm_01) 
 | 
            { 
 | 
                redpoint01.state = challengable ? RedPointState.Simple : RedPointState.None; 
 | 
            } 
 | 
            else 
 | 
            { 
 | 
                redpoint01.state = RedPointState.None; 
 | 
            } 
 | 
  
 | 
            if (!redpointConfirm_02) 
 | 
            { 
 | 
                redpoint02.state = challengable ? RedPointState.Simple : RedPointState.None; 
 | 
            } 
 | 
            else 
 | 
            { 
 | 
                redpoint02.state = RedPointState.None; 
 | 
            } 
 | 
  
 | 
            if (!redpointConfirm_03) 
 | 
            { 
 | 
                redpoint03.state = challengable ? RedPointState.Simple : RedPointState.None; 
 | 
            } 
 | 
            else 
 | 
            { 
 | 
                redpoint03.state = RedPointState.None; 
 | 
            } 
 | 
  
 | 
            UpdateChallengeInfoRedPoint(); 
 | 
        } 
 | 
  
 | 
        private void ParseConfig() 
 | 
        { 
 | 
            var configs = SkyTowerConfig.GetKeys(); 
 | 
            foreach (var item in configs) 
 | 
            { 
 | 
                var key = int.Parse(item); 
 | 
                sortedFloors.Add(key); 
 | 
                var config = SkyTowerConfig.Get(key); 
 | 
                if (config.rewardShow != 0)  
 | 
                {  
 | 
                    rewardShowFloors[key] = config.rewardShow;  
 | 
                } 
 | 
            } 
 | 
  
 | 
            var challengeConfig = SkyTowerServerChallengeConfig.GetKeys(); 
 | 
            foreach (var floorID in challengeConfig) 
 | 
            { 
 | 
                ChallengeFloors.Add(int.Parse(floorID)); 
 | 
            } 
 | 
            ChallengeFloors.Sort(); 
 | 
        } 
 | 
  
 | 
        public bool IsRecommendNextLevel() 
 | 
        { 
 | 
            if (!IsChallengable()) 
 | 
            { 
 | 
                return false; 
 | 
            } 
 | 
  
 | 
            var config = SkyTowerConfig.Get(currentFloor); 
 | 
            if (PlayerDatas.Instance.baseData.FightPoint < (ulong)NPCExConfig.Get(config.bossId).SuppressFightPower) 
 | 
            { 
 | 
                return false; 
 | 
            } 
 | 
  
 | 
            return true; 
 | 
        } 
 | 
  
 | 
        //下一个最近的特殊奖励层 
 | 
        public int GetNextRewardShowFloor() 
 | 
        {  
 | 
            var floors = rewardShowFloors.Keys.ToList();  
 | 
            floors.Sort();  
 | 
            for (var i = 0; i < floors.Count; i++)  
 | 
            {  
 | 
                if (floors[i] >= currentFloor)  
 | 
                {  
 | 
                    return floors[i];  
 | 
                }  
 | 
            }  
 | 
  
 | 
            return 0;  
 | 
        } 
 | 
  
 | 
  
 | 
  
 | 
        private void UpdateChallengeInfoRedPoint() 
 | 
        { 
 | 
            redpoint041.state = RedPointState.None; 
 | 
            redpoint042.state = RedPointState.None; 
 | 
            foreach (var floorInfo in rankFloorPlayerIDs) 
 | 
            { 
 | 
                if (CanGetChallengeReward(floorInfo.Key, fullServerPassNum1)) 
 | 
                { 
 | 
                    //可领取 
 | 
                    redpoint041.state = RedPointState.Simple; 
 | 
                }  
 | 
                if (CanGetChallengeReward(floorInfo.Key, fullServerPassNum2)) 
 | 
                { 
 | 
                    //可领取 
 | 
                    redpoint042.state = RedPointState.Simple; 
 | 
                } 
 | 
            } 
 | 
        } 
 | 
  
 | 
        public int GetChallengeAwardOrder()  
 | 
        {  
 | 
            foreach (var floorInfo in rankFloorPlayerIDs) 
 | 
            { 
 | 
                if (CanGetChallengeReward(floorInfo.Key, fullServerPassNum1)) 
 | 
                { 
 | 
                    return 0; 
 | 
                }  
 | 
                if (CanGetChallengeReward(floorInfo.Key, fullServerPassNum2)) 
 | 
                { 
 | 
                    return 1; 
 | 
                } 
 | 
            } 
 | 
  
 | 
            return 0; 
 | 
        } 
 | 
  
 | 
        public bool CanGetChallengeReward(int floor, int bitIndex) 
 | 
        { 
 | 
            if (!rankFloorPlayerIDs.ContainsKey(floor)) 
 | 
                return false; 
 | 
            var playerCnt = rankFloorPlayerIDs[floor].Length; 
 | 
  
 | 
            //人数不达标无法领奖 
 | 
            if (playerCnt < bitIndex) 
 | 
                return false; 
 | 
  
 | 
            var state = serverRewardRecord.ContainsKey(floor) ? serverRewardRecord[floor] : 0; 
 | 
  
 | 
            //每个数按位存31个激活索引 
 | 
            if (((int)Math.Pow(2, bitIndex) & state) == 0) 
 | 
            { 
 | 
                return true; 
 | 
            } 
 | 
            return false; 
 | 
        }  
 | 
  
 | 
        //0 不可领取 1 可领取 2 已领取  
 | 
        public int CanGetChallengeRewardEx(int floor, int bitIndex) 
 | 
        { 
 | 
            if (!rankFloorPlayerIDs.ContainsKey(floor)) 
 | 
                return 0; 
 | 
            var playerCnt = rankFloorPlayerIDs[floor].Length; 
 | 
  
 | 
            //人数不达标无法领奖 
 | 
            if (playerCnt < bitIndex) 
 | 
                return 0; 
 | 
  
 | 
            var state = serverRewardRecord.ContainsKey(floor) ? serverRewardRecord[floor] : 0; 
 | 
  
 | 
            //每个数按位存31个激活索引 
 | 
            if (((int)Math.Pow(2, bitIndex) & state) == 0) 
 | 
            { 
 | 
                return 1; 
 | 
            } 
 | 
            return 2; 
 | 
        } 
 | 
  
 | 
  
 | 
        public void OnGetSkyTowerPassPlayerInfo(HA9AD_tagGCSkyTowerPassPlayerInfo package) 
 | 
        { 
 | 
            for (int i = 0; i < package.PassFloorList.Length; i++)  
 | 
            { 
 | 
                rankFloorPlayerIDs[(int)package.PassFloorList[i].FloorID] = package.PassFloorList[i].PassPlayerIDList; 
 | 
            } 
 | 
            for (int i = 0; i < package.PassPlayerList.Length; i++)  
 | 
            {  
 | 
                ChallengeInfoFloors[(int)package.PassPlayerList[i].PlayerID] = new ChallengeInfo()  
 | 
                {  
 | 
                    Name = package.PassPlayerList[i].PlayerName.Trim().Replace("\0", ""),  
 | 
                    LV = package.PassPlayerList[i].LV,  
 | 
                    Job = package.PassPlayerList[i].Job,  
 | 
                    Realm = package.PassPlayerList[i].RealmLV,  
 | 
                    PlayerID = (int)package.PassPlayerList[i].PlayerID,  
 | 
                    Face = (int)package.PassPlayerList[i].Face,  
 | 
                    FacePic = (int)package.PassPlayerList[i].FacePic,  
 | 
                }; 
 | 
            } 
 | 
  
 | 
            UpateRedpoint(); 
 | 
            if (OnChallengeState != null) 
 | 
                OnChallengeState(); 
 | 
        } 
 | 
  
 | 
        public uint[] GetPlayerIDs(int floor) 
 | 
        {  
 | 
            if (!rankFloorPlayerIDs.ContainsKey(floor))  
 | 
                return new uint[0];  
 | 
            return rankFloorPlayerIDs[floor];  
 | 
        } 
 | 
  
 | 
        public ChallengeInfo GetPlayerInfo(int floor, int index) 
 | 
        {  
 | 
            if (!rankFloorPlayerIDs.ContainsKey(floor))  
 | 
                return new ChallengeInfo();  
 | 
            if (rankFloorPlayerIDs[floor].Length <= index)  
 | 
                return new ChallengeInfo();  
 | 
            var playerID = rankFloorPlayerIDs[floor][index];  
 | 
            if (!ChallengeInfoFloors.ContainsKey((int)playerID))  
 | 
                return new ChallengeInfo();  
 | 
            return ChallengeInfoFloors[(int)playerID];  
 | 
        } 
 | 
  
 | 
        public struct ChallengeInfo 
 | 
        { 
 | 
            public string Name; 
 | 
            public int LV; 
 | 
            public int Job; 
 | 
            public int Realm; 
 | 
            public int PlayerID; 
 | 
            public int Face;        //基本脸型  
 | 
            public int FacePic;        //头像框 
 | 
        } 
 | 
    } 
 | 
} 
 |