6964 子 【2.0】【开发】炼丹功能精简优化 / 【2.0】【前端】炼丹功能精简优化

client_linchunjie

2019-05-27 092201b68bd106738585b7c0a60bd00dc0833c48

6964 子 【2.0】【开发】炼丹功能精简优化 / 【2.0】【前端】炼丹功能精简优化

 Core/GameEngine/Model/TelPartialConfig/tagAlchemyConfig.cs

@@ -3,40 +3,24 @@


public partial class AlchemyConfig : IConfigPostProcess

{

    static Dictionary<int, Dictionary<int, List<int>>> m_Alchemies = new Dictionary<int, Dictionary<int, List<int>>>();

    static Dictionary<int, List<int>> m_Alchemies = new Dictionary<int, List<int>>();



    public void OnConfigParseCompleted()

    {

        Dictionary<int, List<int>> dict = null;

        if (!m_Alchemies.TryGetValue(AlchemType, out dict))

        {

            dict = new Dictionary<int, List<int>>();

            m_Alchemies.Add(AlchemType, dict);

        }

        List<int> ids = null;

        if (!dict.TryGetValue(AlchemyQuality, out ids))

        if (!m_Alchemies.TryGetValue(AlchemType, out ids))

        {

            ids = new List<int>();

            dict.Add(AlchemyQuality, ids);

            m_Alchemies.Add(AlchemType, ids);

        }

        ids.Add(ID);

    }



    public static List<int> GetAlchemies(int type, int quality)

    {

        if (m_Alchemies.ContainsKey(type)

            && m_Alchemies[type].ContainsKey(quality))

        {

            return m_Alchemies[type][quality];

        }

        return null;

    }



    public static ICollection<int> GetAlchemyQualities(int type)

    public static List<int> GetAlchemies(int type)

    {

        if (m_Alchemies.ContainsKey(type))

        {

            return m_Alchemies[type].Keys;

            return m_Alchemies[type];

        }

        return null;

    }


 Lua/Gen/AlchemyConfigWrap.cs

File was deleted

 Lua/Gen/SnxxzUIAlchemyModelWrap.cs

File was deleted

 Lua/Gen/SnxxzUIAlchemyModelWrap.cs.meta

File was deleted

 Lua/Gen/XLuaGenAutoRegister.cs

@@ -52,9 +52,6 @@
            translator.DelayWrapLoader(typeof(AdventureDialogueConfig), AdventureDialogueConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(AlchemyConfig), AlchemyConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(AlchemyCountConfig), AlchemyCountConfigWrap.__Register);
        
        
@@ -934,9 +931,6 @@
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.ActivityModel), SnxxzUIActivityModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.AlchemyModel), SnxxzUIAlchemyModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(AssetVersionUtility), AssetVersionUtilityWrap.__Register);

 System/Alchemy/AlchemyBaseWin.cs

@@ -20,7 +20,8 @@
            base.AddListeners();

            SetFunctionListener(0, ShowAlchemyNormal);

            SetFunctionListener(1, ShowAlchemyFairy);

            SetFunctionListener(2, ShowAlchemyDrug);

            SetFunctionListener(2, ShowAlchemyNormalDrug);

            SetFunctionListener(3, ShowAlchemyFairyDrug);

        }



        protected override void OnActived()

@@ -48,12 +49,19 @@
            functionOrder = 0;

        }



        private void ShowAlchemyDrug()

        private void ShowAlchemyNormalDrug()

        {

            CloseSubWindows();

            WindowCenter.Instance.Open<AlchemyUseDrugWin>();

            WindowCenter.Instance.Open<AlchemyNormalUseDrugWin>();

            functionOrder = 2;

        }



        private void ShowAlchemyFairyDrug()

        {

            CloseSubWindows();

            WindowCenter.Instance.Open<AlchemyFairyUseDrugWin>();

            functionOrder = 3;

        }

    }



}


 System/Alchemy/AlchemyBriefBehaviour.cs

@@ -29,25 +29,28 @@


        void DisplayAlchemyCount()

        {

            AlchemyCount alchemyCount;

            if (model.TryGetAlchemyCount(model.selectAlchemy, PlayerDatas.Instance.extersion.luckValue, out alchemyCount))

            {

                if (alchemyCount.min == alchemyCount.max)

                {

                    m_AlchemyCount.text = alchemyCount.min.ToString();

                }

                else

                {

                    m_AlchemyCount.text = StringUtility.Contact(alchemyCount.min, "~", alchemyCount.max);

                }

            }

            m_AlchemyCount.gameObject.SetActive(false);



            //AlchemyCount alchemyCount;

            //if (model.TryGetAlchemyCount(model.selectAlchemy, PlayerDatas.Instance.extersion.luckValue, out alchemyCount))

            //{

            //    if (alchemyCount.min == alchemyCount.max)

            //    {

            //        m_AlchemyCount.text = alchemyCount.min.ToString();

            //    }

            //    else

            //    {

            //        m_AlchemyCount.text = StringUtility.Contact(alchemyCount.min, "~", alchemyCount.max);

            //    }

            //}

        }



        void DisplaySuccRate()

        {

            var succRate = model.GetAlchemySuccRate(model.selectAlchemy);

            var rate = (int)(succRate / 100);

            m_AlchemySuccRate.text = rate + "%";

            m_AlchemySuccRate.gameObject.SetActive(false);

            //var succRate = model.GetAlchemySuccRate(model.selectAlchemy);

            //var rate = (int)(succRate / 100);

            //m_AlchemySuccRate.text = rate + "%";

        }



        public void Dispose()


 System/Alchemy/AlchemyDrugProgressBehaviour.cs

