5725 【前端】【1.5】跨服BOSS开发

client_Wu Xijin

2019-01-05 78aefe728e21950bf7dc2b1f93de9b2bae882b68

5725 【前端】【1.5】跨服BOSS开发

 Fight/MapTransferUtility.cs

@@ -843,7 +843,15 @@
            LineID = lineID,

            ExData1 = (uint)_npcId

        };

        GameNetSystem.Instance.SendInfo(_transfer);



        if (GameNetSystem.Instance.crossServerSocketConnected)

        {

            GameNetSystem.Instance.SendToCrossServer(_transfer);

        }

        else

        {

            GameNetSystem.Instance.SendInfo(_transfer);

        }



        return true;

    }


 System/CrossServerBoss/CrossServerBossBoxBehaviour.cs

New file
@@ -0,0 +1,66 @@
//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Saturday, August 18, 2018
//--------------------------------------------------------
using UnityEngine;
using System.Collections;
using UnityEngine.UI;
using TableConfig;

namespace Snxxz.UI
{

    public class CrossServerBossBoxBehaviour : MonoBehaviour
    {
        [SerializeField] Text m_BigBoxCount;
        [SerializeField] Text m_SmallBoxCount;
        [SerializeField] RawImage m_RawImage;

        CrossServerBossModel model { get { return ModelCenter.Instance.GetModel<CrossServerBossModel>(); } }

        public void Display()
        {
            timer = 0f;
            var config = Config.Instance.Get<NPCConfig>(model.bigBoxNpcId);
            UI3DModelExhibition.Instance.ShowNPC(model.bigBoxNpcId, config.UIModeLOffset, config.UIModelRotation, m_RawImage);
            DisplayBoxSurplusInfo();
            model.boxSurplusChangeEvent += OnBoxInfoUpdate;
        }

        public void Dispose()
        {
            model.boxSurplusChangeEvent -= OnBoxInfoUpdate;
            UI3DModelExhibition.Instance.StopShow();
        }

        private void OnBoxInfoUpdate()
        {
            DisplayBoxSurplusInfo();
        }

        private void DisplayBoxSurplusInfo()
        {
            var boxInfo = model.dogzDungeonBox;
            m_BigBoxCount.text = boxInfo.bigBoxSurplus.ToString();
            m_BigBoxCount.color = UIHelper.GetUIColor(boxInfo.bigBoxSurplus > 0 ? TextColType.White : TextColType.Red);
            m_SmallBoxCount.text = boxInfo.smallBoxSurplus.ToString();
            m_SmallBoxCount.color = UIHelper.GetUIColor(boxInfo.smallBoxSurplus > 0 ? TextColType.White : TextColType.Red);
        }

        float timer = 0f;
        private void LateUpdate()
        {
            timer += Time.deltaTime;
            if (timer > 30)
            {
                timer = 0f;
                model.RequestBoxSurplusInfo();
            }
        }

    }

}




 System/CrossServerBoss/CrossServerBossBoxBehaviour.cs.meta

New file
@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: fd93527350eb34b45bb89ef8ff14a008
timeCreated: 1534563273
licenseType: Pro
MonoImporter:
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 System/CrossServerBoss/CrossServerBossBreifInfoBehaviour.cs

New file
@@ -0,0 +1,238 @@
//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Saturday, August 18, 2018
//--------------------------------------------------------
using UnityEngine;
using System.Collections;
using UnityEngine.UI;
using TableConfig;
using System;

namespace Snxxz.UI
{

    public class CrossServerBossBreifInfoBehaviour : FindPreciousBossBriefInfoBehaviour
    {

        [SerializeField] Image m_Attention;

        protected override int selectedBossId {
            get {
                return model.selectedBoss;
            }
            set {
                model.selectedBoss = value;
            }
        }

        protected override InteractorableState interactorableState {
            get {
                var selected = selectedBossId == bossId;
                var config = Config.Instance.Get<CrossServerBossConfig>(bossId);
                var dieOrLocked = false;
                switch (config.MonsterType)
                {
                    case 1:
                    case 2:
                        dieOrLocked = model.dogzDungeonBox.bigBoxSurplus <= 0;
                        break;
                    case 3:
                        dieOrLocked = model.dogzDungeonElite.eliteSurplus <= 0;
                        break;
                    case 4:
                        dieOrLocked = !model.IsBossUnLocked(bossId) || !findPreciousModel.IsBossAlive(bossId);
                        break;
                }

                if (!dieOrLocked)
                {
                    return selected ? InteractorableState.NormalSelected : InteractorableState.NormalUnSelected;
                }
                else
                {
                    return selected ? InteractorableState.DieOrLockedSelected : InteractorableState.DieOrLockedUnSelected;
                }
            }
            set {
                base.interactorableState = value;
            }
        }

