4295 【前端】【1.2】还原加点功能

client_linchunjie

2018-10-23 50a125af7aebd26bd922065015bf43c81b1f8a8b

4295 【前端】【1.2】还原加点功能

 System/Role/AddPointBehaviour.cs

New file
@@ -0,0 +1,99 @@
using System;

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



namespace Snxxz.UI

{

    public class AddPointBehaviour : MonoBehaviour

    {

        [SerializeField] int m_Property;

        [SerializeField] Text m_PropertyName;

        [SerializeField] Text m_PropertyValue;

        [SerializeField] Text m_PropertyPreview;

        [SerializeField] RectTransform m_PointBottom;

        [SerializeField] Button m_Sub;

        [SerializeField] Button m_Add;



        public int property

        {

            get { return m_Property; }

        }



        public Text propertyName

        {

            get { return m_PropertyName; }

        }



        public Text propertyValue

        {

            get { return m_PropertyValue; }

        }



        public Text propertyPreview

        {

            get { return m_PropertyPreview; }

        }



        public RectTransform pointBottom

        {

            get

            {

                return m_PointBottom;

            }

        }



        public Action<int> onPreview;

        public Action<int, bool> onSub;

        public Action<int, bool> onAdd;



        private void Awake()

        {

            UIEventTrigger.Get(m_PropertyPreview.gameObject).OnNoParamsClick = () =>

            {

                if (onPreview != null)

                {

                    onPreview(property);

                }

            };

            UIEventTrigger.Get(m_Sub.gameObject).OnDown = OnSubDown;

            UIEventTrigger.Get(m_Sub.gameObject).OnUp = OnSubUp;

            UIEventTrigger.Get(m_Add.gameObject).OnDown = OnAddDown;

            UIEventTrigger.Get(m_Add.gameObject).OnUp = OnAddUp;

        }



        private void OnAddUp(GameObject go)

        {

            if (onAdd != null)

            {

                onAdd(property, false);

            }

        }



        private void OnAddDown(GameObject go)

        {

            if (onAdd != null)

            {

                onAdd(property, true);

            }

        }



        private void OnSubDown(GameObject go)

        {

            if (onSub != null)

            {

                onSub(property, true);

            }

        }



        private void OnSubUp(GameObject go)

        {

            if (onSub != null)

            {

                onSub(property, false);

            }

        }

    }

}


 System/Role/AddPointBehaviour.cs.meta

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

 System/Role/RoleAttrWin.cs

@@ -11,12 +11,15 @@
        [SerializeField] Button closeBtn;

        [SerializeField] Button baseBtn;

        [SerializeField] Button specialBtn;

        [SerializeField] Button addBtn;



        [SerializeField] Image baseImg;

        [SerializeField] Image specialImg;

        [SerializeField] Image addImg;



        [SerializeField] Text m_BaseTxt;

        [SerializeField] Text m_SpecialTxt;

        [SerializeField] Text m_AddTxt;



        private readonly Color selectTxtCol = new Color32(52, 7, 1, 255);

        private readonly Color unSelectTxtCol = new Color32(125, 91, 52, 255);

@@ -36,15 +39,31 @@


        [SerializeField] Text descText;



        private void OnAddBtn()

        {

            if (attrShowType == 3) return;

            attrShowType = 3;



            addImg.SetSprite("2LVSelectTab_b");

            specialImg.SetSprite("2LVUnSelectTab_b");

            baseImg.SetSprite("2LVUnSelectTab_b");

            m_BaseTxt.color = unSelectTxtCol;

            m_SpecialTxt.color = unSelectTxtCol;

            m_AddTxt.color = selectTxtCol;

            OnRefreshScroll();

        }



        private void OnSpecialBtn()

        {

            if (attrShowType == 2) return;

            attrShowType = 2;



            addImg.SetSprite("2LVUnSelectTab_b");

            specialImg.SetSprite("2LVSelectTab_b");

            baseImg.SetSprite("2LVUnSelectTab_b");

            m_BaseTxt.color = unSelectTxtCol;

            m_SpecialTxt.color = selectTxtCol;

            m_AddTxt.color = unSelectTxtCol;



            OnRefreshScroll();

        }

@@ -54,10 +73,12 @@
            if (attrShowType == 1) return;

            attrShowType = 1;



            addImg.SetSprite("2LVUnSelectTab_b");

            specialImg.SetSprite("2LVUnSelectTab_b");

            baseImg.SetSprite("2LVSelectTab_b");

            m_BaseTxt.color = selectTxtCol;

            m_SpecialTxt.color = unSelectTxtCol;

            m_AddTxt.color = unSelectTxtCol;



            OnRefreshScroll();

        }

