using System;  
 | 
using System.Collections;  
 | 
using System.Collections.Generic;  
 | 
using UnityEngine;  
 | 
namespace vnxbqy.UI  
 | 
{  
 | 
      
 | 
      
 | 
    public class RidingPetBossModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk  
 | 
    {  
 | 
        Dictionary<int, bool> m_BossAliceStates = new Dictionary<int, bool>();  
 | 
  
 | 
        public const int RIDINGPETBOSS_MAP = 31200;  
 | 
  
 | 
        public int[] BossIDArray;  
 | 
        public int[] Boss1RewardIDArray;  
 | 
        public int[] Boss2RewardIDArray;  
 | 
  
 | 
        Dictionary<int, RidingPetBossLine> RidingPetBossLineDict = new Dictionary<int, RidingPetBossLine>();  
 | 
        private string m_MountsBossID;  
 | 
        private string m_Boss1RewardID;  
 | 
        private string m_Boss2RewardID;  
 | 
  
 | 
        Dictionary<int, List<RidingPetBossReward>> m_PreviewItems = new Dictionary<int, List<RidingPetBossReward>>();  
 | 
  
 | 
        public readonly Redpoint redpoint = new Redpoint(218, 21801);  
 | 
  
 | 
        public event Action GetRidingPetBossLineDictAction;  
 | 
        public event Action onBossStateRefresh;  
 | 
  
 | 
        DailyQuestModel dailyQuestModel { get { return ModelCenter.Instance.GetModel<DailyQuestModel>(); } }  
 | 
  
 | 
        public override void Init()  
 | 
        {  
 | 
            m_MountsBossID = FuncConfigConfig.Get("QCBOSSID").Numerical1;  
 | 
            m_Boss1RewardID = FuncConfigConfig.Get("QCBOSSID").Numerical2;  
 | 
            m_Boss2RewardID = FuncConfigConfig.Get("QCBOSSID").Numerical3;  
 | 
            BossIDArray = ConfigParse.GetMultipleStr<int>(m_MountsBossID);  
 | 
            Boss1RewardIDArray = ConfigParse.GetMultipleStr<int>(m_Boss1RewardID);  
 | 
            Boss2RewardIDArray = ConfigParse.GetMultipleStr<int>(m_Boss2RewardID);  
 | 
  
 | 
            var configs = RidingPetBossRewardConfig.GetValues();  
 | 
            foreach (var config in configs)  
 | 
            {  
 | 
                List<RidingPetBossReward> bossRewards;  
 | 
                if (!m_PreviewItems.TryGetValue(config.lineId, out bossRewards))  
 | 
                {  
 | 
                    bossRewards = new List<RidingPetBossReward>();  
 | 
                    m_PreviewItems.Add(config.lineId, bossRewards);  
 | 
                }  
 | 
                var worldLevelArea = LitJson.JsonMapper.ToObject<int[]>(config.worldLevel);  
 | 
                var rankArea = LitJson.JsonMapper.ToObject<int[]>(config.rank);  
 | 
                var itemArray = LitJson.JsonMapper.ToObject<int[][]>(config.items);  
 | 
                var items = new List<Item>(itemArray.Length);  
 | 
                for (int i = 0; i < itemArray.Length; i++)  
 | 
                {  
 | 
                    items.Add(new Item()  
 | 
                    {  
 | 
                        id = itemArray[i][0],  
 | 
                        count = itemArray[i][1],  
 | 
                        quality = itemArray[i].Length > 2 ? itemArray[i][2] : 0,  
 | 
                    });  
 | 
                }  
 | 
                bossRewards.Add(new RidingPetBossReward()  
 | 
                {  
 | 
                    worldLevelArea = new Int2(worldLevelArea[0], worldLevelArea[1]),  
 | 
                    rankArea = new Int2(rankArea[0], rankArea[1]),  
 | 
                    items = items  
 | 
                });  
 | 
            }  
 | 
  
 | 
            DailyQuestActionTimer.Instance.RefreshDailyQuestState += RefreshDailyQuestState;  
 | 
        }  
 | 
  
 | 
        public void OnBeforePlayerDataInitialize()  
 | 
        {  
 | 
            m_BossAliceStates.Clear();  
 | 
        }  
 | 
  
 | 
        public void OnPlayerLoginOk()  
 | 
        {  
 | 
            UpdateRedpoint();  
 | 
        }  
 | 
  
 | 
        public override void UnInit()  
 | 
        {  
 | 
            DailyQuestActionTimer.Instance.RefreshDailyQuestState -= RefreshDailyQuestState;  
 | 
        }  
 | 
  
 | 
        public bool TryGetPreviewItems(int lineId, out List<RidingPetBossReward> bossRewards)  
 | 
        {  
 | 
            bossRewards = null;  
 | 
            if (m_PreviewItems.ContainsKey(lineId))  
 | 
            {  
 | 
                var worldLevel = PlayerDatas.Instance.worldLv;  
 | 
                bossRewards = m_PreviewItems[lineId].FindAll((x) =>  
 | 
                 {  
 | 
                     return x.SatisfyCondition((int)worldLevel);  
 | 
                 });  
 | 
                return bossRewards != null;  
 | 
            }  
 | 
            return false;  
 | 
        }  
 | 
  
 | 
        private void RefreshDailyQuestState()  
 | 
        {  
 | 
            UpdateRedpoint();  
 | 
        }  
 | 
  
 | 
        public void ReceivePackage(HAC07_tagGCHorsePetBossInfo package)  
 | 
        {  
 | 
            m_BossAliceStates[0] = !MathUtility.GetBitValue(package.IsEnd, 0);  
 | 
            m_BossAliceStates[1] = !MathUtility.GetBitValue(package.IsEnd, 1);  
 | 
            if (onBossStateRefresh != null)  
 | 
            {  
 | 
                onBossStateRefresh();  
 | 
            }  
 | 
  
 | 
            UpdateRedpoint();  
 | 
        }  
 | 
  
 | 
        public void ReceivePackage(HA007_tagGCFBLinePlayerCnt package)  
 | 
        {  
 | 
            if (package.MapID != RIDINGPETBOSS_MAP)  
 | 
            {  
 | 
                return;  
 | 
            }  
 | 
  
 | 
            RidingPetBossLineDict.Clear();  
 | 
  
 | 
            for (int i = 0; i < package.Count; i++)  
 | 
            {  
 | 
                var mapState = package.FBLineInfoList[i];  
 | 
                RidingPetBossLineDict[mapState.FBLineID] = new RidingPetBossLine()  
 | 
                {  
 | 
                    playerCnt = mapState.PlayerCnt,  
 | 
                    remainedHP = int.Parse(mapState.ExtraStr)  
 | 
                };  
 | 
            }  
 | 
            if (GetRidingPetBossLineDictAction != null)  
 | 
            {  
 | 
                GetRidingPetBossLineDictAction();  
 | 
            }  
 | 
        }  
 | 
  
 | 
        public string GetBossName(int index)  
 | 
        {  
 | 
            return NPCConfig.Get(BossIDArray[index]).charName;  
 | 
        }  
 | 
  
 | 
        public int GetBossRemianedHP(int index)  
 | 
        {  
 | 
            if (RidingPetBossLineDict.Count == 0 || !RidingPetBossLineDict.ContainsKey(index))  
 | 
            {  
 | 
                return 100;  
 | 
            }  
 | 
            else  
 | 
            {  
 | 
                return RidingPetBossLineDict[index].remainedHP;  
 | 
            }  
 | 
        }  
 | 
  
 | 
        public bool IsBossAlive(int index)  
 | 
        {  
 | 
            return m_BossAliceStates.ContainsKey(index) ? m_BossAliceStates[index] : false;  
 | 
        }  
 | 
  
 | 
        void UpdateRedpoint()  
 | 
        {  
 | 
            var redpointable = false;  
 | 
            if (dailyQuestModel.GetQuestState((int)DailyQuestType.RidingPetActivity)  
 | 
                == DailyQuestModel.DailyQuestState.Normal)  
 | 
            {  
 | 
                if (IsBossAlive(0) || IsBossAlive(1))  
 | 
                {  
 | 
                    redpointable = true;  
 | 
                }  
 | 
            }  
 | 
  
 | 
            redpoint.state = redpointable ? RedPointState.Simple : RedPointState.None;  
 | 
        }  
 | 
    }  
 | 
  
 | 
    public struct RidingPetBossLine  
 | 
    {  
 | 
        public int playerCnt;  
 | 
        public int remainedHP;  
 | 
    }  
 | 
  
 | 
    public struct RidingPetBossReward  
 | 
    {  
 | 
        public Int2 worldLevelArea;  
 | 
        public Int2 rankArea;  
 | 
        public List<Item> items;  
 | 
  
 | 
        public bool SatisfyCondition(int worldLevel)  
 | 
        {  
 | 
            if (worldLevel < worldLevelArea.x  
 | 
                || worldLevel > worldLevelArea.y)  
 | 
            {  
 | 
                return false;  
 | 
            }  
 | 
            return true;  
 | 
        }  
 | 
    }  
 | 
}  
 |