        protected override bool isUnLocked {
            get {
                return model.IsBossUnLocked(bossId);
            }
        }

        CrossServerBossModel model { get { return ModelCenter.Instance.GetModel<CrossServerBossModel>(); } }

        public override void Display(object _data)
        {
            base.Display(_data);

            m_Attention.gameObject.SetActive(findPreciousModel.IsBossSubscribed(bossId));
            var config = Config.Instance.Get<CrossServerBossConfig>(bossId);
            var npcConfig = Config.Instance.Get<NPCConfig>(bossId);

            DrawBossBaseInfo(config.PortraitID, npcConfig.charName, npcConfig.NPCLV, npcConfig.ClientRealm);
            UpdateBossRebornCoolDown(isUnLocked);
            UpdateBossPortrait(interactorableState);
            OnSelected(bossId);

            model.boxSurplusChangeEvent -= OnBoxInfoUpdate;
            model.eliteSurplusChangeEvent -= OnGuardInfoUpdate;
            model.dogzDungeonBox.refreshTimeEvent -= OnBoxRefreshTimeChange;
            model.dogzDungeonElite.refreshTimeEvent -= OnEliteRefreshTimeChange;

            switch (config.MonsterType)
            {
                case 1:
                case 2:
                    model.dogzDungeonBox.refreshTimeEvent += OnBoxRefreshTimeChange;
                    model.boxSurplusChangeEvent += OnBoxInfoUpdate;
                    break;
                case 3:
                    model.dogzDungeonElite.refreshTimeEvent += OnEliteRefreshTimeChange;
                    model.eliteSurplusChangeEvent += OnGuardInfoUpdate;
                    break;
            }

            model.bossSelectedEvent -= OnSelected;
            model.bossSelectedEvent += OnSelected;
        }

        public override void Dispose()
        {
            base.Dispose();
            model.bossSelectedEvent -= OnSelected;
            model.boxSurplusChangeEvent -= OnBoxInfoUpdate;
            model.eliteSurplusChangeEvent -= OnGuardInfoUpdate;
            model.dogzDungeonBox.refreshTimeEvent -= OnBoxRefreshTimeChange;
            model.dogzDungeonElite.refreshTimeEvent -= OnEliteRefreshTimeChange;
        }

        protected override void UpdateBossRebornCoolDown(bool _isUnLocked)
        {
            if (_isUnLocked)
            {
                var config = Config.Instance.Get<DogzDungeonConfig>(bossId);
                var refreshTime = TimeUtility.ServerNow;
                switch (config.MonsterType)
                {
                    case 1:
                    case 2:
                        refreshTime = model.dogzDungeonBox.refreshTime;
                        break;
                    case 3:
                        refreshTime = model.dogzDungeonElite.refreshTime;
                        break;
                    case 4:
                        FindPreciousModel.BossInfo bossInfo;
                        if (findPreciousModel.TryGetBossInfo(bossId, out bossInfo) && !bossInfo.IsBossAlive())
                        {
                            refreshTime = bossInfo.refreshTime;
                        }
                        break;
                }

                if (refreshTime > TimeUtility.ServerNow)
                {
                    m_CoolDown.Begin((int)(refreshTime - TimeUtility.ServerNow).TotalSeconds, OnBossCoolDownCompleted);
                }
                else
                {
                    m_CoolDown.gameObject.SetActive(false);
                }
            }
            else
            {
                m_CoolDown.gameObject.SetActive(false);
            }
        }


        private void OnBoxRefreshTimeChange()
        {
            UpdateBossRebornCoolDown(isUnLocked);
        }

        private void OnEliteRefreshTimeChange()
        {
            UpdateBossRebornCoolDown(isUnLocked);
        }

        private void OnGuardInfoUpdate()
        {
            UpdateBossPortrait(interactorableState);
        }

        private void OnBoxInfoUpdate()
        {
            UpdateBossPortrait(interactorableState);
        }