@@ -154,6 +175,7 @@
            m_Controller.OnGetDynamicSize += OnGetDynamicSize;

            specialBtn.onClick.AddListener(OnSpecialBtn);

            baseBtn.onClick.AddListener(OnBaseBtn);

            addBtn.onClick.AddListener(OnAddBtn);

            closeBtn.onClick.AddListener(OnClose);

        }




 System/Role/RolePanel.cs

@@ -44,6 +44,7 @@
        [SerializeField] RectTransform m_ContainerExp;

        [SerializeField] Slider m_ExpSlider;

        [SerializeField] Text m_WorldExp;

        [SerializeField] Button m_AddPoint;

        [SerializeField] Button m_PlayerPropertyBtn;

        [SerializeField] Button m_TitleBtn;

        [SerializeField] Button m_RenameBtn;

@@ -127,17 +128,19 @@
        {

            WindowCenter.Instance.Open<RoleAttrWin>();

        }

        //private void OnPromoteClick()

        //{

        //    if (FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.AddPoint))

        //    {

        //        WindowCenter.Instance.Open<RolePoint>();

        //    }

        //    else

        //    {

        //        FuncOpen.Instance.ProcessorFuncErrorTip((int)FuncOpenEnum.AddPoint);

        //    }

        //}



        private void OnPromoteClick()

        {

            if (FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.AddPoint))

            {

                WindowCenter.Instance.Open<RolePointWin>();

            }

            else

            {

                FuncOpen.Instance.ProcessorFuncErrorTip((int)FuncOpenEnum.AddPoint);

            }

        }



        private void OnRefreshPlayerInfo(PlayerDataRefresh refreshType)

        {

            switch (refreshType)

@@ -269,7 +272,7 @@
            functionButtonMagician.onClick.AddListener(OnFuncMagician);

            functionButtonGulu.onClick.AddListener(OnFuncGulu);

            functionButtonHorucx.onClick.AddListener(OnFuncHorucx);

            //m_PromoteBtn.onClick.AddListener(OnPromoteClick);

            m_AddPoint.onClick.AddListener(OnPromoteClick);

            m_PlayerPropertyBtn.onClick.AddListener(OnAttrExplainClick);

            m_TitleBtn.onClick.AddListener(OnDesignationClick);

            m_RenameBtn.onClick.AddListener(OnRenameClick);


 System/Role/RolePointModel.cs

New file
@@ -0,0 +1,115 @@
using System;
using System.Collections.Generic;
using TableConfig;
namespace Snxxz.UI
{
    public class RolePointModel : Model,IPlayerLoginOk
    {
        public override void Init()
        {
            ParseConfig();
            FuncOpen.Instance.OnFuncStateChangeEvent += OnFuncStateChangeEvent;
            PlayerDatas.Instance.PlayerDataRefreshInfoEvent += PlayerDataRefreshInfoEvent;
        }

        public override void UnInit()
        {

            FuncOpen.Instance.OnFuncStateChangeEvent -= OnFuncStateChangeEvent;

            PlayerDatas.Instance.PlayerDataRefreshInfoEvent -= PlayerDataRefreshInfoEvent;
        }



        public void OnPlayerLoginOk()

        {

            UpdateRedPoint();

        }



        private void PlayerDataRefreshInfoEvent(PlayerDataRefresh refreshType)

        {

            if (refreshType == PlayerDataRefresh.FreePoint)

            {

                UpdateRedPoint();

            }

        }



        private void OnFuncStateChangeEvent(int func)
        {
            if ((FuncOpenEnum)func == FuncOpenEnum.AddPoint)
            {
                UpdateRedPoint();
            }
        }

        private Dictionary<int, Dictionary<int, string>> formulaDict = new Dictionary<int, Dictionary<int, string>>();
        public bool TryGetPointFormula(int job, out Dictionary<int, string> dict)
        {
            return formulaDict.TryGetValue(job, out dict);
        }

        public bool ContainsProperty(int type)
        {
            Dictionary<int, string> dict;
            return formulaDict.TryGetValue(PlayerDatas.Instance.baseData.Job, out dict) && dict.ContainsKey(type);
        }

        private Dictionary<int, Dictionary<int, float>> suggestDict = new Dictionary<int, Dictionary<int, float>>();
        public bool TryGetPointSuggest(int job, out Dictionary<int, float> dict)
        {
            return suggestDict.TryGetValue(job, out dict);
        }



        public int[] propertys { get; private set; }

        private Dictionary<int, Dictionary<int, int>> initPointDict = new Dictionary<int, Dictionary<int, int>>();
        public bool TryGetPointInit(int job,out Dictionary<int, int> dict)
        {
            return initPointDict.TryGetValue(job, out dict);
        }

        private void ParseConfig()
        {
            FuncConfigConfig config;
            for (int i = 1; i <= 3; i++)
            {
                config = Config.Instance.Get<FuncConfigConfig>(string.Format("PointAttr{0}", i));
                if (config != null)
                {
                    Dictionary<int, string> dic = ConfigParse.GetDic<int, string>(config.Numerical1);
                    formulaDict.Add(i, dic);
                }
                config = Config.Instance.Get<FuncConfigConfig>(string.Format("PointAdd{0}", i));
                if (config != null)
                {
                    Dictionary<int, float> dic = ConfigParse.GetDic<int, float>(config.Numerical1);
                    suggestDict.Add(i, dic);
                }
                config = Config.Instance.Get<FuncConfigConfig>(string.Format("CreatRolePoint{0}", i));
                if (config != null)
                {
                    Dictionary<int, int> dic = ConfigParse.GetDic<int, int>(config.Numerical1);
                    initPointDict.Add(i, dic);
                }
            }
            config = Config.Instance.Get<FuncConfigConfig>("PointAddAttr");
            propertys = ConfigParse.GetMultipleStr<int>(config.Numerical1);
        }

        public Redpoint redpoint = new Redpoint(10101, 1010101);

        public void UpdateRedPoint()
        {
            if (!FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.AddPoint))
            {
                return;
            }
            redpoint.state = PlayerDatas.Instance.baseData.FreePoint > 0 ? RedPointState.Simple : RedPointState.None;
        }

        public void SendAddPoint(int type, int point)
        {
            C0301_tagCAddPoint pak = new C0301_tagCAddPoint();
            pak.Type = (byte)type;
            pak.Point = (ushort)point;
            GameNetSystem.Instance.SendInfo(pak);
        }

    }
}

 System/Role/RolePointModel.cs.meta

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

 System/Role/RolePointWin.cs