@@ -40,11 +40,9 @@


            alchemyId = 0;



            Int2 position;

            if (model.IsStoveAlcheming(m_AlchemyType, out position))

            if (model.IsStoveAlcheming(m_AlchemyType, out alchemyId))

            {

                isAlcheming = model.GetStoveState(position.y) == 1;

                alchemyId = position.y;

                isAlcheming = model.GetStoveState(alchemyId) == 1;

            }



            this.gameObject.SetActive(isAlcheming);


 System/Alchemy/AlchemyDrugWin.cs

@@ -52,7 +52,6 @@
            m_AlchemyStove.Display();



            model.selectAlchemyRefresh += SelectAlchemyRefresh;

            model.selectQualityRefresh += SelectQualityRefresh;

            model.alchemyStateRefresh += AlchemyStateRefresh;

        }



@@ -69,7 +68,6 @@
            m_AlchemyStove.Dispose();



            model.selectAlchemyRefresh -= SelectAlchemyRefresh;

            model.selectQualityRefresh -= SelectQualityRefresh;

            model.alchemyStateRefresh -= AlchemyStateRefresh;

        }



@@ -80,63 +78,35 @@


        void SetDefaultSelect()

        {

            Int2 position;

            if (model.IsStoveAlcheming(model.selectAlchemyType, out position))

            int alchemyId = 0;

            if (model.IsStoveAlcheming(model.selectAlchemyType, out alchemyId))

            {

                model.selectQuality = position.x;

                model.selectAlchemy = position.y;

                model.selectAlchemy = alchemyId;

                return;

            }



            var qualities = AlchemyConfig.GetAlchemyQualities((int)m_AlchemyType);



            if (model.jumpAlchemy != 0)

            {

                foreach (var quality in qualities)

                var alchemys = AlchemyConfig.GetAlchemies((int)m_AlchemyType);

                if (alchemys.Contains(model.jumpAlchemy))

                {

                    var alchemys = AlchemyConfig.GetAlchemies((int)m_AlchemyType, quality);

                    if (alchemys.Contains(model.jumpAlchemy))

                    {

                        model.selectQuality = quality;

                        model.selectAlchemy = model.jumpAlchemy;

                        return;

                    }

                }

            }



            foreach (var quality in qualities)

            {

                var alchemys = AlchemyConfig.GetAlchemies((int)m_AlchemyType, quality);

                foreach (var alchemyId in alchemys)

                {

                    var redpointId = model.GetAlchemyRedpointId(alchemyId);

                    if (RedpointCenter.Instance.GetRedpointState(redpointId) == RedPointState.Simple)

                    {

                        model.selectQuality = quality;

                        model.selectAlchemy = alchemyId;

                        return;

                    }

                }

            }



            {

                model.selectQuality = qualities.First();



                var alchemys = AlchemyConfig.GetAlchemies((int)m_AlchemyType, model.selectQuality);

                model.selectAlchemy = alchemys[0];

            }

        }



        private void SelectQualityRefresh()

        {

            if (model.selectQuality != 0)

            {

                Int2 position;

                if (model.IsStoveAlcheming(m_AlchemyType, out position))

                {

                    model.selectAlchemy = model.jumpAlchemy;

                    return;

                }

                var alchemys = AlchemyConfig.GetAlchemies((int)m_AlchemyType, model.selectQuality);

            }



            {

                var alchemys = AlchemyConfig.GetAlchemies((int)m_AlchemyType);

                foreach (var id in alchemys)

                {

                    var redpointId = model.GetAlchemyRedpointId(id);

                    if (RedpointCenter.Instance.GetRedpointState(redpointId) == RedPointState.Simple)

                    {

                        model.selectAlchemy = id;

                        return;

                    }

                }



                model.selectAlchemy = alchemys[0];

            }

        }


 System/Alchemy/AlchemyFairyUseDrugWin.cs

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

//    [Author]:           第二世界

//    [  Date ]:           Monday, May 27, 2019

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



using System;

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using UnityEngine.UI;



namespace Snxxz.UI {



    public class AlchemyFairyUseDrugWin : AlchemyUseDrugWin

    {

    }



}










 System/Alchemy/AlchemyFairyUseDrugWin.cs.meta

copy from Lua/Gen/AlchemyConfigWrap.cs.meta
copy to System/Alchemy/AlchemyFairyUseDrugWin.cs.meta
File was copied from Lua/Gen/AlchemyConfigWrap.cs.meta
@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: 0610d6fbd3e0c9d4d820b95afe155810
timeCreated: 1557818428
guid: 8001865df13f9d24495c21eeddaebbd8
timeCreated: 1558949867
licenseType: Pro
MonoImporter:
  serializedVersion: 2

 System/Alchemy/AlchemyModel.cs

@@ -19,28 +19,11 @@
        public readonly Redpoint redpoint = new Redpoint(MainRedDot.RedPoint_key, 110);

        public readonly Redpoint alchemyDrugRedpoint1 = new Redpoint(110, 11001);

        public readonly Redpoint alchemyDrugRedpoint2 = new Redpoint(110, 11002);

        public readonly Redpoint alchemyDrugREdpoint3 = new Redpoint(110, 11003);

        Dictionary<int, Dictionary<int, Redpoint>> alchemyQualityRedpoints = new Dictionary<int, Dictionary<int, Redpoint>>();

        public readonly Redpoint alchemyDrugRedpoint3 = new Redpoint(110, 11003);

        public readonly Redpoint alchemyDrugRedpoint4 = new Redpoint(110, 11004);

        Dictionary<int, AlchemyRedpoint> alchemyRedpoints = new Dictionary<int, AlchemyRedpoint>();



        public static int redpointIndex = 110010000;



        int m_SelectQuality = 0;

        public int selectQuality

        {

            get { return m_SelectQuality; }

            set

            {

                if (m_SelectQuality != value)

                {

                    m_SelectQuality = value;

                    if (selectQualityRefresh != null)

                    {

                        selectQualityRefresh();

                    }

                }

            }

        }



        int m_SelectAlchemy = 0;

        public int selectAlchemy