        protected override void DrawBossBaseInfo(string _icon, string _name, int _level, int _realm)
        {
            var config = Config.Instance.Get<DogzDungeonConfig>(bossId);
            switch (config.MonsterType)
            {
                case 1:
                case 2:
                    m_BossName.text = Language.Get("DogzMap1");
                    m_BossLevel.text = string.Empty;
                    break;
                case 3:
                    m_BossName.text = Language.Get("DogzMap2");
                    m_BossLevel.text = string.Empty;
                    break;
                case 4:
                    m_BossName.text = _name;
                    m_BossLevel.text = Language.Get("Z1024", _level);
                    break;
            }

            m_Portrait.SetSprite(_icon);
            m_Portrait.SetNativeSize();

            if (m_Realm != null && m_RealmContainer != null)
            {
                if (Config.Instance.ContainKey<RealmConfig>(_realm))
                {
                    m_RealmContainer.gameObject.SetActive(true);
                    var realmConfig = Config.Instance.Get<RealmConfig>(_realm);
                    if (realmConfig != null)
                    {
                        m_Realm.SetSprite(realmConfig.Img);
                    }
                }
                else
                {
                    m_RealmContainer.gameObject.SetActive(false);
                }
            }
        }

        private void OnSelected(int _bossId)
        {
            UpdateBossNameLevelFont(interactorableState);
        }

        protected override void OnSubscribe(int _bossId)
        {
            base.OnSubscribe(_bossId);
            if (bossId != _bossId)
            {
                return;
            }

            m_Attention.gameObject.SetActive(findPreciousModel.IsBossSubscribed(bossId));
        }

    }

}





 System/CrossServerBoss/CrossServerBossBreifInfoBehaviour.cs.meta

New file
@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: 37dc9df1ef268f749aefe00b2248ba8f
timeCreated: 1534559500
licenseType: Pro
MonoImporter:
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 System/CrossServerBoss/CrossServerBossEliteMonsterBehaviour.cs

New file
@@ -0,0 +1,62 @@
//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Saturday, August 18, 2018
//--------------------------------------------------------
using UnityEngine;
using System.Collections;
using UnityEngine.UI;
using TableConfig;

namespace Snxxz.UI
{

    public class CrossServerBossEliteMonsterBehaviour : MonoBehaviour
    {
        [SerializeField] Text m_Elite;
        [SerializeField] RawImage m_RawImage;

        CrossServerBossModel model { get { return ModelCenter.Instance.GetModel<CrossServerBossModel>(); } }

        public void Display()
        {
            timer = 0f;
            var config = Config.Instance.Get<NPCConfig>(model.eliteMonsters[0]);
            UI3DModelExhibition.Instance.ShowNPC(model.eliteMonsters[0], config.UIModeLOffset, config.UIModelRotation, m_RawImage);
            DisplayGuardSurplusInfo();
            model.eliteSurplusChangeEvent += OnGuardInfoUpdate;
        }

        public void Dispose()
        {
            model.eliteSurplusChangeEvent -= OnGuardInfoUpdate;
            UI3DModelExhibition.Instance.StopShow();
        }

        private void OnGuardInfoUpdate()
        {
            DisplayGuardSurplusInfo();
        }

        private void DisplayGuardSurplusInfo()
        {
            var guard = model.dogzDungeonElite;
            m_Elite.text = guard.eliteSurplus.ToString();
            m_Elite.color = UIHelper.GetUIColor(guard.eliteSurplus > 0 ? TextColType.White : TextColType.Red);
        }

        float timer = 0f;
        private void LateUpdate()
        {
            timer += Time.deltaTime;
            if (timer > 30f)
            {
                timer = 0f;
                model.RequestEliteSurplusInfo();
            }
        }
    }

}




 System/CrossServerBoss/CrossServerBossEliteMonsterBehaviour.cs.meta

New file
@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: cb252ef23aa597c4f828e8e54087f660
timeCreated: 1534563304
licenseType: Pro
MonoImporter:
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 System/CrossServerBoss/CrossServerBossModel.cs

@@ -2,6 +2,7 @@
using System.Collections.Generic;
using UnityEngine;
using TableConfig;
using System;

namespace Snxxz.UI
{
@@ -18,14 +19,73 @@
        public int smallBoxNpcId = 0;
        public List<int> eliteMonsters = new List<int>();