New file
@@ -0,0 +1,458 @@
//--------------------------------------------------------

//    [Author]:           第二世界

//    [  Date ]:           Tuesday, October 23, 2018

//--------------------------------------------------------



using System;

using System.Collections;

using System.Collections.Generic;

using TableConfig;

using UnityEngine;

using UnityEngine.UI;



namespace Snxxz.UI

{



    public class RolePointWin : Window

    {

        [SerializeField] Button m_Close;
        [SerializeField] Button m_Suggest;
        [SerializeField] Button m_Confirm;
        [SerializeField] Text m_Point;
        [SerializeField] RectTransform m_ContainerRight;
        [SerializeField] List<PropertyValue> m_PropertyValues;
        [SerializeField] List<AddPointBehaviour> m_AddPoints;
        [SerializeField] NumKeyBoard m_NumkeyBoard;



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



        bool isSpeedUp = false;

        int presentAddPoint = 0;

        int surplusPoint = 0;

        Dictionary<int, int> allocatPoints = new Dictionary<int, int>();



        static WaitForSeconds waitSpeedUp = new WaitForSeconds(0.5f);

        static WaitForSeconds waitSpeedFaster = new WaitForSeconds(0.05f);

        static WaitForSeconds waitSpeedSlow = new WaitForSeconds(0.2f);



        const int WAITCNT = 1;





        protected override void BindController()

        {



        }



        protected override void AddListeners()

        {

            m_Close.onClick.AddListener(CloseClick);

            m_Confirm.onClick.AddListener(Confirm);

            m_Suggest.onClick.AddListener(Suggest);

            m_NumkeyBoard.onValueChange.AddListener(OnPointValChange);

            m_NumkeyBoard.onConfirm.AddListener((bool isOk) =>

            {

                if (isOk)

                {

                    m_NumkeyBoard.gameObject.SetActive(false);

                }

            });

            for (int i = 0; i < m_AddPoints.Count; i++)

            {

                m_AddPoints[i].onPreview = OnPreview;

                m_AddPoints[i].onSub = OnSub;

                m_AddPoints[i].onAdd = OnAdd;

            }

        }



        protected override void OnPreOpen()