@@ -72,12 +55,12 @@


        public bool isServerPrepare { get; private set; }



        public event Action selectQualityRefresh;

        public event Action selectAlchemyRefresh;

        public event Action alchemyStateRefresh;

        public event Action alchemyDrugUseRefresh;



        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }

        ReikiRootModel reikiRootModel { get { return ModelCenter.Instance.GetModel<ReikiRootModel>(); } }



        public override void Init()

        {

@@ -85,6 +68,7 @@
            PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshEvent;

            packModel.refreshItemCountEvent += RefreshItemCountEvent;

            GlobalTimeEvent.Instance.secondEvent += PerSecond;

            reikiRootModel.onReikiRootPointRefresh += OnReikiRootPointRefresh;



            ParseConfig();

        }

@@ -113,6 +97,7 @@
            PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshEvent;

            packModel.refreshItemCountEvent -= RefreshItemCountEvent;

            GlobalTimeEvent.Instance.secondEvent -= PerSecond;

            reikiRootModel.onReikiRootPointRefresh -= OnReikiRootPointRefresh;

        }



        private void RefreshItemCountEvent(PackType packType, int arg2, int itemId)

@@ -128,9 +113,17 @@
            }

        }



        private void OnReikiRootPointRefresh()

        {

            if (isServerPrepare)

            {

                CheckRedpoint();

            }

        }



        private void PlayerDataRefreshEvent(PlayerDataType dataType)

        {

            if (dataType == PlayerDataType.LuckValue)

            if (dataType == PlayerDataType.FreePoint)

            {

                CheckRedpoint();

            }

@@ -225,30 +218,16 @@
                m_AlchemyDrugQualitys.Sort();

            }



            var qualitys = AlchemyConfig.GetAlchemyQualities((int)AlchemyType.Normal);

            alchemyQualityRedpoints.Add((int)AlchemyType.Normal, new Dictionary<int, Redpoint>());

            foreach (var quality in qualitys)

            var alchemys = AlchemyConfig.GetAlchemies((int)AlchemyType.Normal);

            foreach (var id in alchemys)

            {

                var qualityRedpoint = new Redpoint(alchemyDrugRedpoint1.id, redpointIndex++); ;

                alchemyQualityRedpoints[(int)AlchemyType.Normal].Add(quality, qualityRedpoint);

                var alchemys = AlchemyConfig.GetAlchemies((int)AlchemyType.Normal, quality);

                foreach (var id in alchemys)

                {

                    alchemyRedpoints.Add(id, new AlchemyRedpoint(qualityRedpoint.id));

                }

                alchemyRedpoints.Add(id, new AlchemyRedpoint(alchemyDrugRedpoint1.id));

            }



            qualitys = AlchemyConfig.GetAlchemyQualities((int)AlchemyType.Fairy);

            alchemyQualityRedpoints.Add((int)AlchemyType.Fairy, new Dictionary<int, Redpoint>());

            foreach (var quality in qualitys)

            alchemys = AlchemyConfig.GetAlchemies((int)AlchemyType.Fairy);

            foreach (var id in alchemys)

            {

                var qualityRedpoint = new Redpoint(alchemyDrugRedpoint2.id, redpointIndex++); ;

                alchemyQualityRedpoints[(int)AlchemyType.Fairy].Add(quality, qualityRedpoint);

                var alchemys = AlchemyConfig.GetAlchemies((int)AlchemyType.Fairy, quality);

                foreach (var id in alchemys)

                {

                    alchemyRedpoints.Add(id, new AlchemyRedpoint(qualityRedpoint.id));

                }

                alchemyRedpoints.Add(id, new AlchemyRedpoint(alchemyDrugRedpoint2.id));

            }

        }