        int m_SelectedBoss = 0;
        public int selectedBoss {
            get {
                return this.m_SelectedBoss;
            }
            set {
                if (this.m_SelectedBoss != value)
                {
                    this.m_SelectedBoss = value;
                    if (bossSelectedEvent != null)
                    {
                        bossSelectedEvent(value);
                    }
                }
            }
        }

        int m_BigBoxCollectCount = 0;
        public int bigBoxCollectCount {
            get { return m_BigBoxCollectCount; }
            set {
                if (m_BigBoxCollectCount != value)
                {
                    m_BigBoxCollectCount = value;
                    if (bigBoxCollectCountChangeEvent != null)
                    {
                        bigBoxCollectCountChangeEvent();
                    }
                }
            }
        }

        int m_SmallBoxCollectCount = 0;
        public int smallBoxCollectCount {
            get { return m_SmallBoxCollectCount; }
            set { m_SmallBoxCollectCount = value; }
        }

        public int wearyValue {
            get {
                return dogzDungeonModel.wearyValue;
            }
        }

        public event Action<int> bossSelectedEvent;
        public event Action bossWearyValueChangeEvent;
        public event Action bigBoxCollectCountChangeEvent;
        public event Action boxSurplusChangeEvent;
        public event Action eliteSurplusChangeEvent;

        public DogzDungeonBox dogzDungeonBox = new DogzDungeonBox();
        public DogzDungeonElite dogzDungeonElite = new DogzDungeonElite();
        public Redpoint redpoint = new Redpoint(FindPreciousModel.LOOTPRECIOUs_REDPOINTID, REDPOINT);

        FindPreciousModel findPreciousModel { get { return ModelCenter.Instance.GetModel<FindPreciousModel>(); } }
        DogzDungeonModel dogzDungeonModel { get { return ModelCenter.Instance.GetModel<DogzDungeonModel>(); } }

        public override void Init()
        {
            ParseConfig();
            FuncOpen.Instance.OnFuncStateChangeEvent += OnFunctionStateChange;
        }

        public override void UnInit()
        {
            FuncOpen.Instance.OnFuncStateChangeEvent -= OnFunctionStateChange;
        }


        public bool IsAtCrossServerBossMap()
        {
@@ -55,6 +115,261 @@

        }

        public bool TryGetBossData(int bossId, out CrossServerBossData data)
        {
            return bosses.TryGetValue(bossId, out data);
        }

        public List<int> GetNpcIds()
        {
            var npcIds = new List<int>();
            npcIds.Add(bigBoxNpcId);
            npcIds.Add(eliteMonsters[0]);
            npcIds.AddRange(bosses.Keys);

            return npcIds;
        }

        public List<int> GetBosses()
        {
            return new List<int>(bosses.Keys);
        }

        public int GetRecommendNpc()
        {
            if (bigBoxCollectCount < GeneralDefine.dogzBoxLimit)
            {
                return bigBoxNpcId;
            }

            if (wearyValue < GeneralDefine.bossWearyValues[2])
            {
                var playerLevel = PlayerDatas.Instance.baseData.LV;
                for (int i = sortedBossIds.Count - 1; i >= 0; i--)
                {
                    var bossId = sortedBossIds[i];
                    var npcConfig = Config.Instance.Get<NPCConfig>(bossId);
                    if (IsBossUnLocked(bossId) && findPreciousModel.IsBossAlive(bossId) && playerLevel >= npcConfig.NPCLV)
                    {
                        return bossId;
                    }
                }

                return sortedBossIds[0];
            }

            return eliteMonsters[0];
        }

        public int GetRecommendKillElite()
        {
            var Elite = dogzDungeonElite.GetAliveElite();
            if (Elite == 0)
            {
                Elite = eliteMonsters[0];
            }

            return Elite;
        }

        public bool IsBossUnLocked(int _bossId)
        {
            if (_bossId == bigBoxNpcId || _bossId == smallBoxNpcId)
            {
                return true;
            }

            if (eliteMonsters.Contains(_bossId))
            {
                return true;
            }

            return bosses.ContainsKey(_bossId) && bosses[_bossId].isUnLocked;
        }