        {

            PlayerDatas.Instance.PlayerDataRefreshInfoEvent += OnPlayerInfoRefresh;

            m_NumkeyBoard.gameObject.SetActive(false);

            Dictionary<int, string> dict = null;

            if (model.TryGetPointFormula(PlayerDatas.Instance.baseData.Job, out dict))

            {

                int i = 0;

                foreach (var _type in dict.Keys)

                {

                    m_PropertyValues[i].property = _type;

                    i++;

                }

            }

            OnRefreshProprety();

            isSpeedUp = false;

        }



        protected override void OnAfterOpen()

        {

            HandleAchievement();

        }



        protected override void OnPreClose()

        {

            PlayerDatas.Instance.PlayerDataRefreshInfoEvent -= OnPlayerInfoRefresh;

            isSpeedUp = false;

            StopAllCoroutines();

        }



        protected override void OnAfterClose()

        {

            if (!WindowJumpMgr.Instance.IsJumpState

                && !WindowCenter.Instance.IsOpen<RolePanel>()

                && !WindowCenter.Instance.IsOpen<MainInterfaceWin>())

            {

                WindowCenter.Instance.Open<MainInterfaceWin>();

            }

        }



        void OnRefreshProprety()

        {

            if (model.propertys != null)

            {

                for (int i = 0; i < model.propertys.Length; i++)

                {

                    var proprety = model.propertys[i];

                    var behaviour = m_AddPoints.Find((x) =>

                    {

                        return x.property == proprety;

                    });

                    var config = Config.Instance.Get<PlayerPropertyConfig>(proprety);

                    behaviour.propertyName.text = config.Name;

                    behaviour.propertyValue.text = UIHelper.GetPropertyMapPlayerData((AttrEnum)proprety).ToString();

                    allocatPoints[proprety] = 0;

                    behaviour.propertyPreview.text = allocatPoints[proprety].ToString();

                }

            }



            surplusPoint = (int)PlayerDatas.Instance.baseData.FreePoint;

            m_Point.text = surplusPoint.ToString();



            OnRefreshAdd();

        }



        private void OnRefreshAdd()

        {

            Equation.Instance.Clear();

            foreach (var key in allocatPoints.Keys)

            {

                var config = Config.Instance.Get<PlayerPropertyConfig>(key);

                Equation.Instance.AddKeyValue(config.Parameter, allocatPoints[key]);

            }

            Dictionary<int, string> dict = null;

            if (model.TryGetPointFormula(PlayerDatas.Instance.baseData.Job, out dict))

            {

                foreach (var property in dict.Keys)

                {

                    float value = Equation.Instance.Eval<float>(dict[property]);

                    GetProperty(property).RefreshAdd(value);

                }

            }

        }



        private PropertyValue GetProperty(int property)

        {

            return m_PropertyValues.Find((x) =>

            {

                return x.property == property;

            });

        }



        private void HandleAchievement()

        {

            if (AchievementGoto.achievementType == AchievementGoto.RolePoint)

            {

                var _effect = AchievementGuideEffectPool.Require(1);

                _effect.transform.SetParentEx(m_Suggest.transform, Vector3.zero, Vector3.zero, Vector3.one);

                AchievementGoto.achievementType = 0;

            }

        }



        private void Confirm()

        {

            foreach (int key in allocatPoints.Keys)

            {

                if (allocatPoints[key] > 0)

                {

                    model.SendAddPoint(key, allocatPoints[key]);

                }

            }

        }



        private void Suggest()

        {

            int points = (int)PlayerDatas.Instance.baseData.FreePoint;

            int totalpoints = points;

            int pt = 0;



            Dictionary<int, float> suggestDict = null;

            model.TryGetPointSuggest(PlayerDatas.Instance.baseData.Job, out suggestDict);

            Dictionary<int, int> initDict = null;

            model.TryGetPointInit(PlayerDatas.Instance.baseData.Job, out initDict);



            if (suggestDict == null || initDict == null)

            {

                return;

            }



            foreach (var property in suggestDict.Keys)

            {

                totalpoints += ((int)UIHelper.GetPropertyMapPlayerData((AttrEnum)property) - initDict[property]);

            }



            allocatPoints.Clear();

            foreach (var property in initDict.Keys)

            {

                allocatPoints.Add(property, 0);

                var behaviour = m_AddPoints.Find((x) =>

                {

                    return x.property == property;

                });

                behaviour.propertyPreview.text = allocatPoints[property].ToString();

            }



            foreach (var property in suggestDict.Keys)

            {

                int expectpt = Mathf.RoundToInt(suggestDict[property] * totalpoints);

                int presentpt = expectpt - ((int)UIHelper.GetPropertyMapPlayerData((AttrEnum)property) - initDict[property]);

                if (presentpt > 0)

                {

                    if (pt + presentpt > points)

                    {

                        presentpt = points - pt;

                    }

                    pt += presentpt;

                    allocatPoints[property] = presentpt;

                }

                var behaviour = m_AddPoints.Find((x) =>

                {

                    return x.property == property;

                });

                behaviour.propertyPreview.text = allocatPoints[property].ToString();

            }



            surplusPoint = points - pt;

            m_Point.text = surplusPoint.ToString();

            OnRefreshAdd();

        }