@@ -300,7 +279,7 @@
                error = 2;

                return false;

            }

            if (PlayerDatas.Instance.extersion.luckValue < config.LearnNeedLuck)

            if (reikiRootModel.GetReikiRootTotalPointWithFree() < config.LearnNeedLuck)

            {

                error = 3;

                return false;

@@ -332,18 +311,6 @@
        public int GetAlchemyRedpointId(int id)

        {

            return alchemyRedpoints.ContainsKey(id) ? alchemyRedpoints[id].redpoint.id : 0;

        }



        public int GetQualityRedpointId(int alchemyType, int quality)

        {

            if (alchemyQualityRedpoints.ContainsKey(alchemyType))

            {

                if (alchemyQualityRedpoints[alchemyType].ContainsKey(quality))

                {

                    return alchemyQualityRedpoints[alchemyType][quality].id;

                }

            }

            return 0;

        }



        public float GetAlchemySuccRate(int alchemyId)

@@ -450,22 +417,17 @@
            return true;

        }



        public bool IsStoveAlcheming(AlchemyType alchemyType, out Int2 alchemyPosition)

        public bool IsStoveAlcheming(AlchemyType alchemyType, out int _alchemyId)

        {

            alchemyPosition = default(Int2);

            var qualities = AlchemyConfig.GetAlchemyQualities((int)alchemyType);

            foreach (var quality in qualities)

            _alchemyId = 0;

            var alchemys = AlchemyConfig.GetAlchemies((int)alchemyType);

            foreach (var alchemyId in alchemys)

            {

                var alchemys = AlchemyConfig.GetAlchemies((int)alchemyType, quality);

                foreach (var alchemyId in alchemys)

                var state = GetStoveState(alchemyId);

                if (state != 0)

                {

                    var state = GetStoveState(alchemyId);

                    if (state != 0)

                    {

                        alchemyPosition.x = quality;

                        alchemyPosition.y = alchemyId;

                        return true;

                    }

                    _alchemyId = alchemyId;

                    return true;

                }

            }

            return false;

@@ -560,19 +522,19 @@


                var requireCheckRedpoint = false;



                Int2 position;

                if (IsStoveAlcheming(AlchemyType.Normal, out position)

                    && GetStoveState(position.y) == 2

                    && alchemyRedpoints.ContainsKey(position.y)

                    && alchemyRedpoints[position.y].endRedpoint.state != RedPointState.Simple)

                int alchemyId = 0;

                if (IsStoveAlcheming(AlchemyType.Normal, out alchemyId)

                    && GetStoveState(alchemyId) == 2

                    && alchemyRedpoints.ContainsKey(alchemyId)

                    && alchemyRedpoints[alchemyId].endRedpoint.state != RedPointState.Simple)

                {

                    requireCheckRedpoint = true;

                }



                if (IsStoveAlcheming(AlchemyType.Fairy, out position)

                    && GetStoveState(position.y) == 2

                    && alchemyRedpoints.ContainsKey(position.y)

                    && alchemyRedpoints[position.y].endRedpoint.state != RedPointState.Simple)

                if (IsStoveAlcheming(AlchemyType.Fairy, out alchemyId)

                    && GetStoveState(alchemyId) == 2

                    && alchemyRedpoints.ContainsKey(alchemyId)

                    && alchemyRedpoints[alchemyId].endRedpoint.state != RedPointState.Simple)

                {

                    requireCheckRedpoint = true;

                }

@@ -587,23 +549,6 @@
        static List<int> s_Endables = new List<int>();

        static List<int> s_Studyables = new List<int>();

        static List<int> s_Alchemyables = new List<int>();



        static Dictionary<AlchemyType, List<int>> s_SortQualitys = new Dictionary<AlchemyType, List<int>>();



        public List<int> GetSortQualitys(AlchemyType alchemyType)

        {

            if (!s_SortQualitys.ContainsKey(alchemyType))

            {

                s_SortQualitys.Add(alchemyType, new List<int>(AlchemyConfig.GetAlchemyQualities((int)alchemyType)));

                s_SortQualitys[alchemyType].Sort(QualityCompare);

            }

            return s_SortQualitys[alchemyType];

        }



        private int QualityCompare(int x, int y)

        {

            return -x.CompareTo(y);

        }



        void CheckRedpoint()

        {

@@ -625,37 +570,33 @@


        void CheckRedpoint(AlchemyType alchemyType)

        {

            Int2 position;

            if (IsStoveAlcheming(alchemyType, out position))

            int alchemyId = 0;

            if (IsStoveAlcheming(alchemyType, out alchemyId))

            {

                var state = GetStoveState(position.y);

                var state = GetStoveState(alchemyId);

                if (state == 2)

                {

                    s_Endables.Add(position.y);

                    s_Endables.Add(alchemyId);

                }

            }

            else

            {

                var hasStudyRed = false;



                var qualitys = AlchemyConfig.GetAlchemyQualities((int)alchemyType);

                foreach (var quality in qualitys)

                var alchemys = AlchemyConfig.GetAlchemies((int)alchemyType);

                foreach (var id in alchemys)

                {

                    var alchemys = AlchemyConfig.GetAlchemies((int)alchemyType, quality);

                    foreach (var id in alchemys)

                    if (!IsGraspRecipe(id))

                    {

                        if (!IsGraspRecipe(id))

                        var config = AlchemyConfig.Get(id);

                        var count = packModel.GetItemCountByID(PackType.Item, config.LearnNeedItemID);

                        if (count <= 0 || stoveLevel < config.LearnNeedAlchemLV

                            || reikiRootModel.GetReikiRootTotalPointWithFree() < config.LearnNeedLuck)

                        {

                            var config = AlchemyConfig.Get(id);

                            var count = packModel.GetItemCountByID(PackType.Item, config.LearnNeedItemID);

                            if (count <= 0 || stoveLevel < config.LearnNeedAlchemLV

                                || PlayerDatas.Instance.extersion.luckValue < config.LearnNeedLuck)

                            {

                                continue;

                            }

                            s_Studyables.Add(id);

                            hasStudyRed = true;

                            continue;

                        }

                        s_Studyables.Add(id);

                        hasStudyRed = true;

                    }

                }



@@ -664,28 +605,17 @@
                    return;

                }



                qualitys = GetSortQualitys(alchemyType);

                foreach (var quality in qualitys)

                alchemys = AlchemyConfig.GetAlchemies((int)alchemyType);

                foreach (var id in alchemys)

                {

                    var alchemyable = false;

                    var alchemys = AlchemyConfig.GetAlchemies((int)alchemyType, quality);

                    foreach (var id in alchemys)

                    if (!IsGraspRecipe(id))

                    {

                        if (!IsGraspRecipe(id))

                        {

                            continue;

                        }

                        Item item;

                        if (IsAlchemyEnoughMaterial(id, out item))

                        {

                            s_Alchemyables.Add(id);

                            alchemyable = true;

                        }

                        continue;

                    }



                    if (alchemyable && alchemyType == AlchemyType.Normal)

                    Item item;

                    if (IsAlchemyEnoughMaterial(id, out item))

                    {

                        break;

                        s_Alchemyables.Add(id);

                    }

                }

            }

@@ -693,48 +623,54 @@


        void RefreshRedpoint()

        {

            var qualitys = AlchemyConfig.GetAlchemyQualities((int)AlchemyType.Normal);

            foreach (var quality in qualitys)

            var alchemys = AlchemyConfig.GetAlchemies((int)AlchemyType.Normal);

            foreach (var id in alchemys)

            {

                var alchemys = AlchemyConfig.GetAlchemies((int)AlchemyType.Normal, quality);

                foreach (var id in alchemys)

                {

                    var redpoint = alchemyRedpoints[id];

                    redpoint.studyRedpoint.state = s_Studyables.Contains(id) ? RedPointState.Simple : RedPointState.None;

                    redpoint.endRedpoint.state = s_Endables.Contains(id) ? RedPointState.Simple : RedPointState.None;

                    redpoint.alchemyRedpoint.state = s_Alchemyables.Contains(id) ? RedPointState.Simple : RedPointState.None;

                }

                var redpoint = alchemyRedpoints[id];

                redpoint.studyRedpoint.state = s_Studyables.Contains(id) ? RedPointState.Simple : RedPointState.None;

                redpoint.endRedpoint.state = s_Endables.Contains(id) ? RedPointState.Simple : RedPointState.None;

                redpoint.alchemyRedpoint.state = s_Alchemyables.Contains(id) ? RedPointState.Simple : RedPointState.None;

            }



            qualitys = AlchemyConfig.GetAlchemyQualities((int)AlchemyType.Fairy);

            foreach (var quality in qualitys)

            alchemys = AlchemyConfig.GetAlchemies((int)AlchemyType.Fairy);

            foreach (var id in alchemys)

            {

                var alchemys = AlchemyConfig.GetAlchemies((int)AlchemyType.Fairy, quality);

                foreach (var id in alchemys)

                {

                    var redpoint = alchemyRedpoints[id];

                    redpoint.studyRedpoint.state = s_Studyables.Contains(id) ? RedPointState.Simple : RedPointState.None;

                    redpoint.endRedpoint.state = s_Endables.Contains(id) ? RedPointState.Simple : RedPointState.None;

                    redpoint.alchemyRedpoint.state = s_Alchemyables.Contains(id) ? RedPointState.Simple : RedPointState.None;

                }

                var redpoint = alchemyRedpoints[id];

                redpoint.studyRedpoint.state = s_Studyables.Contains(id) ? RedPointState.Simple : RedPointState.None;

                redpoint.endRedpoint.state = s_Endables.Contains(id) ? RedPointState.Simple : RedPointState.None;

                redpoint.alchemyRedpoint.state = s_Alchemyables.Contains(id) ? RedPointState.Simple : RedPointState.None;

            }

        }



        void RefreshUseDrugRedpoint()

        {

            var useable = false;

            var normalUseable = false;

            var fairyUseable = false;

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

            {

                foreach (var itemId in m_AlchemyDrugs)

                {

                    if (GetAlchemyDrugState(itemId) == 0)

                    {

                        useable = true;

                        break;

                        var config = AttrFruitConfig.Get(itemId);

                        if (config.drugType == (int)AlchemyType.Normal)

                        {

                            normalUseable = true;

                        }

                        if (config.drugType == (int)AlchemyType.Fairy)

                        {

                            fairyUseable = true;

                        }



                        if (normalUseable && fairyUseable)

                        {

                            break;

                        }

                    }

                }

            }

            alchemyDrugREdpoint3.state = useable ? RedPointState.Simple : RedPointState.None;

            alchemyDrugRedpoint3.state = normalUseable ? RedPointState.Simple : RedPointState.None;

            alchemyDrugRedpoint4.state = fairyUseable ? RedPointState.Simple : RedPointState.None;

        }

    }




 System/Alchemy/AlchemyNormalUseDrugWin.cs

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

//    [Author]:           第二世界

//    [  Date ]:           Monday, May 27, 2019

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



using System;

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using UnityEngine.UI;



namespace Snxxz.UI

{



    public class AlchemyNormalUseDrugWin : AlchemyUseDrugWin

    {



    }



}










 System/Alchemy/AlchemyNormalUseDrugWin.cs.meta

File was renamed from Lua/Gen/AlchemyConfigWrap.cs.meta
@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: 0610d6fbd3e0c9d4d820b95afe155810
timeCreated: 1557818428
guid: e7f7c7a4326a38f498f93962e78177f3
timeCreated: 1558949095
licenseType: Pro
MonoImporter:
  serializedVersion: 2

 System/Alchemy/AlchemyNotifyBehaviour.cs

@@ -34,17 +34,17 @@
        {

            var isAlchemyComplete = false;



            Int2 position;

            if (model.IsStoveAlcheming(AlchemyType.Normal, out position))

            int alchemyId;

            if (model.IsStoveAlcheming(AlchemyType.Normal, out alchemyId))

            {

                if (model.GetStoveState(position.y) == 2 && !model.alchemyNormalNotifySymbol)

                if (model.GetStoveState(alchemyId) == 2 && !model.alchemyNormalNotifySymbol)

                {

                    isAlchemyComplete = true;

                }

            }

            if (model.IsStoveAlcheming(AlchemyType.Fairy, out position))

            if (model.IsStoveAlcheming(AlchemyType.Fairy, out alchemyId))

            {

                if (model.GetStoveState(position.y) == 2 && !model.alchemyFairyNotifySymbol)

                if (model.GetStoveState(alchemyId) == 2 && !model.alchemyFairyNotifySymbol)

                {

                    isAlchemyComplete = true;

                }

@@ -68,10 +68,10 @@


        private void Goto()

        {

            Int2 position;

            if (model.IsStoveAlcheming(AlchemyType.Normal, out position))

            int alchemyId;

            if (model.IsStoveAlcheming(AlchemyType.Normal, out alchemyId))

            {

                if (model.GetStoveState(position.y) == 2)

                if (model.GetStoveState(alchemyId) == 2)

                {

                    model.alchemyNormalNotifySymbol = true;

                    gameObject.SetActive(false);

@@ -79,9 +79,9 @@
                    return;

                }

            }

            if (model.IsStoveAlcheming(AlchemyType.Fairy, out position))

            if (model.IsStoveAlcheming(AlchemyType.Fairy, out alchemyId))

            {

                if (model.GetStoveState(position.y) == 2)

                if (model.GetStoveState(alchemyId) == 2)

                {

                    model.alchemyFairyNotifySymbol = true;

                    gameObject.SetActive(false);

@@ -93,17 +93,17 @@


        private void Close()

        {

            Int2 position;

            if (model.IsStoveAlcheming(AlchemyType.Normal, out position))

            int alchemyId;

            if (model.IsStoveAlcheming(AlchemyType.Normal, out alchemyId))

            {

                if (model.GetStoveState(position.y) == 2)

                if (model.GetStoveState(alchemyId) == 2)

                {

                    model.alchemyNormalNotifySymbol = true;

                }

            }

            if (model.IsStoveAlcheming(AlchemyType.Fairy, out position))

            if (model.IsStoveAlcheming(AlchemyType.Fairy, out alchemyId))

            {

                if (model.GetStoveState(position.y) == 2)

                if (model.GetStoveState(alchemyId) == 2)

                {

                    model.alchemyFairyNotifySymbol = true;

                }


 System/Alchemy/AlchemyQualityCell.cs

@@ -25,39 +25,10 @@


        public void Display(int quality)

        {

            this.quality = quality;

            m_QualityName.text = Language.Get("AlchemyQualityName", Language.Get("Num_CHS_" + quality));

            m_ContainerSelect.gameObject.SetActive(model.selectQuality == quality);

            m_Arrow.transform.localEulerAngles = new Vector3(0, 0, model.selectQuality == quality ? -90 : 0);

            m_Redpoint.redpointId = model.GetQualityRedpointId((int)model.selectAlchemyType, quality);

        }



        private void OnSelect()

        {

            if (model.selectQuality == quality)

            {

                model.selectQuality = 0;

            }

            else

            {

                Int2 position;

                if (model.IsStoveAlcheming(model.selectAlchemyType, out position))

                {

                    if (position.x != quality)

                    {

                        if (model.GetStoveState(position.y) == 2)

                        {

                            SysNotifyMgr.Instance.ShowTip("AlchemingSwitchError_1");

                        }

                        else

                        {

                            SysNotifyMgr.Instance.ShowTip("AlchemingSwitchError");

                        }

                        return;

                    }

                }

                model.selectQuality = quality;

            }

        }

    }

}

 System/Alchemy/AlchemyRecipeCell.cs

@@ -40,12 +40,12 @@


        private void OnSelect()

        {

            Int2 position;

            if (model.IsStoveAlcheming(model.selectAlchemyType, out position))

            int alchemyId;

            if (model.IsStoveAlcheming(model.selectAlchemyType, out alchemyId))

            {

                if (position.y != id)

                if (alchemyId != id)

                {

                    if (model.GetStoveState(position.y) == 2)

                    if (model.GetStoveState(alchemyId) == 2)

                    {

                        SysNotifyMgr.Instance.ShowTip("AlchemingSwitchError_1");

                    }


 System/Alchemy/AlchemyScrollBehaviour.cs

@@ -24,14 +24,13 @@


            DisplayRecipes();



            var qualities = new List<int>(AlchemyConfig.GetAlchemyQualities(alchemyType));

            var index = qualities.IndexOf(model.selectQuality);

            var alchemies = new List<int>(AlchemyConfig.GetAlchemies(alchemyType));

            var index = alchemies.IndexOf(model.selectAlchemy);

            if (index != -1)

            {

                m_Controller.JumpIndex(index);

            }



            model.selectQualityRefresh += SelectQualityRefresh;

            model.selectAlchemyRefresh += SelectAlchemyRefresh;

            model.alchemyStateRefresh += AlchemyStateRefresh;

        }

@@ -39,18 +38,10 @@
        void DisplayRecipes()

        {

            m_Controller.Refresh();

            var qualities = AlchemyConfig.GetAlchemyQualities(alchemyType);

            foreach (var quality in qualities)

            var alchemies = AlchemyConfig.GetAlchemies(alchemyType);

            foreach (var id in alchemies)

            {

                m_Controller.AddCell(ScrollerDataType.Header, quality);

                if (model.selectQuality == quality)

                {

                    var recipes = AlchemyConfig.GetAlchemies(alchemyType, quality);

                    foreach (var id in recipes)

                    {

                        m_Controller.AddCell(ScrollerDataType.Normal, id);

                    }

                }

                m_Controller.AddCell(ScrollerDataType.Normal, id);

            }

            m_Controller.Restart();

        }

@@ -86,7 +77,6 @@


        public void Dispose()

        {

            model.selectQualityRefresh -= SelectQualityRefresh;

            model.selectAlchemyRefresh -= SelectAlchemyRefresh;

            model.alchemyStateRefresh -= AlchemyStateRefresh;

        }


 System/Alchemy/AlchemyStoveBehaviour.cs

@@ -22,7 +22,7 @@
        [SerializeField] Image m_ViewSlider;

        [SerializeField] float m_SliderLength;



        [SerializeField] Text m_LuckValue;

        [SerializeField] Text m_ReikiPoint;

        [SerializeField] Transform m_ContainerGrasp;

        [SerializeField] Button m_Func;

        [SerializeField] Text m_FuncLabel;

@@ -56,6 +56,7 @@


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

        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }

        ReikiRootModel reikiRootModel { get { return ModelCenter.Instance.GetModel<ReikiRootModel>(); } }



        private void Awake()

        {

@@ -68,12 +69,13 @@
            model.alchemyStateRefresh += AlchemyStateRefresh;

            PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshEvent;

            packModel.refreshItemCountEvent += RefreshItemCountEvent;

            reikiRootModel.onReikiRootPointRefresh += OnReikiRootPointRefresh;



            m_State = model.GetStoveState(model.selectAlchemy);



            DisplayAlchemyMaterials();

            DisplayStove();

            DisplayLuckValue();

            DisplayReikiPoint();

        }



        void DisplayAlchemyMaterials()

@@ -160,9 +162,9 @@
            }

        }



        void DisplayLuckValue()

        void DisplayReikiPoint()

        {

            m_LuckValue.text = PlayerDatas.Instance.extersion.luckValue.ToString();

            m_ReikiPoint.text = reikiRootModel.GetReikiRootTotalPointWithFree().ToString();

        }



        void DisplayViewLength()

@@ -269,9 +271,9 @@


        private void PlayerDataRefreshEvent(PlayerDataType dataType)

        {

            if (dataType == PlayerDataType.LuckValue)

            if (dataType == PlayerDataType.FreePoint)

            {

                DisplayLuckValue();

                DisplayReikiPoint();

            }

        }



@@ -324,8 +326,8 @@
            switch (state)

            {

                case 0:

                    Int2 alchemyPosition;

                    if (model.IsStoveAlcheming(model.selectAlchemyType, out alchemyPosition))

                    int alchemyId;

                    if (model.IsStoveAlcheming(model.selectAlchemyType, out alchemyId))

                    {

                        SysNotifyMgr.Instance.ShowTip("AlchemingError");

                        return;

@@ -336,18 +338,18 @@
                        ItemTipUtility.Show(item.id);

                        return;

                    }

                    var succRate = model.GetAlchemySuccRate(model.selectAlchemy);

                    if (succRate / 100 < 100)

                    {

                        ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("AlchemyLowRateRemind"), (bool isOk) =>

                          {

                              if (isOk)

                              {

                                  SendAlchemyPackage();

                              }

                          });

                        return;

                    }

                    //var succRate = model.GetAlchemySuccRate(model.selectAlchemy);

                    //if (succRate / 100 < 100)

                    //{

                    //    ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("AlchemyLowRateRemind"), (bool isOk) =>

                    //      {

                    //          if (isOk)

                    //          {

                    //              SendAlchemyPackage();

                    //          }

                    //      });

                    //    return;

                    //}

                    break;

                case 1:

                    ConfirmCancel.ShowPopConfirm(Language.Get("Mail101"), Language.Get("StopAlchemyDrugRemind"), (bool isOk) =>

@@ -400,12 +402,18 @@
            }

        }



        private void OnReikiRootPointRefresh()

        {

            DisplayReikiPoint();

        }



        public void Dispose()

        {

            model.selectAlchemyRefresh -= SelectAlchemyRefresh;

            model.alchemyStateRefresh -= AlchemyStateRefresh;

            PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshEvent;

            packModel.refreshItemCountEvent -= RefreshItemCountEvent;

            reikiRootModel.onReikiRootPointRefresh += OnReikiRootPointRefresh;



            StopAllCoroutines();

            animationStep = false;


 System/Alchemy/AlchemyStudyBehaviour.cs

@@ -10,12 +10,13 @@
    {

        [SerializeField] ItemBehaviour m_Item;

        [SerializeField] Text m_StoveCondition;

        [SerializeField] Text m_PropertyCondition;

        [SerializeField] Text m_ReikiPointCondition;

        [SerializeField] Button m_Func;

        [SerializeField] Text m_FuncLabel;



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

        PackModel packModel { get { return ModelCenter.Instance.GetModel<PackModel>(); } }

        ReikiRootModel reikiRootModel { get { return ModelCenter.Instance.GetModel<ReikiRootModel>(); } }



        private void Awake()

        {

@@ -51,13 +52,12 @@
        void DisplayPropertyCondition()

        {

            var config = AlchemyConfig.Get(model.selectAlchemy);

            m_PropertyCondition.gameObject.SetActive(config.LearnNeedLuck > 0);

            m_ReikiPointCondition.gameObject.SetActive(config.LearnNeedLuck > 0);

            if (config.LearnNeedLuck > 0)

            {

                var satisfy = PlayerDatas.Instance.extersion.luckValue >= config.LearnNeedLuck;

                var propertyConfig = PlayerPropertyConfig.Get((int)PropertyType.Luck);

                m_PropertyCondition.text = Language.Get("AlchemyCondition_2", propertyConfig.Name, config.LearnNeedLuck);

                m_PropertyCondition.color = UIHelper.GetUIColor(satisfy ? TextColType.Green : TextColType.Red, true);

                var satisfy = reikiRootModel.GetReikiRootTotalPointWithFree() >= config.LearnNeedLuck;

                m_ReikiPointCondition.text = Language.Get("AlchemyCondition_2", config.LearnNeedLuck);

                m_ReikiPointCondition.color = UIHelper.GetUIColor(satisfy ? TextColType.Green : TextColType.Red, true);

            }

        }




 System/Alchemy/AlchemyUseDrugWin.cs

@@ -14,8 +14,9 @@


    public class AlchemyUseDrugWin : Window

    {

        [SerializeField] AlchemyType m_AlchemyType;

        [SerializeField] ScrollerController m_Controller;

        [SerializeField] AlchemySortBehaviour m_AlchemyTypeSort;

        //[SerializeField] AlchemySortBehaviour m_AlchemyTypeSort;

        [SerializeField] AlchemySortBehaviour m_AlchemyQualitySort;



        List<int> displayItems = new List<int>();

@@ -35,7 +36,7 @@


        protected override void OnPreOpen()

        {

            m_AlchemyTypeSort.Display();

            //m_AlchemyTypeSort.Display();

            m_AlchemyQualitySort.Display();

            

            AlchemySortBehaviour.onSortRefresh += OnSortRefresh;

@@ -92,9 +93,12 @@
            foreach (var id in items)

            {

                var config = AttrFruitConfig.Get(id);

                if (config.drugType != (int)m_AlchemyType)

                {

                    continue;

                }

                var itemConfig = ItemConfig.Get(id);

                if (m_AlchemyTypeSort.IsSortEnabled(config.drugType)

                    && m_AlchemyQualitySort.IsSortEnabled(itemConfig.LV))

                if (m_AlchemyQualitySort.IsSortEnabled(itemConfig.LV))

                {

                    displayItems.Add(id);

                }


 System/KnapSack/Logic/ItemLogicUtility.cs

@@ -586,8 +586,8 @@
                    if (alchemyModel.TryGetAlchemyByStudyMaterial(item.itemId, out alchemyId))

                    {

                        var alchemyConfig = AlchemyConfig.Get(alchemyId);

                        Int2 position;

                        if (alchemyModel.IsStoveAlcheming((AlchemyType)alchemyConfig.AlchemType, out position))

                        int alchemingId;

                        if (alchemyModel.IsStoveAlcheming((AlchemyType)alchemyConfig.AlchemType, out alchemingId))

                        {

                            return false;

                        }


 System/KnapSack/Logic/ItemOperateUtility.cs

@@ -428,8 +428,8 @@
                    if (alchemyModel.TryGetAlchemyByStudyMaterial(useItemModel.itemId, out alchemyId))

                    {

                        var alchemyConfig = AlchemyConfig.Get(alchemyId);

                        Int2 position;

                        if (alchemyModel.IsStoveAlcheming((AlchemyType)alchemyConfig.AlchemType, out position))

                        int alchemingId;

                        if (alchemyModel.IsStoveAlcheming((AlchemyType)alchemyConfig.AlchemType, out alchemingId))

                        {

                            SysNotifyMgr.Instance.ShowTip("AlchemyStudyJumpError_1");

                            return;

@@ -466,7 +466,18 @@
            {
                if (CheckItemUselimit(useItemModel.itemId))
                {
                    WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.MakeDrug);
                    var fruitConfig = AttrFruitConfig.Get(useItemModel.itemId);
                    if (fruitConfig != null)

                    {

                        if (fruitConfig.drugType == (int)AlchemyType.Normal)

                        {

                            WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.UseNormalDrug);
                        }

                        else if (fruitConfig.drugType == (int)AlchemyType.Fairy)

                        {

                            WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.UseFairyDrug);
                        }

                    }
                }
                return;
            }

 System/RolePromote/RolePromoteModel.cs

@@ -432,7 +432,8 @@
                _id == realmModel.levelUpRedpoint.id ||

                _id == equipGemModel.redpoint.id ||

                _id == reikiRootModel.redpoint.id ||

                _id == alchemyModel.alchemyDrugREdpoint3.id)

                _id == alchemyModel.alchemyDrugRedpoint3.id ||

                _id == alchemyModel.alchemyDrugRedpoint4.id)

            {

                CheckPromoteDetailEffect();

            }

@@ -468,7 +469,8 @@
                case PromoteDetailType.FairyHeart:

                    return ModelCenter.Instance.GetModel<PlayerMethodData>().fairyHeartRedpoint.state == RedPointState.Simple;

                case PromoteDetailType.BlastFurnace:

                    return alchemyModel.alchemyDrugREdpoint3.state == RedPointState.Simple;

                    return alchemyModel.alchemyDrugRedpoint3.state == RedPointState.Simple

                        || alchemyModel.alchemyDrugRedpoint4.state == RedPointState.Simple;

                case PromoteDetailType.max:

                    break;

            }


 System/Tip/PromoteDetailsWin.cs

@@ -31,6 +31,8 @@
            get { return ModelCenter.Instance.GetModel<TreasureModel>(); }

        }



        AlchemyModel alchemyModel { get { return ModelCenter.Instance.GetModel<AlchemyModel>(); } }



        #region Built-in

        protected override void BindController()

        {

@@ -110,7 +112,14 @@
                    WindowCenter.Instance.Open<EquipFrameWin>(false, 1);

                    break;

                case RolePromoteModel.PromoteDetailType.BlastFurnace:

                    WindowCenter.Instance.Open<AlchemyBaseWin>(false, 2);

                    if (alchemyModel.alchemyDrugRedpoint3.state == RedPointState.Simple)

                    {

                        WindowCenter.Instance.Open<AlchemyBaseWin>(false, 2);

                    }

                    else if (alchemyModel.alchemyDrugRedpoint4.state == RedPointState.Simple)

                    {

                        WindowCenter.Instance.Open<AlchemyBaseWin>(false, 3);

                    }

                    break;

            }

            CloseClick();


 System/WindowJump/WindowJumpMgr.cs

@@ -502,11 +502,8 @@
                        break;

                }

                break;

            case JumpUIType.MakeDrug:

                if (ItemOperateUtility.Instance.useItemModel != null)

                {

                    //RoleElixirTipWin.makeUseId = ItemOperateUtility.Instance.useItemModel.itemId;

                }

            case JumpUIType.UseNormalDrug:

            case JumpUIType.UseFairyDrug:

                SetJumpLogic<AlchemyBaseWin>(_tagWinSearchModel.TABID);

                break;

            case JumpUIType.SevenDaysTour281:

@@ -1505,7 +1502,7 @@
    UnionChat2 = 135, //仙盟频道

    TicketCompose1 = 136, //冰晶矿脉门票合成

    TicketCompose2 = 137, //古神禁地

    MakeDrug = 138, //丹药使用

    UseNormalDrug = 138, //丹药使用

    XianBaguaIntr = 139, //仙族法宝八卦炉介绍界面

    UnionTask2 = 140, //仙盟任务界面回到主界面

    OpenServerActivityFunc2_1 = 141, //活动发红包（精彩活动）

@@ -1687,6 +1684,7 @@
    AlchemyNormal = 320,

    AlchemyFairy = 321,

    RolePromote = 322,

    UseFairyDrug = 323,



    DhszTs = 1001,//定海神针功法提升界面

    HyqTs = 1002,//皓月枪功法提升界面