        public void RequestBoxAndEliteSurplusInfo()
        {
            var sendInfo = new CA227_tagCMQueryNPCCntInfo();
            sendInfo.MapID = DATA_MAPID;
            sendInfo.LineID = 0;
            var stringArray = new string[eliteMonsters.Count + 2];
            for (int i = 0; i < eliteMonsters.Count; i++)
            {
                stringArray[i] = eliteMonsters[i].ToString();
            }

            stringArray[eliteMonsters.Count] = bigBoxNpcId.ToString();
            stringArray[eliteMonsters.Count + 1] = smallBoxNpcId.ToString();

            sendInfo.NPCIDList = string.Format("[{0}]", string.Join(",", stringArray));
            sendInfo.NPCIDListLen = (byte)sendInfo.NPCIDList.Length;
            GameNetSystem.Instance.SendInfo(sendInfo);
        }

        public void RequestBoxSurplusInfo()
        {
            var sendInfo = new CA227_tagCMQueryNPCCntInfo();
            sendInfo.MapID = DATA_MAPID;
            sendInfo.LineID = 0;
            sendInfo.NPCIDList = string.Format("[{0},{1}]", bigBoxNpcId, smallBoxNpcId);
            sendInfo.NPCIDListLen = (byte)sendInfo.NPCIDList.Length;
            GameNetSystem.Instance.SendInfo(sendInfo);
        }

        public void RequestEliteSurplusInfo()
        {
            var sendInfo = new CA227_tagCMQueryNPCCntInfo();
            sendInfo.MapID = DATA_MAPID;
            sendInfo.LineID = 0;
            var stringArray = new string[eliteMonsters.Count];
            for (int i = 0; i < stringArray.Length; i++)
            {
                stringArray[i] = eliteMonsters[i].ToString();
            }

            sendInfo.NPCIDList = string.Format("[{0}]", string.Join(",", stringArray));
            sendInfo.NPCIDListLen = (byte)sendInfo.NPCIDList.Length;
            GameNetSystem.Instance.SendInfo(sendInfo);
        }

        public void UpdateMonsterSurplusInfo(HA714_tagMCNPCCntList _npcInfoes)
        {
            if (_npcInfoes.MapID != DATA_MAPID)
            {
                return;
            }

            var updatedBigBox = false;
            var updatedSmallBox = false;
            var updatedEliteNpcIds = new List<int>();

            for (int i = 0; i < _npcInfoes.NPCInfoList.Length; i++)
            {
                var npcInfo = _npcInfoes.NPCInfoList[i];
                if (npcInfo.NPCID == bigBoxNpcId)
                {
                    dogzDungeonBox.bigBoxSurplus = (int)npcInfo.Cnt;
                    updatedBigBox = true;
                }

                if (npcInfo.NPCID == smallBoxNpcId)
                {
                    dogzDungeonBox.smallBoxSurplus = (int)npcInfo.Cnt;
                    updatedSmallBox = true;
                }

                if (eliteMonsters.Contains((int)npcInfo.NPCID))
                {
                    dogzDungeonElite.UpdateEliteInfo((int)npcInfo.NPCID, (int)npcInfo.Cnt);
                    updatedEliteNpcIds.Add((int)npcInfo.NPCID);
                }
            }

            if (!updatedBigBox)
            {
                dogzDungeonBox.bigBoxSurplus = 0;
            }

            if (!updatedSmallBox)
            {
                dogzDungeonBox.smallBoxSurplus = 0;
            }

            if (boxSurplusChangeEvent != null)
            {
                boxSurplusChangeEvent();
            }

            foreach (var item in eliteMonsters)
            {
                if (!updatedEliteNpcIds.Contains(item))
                {
                    dogzDungeonElite.UpdateEliteInfo(item, 0);
                }
            }

            if (eliteSurplusChangeEvent != null)
            {
                eliteSurplusChangeEvent();
            }
        }

        public void UpdateBoxOrEliteRefreshTime(HA904_tagGCDogzNPCRefreshTime _refreshTimes)
        {
            var containBox = false;
            var boxRefreshSecond = 0;

            var containElite = false;
            var eliteRefreshSecond = 0;

            for (int i = 0; i < _refreshTimes.InfoList.Length; i++)
            {
                var info = _refreshTimes.InfoList[i];
                if (bigBoxNpcId == info.NPCID || smallBoxNpcId == info.NPCID)
                {
                    containBox = true;
                    boxRefreshSecond = (int)info.RefreshSecond;
                }

                if (eliteMonsters.Contains((int)info.NPCID))
                {
                    containElite = true;
                    eliteRefreshSecond = (int)info.RefreshSecond;
                }
            }

            if (containBox)
            {
                dogzDungeonBox.UpdateBoxRefreshTime(boxRefreshSecond);
            }

            if (containElite)
            {
                dogzDungeonElite.UpdateEliteRefreshTime(eliteRefreshSecond);
            }

            if (WindowCenter.Instance.IsOpen("DogzDungeonWin"))
            {
                if (containBox)
                {
                    RequestBoxSurplusInfo();
                }

                if (containElite)
                {
                    RequestEliteSurplusInfo();
                }
            }
        }