        private void OnPlayerInfoRefresh(PlayerDataRefresh refreshType)

        {

            switch (refreshType)

            {

                case PlayerDataRefresh.FreePoint:

                    {

                        OnRefreshProprety();

                    }

                    break;

                case PlayerDataRefresh.STR:

                case PlayerDataRefresh.PNE:

                case PlayerDataRefresh.PHY:

                case PlayerDataRefresh.CON:

                    {

                        OnRefreshProprety();

                    }

                    break;

                case PlayerDataRefresh.MAXATK:

                case PlayerDataRefresh.MINATK:

                case PlayerDataRefresh.MaxHP:

                case PlayerDataRefresh.DEF:

                case PlayerDataRefresh.HIT:

                case PlayerDataRefresh.AtkInterval:

                case PlayerDataRefresh.BattleValEx1:

                    {

                        foreach (var property in m_PropertyValues)

                        {

                            property.RefreshValue();

                        }

                    }

                    break;

            }

        }



        private void OnPointValChange()

        {

            var key = presentAddPoint;

            surplusPoint += allocatPoints[key];

            int num = int.Parse(m_NumkeyBoard.Value);

            if (surplusPoint - num < 0)

            {

                num = surplusPoint;

            }

            allocatPoints[key] = num;

            surplusPoint -= num;

            OnUpdatePoint(key);

            m_NumkeyBoard.Value = num.ToString();

        }



        private void OnUpdatePoint(int key)

        {

            var behaviour = m_AddPoints.Find((x) =>

            {

                return x.property == key;

            });

            behaviour.propertyPreview.text = allocatPoints[key].ToString();

            m_Point.text = surplusPoint.ToString();

            OnRefreshAdd();

        }



        private void OnAdd(int property, bool down)

        {

            if (!down)

            {

                isSpeedUp = false;

                StopAllCoroutines();

                return;

            }

            isSpeedUp = true;

            if (allocatPoints.ContainsKey(property))

            {

                if (surplusPoint < 1)

                {

                    return;

                }

                allocatPoints[property]++;

                surplusPoint--;

                OnUpdatePoint(property);

            }

            StartCoroutine(Co_OnSpeedUp(true, property));

        }



        private void OnSub(int property, bool down)

        {

            if (!down)

            {

                isSpeedUp = false;

                StopAllCoroutines();

                return;

            }

            isSpeedUp = true;

            if (allocatPoints.ContainsKey(property))

            {

                if (allocatPoints[property] < 1)

                {

                    return;

                }

                allocatPoints[property]--;

                surplusPoint++;

                OnUpdatePoint(property);

            }

            StartCoroutine(Co_OnSpeedUp(false, property));

        }



        IEnumerator Co_OnSpeedUp(bool up, int property)

        {

            yield return waitSpeedUp;

            int upCnt = 0;

            while (isSpeedUp)

            {

                if (allocatPoints.ContainsKey(property))

                {

                    if (up)

                    {

                        if (surplusPoint < 1)

                        {

                            yield break;

                        }

                        allocatPoints[property]++;

                        surplusPoint--;

                        OnUpdatePoint(property);

                    }

                    else

                    {

                        if (allocatPoints[property] < 1)

                        {

                            yield break;

                        }

                        allocatPoints[property]--;

                        surplusPoint++;

                        OnUpdatePoint(property);

                    }

                }

                if (upCnt < WAITCNT)

                {

                    yield return waitSpeedSlow;

                }

                else

                {

                    yield return waitSpeedFaster;

                }

                upCnt++;

            }

        }



        private void OnPreview(int property)