        public void OnPlayerLoginOk()
        {
            UpdateRedpoint();
        }

        private void OnFunctionStateChange(int id)
        {
            if (id == 138)
            {
                UpdateRedpoint();
            }
        }

        private void UpdateRedpoint()
        {
            if (!FuncOpen.Instance.IsFuncOpen(138))
            {
                redpoint.count = 0;
            }
            else
            {
                var wearyValueLimit = GeneralDefine.bossWearyValues[2];
                redpoint.count = wearyValueLimit - wearyValue;
            }

            redpoint.state = redpoint.count > 0 ? RedPointState.Quantity : RedPointState.None;
        }

        private void ParseConfig()
        {
            var configs = Config.Instance.GetAllValues<CrossServerBossConfig>();
@@ -81,6 +396,76 @@
            sortedBossIds.Sort(CrossServerBossData.LevelCompare);
        }


    }

    public class CrossServerBossBox
    {
        public int bigBoxSurplus;
        public int smallBoxSurplus;
        public DateTime refreshTime { get; private set; }

        public event Action refreshTimeEvent;

        public void UpdateBoxInfo(int _big, int _small)
        {
            bigBoxSurplus = _big;
            smallBoxSurplus = _small;
        }

        public void UpdateBoxRefreshTime(int _seconds)
        {
            refreshTime = TimeUtility.ServerNow + new TimeSpan(_seconds * TimeSpan.TicksPerSecond);
            if (refreshTimeEvent != null)
            {
                refreshTimeEvent();
            }
        }
    }

    public class CrossServerBossElite
    {
        public Dictionary<int, int> eliteCounts = new Dictionary<int, int>();
        public int eliteSurplus {
            get {
                var count = 0;
                foreach (var eliteCount in eliteCounts.Values)
                {
                    count += eliteCount;
                }
                return count;
            }
        }

        public DateTime refreshTime { get; private set; }
        public event Action refreshTimeEvent;

        public void UpdateEliteInfo(int _npcId, int _count)
        {
            eliteCounts[_npcId] = _count;
        }

        public void UpdateEliteRefreshTime(int _seconds)
        {
            refreshTime = TimeUtility.ServerNow + new TimeSpan(_seconds * TimeSpan.TicksPerSecond);
            if (refreshTimeEvent != null)
            {
                refreshTimeEvent();
            }
        }

        public int GetAliveElite()
        {
            foreach (var EliteCount in eliteCounts)
            {
                if (EliteCount.Value > 0)
                {
                    return EliteCount.Key;
                }
            }

            return 0;
        }
    }

    public class CrossServerBossData

 System/CrossServerBoss/CrossServerBossWin.cs

New file
@@ -0,0 +1,269 @@
//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Saturday, August 18, 2018
//--------------------------------------------------------

using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using TableConfig;

namespace Snxxz.UI
{

    public class CrossServerBossWin : Window
    {
        [SerializeField] CyclicScroll m_Bosses;
        [SerializeField] CrossServerBossBoxBehaviour m_BoxBehaviour;
        [SerializeField] CrossServerBossEliteMonsterBehaviour m_EliteMonsterBehaviour;
        [SerializeField] BossIntroduceBehaviour m_BossIntroduce;

        [SerializeField] Button m_Goto;
        [SerializeField] ImageEx m_ImageGoto;
        [SerializeField] Button m_KillRecord;
        [SerializeField] Transform m_SurpassLevel;
        [SerializeField] ToggleButton m_Subscribe;

        [SerializeField] RectTransform m_ContainerBoxCollectWeary;
        [SerializeField] TextEx m_BoxCollectWearyValue;
        [SerializeField] RectTransform m_ContainerBossKillWeary;
        [SerializeField] TextEx m_BossKillWearyValue;

        CrossServerBossModel model { get { return ModelCenter.Instance.GetModel<CrossServerBossModel>(); } }
        FindPreciousModel findPreciousModel { get { return ModelCenter.Instance.GetModel<FindPreciousModel>(); } }
        DungeonModel dungeonModel { get { return ModelCenter.Instance.GetModel<DungeonModel>(); } }
        BossHomeModel bossHomeModel { get { return ModelCenter.Instance.GetModel<BossHomeModel>(); } }

        #region Built-in
        protected override void BindController()
        {
        }

        protected override void AddListeners()
        {
            m_Goto.AddListener(GotoKillBoss);
            m_KillRecord.AddListener(ShowKillRecords);
            m_Subscribe.AddListener(SwitchSubscribeBoss);
        }

        protected override void OnPreOpen()
        {
        }

        protected override void OnAfterOpen()
        {
            model.bossSelectedEvent += OnBossSelected;
            findPreciousModel.bossSubscribeChangeEvent += OnSubscribeBoss;
        }

        protected override void OnPreClose()
        {
            model.bossSelectedEvent -= OnBossSelected;
            findPreciousModel.bossSubscribeChangeEvent -= OnSubscribeBoss;
        }

        protected override void OnAfterClose()
        {
        }

        protected override void OnActived()
        {
            base.OnActived();
            ShowBosses();
            model.RequestBoxAndEliteSurplusInfo();
        }
        #endregion

        private void ShowBosses()
        {
            var bosses = model.GetNpcIds();
            model.selectedBoss = model.GetRecommendNpc();
            m_Bosses.Init(bosses);
            m_Bosses.MoveToCenter(bosses.IndexOf(model.selectedBoss));

            DisplayItemDropTip(model.selectedBoss);
            DisplayBossBaseInfo(model.selectedBoss);
            DisplayWearyValue(model.selectedBoss);
        }

        private void ShowKillRecords()
        {
            findPreciousModel.ViewKillRecordsBoss = model.selectedBoss;
            WindowCenter.Instance.Open<KillRecordsWin>();
        }

        private void SwitchSubscribeBoss()
        {
            if (findPreciousModel.IsBossSubscribed(model.selectedBoss))
            {
                findPreciousModel.RequestDeSubscribeBoss(model.selectedBoss);
            }
            else
            {
                findPreciousModel.RequestSubscribeBoss(model.selectedBoss, false);
            }
        }

        private void GotoKillBoss()
        {
            var error = 0;
            if (TestGotoKillBoss(out error))
            {
                if (PlayerDatas.Instance.baseData.MapID == CrossServerBossModel.DATA_MAPID)
                {
                    WindowJumpMgr.Instance.ClearJumpData();
                    WindowCenter.Instance.Close<CrossServerWin>();
                    WindowCenter.Instance.Open<MainInterfaceWin>();
                }

                var config = Config.Instance.Get<CrossServerBossConfig>(model.selectedBoss);
                switch (config.MonsterType)
                {
                    case 1:
                    case 2:
                    case 3:
                        if (PlayerDatas.Instance.baseData.MapID != CrossServerBossModel.DATA_MAPID)
                        {
                            var map = Config.Instance.Get<MapConfig>(CrossServerBossModel.DATA_MAPID);
                            var position = new Vector3(map.BornPoints[0].x, 0, map.BornPoints[0].y);
                            MapTransferUtility.Instance.Clear();
                            MapTransferUtility.Send_WorldTransfer(CrossServerBossModel.DATA_MAPID, position, MapTransferType.WorldTransport, 0, 0);
                        }
                        break;
                    case 4:
                        MapTransferUtility.Instance.MoveToNPC(model.selectedBoss);
                        break;
                }
            }
            else
            {
                ProcessGotoKillBossError(error);
            }
        }

        private bool TestGotoKillBoss(out int error)
        {
            var mapId = PlayerDatas.Instance.baseData.MapID;

            var mapConfig = Config.Instance.Get<MapConfig>(mapId);
            if (mapConfig.MapFBType != (int)MapType.OpenCountry)
            {
                error = 1;
                return false;
            }

            error = 0;
            return true;
        }

        private void ProcessGotoKillBossError(int _error)
        {
            switch (_error)
            {
                case 1:
                    SysNotifyMgr.Instance.ShowTip("InDungeon_CantGo");
                    break;
            }
        }