        {

            presentAddPoint = property;

            m_NumkeyBoard.gameObject.SetActive(true);

            m_NumkeyBoard.max = (uint)surplusPoint + (uint)allocatPoints[property];

            m_NumkeyBoard.min = 0;

            var behaviour = m_AddPoints.Find((x) =>

            {

                return x.property == property;

            });

            RectTransform parent = behaviour.pointBottom;

            var worldpos = parent.TransformPoint(new Vector3(0, -parent.rect.height / 2, 0));

            var localpos = m_ContainerRight.InverseTransformPoint(worldpos);

            m_NumkeyBoard.transform.localPosition = localpos;

        }



        [Serializable]

        public class PropertyValue

        {

            private int m_Property;

            public int property

            {

                get

                {

                    return m_Property;

                }

                set

                {

                    m_Property = value;

                    Refresh();

                }

            }



            [SerializeField] Text m_PropertyName;

            [SerializeField] Text m_PropertyValue;

            [SerializeField] Text m_PropertyAdd;



            public void Refresh()

            {

                var config = Config.Instance.Get<PlayerPropertyConfig>(property);

                if (config != null)

                {

                    m_PropertyName.text = config.Name;

                    RefreshValue();

                    RefreshAdd(0);

                }

            }



            public void RefreshValue()

            {

                var config = Config.Instance.Get<PlayerPropertyConfig>(property);

                if ((AttrEnum)property == AttrEnum.ATK)

                {

                    m_PropertyValue.text = StringUtility.Contact(UIHelper.ReplaceLargeNum((ulong)PlayerDatas.Instance.extersion.MINATK),

                        "-", UIHelper.ReplaceLargeNum((ulong)PlayerDatas.Instance.extersion.MAXATK));

                }

                else

                {

                    m_PropertyValue.text = UIHelper.ReplaceLargeNum((ulong)UIHelper.GetPropertyMapPlayerData((AttrEnum)property));

                }

            }



            public void RefreshAdd(float _value)

            {

                m_PropertyAdd.gameObject.SetActive(_value != 0);

                if (_value > 0)

                {

                    m_PropertyAdd.text = StringUtility.Contact("+", _value);

                }

            }

        }

    }

}










 System/Role/RolePointWin.cs.meta

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

 System/RolePromote/RolePromoteModel.cs

@@ -134,6 +134,8 @@


        RoleModel roleModel { get { return ModelCenter.Instance.GetModel<RoleModel>(); } }



        RolePointModel rolePointModel { get { return ModelCenter.Instance.GetModel<RolePointModel>(); } }



        #region 配置

        public Dictionary<int, int> wingLv2GenerDict = new Dictionary<int, int>();

        public Dictionary<int, List<RoleStrongerConfig>> roleStrongerDic = new Dictionary<int, List<RoleStrongerConfig>>();

@@ -533,7 +535,7 @@
                _id == methodData.fairyHeartRedpoint.id ||

                _id == realmModel.realmRedpoint.id ||

                _id == gemModel.gemTagRedPoint.id ||

                //_id == blastFurnaceModel.MakeDrugRedpoint.id ||

                _id == rolePointModel.redpoint.id ||

                IsTreasureRedpoint(_id))

            {

                CheckPromoteDetailEffect();

@@ -569,6 +571,8 @@
                case PromoteDetailType.BetterEquip:

                    var dict = modelInterface.CheckBetterEquipByRealm();

                    return dict != null && dict.Count > 0;

                case PromoteDetailType.AddPoint:

                    return rolePointModel.redpoint.state == RedPointState.Simple;

                case PromoteDetailType.EquipStrength:

                    return strengthengmodel.StrengthRedpoint.state == RedPointState.Simple;

                case PromoteDetailType.Mount:

@@ -617,6 +621,7 @@
        public enum PromoteDetailType

        {

            BetterEquip,

            AddPoint,

            EquipStrength,

            Mount,

            Pet,


 System/Tip/PromoteDetailsWin.cs

@@ -72,6 +72,9 @@
                case RolePromoteModel.PromoteDetailType.BetterEquip:

                    WindowCenter.Instance.Open<KnapSackWin>();

                    break;

                case RolePromoteModel.PromoteDetailType.AddPoint:

                    WindowCenter.Instance.Open<RolePointWin>();

                    break;

                case RolePromoteModel.PromoteDetailType.EquipStrength:

                    WindowCenter.Instance.Open<EquipReinforceWin>();

                    break;


 System/WindowBase/ModelCenter.cs

@@ -199,6 +199,7 @@
            RegisterModel<TalentModel>();

            RegisterModel<OpenServerActivityNotifyModel>();

            RegisterModel<WishingPoolModel>();

            RegisterModel<RolePointModel>();

            inited = true;

        }