        private void OnSubscribeBoss(int _bossId)
        {
            m_Subscribe.isOn = findPreciousModel.IsBossSubscribed(model.selectedBoss);
        }

        private void OnBossSelected(int _bossId)
        {
            DisplayItemDropTip(_bossId);
            DisplayBossBaseInfo(_bossId);
            DisplayWearyValue(_bossId);
        }

        private void DisplayBossBaseInfo(int _bossId)
        {
            var config = Config.Instance.Get<CrossServerBossConfig>(_bossId);
            switch (config.MonsterType)
            {
                case 1:
                case 2:
                    m_KillRecord.gameObject.SetActive(false);
                    m_BossIntroduce.Dispose();
                    m_BossIntroduce.gameObject.SetActive(false);
                    m_EliteMonsterBehaviour.Dispose();
                    m_EliteMonsterBehaviour.gameObject.SetActive(false);
                    m_BoxBehaviour.gameObject.SetActive(true);
                    m_BoxBehaviour.Display();
                    break;
                case 3:
                    m_KillRecord.gameObject.SetActive(false);
                    m_BossIntroduce.Dispose();
                    m_BossIntroduce.gameObject.SetActive(false);
                    m_BoxBehaviour.gameObject.SetActive(false);
                    m_BoxBehaviour.Dispose();

                    m_EliteMonsterBehaviour.gameObject.SetActive(true);
                    m_EliteMonsterBehaviour.Display();
                    break;
                case 4:
                    m_KillRecord.gameObject.SetActive(true);
                    m_BoxBehaviour.Dispose();
                    m_BoxBehaviour.gameObject.SetActive(false);
                    m_EliteMonsterBehaviour.Dispose();
                    m_EliteMonsterBehaviour.gameObject.SetActive(false);

                    m_BossIntroduce.gameObject.SetActive(true);
                    m_BossIntroduce.Display(_bossId, true);
                    m_Subscribe.isOn = findPreciousModel.IsBossSubscribed(_bossId);
                    break;
            }
        }

        private void DisplayItemDropTip(int _bossId)
        {
            var config = Config.Instance.Get<CrossServerBossConfig>(model.selectedBoss);
            switch (config.MonsterType)
            {
                case 1:
                case 2:
                case 3:
                    m_SurpassLevel.gameObject.SetActive(false);
                    break;
                case 4:
                    var npcDropConfig = Config.Instance.Get<NPCDropItemConfig>(_bossId);
                    m_SurpassLevel.gameObject.SetActive(npcDropConfig.MaxLV != 0 && PlayerDatas.Instance.baseData.LV > npcDropConfig.MaxLV);
                    break;
            }
        }

        private void DisplayWearyValue(int _bossId)
        {
            var config = Config.Instance.Get<CrossServerBossConfig>(model.selectedBoss);
            switch (config.MonsterType)
            {
                case 1:
                case 2:
                    m_ContainerBoxCollectWeary.gameObject.SetActive(true);
                    m_ContainerBossKillWeary.gameObject.SetActive(false);
                    var bigBoxCollectCountLimit = GeneralDefine.dogzBoxLimit;
                    m_BoxCollectWearyValue.text = StringUtility.Contact(model.bigBoxCollectCount, "/", bigBoxCollectCountLimit);
                    m_BoxCollectWearyValue.colorType = model.bigBoxCollectCount >= bigBoxCollectCountLimit ? TextColType.Red : TextColType.DarkGreen;
                    break;
                case 3:
                case 4:
                    m_ContainerBoxCollectWeary.gameObject.SetActive(false);
                    m_ContainerBossKillWeary.gameObject.SetActive(true);
                    var wearyValueLimit = GeneralDefine.bossWearyValues[2];
                    m_BossKillWearyValue.text = StringUtility.Contact(model.wearyValue, "/", wearyValueLimit);
                    m_BossKillWearyValue.colorType = model.wearyValue >= wearyValueLimit ? TextColType.Red : TextColType.DarkGreen;
                    break;
            }
        }

    }

}





 System/CrossServerBoss/CrossServerBossWin.cs.meta

New file
@@ -0,0 +1,12 @@
fileFormatVersion: 2
guid: 348cda1bebe122948b82c7a60df7dc4b
timeCreated: 1534559453
licenseType: Pro
MonoImporter:
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: