Merge branch 'master' of http://192.168.0.87:10010/r/snxxz_scripts

client_Hale

2019-04-18 9bc43b44cb607c380fa861313f78aac16692a3a7

Merge branch 'master' of http://192.168.0.87:10010/r/snxxz_scripts

 Core/GameEngine/DataToCtl/PackageRegedit.cs

@@ -25,6 +25,7 @@
    public static void Init()

    {

        // 登记相应的数据体及对应的数据转逻辑类

        Register(typeof(HA325_tagMCNPCAttackCountInfo), typeof(DTCA325_tagMCNPCAttackCountInfo));

        Register(typeof(HB215_tagMCFBBuyBuffInfo), typeof(DTCB215_tagMCFBBuyBuffInfo));

        Register(typeof(HA718_tagMCCollectAwardItemInfo), typeof(DTCA718_tagMCCollectAwardItemInfo));

        Register(typeof(HB214_tagMCCuntomFBPrizeInfo), typeof(DTCB214_tagMCCuntomFBPrizeInfo));


 Core/GameEngine/Model/Config/AlchemyConfig.cs

@@ -1,234 +1,235 @@
//--------------------------------------------------------

//    [Author]:           Fish

//    [  Date ]:           Thursday, February 14, 2019

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



using System.Collections.Generic;

using System.IO;

using System.Threading;

using System;

using UnityEngine;



[XLua.LuaCallCSharp]

public partial class AlchemyConfig

{



    public readonly int AlchemyID;

//--------------------------------------------------------
//    [Author]:           Fish
//    [  Date ]:           Wednesday, April 17, 2019
//--------------------------------------------------------

using System.Collections.Generic;
using System.IO;
using System.Threading;
using System;
using UnityEngine;

[XLua.LuaCallCSharp]
public partial class AlchemyConfig
{

    public readonly int ID;

    public readonly string AlchemName;

    public readonly int AlchemItemID;

    public readonly int AlchemType;

    public readonly int AlchemyQuality;

    public readonly string MaterialAll;

    public readonly int AlchemyEXP;

    public readonly string AlchemyItem;

    public readonly int[] SpecialItem;

    public readonly string AlchemyIUp;

    public readonly string AlchemPreviewItem;

    public readonly int BlastFurnaceLV;

    public readonly string ICONID;



    public AlchemyConfig()

    {

    }



    public AlchemyConfig(string input)

    {

        try

        {

            var tables = input.Split('\t');



            int.TryParse(tables[0],out AlchemyID); 
    public readonly int LearnNeedItemID;

    public readonly int LearnNeedAlchemLV;

    public readonly int LearnNeedLuck;

    public readonly int NeedTime;

    public readonly int AlchemyExp;

    public readonly string Material;

    public readonly int drugPromoteType;

    public readonly string description;

    public AlchemyConfig()
    {
    }

    public AlchemyConfig(string input)
    {
        try
        {
            var tables = input.Split('\t');

            int.TryParse(tables[0],out ID); 


            AlchemName = tables[1];



            int.TryParse(tables[2],out AlchemyQuality); 
            int.TryParse(tables[2],out AlchemItemID); 


            MaterialAll = tables[3];

            int.TryParse(tables[3],out AlchemType); 


            int.TryParse(tables[4],out AlchemyEXP); 
            int.TryParse(tables[4],out AlchemyQuality); 


            AlchemyItem = tables[5];

            int.TryParse(tables[5],out LearnNeedItemID); 


            string[] SpecialItemStringArray = tables[6].Trim().Split(StringUtility.splitSeparator,StringSplitOptions.RemoveEmptyEntries);
            SpecialItem = new int[SpecialItemStringArray.Length];
            for (int i=0;i<SpecialItemStringArray.Length;i++)
            {
                 int.TryParse(SpecialItemStringArray[i],out SpecialItem[i]);
            }

            int.TryParse(tables[6],out LearnNeedAlchemLV); 


            AlchemyIUp = tables[7];

            int.TryParse(tables[7],out LearnNeedLuck); 


            AlchemPreviewItem = tables[8];

            int.TryParse(tables[8],out NeedTime); 


            int.TryParse(tables[9],out BlastFurnaceLV); 
            int.TryParse(tables[9],out AlchemyExp); 


            ICONID = tables[10];

        }

        catch (Exception ex)

        {

            DebugEx.Log(ex);

        }

    }

            Material = tables[10];



    static Dictionary<string, AlchemyConfig> configs = new Dictionary<string, AlchemyConfig>();

    public static AlchemyConfig Get(string id)

    {   
        if (!inited)

        {

            Debug.Log("AlchemyConfig 还未完成初始化。");

            return null;

        }

		
        if (configs.ContainsKey(id))

        {

            return configs[id];

        }

            int.TryParse(tables[11],out drugPromoteType); 


        AlchemyConfig config = null;

        if (rawDatas.ContainsKey(id))

        {

            config = configs[id] = new AlchemyConfig(rawDatas[id]);

            rawDatas.Remove(id);

        }



        return config;

    }



    public static AlchemyConfig Get(int id)

    {

        return Get(id.ToString());

    }



    public static List<string> GetKeys()

    {

        var keys = new List<string>();

        keys.AddRange(configs.Keys);

        keys.AddRange(rawDatas.Keys);

        return keys;

    }



    public static List<AlchemyConfig> GetValues()

    {

        var values = new List<AlchemyConfig>();

        values.AddRange(configs.Values);



        var keys = new List<string>(rawDatas.Keys);

        foreach (var key in keys)

        {

            values.Add(Get(key));

        }



        return values;

    }



    public static bool Has(string id)

    {

        return configs.ContainsKey(id) || rawDatas.ContainsKey(id);

    }



    public static bool Has(int id)

    {

        return Has(id.ToString());

    }



    public static bool inited { get; private set; }

    protected static Dictionary<string, string> rawDatas = new Dictionary<string, string>();

    public static void Init(bool sync=false)

    {

        inited = false;

        var path = string.Empty;

        if (AssetSource.refdataFromEditor)

        {

            path = ResourcesPath.CONFIG_FODLER +"/Alchemy.txt";

        }

        else

        {

            path = AssetVersionUtility.GetAssetFilePath("config/Alchemy.txt");

        }



        var tempConfig = new AlchemyConfig();

        var preParse = tempConfig is IConfigPostProcess;



        if (sync)

        {

            var lines = File.ReadAllLines(path);

            if (!preParse)

            {

                rawDatas = new Dictionary<string, string>(lines.Length - 3);

            }

            for (int i = 3; i < lines.Length; i++)

            {

                try 
                {

                    var line = lines[i];

                    var index = line.IndexOf("\t");

                    if (index == -1)

                    {

                        continue;

                    }

                    var id = line.Substring(0, index);



                    if (preParse)

                    {

                        var config = new AlchemyConfig(line);

                        configs[id] = config;

                        (config as IConfigPostProcess).OnConfigParseCompleted();

                    }

                    else

                    {

                        rawDatas[id] = line;

                    }

                }

                catch (System.Exception ex)

                {

                    Debug.LogError(ex);

                }

            }

            inited = true;

        }

        else

        {

            ThreadPool.QueueUserWorkItem((object _object) =>

            {

                var lines = File.ReadAllLines(path);

                if (!preParse)

                {

                    rawDatas = new Dictionary<string, string>(lines.Length - 3);

                }

                for (int i = 3; i < lines.Length; i++)

                {

                    try 
                    {

                       var line = lines[i];

                        var index = line.IndexOf("\t");

                        if (index == -1)

                        {

                            continue;

                        }

                        var id = line.Substring(0, index);



                        if (preParse)

                        {

                            var config = new AlchemyConfig(line);

                            configs[id] = config;

                            (config as IConfigPostProcess).OnConfigParseCompleted();

                        }

                        else

                        {

                            rawDatas[id] = line;

                        }

                    }

                    catch (System.Exception ex)

                    {

                        Debug.LogError(ex);

                    }

                }



                inited = true;

            });

        }

    }



}









            description = tables[12];
        }
        catch (Exception ex)
        {
            DebugEx.Log(ex);
        }
    }

    static Dictionary<string, AlchemyConfig> configs = new Dictionary<string, AlchemyConfig>();
    public static AlchemyConfig Get(string id)
    {   
        if (!inited)
        {
            Debug.Log("AlchemyConfig 还未完成初始化。");
            return null;
        }
		
        if (configs.ContainsKey(id))
        {
            return configs[id];
        }

        AlchemyConfig config = null;
        if (rawDatas.ContainsKey(id))
        {
            config = configs[id] = new AlchemyConfig(rawDatas[id]);
            rawDatas.Remove(id);
        }

        return config;
    }

    public static AlchemyConfig Get(int id)
    {
        return Get(id.ToString());
    }

    public static List<string> GetKeys()
    {
        var keys = new List<string>();
        keys.AddRange(configs.Keys);
        keys.AddRange(rawDatas.Keys);
        return keys;
    }

    public static List<AlchemyConfig> GetValues()
    {
        var values = new List<AlchemyConfig>();
        values.AddRange(configs.Values);

        var keys = new List<string>(rawDatas.Keys);
        foreach (var key in keys)
        {
            values.Add(Get(key));
        }

        return values;
    }

    public static bool Has(string id)
    {
        return configs.ContainsKey(id) || rawDatas.ContainsKey(id);
    }

    public static bool Has(int id)
    {
        return Has(id.ToString());
    }

    public static bool inited { get; private set; }
    protected static Dictionary<string, string> rawDatas = new Dictionary<string, string>();
    public static void Init(bool sync=false)
    {
        inited = false;
        var path = string.Empty;
        if (AssetSource.refdataFromEditor)
        {
            path = ResourcesPath.CONFIG_FODLER +"/Alchemy.txt";
        }
        else
        {
            path = AssetVersionUtility.GetAssetFilePath("config/Alchemy.txt");
        }

        var tempConfig = new AlchemyConfig();
        var preParse = tempConfig is IConfigPostProcess;

        if (sync)
        {
            var lines = File.ReadAllLines(path);
            if (!preParse)
            {
                rawDatas = new Dictionary<string, string>(lines.Length - 3);
            }
            for (int i = 3; i < lines.Length; i++)
            {
                try 
                {
                    var line = lines[i];
                    var index = line.IndexOf("\t");
                    if (index == -1)
                    {
                        continue;
                    }
                    var id = line.Substring(0, index);

                    if (preParse)
                    {
                        var config = new AlchemyConfig(line);
                        configs[id] = config;
                        (config as IConfigPostProcess).OnConfigParseCompleted();
                    }
                    else
                    {
                        rawDatas[id] = line;
                    }
                }
                catch (System.Exception ex)
                {
                    Debug.LogError(ex);
                }
            }
            inited = true;
        }
        else
        {
            ThreadPool.QueueUserWorkItem((object _object) =>
            {
                var lines = File.ReadAllLines(path);
                if (!preParse)
                {
                    rawDatas = new Dictionary<string, string>(lines.Length - 3);
                }
                for (int i = 3; i < lines.Length; i++)
                {
                    try 
                    {
                       var line = lines[i];
                        var index = line.IndexOf("\t");
                        if (index == -1)
                        {
                            continue;
                        }
                        var id = line.Substring(0, index);

                        if (preParse)
                        {
                            var config = new AlchemyConfig(line);
                            configs[id] = config;
                            (config as IConfigPostProcess).OnConfigParseCompleted();
                        }
                        else
                        {
                            rawDatas[id] = line;
                        }
                    }
                    catch (System.Exception ex)
                    {
                        Debug.LogError(ex);
                    }
                }

                inited = true;
            });
        }
    }

}





 Core/GameEngine/Model/Config/AlchemyConfig.cs.meta

@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: 93a73d5a5e9d51c4abc2515a6180cac4
timeCreated: 1550121897
timeCreated: 1555494121
licenseType: Pro
MonoImporter:
  serializedVersion: 2

 Core/GameEngine/Model/Config/AlchemyCountConfig.cs

File was renamed from Core/GameEngine/Model/Config/EquipSuitCompoundConfig.cs
@@ -1,6 +1,6 @@
//--------------------------------------------------------
//    [Author]:           Fish
//    [  Date ]:           Thursday, February 14, 2019
//    [  Date ]:           Wednesday, April 17, 2019
//--------------------------------------------------------

using System.Collections.Generic;
@@ -10,50 +10,28 @@
using UnityEngine;

[XLua.LuaCallCSharp]
public partial class EquipSuitCompoundConfig
public partial class AlchemyCountConfig
{

    public readonly int ID;
    public readonly int SuiteType;
    public readonly int EquipPlace;
    public readonly int SuiteLV;
    public readonly int Job;
    public readonly int[] CostItemID;
    public readonly int[] CostItemCnt;
    public readonly int AlchemyQuality;

    public readonly int LuckValue;

    public readonly string CntRateList;

    public EquipSuitCompoundConfig()
    public AlchemyCountConfig()
    {
    }

    public EquipSuitCompoundConfig(string input)
    public AlchemyCountConfig(string input)
    {
        try
        {
            var tables = input.Split('\t');

            int.TryParse(tables[0],out ID); 

            int.TryParse(tables[1],out SuiteType); 

            int.TryParse(tables[2],out EquipPlace); 

            int.TryParse(tables[3],out SuiteLV); 

            int.TryParse(tables[4],out Job); 

            string[] CostItemIDStringArray = tables[5].Trim().Split(StringUtility.splitSeparator,StringSplitOptions.RemoveEmptyEntries);
            CostItemID = new int[CostItemIDStringArray.Length];
            for (int i=0;i<CostItemIDStringArray.Length;i++)
            {
                 int.TryParse(CostItemIDStringArray[i],out CostItemID[i]);
            }

            string[] CostItemCntStringArray = tables[6].Trim().Split(StringUtility.splitSeparator,StringSplitOptions.RemoveEmptyEntries);
            CostItemCnt = new int[CostItemCntStringArray.Length];
            for (int i=0;i<CostItemCntStringArray.Length;i++)
            {
                 int.TryParse(CostItemCntStringArray[i],out CostItemCnt[i]);
            }
            int.TryParse(tables[0],out AlchemyQuality); 


            int.TryParse(tables[1],out LuckValue); 


            CntRateList = tables[2];
        }
        catch (Exception ex)
        {
@@ -61,12 +39,12 @@
        }
    }

    static Dictionary<string, EquipSuitCompoundConfig> configs = new Dictionary<string, EquipSuitCompoundConfig>();
    public static EquipSuitCompoundConfig Get(string id)
    static Dictionary<string, AlchemyCountConfig> configs = new Dictionary<string, AlchemyCountConfig>();
    public static AlchemyCountConfig Get(string id)
    {   
        if (!inited)
        {
            Debug.Log("EquipSuitCompoundConfig 还未完成初始化。");
            Debug.Log("AlchemyCountConfig 还未完成初始化。");
            return null;
        }
        
@@ -75,17 +53,17 @@
            return configs[id];
        }

        EquipSuitCompoundConfig config = null;
        AlchemyCountConfig config = null;
        if (rawDatas.ContainsKey(id))
        {
            config = configs[id] = new EquipSuitCompoundConfig(rawDatas[id]);
            config = configs[id] = new AlchemyCountConfig(rawDatas[id]);
            rawDatas.Remove(id);
        }

        return config;
    }

    public static EquipSuitCompoundConfig Get(int id)
    public static AlchemyCountConfig Get(int id)
    {
        return Get(id.ToString());
    }
@@ -98,9 +76,9 @@
        return keys;
    }

    public static List<EquipSuitCompoundConfig> GetValues()
    public static List<AlchemyCountConfig> GetValues()
    {
        var values = new List<EquipSuitCompoundConfig>();
        var values = new List<AlchemyCountConfig>();
        values.AddRange(configs.Values);

        var keys = new List<string>(rawDatas.Keys);
@@ -130,14 +108,14 @@
        var path = string.Empty;
        if (AssetSource.refdataFromEditor)
        {
            path = ResourcesPath.CONFIG_FODLER +"/EquipSuitCompound.txt";
            path = ResourcesPath.CONFIG_FODLER +"/AlchemyCount.txt";
        }
        else
        {
            path = AssetVersionUtility.GetAssetFilePath("config/EquipSuitCompound.txt");
            path = AssetVersionUtility.GetAssetFilePath("config/AlchemyCount.txt");
        }

        var tempConfig = new EquipSuitCompoundConfig();
        var tempConfig = new AlchemyCountConfig();
        var preParse = tempConfig is IConfigPostProcess;

        if (sync)
@@ -161,7 +139,7 @@

                    if (preParse)
                    {
                        var config = new EquipSuitCompoundConfig(line);
                        var config = new AlchemyCountConfig(line);
                        configs[id] = config;
                        (config as IConfigPostProcess).OnConfigParseCompleted();
                    }
@@ -200,7 +178,7 @@

                        if (preParse)
                        {
                            var config = new EquipSuitCompoundConfig(line);
                            var config = new AlchemyCountConfig(line);
                            configs[id] = config;
                            (config as IConfigPostProcess).OnConfigParseCompleted();
                        }

 Core/GameEngine/Model/Config/AlchemyCountConfig.cs.meta

copy from Lua/Gen/AlchemyConfigWrap.cs.meta
copy to Core/GameEngine/Model/Config/AlchemyCountConfig.cs.meta
File was copied from Lua/Gen/AlchemyConfigWrap.cs.meta
@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: 6505f3167ec49824a860a7a3491fb187
timeCreated: 1550122890
guid: 5f36f1c0496212c43ab7871e4d3d42dd
timeCreated: 1555489466
licenseType: Pro
MonoImporter:
  serializedVersion: 2

 Core/GameEngine/Model/Config/EquipSuitCompoundConfig.cs.meta

File was deleted

 Core/GameEngine/Model/Config/MapEventPointConfig.cs

@@ -1,6 +1,6 @@
//--------------------------------------------------------
//    [Author]:           Fish
//    [  Date ]:           Thursday, February 14, 2019
//    [  Date ]:           Wednesday, April 17, 2019
//--------------------------------------------------------

using System.Collections.Generic;
@@ -19,6 +19,7 @@
    public readonly int IsShowInfo;
    public readonly int ShowInMipMap;
    public readonly int Colour;
    public readonly string NpcDescription;
    public readonly int LowLV;
    public readonly int HighestLV;
    public readonly int Defense;
@@ -48,17 +49,19 @@

            int.TryParse(tables[5],out Colour); 

            int.TryParse(tables[6],out LowLV); 
            NpcDescription = tables[6];

            int.TryParse(tables[7],out HighestLV); 
            int.TryParse(tables[7],out LowLV); 

            int.TryParse(tables[8],out Defense); 
            int.TryParse(tables[8],out HighestLV); 

            Drop1 = tables[9];
            int.TryParse(tables[9],out Defense); 

            Drop2 = tables[10];
            Drop1 = tables[10];

            EXP = tables[11];
            Drop2 = tables[11];

            EXP = tables[12];
        }
        catch (Exception ex)
        {

 Core/GameEngine/Model/Config/MapEventPointConfig.cs.meta

@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: c1d2ccde5bec1a54ab028c9dbaf5486d
timeCreated: 1550121464
timeCreated: 1555487423
licenseType: Pro
MonoImporter:
  serializedVersion: 2

 Core/GameEngine/Model/TelPartialConfig/tagAlchemyConfig.cs

@@ -3,29 +3,42 @@


public partial class AlchemyConfig : IConfigPostProcess

{

    private static Dictionary<int, List<AlchemyConfig>> s_alchemyModelDict = new Dictionary<int, List<AlchemyConfig>>();//用于记录商城数据

    private int type = 0;

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



    public void OnConfigParseCompleted()

    {

        type = (int)Math.Floor((double)AlchemyID / 100);

        if (!s_alchemyModelDict.ContainsKey(type))

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

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

        {

            List<AlchemyConfig> modellist = new List<AlchemyConfig>();

            modellist.Add(this);

            s_alchemyModelDict.Add(type, modellist);

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

            m_Alchemies.Add(AlchemType, dict);

        }

        else

        List<int> ids = null;

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

        {

            s_alchemyModelDict[type].Add(this);

            ids = new List<int>();

            dict.Add(AlchemyQuality, ids);

        }

        ids.Add(ID);

    }



    public static List<AlchemyConfig> GetTypeAlchemyModel(int type)

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

    {

        List<AlchemyConfig> modellist = null;

        s_alchemyModelDict.TryGetValue(type, out modellist);

        return modellist;

        if (m_Alchemies.ContainsKey(type)

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

        {

            return m_Alchemies[type][quality];

        }

        return null;

    }



    public static ICollection<int> GetAlchemyQualities(int type)

    {

        if (m_Alchemies.ContainsKey(type))

        {

            return m_Alchemies[type].Keys;

        }

        return null;

    }

}




 Core/GameEngine/Model/TelPartialConfig/tagEquipSuitCompoundConfig.cs

File was deleted

 Core/GameEngine/Model/TelPartialConfig/tagEquipSuitCompoundConfig.cs.meta

File was deleted

 Core/NetworkPackage/ClientPack/ClientToMapServer/CA5_Function/CA576_tagCMPlayerRefine.cs

@@ -4,8 +4,8 @@
// A5 76 玩家炼丹 #tagCMPlayerRefine





public class CA576_tagCMPlayerRefine : GameNetPackBasic {


    public ushort RefineNum;    // 配方编号

    public uint UseRateItem;    // 附加材料ID

    public uint AlchemyID;    // 丹药ID

    public byte DoType;    // 0-学习 1-开始炼丹 2-停止炼丹 3-开炉取丹




    public CA576_tagCMPlayerRefine () {


        combineCmd = (ushort)0x03FE;


@@ -13,8 +13,8 @@
    }





    public override void WriteToBytes () {


        WriteBytes (RefineNum, NetDataType.WORD);

        WriteBytes (UseRateItem, NetDataType.DWORD);

        WriteBytes (AlchemyID, NetDataType.DWORD);

        WriteBytes (DoType, NetDataType.BYTE);

    }





}



 Core/NetworkPackage/DTCFile/ServerPack/HA3_Function/DTCA325_tagMCNPCAttackCountInfo.cs

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

//    [Author]:           第二世界

//    [  Date ]:           Wednesday, April 17, 2019

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



using System;

using System.Collections;

using System.Collections.Generic;

using Snxxz.UI;

public class DTCA325_tagMCNPCAttackCountInfo : DtcBasic

{



    public override void Done(GameNetPackBasic vNetPack)

    {

        base.Done(vNetPack);

        var package = vNetPack as HA325_tagMCNPCAttackCountInfo;

        ModelCenter.Instance.GetModel<DungeonModel>().UpdateDungeonAttackNpcInfo(package);

    }



}










 Core/NetworkPackage/DTCFile/ServerPack/HA3_Function/DTCA325_tagMCNPCAttackCountInfo.cs.meta

copy from Lua/Gen/AlchemyConfigWrap.cs.meta
copy to Core/NetworkPackage/DTCFile/ServerPack/HA3_Function/DTCA325_tagMCNPCAttackCountInfo.cs.meta
File was copied from Lua/Gen/AlchemyConfigWrap.cs.meta
@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: 6505f3167ec49824a860a7a3491fb187
timeCreated: 1550122890
guid: 99d0cc78beb3e9d45910bade3ca6f795
timeCreated: 1555490346
licenseType: Pro
MonoImporter:
  serializedVersion: 2

 Core/NetworkPackage/DTCFile/ServerPack/HA3_Function/DTCA326_tagMCNPCIDCollectionCntInfo.cs

@@ -35,8 +35,9 @@
                smallBoxCollectCount += collect.CollectionCnt;
            }

            ModelCenter.Instance.GetModel<DungeonModel>().UpdateDungeonCollectNpcInfo((int)collect.NPCID, collect.CollectionCnt);
        }
        }



        ModelCenter.Instance.GetModel<DungeonModel>().UpdateDungeonCollectNpcInfo(package);

        model.bigBoxCollectCount = bigBoxCollectCount;
        model.smallBoxCollectCount = smallBoxCollectCount;

 Core/NetworkPackage/DTCFile/ServerPack/HA3_Function/DTCA3BF_tagMCPlayerStoveMsg.cs

@@ -1,30 +1,23 @@
using UnityEngine;
using System.Collections;
using Snxxz.UI;

// A3 BF 通知客户端炼丹炉信息 #tagMCPlayerStoveMsg



public class DTCA3BF_tagMCPlayerStoveMsg : DtcBasic {

    BlastFurnaceModel _furnaceModel;
    BlastFurnaceModel FurnaceModel
    {
        get
        {
            return _furnaceModel ?? (_furnaceModel = ModelCenter.Instance.GetModel<BlastFurnaceModel>());
        }
    }

    public override void Done(GameNetPackBasic vNetPack) {

        base.Done(vNetPack);

        HA3BF_tagMCPlayerStoveMsg vNetData = vNetPack as HA3BF_tagMCPlayerStoveMsg;
        FurnaceModel.RefreshBlastFurnaceModel(vNetData);

    }

}

using UnityEngine;

using System.Collections;

using Snxxz.UI;



// A3 BF 通知客户端炼丹炉信息 #tagMCPlayerStoveMsg







public class DTCA3BF_tagMCPlayerStoveMsg : DtcBasic

{



    public override void Done(GameNetPackBasic vNetPack)

    {



        base.Done(vNetPack);



        var package = vNetPack as HA3BF_tagMCPlayerStoveMsg;



        ModelCenter.Instance.GetModel<AlchemyModel>().ReceivePackage(package);

    }



}




 Core/NetworkPackage/DTCFile/ServerPack/HAD_SaleActivity.meta

File was deleted

 Core/NetworkPackage/DTCFile/ServerPack/HAE_Truck.meta

File was deleted

 Core/NetworkPackage/DTCFile/ServerPack/HAF_Merge.meta

File was deleted

 Core/NetworkPackage/DTCFile/ServerPack/HB0_Event.meta

File was deleted

 Core/NetworkPackage/ServerPack/HA3_Function/HA325_tagMCNPCAttackCountInfo.cs

New file
@@ -0,0 +1,29 @@
using UnityEngine;

using System.Collections;



// A3 25 NPC已攻击次数信息 #tagMCNPCAttackCountInfo



public class HA325_tagMCNPCAttackCountInfo : GameNetPackBasic {

    public byte Count;

    public  tagMCNPCAttackCount[] NPCAttackCountList;



    public HA325_tagMCNPCAttackCountInfo () {

        _cmd = (ushort)0xA325;

    }



    public override void ReadFromBytes (byte[] vBytes) {

        TransBytes (out Count, vBytes, NetDataType.BYTE);

        NPCAttackCountList = new tagMCNPCAttackCount[Count];

        for (int i = 0; i < Count; i ++) {

            NPCAttackCountList[i] = new tagMCNPCAttackCount();

            TransBytes (out NPCAttackCountList[i].NPCID, vBytes, NetDataType.DWORD);

            TransBytes (out NPCAttackCountList[i].AttackCount, vBytes, NetDataType.BYTE);

        }

    }



    public struct tagMCNPCAttackCount {

        public uint NPCID;

        public byte AttackCount;        //已攻击次数

    }



}


 Core/NetworkPackage/ServerPack/HA3_Function/HA325_tagMCNPCAttackCountInfo.cs.meta

copy from Lua/Gen/AlchemyConfigWrap.cs.meta
copy to Core/NetworkPackage/ServerPack/HA3_Function/HA325_tagMCNPCAttackCountInfo.cs.meta
File was copied from Lua/Gen/AlchemyConfigWrap.cs.meta
@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: 6505f3167ec49824a860a7a3491fb187
timeCreated: 1550122890
guid: 11bfbdd59c80c48408204371a3c8b60d
timeCreated: 1555490312
licenseType: Pro
MonoImporter:
  serializedVersion: 2

 Core/NetworkPackage/ServerPack/HA3_Function/HA3BF_tagMCPlayerStoveMsg.cs

@@ -1,39 +1,37 @@
using UnityEngine;
using System.Collections;

// A3 BF 通知客户端炼丹炉信息 #tagMCPlayerStoveMsg



public class HA3BF_tagMCPlayerStoveMsg : GameNetPackBasic {

    public byte StoveLV;    // 炼丹炉等级

    public uint StoveExp;    // 炼丹炉经验 

    public uint ItemID;    // 合成物品id



    public HA3BF_tagMCPlayerStoveMsg () {

        _cmd = (ushort)0xA3BF;

    }



    public override void ReadFromBytes (byte[] vBytes) {

        TransBytes (out StoveLV, vBytes, NetDataType.BYTE);

        TransBytes (out StoveExp, vBytes, NetDataType.DWORD);

        TransBytes (out ItemID, vBytes, NetDataType.DWORD);

    }



}

using UnityEngine;

using System.Collections;



// A3 BF 通知客户端炼丹炉信息 #tagMCPlayerStoveMsg



public class HA3BF_tagMCPlayerStoveMsg : GameNetPackBasic {

    public byte StoveLV;    // 炼丹炉等级

    public uint StoveExp;    // 炼丹炉经验

    public uint ItemID;    // 合成物品id

    public byte ItemCnt;    // 丹药数量

    public ushort StoveCnt;    // 丹药数量

    public  tagMCPlayerStoveInfo[] InfoList;



    public HA3BF_tagMCPlayerStoveMsg () {

        _cmd = (ushort)0xA3BF;

    }



    public override void ReadFromBytes (byte[] vBytes) {

        TransBytes (out StoveLV, vBytes, NetDataType.BYTE);

        TransBytes (out StoveExp, vBytes, NetDataType.DWORD);

        TransBytes (out ItemID, vBytes, NetDataType.DWORD);

        TransBytes (out ItemCnt, vBytes, NetDataType.BYTE);

        TransBytes (out StoveCnt, vBytes, NetDataType.WORD);

        InfoList = new tagMCPlayerStoveInfo[StoveCnt];

        for (int i = 0; i < StoveCnt; i ++) {

            InfoList[i] = new tagMCPlayerStoveInfo();

            TransBytes (out InfoList[i].AlchemyID, vBytes, NetDataType.DWORD);

            TransBytes (out InfoList[i].StartTime, vBytes, NetDataType.DWORD);

        }

    }



    public struct tagMCPlayerStoveInfo {

        public uint AlchemyID;        // 丹 ID

        public uint StartTime;        // 开始炼的时间 
    }



}


 Core/NetworkPackage/ServerPack/HAD_SaleActivity.meta

File was deleted

 Core/NetworkPackage/ServerPack/HAE_Truck.meta

File was deleted

 Core/NetworkPackage/ServerPack/HB0_Event.meta

File was deleted

 Lua/Gen/AlchemyConfigWrap.cs

File was deleted

 Lua/Gen/EquipSuitCompoundConfigWrap.cs

File was deleted

 Lua/Gen/EquipSuitCompoundConfigWrap.cs.meta

File was deleted

 Lua/Gen/XLuaGenAutoRegister.cs

@@ -49,9 +49,6 @@
            translator.DelayWrapLoader(typeof(ActorShowConfig), ActorShowConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(AlchemyConfig), AlchemyConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(AlchemySpecConfig), AlchemySpecConfigWrap.__Register);
        
        
@@ -232,12 +229,7 @@
        
            translator.DelayWrapLoader(typeof(EquipSuitAttrConfig), EquipSuitAttrConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(EquipSuitCompoundConfig), EquipSuitCompoundConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(EquipSuitConfig), EquipSuitConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(EquipSuitNameConfig), EquipSuitNameConfigWrap.__Register);
        

 System/Alchemy.meta

File was renamed from Core/NetworkPackage/ServerPack/HAF_Merge.meta
@@ -1,7 +1,7 @@
fileFormatVersion: 2
guid: fa14960fa44b0d1439bab471a764e34f
guid: 60b865c8d6df5cf41902dae9d6ea38b6
folderAsset: yes
timeCreated: 1547643019
timeCreated: 1555052736
licenseType: Pro
DefaultImporter:
  userData: 

 System/Alchemy/AlchemyBaseWin.cs

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

//    [Author]:           第二世界

//    [  Date ]:           Thursday, April 18, 2019

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



using System;

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using UnityEngine.UI;



namespace Snxxz.UI {



    public class AlchemyBaseWin : Window

    {

        [SerializeField] FunctionButtonGroup m_FuncGroup;

        [SerializeField] FunctionButton m_AlchemyNormal;

        [SerializeField] FunctionButton m_AlchemyFairy;

        [SerializeField] Button m_Close;

        [SerializeField] Button m_Left;

        [SerializeField] Button m_Right;



        #region Built-in

        protected override void BindController()

        {

        }



        protected override void AddListeners()

        {

            m_AlchemyNormal.AddListener(ShowAlchemyNormal);
            m_AlchemyFairy.AddListener(ShowAlchemyFairy);
            m_Left.AddListener(()=> 
            {

                m_FuncGroup.TriggerLast();

            });
            m_Right.AddListener(()=> 
            {

                m_FuncGroup.TriggerNext();

            });
            m_Close.AddListener(CloseClick);

        }



        protected override void OnPreOpen()

        {

        }



        protected override void OnActived()

        {

            base.OnActived();

            m_FuncGroup.TriggerByOrder(functionOrder);

        }



        protected override void OnAfterOpen()

        {

        }



        protected override void OnPreClose()

        {

            CloseSubWindows();
            if (!WindowJumpMgr.Instance.IsJumpState)
            {
                WindowCenter.Instance.Open<MainInterfaceWin>();
            }

        }



        protected override void OnAfterClose()

        {

        }

        #endregion



        private void ShowAlchemyFairy()

        {

            CloseSubWindows();

            WindowCenter.Instance.Open<AlchemyFairyDrugWin>();

            functionOrder = m_AlchemyFairy.order;

        }



        private void ShowAlchemyNormal()

        {

            CloseSubWindows();

            WindowCenter.Instance.Open<AlchemyBasicDrugWin>();

            functionOrder = m_AlchemyNormal.order;

        }



        private void CloseSubWindows()

        {

            var children = WindowConfig.Get().FindChildWindows("AlchemyBaseWin");
            foreach (var window in children)
            {
                WindowCenter.Instance.Close(window);
            }

        }



    }



}










 System/Alchemy/AlchemyBaseWin.cs.meta

copy from Lua/Gen/AlchemyConfigWrap.cs.meta
copy to System/Alchemy/AlchemyBaseWin.cs.meta
File was copied from Lua/Gen/AlchemyConfigWrap.cs.meta
@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: 6505f3167ec49824a860a7a3491fb187
timeCreated: 1550122890
guid: 0b437d3b0173d5845add5741ae809f44
timeCreated: 1555556613
licenseType: Pro
MonoImporter:
  serializedVersion: 2

 System/Alchemy/AlchemyBasicDrugWin.cs

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

//    [Author]:           第二世界

//    [  Date ]:           Wednesday, April 17, 2019

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



using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using UnityEngine;

using UnityEngine.UI;



namespace Snxxz.UI

{



    public class AlchemyBasicDrugWin : Window

    {

        [SerializeField] AlchemyScrollBehaviour m_AlchemyScroll;

        [SerializeField] AlchemyDrugBriefBehaviour m_AlchemyDrug;

        [SerializeField] AlchemyStudyBehaviour m_AlchemyStudy;

        [SerializeField] AlchemyBriefBehaviour m_AlchemyBrief;

        [SerializeField] AlchemyStoveBehaviour m_AlchemyStove;



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

        #region Built-in

        protected override void BindController()

        {

        }



        protected override void AddListeners()

        {

        }



        protected override void OnPreOpen()

        {

            SetDefaultSelect();



            m_AlchemyScroll.Display((int)AlchemyType.Normal);

            DisplayAlchmey();

            m_AlchemyDrug.Display();

            m_AlchemyStove.Display();



            model.selectAlchemyRefresh += SelectAlchemyRefresh;

            model.selectQualityRefresh += SelectQualityRefresh;

        }



        protected override void OnAfterOpen()

        {

        }



        protected override void OnPreClose()

        {

            m_AlchemyScroll.Dispose();

            m_AlchemyDrug.Dispose();

            m_AlchemyStudy.Dispose();

            m_AlchemyBrief.Dispose();

            m_AlchemyStove.Dispose();



            model.selectAlchemyRefresh -= SelectAlchemyRefresh;

            model.selectQualityRefresh -= SelectQualityRefresh;

        }



        protected override void OnAfterClose()

        {

        }

        #endregion



        void SetDefaultSelect()

        {

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

            model.selectQuality = qualities.First();



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

            model.selectAlchemy = alchemys[0];

        }



        private void SelectQualityRefresh()

        {

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

            model.selectAlchemy = alchemys[0];

        }



        private void SelectAlchemyRefresh()

        {

            DisplayAlchmey();

        }



        void DisplayAlchmey()

        {

            var grasp = model.IsGraspRecipe(model.selectAlchemy);

            m_AlchemyStudy.gameObject.SetActive(!grasp);

            m_AlchemyBrief.gameObject.SetActive(grasp);



            if (grasp)

            {

                m_AlchemyStudy.Display();

                m_AlchemyBrief.Dispose();

            }

            else

            {

                m_AlchemyBrief.Display();

                m_AlchemyStudy.Dispose();

            }

        }

    }

}










 System/Alchemy/AlchemyBasicDrugWin.cs.meta

copy from Lua/Gen/AlchemyConfigWrap.cs.meta
copy to System/Alchemy/AlchemyBasicDrugWin.cs.meta
File was copied from Lua/Gen/AlchemyConfigWrap.cs.meta
@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: 6505f3167ec49824a860a7a3491fb187
timeCreated: 1550122890
guid: 6d3deff49eaa78944ad224bbc59064d7
timeCreated: 1555482529
licenseType: Pro
MonoImporter:
  serializedVersion: 2

 System/Alchemy/AlchemyBriefBehaviour.cs

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

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



namespace Snxxz.UI

{

    public class AlchemyBriefBehaviour : MonoBehaviour

    {

        [SerializeField] Text m_AlchemyTime;

        [SerializeField] Text m_AlchemyCount;

        [SerializeField] Text m_AlchemySuccRate;



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



        public void Display()

        {

            DisplayAlchemyTime();

            DisplayAlchemyCount();

            DisplaySuccRate();

        }



        void DisplayAlchemyTime()

        {

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

            m_AlchemyTime.text = TimeUtility.SecondsToDHMSCHS(config.NeedTime);

        }



        void DisplayAlchemyCount()

        {

            AlchemyCount alchemyCount;

            if (model.TryGetAlchemyCount(model.selectAlchemy, 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 + "%";

        }



        public void Dispose()

        {

        }

    }

}


 System/Alchemy/AlchemyBriefBehaviour.cs.meta

copy from Lua/Gen/AlchemyConfigWrap.cs.meta
copy to System/Alchemy/AlchemyBriefBehaviour.cs.meta
File was copied from Lua/Gen/AlchemyConfigWrap.cs.meta
@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: 6505f3167ec49824a860a7a3491fb187
timeCreated: 1550122890
guid: e3b7248086741cd45bf5fc4ddd1fb48e
timeCreated: 1555488329
licenseType: Pro
MonoImporter:
  serializedVersion: 2

 System/Alchemy/AlchemyDrugBriefBehaviour.cs

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

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



namespace Snxxz.UI

{

    public class AlchemyDrugBriefBehaviour : MonoBehaviour

    {

        [SerializeField] ItemBehaviour m_Item;

        [SerializeField] Transform m_ContainerProperty;

        [SerializeField] PropertyBehaviour[] m_Propertys;

        [SerializeField] Text m_Effect;



        static Dictionary<int, int> s_Propertys = new Dictionary<int, int>();



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



        public void Display()

        {

            DisplayItem();

            DisplayProperty();

            DisplayEffect();



            model.selectAlchemyRefresh -= SelectAlchemyRefresh;

            model.selectAlchemyRefresh += SelectAlchemyRefresh;

        }



        void DisplayItem()

        {

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

            m_Item.SetItem(config.AlchemItemID, 0);

        }



        void DisplayProperty()

        {

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

            m_ContainerProperty.gameObject.SetActive(config.drugPromoteType == 1);

            if (config.drugPromoteType == 1)

            {

                var itemConfig = ItemConfig.Get(config.AlchemItemID);

                GetItemPromoteProperty(itemConfig,ref s_Propertys);

                var index = 0;

                foreach (var property in s_Propertys.Keys)

                {

                    if (index < m_Propertys.Length)

                    {

                        m_Propertys[index].gameObject.SetActive(true);

                        m_Propertys[index].Display(property, s_Propertys[property]);

                        index++;

                    }

                }

                for (int i = index; i < m_Propertys.Length; i++)

                {

                    m_Propertys[i].gameObject.SetActive(false);

                }

            }

        }



        void DisplayEffect()

        {

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

            m_Effect.gameObject.SetActive(config.drugPromoteType == 2);

            if (config.drugPromoteType == 2)

            {

                m_Effect.text = config.description;

            }

        }



        private void SelectAlchemyRefresh()

        {

            DisplayItem();

            DisplayProperty();

            DisplayEffect();

        }



        public void Dispose()

        {

            model.selectAlchemyRefresh -= SelectAlchemyRefresh;

        }



        static void GetItemPromoteProperty(ItemConfig config, ref Dictionary<int, int> dict)

        {

            dict.Clear();

            if (config == null)

            {

                return;

            }

            if (config.Effect1 != 0)

            {

                dict.Add(config.Effect1, config.EffectValueA1);

            }

            if (config.Effect2 != 0)

            {

                dict.Add(config.Effect2, config.EffectValueA2);

            }

            if (config.Effect3 != 0)

            {

                dict.Add(config.Effect3, config.EffectValueA3);

            }

            if (config.Effect4 != 0)

            {

                dict.Add(config.Effect4, config.EffectValueA4);

            }

            if (config.Effect5 != 0)

            {

                dict.Add(config.Effect5, config.EffectValueA5);

            }

        }

    }

}


 System/Alchemy/AlchemyDrugBriefBehaviour.cs.meta

File was renamed from Lua/Gen/AlchemyConfigWrap.cs.meta
@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: 6505f3167ec49824a860a7a3491fb187
timeCreated: 1550122890
guid: 90d98004fd586034e948253625325eb4
timeCreated: 1555492947
licenseType: Pro
MonoImporter:
  serializedVersion: 2

 System/Alchemy/AlchemyFairyDrugWin.cs

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

//    [Author]:           第二世界

//    [  Date ]:           Thursday, April 18, 2019

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



using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

using UnityEngine;

using UnityEngine.UI;



namespace Snxxz.UI

{



    public class AlchemyFairyDrugWin : Window

    {

        [SerializeField] AlchemyScrollBehaviour m_AlchemyScroll;

        [SerializeField] AlchemyDrugBriefBehaviour m_AlchemyDrug;

        [SerializeField] AlchemyStudyBehaviour m_AlchemyStudy;

        [SerializeField] AlchemyBriefBehaviour m_AlchemyBrief;

        [SerializeField] AlchemyStoveBehaviour m_AlchemyStove;



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

        #region Built-in

        protected override void BindController()

        {

        }



        protected override void AddListeners()

        {

        }



        protected override void OnPreOpen()

        {

            SetDefaultSelect();



            m_AlchemyScroll.Display((int)AlchemyType.Fairy);

            DisplayAlchmey();

            m_AlchemyDrug.Display();

            m_AlchemyStove.Display();



            model.selectAlchemyRefresh += SelectAlchemyRefresh;

            model.selectQualityRefresh += SelectQualityRefresh;

        }



        protected override void OnAfterOpen()

        {

        }



        protected override void OnPreClose()

        {

            m_AlchemyScroll.Dispose();

            m_AlchemyDrug.Dispose();

            m_AlchemyStudy.Dispose();

            m_AlchemyBrief.Dispose();

            m_AlchemyStove.Dispose();



            model.selectAlchemyRefresh -= SelectAlchemyRefresh;

            model.selectQualityRefresh -= SelectQualityRefresh;

        }



        protected override void OnAfterClose()

        {

        }

        #endregion



        void SetDefaultSelect()

        {

            var qualities = AlchemyConfig.GetAlchemyQualities((int)AlchemyType.Fairy);

            model.selectQuality = qualities.First();



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

            model.selectAlchemy = alchemys[0];

        }



        private void SelectQualityRefresh()

        {

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

            model.selectAlchemy = alchemys[0];

        }



        private void SelectAlchemyRefresh()

        {

            DisplayAlchmey();

        }



        void DisplayAlchmey()

        {

            var grasp = model.IsGraspRecipe(model.selectAlchemy);

            m_AlchemyStudy.gameObject.SetActive(!grasp);

            m_AlchemyBrief.gameObject.SetActive(grasp);



            if (grasp)

            {

                m_AlchemyStudy.Display();

                m_AlchemyBrief.Dispose();

            }

            else

            {

                m_AlchemyBrief.Display();

                m_AlchemyStudy.Dispose();

            }

        }

    }



}










 System/Alchemy/AlchemyFairyDrugWin.cs.meta

copy from Lua/Gen/AlchemyConfigWrap.cs.meta
copy to System/Alchemy/AlchemyFairyDrugWin.cs.meta
File was copied from Lua/Gen/AlchemyConfigWrap.cs.meta
@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: 6505f3167ec49824a860a7a3491fb187
timeCreated: 1550122890
guid: a956b841a88839a4594216946ae6bb55
timeCreated: 1555568773
licenseType: Pro
MonoImporter:
  serializedVersion: 2

 System/Alchemy/AlchemyModel.cs

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

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

{

    public class AlchemyModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk

    {

        Dictionary<int, uint> m_AlchemyTimes = new Dictionary<int, uint>();

        Dictionary<int, AlchemyCount> m_AlchemyCounts = new Dictionary<int, AlchemyCount>();

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

        Dictionary<int, List<Item>> m_AlchemyMaterials = new Dictionary<int, List<Item>>();



        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

        {

            get { return m_SelectAlchemy; }

            set

            {

                if (m_SelectAlchemy != value)

                {

                    m_SelectAlchemy = value;

                    if (selectAlchemyRefresh != null)

                    {

                        selectAlchemyRefresh();

                    }

                }

            }

        }



        public int stoveLevel { get; private set; }

        public int stoveExp { get; private set; }

        public string alchemySuccRate { get; private set; }



        public event Action selectQualityRefresh;

        public event Action selectAlchemyRefresh;

        public event Action alchemyStateRefresh;



        public override void Init()

        {

            ParseConfig();

        }



        public void OnBeforePlayerDataInitialize()

        {

            m_AlchemyTimes.Clear();

            stoveLevel = 0;

            stoveExp = 0;

        }



        public void OnPlayerLoginOk()

        {

        }



        void ParseConfig()

        {

            {

                var configs = AlchemyCountConfig.GetValues();

                foreach (var config in configs)

                {

                    var intArray = LitJson.JsonMapper.ToObject<int[][]>(config.CntRateList);

                    var min = intArray[0][1];

                    var max = intArray[intArray.Length - 1][1];

                    if (m_AlchemyCounts.ContainsKey(config.AlchemyQuality))

                    {

                        var alchemyCount = m_AlchemyCounts[config.AlchemyQuality];

                        if (min < alchemyCount.min)

                        {

                            alchemyCount.min = min;

                            m_AlchemyCounts[config.AlchemyQuality] = alchemyCount;

                        }

                        if (max > alchemyCount.max)

                        {

                            alchemyCount.max = max;

                            m_AlchemyCounts[config.AlchemyQuality] = alchemyCount;

                        }

                    }

                    else

                    {

                        m_AlchemyCounts[config.AlchemyQuality] = new AlchemyCount()

                        {

                            min = min,

                            max = max,

                        };

                    }

                }

            }



            {

                var funcConfig = FuncConfigConfig.Get("alchemySuccess");

                alchemySuccRate = funcConfig.Numerical3;



                var json = LitJson.JsonMapper.ToObject(funcConfig.Numerical2);

                foreach (var key in json.Keys)

                {

                    var quality = int.Parse(key);

                    m_AlchemyQualityLucks.Add(quality, int.Parse(json[key].ToString()));

                }

            }



            {

                var configs = AlchemyConfig.GetValues();

                foreach (var config in configs)

                {

                    m_AlchemyMaterials.Add(config.ID, new List<Item>());

                    var dict = ConfigParse.GetDic<int, int>(config.Material);

                    foreach (var key in dict.Keys)

                    {

                        m_AlchemyMaterials[config.ID].Add(new Item()

                        {

                            id = key,

                            count = dict[key],

                        });

                    }

                }

            }

        }



        public bool TryGetAlchemyStartTime(int alchemyId, out uint tick)

        {

            return m_AlchemyTimes.TryGetValue(alchemyId, out tick);

        }



        public bool TryGetAlchemyCount(int alchemyId, out AlchemyCount alchemyCount)

        {

            var config = AlchemyConfig.Get(alchemyId);

            if (config == null)

            {

                alchemyCount = default(AlchemyCount);

                return false;

            }

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

            {

                alchemyCount = AlchemyCount.one;

                return true;

            }

            return m_AlchemyCounts.TryGetValue(config.AlchemyQuality, out alchemyCount);

        }



        public bool TryGetAlchemyMaterials(int alchemyId, out List<Item> items)

        {

            return m_AlchemyMaterials.TryGetValue(alchemyId, out items);

        }



        public float GetAlchemySuccRate(int alchemyId)

        {

            var config = AlchemyConfig.Get(alchemyId);

            if (config == null)

            {

                return 0f;

            }

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

            {

                return 10000f;

            }

            var itemConfig = ItemConfig.Get(config.AlchemItemID);

            var luckValue = PlayerDatas.Instance.extersion.luckValue;

            return GetAlchemySuccRate(stoveLevel, itemConfig.LV, luckValue);

        }



        public float GetAlchemySuccRate(int stoveLevel, int itemLevel, int luck)

        {

            Equation.Instance.Clear();

            Equation.Instance.AddKeyValue("alchemyLV", stoveLevel);

            Equation.Instance.AddKeyValue("alchemyQuality", itemLevel);

            Equation.Instance.AddKeyValue("curLuckValue", luck);

            var qualityNeedLuck = m_AlchemyQualityLucks.ContainsKey(itemLevel) ? m_AlchemyQualityLucks[itemLevel] : 0;

            Equation.Instance.AddKeyValue("qualityNeedLuck", qualityNeedLuck);

            return Equation.Instance.Eval<float>(alchemySuccRate);

        }



        public bool IsGraspRecipe(int alchemyId)

        {

            return m_AlchemyTimes.ContainsKey(alchemyId);

        }



        public void ReceivePackage(HA3BF_tagMCPlayerStoveMsg package)

        {

            for (int i = 0; i < package.StoveCnt; i++)

            {

                var data = package.InfoList[i];

                m_AlchemyTimes[(int)data.AlchemyID] = data.StartTime;

            }



            stoveLevel = package.StoveLV;

            stoveExp = (int)package.StoveExp;



            if (package.ItemID != 0)

            {

                if (package.ItemCnt > 0)//炼丹成功

                {



                }

                else//炼丹失败

                {



                }

            }



            if (alchemyStateRefresh != null)

            {

                alchemyStateRefresh();

            }

        }



        public override void UnInit()

        {

        }

    }



    public enum AlchemyType

    {

        Normal = 1,

        Fairy = 2,

    }



    public struct AlchemyCount

    {

        public int min;

        public int max;



        public static readonly AlchemyCount one = new AlchemyCount()

        {

            min = 1,

            max = 1,

        };

    }

}


 System/Alchemy/AlchemyModel.cs.meta

copy from Lua/Gen/AlchemyConfigWrap.cs.meta
copy to System/Alchemy/AlchemyModel.cs.meta
File was copied from Lua/Gen/AlchemyConfigWrap.cs.meta
@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: 6505f3167ec49824a860a7a3491fb187
timeCreated: 1550122890
guid: 7b06704a3df2bf14fbf7225247f46297
timeCreated: 1555052742
licenseType: Pro
MonoImporter:
  serializedVersion: 2

 System/Alchemy/AlchemyQualityCell.cs

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

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



namespace Snxxz.UI

{

    public class AlchemyQualityCell : CellView

    {

        [SerializeField] Text m_QualityName;

        [SerializeField] Image m_Arrow;

        [SerializeField] Transform m_ContainerSelect;

        [SerializeField] Button m_Func;



        int quality = 0;



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



        private void Awake()

        {

            m_Func.SetListener(OnSelect);

        }



        public void Display(int quality)

        {

            this.quality = quality;

            m_QualityName.text = string.Format("{0}品丹方", 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);

        }



        private void OnSelect()

        {

            model.selectQuality = quality;

        }

    }

}


 System/Alchemy/AlchemyQualityCell.cs.meta

copy from Lua/Gen/AlchemyConfigWrap.cs.meta
copy to System/Alchemy/AlchemyQualityCell.cs.meta
File was copied from Lua/Gen/AlchemyConfigWrap.cs.meta
@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: 6505f3167ec49824a860a7a3491fb187
timeCreated: 1550122890
guid: cdac99ced8fa6b243a6255caaf4b196c
timeCreated: 1555483987
licenseType: Pro
MonoImporter:
  serializedVersion: 2

 System/Alchemy/AlchemyRecipeCell.cs

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

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



namespace Snxxz.UI

{

    public class AlchemyRecipeCell : CellView

    {

        [SerializeField] Text m_AlchemyName;

        [SerializeField] Text m_UnGrasp;

        [SerializeField] Transform m_ContainerSelect;

        [SerializeField] Button m_Func;



        int id = 0;



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



        private void Awake()

        {

            m_Func.SetListener(OnSelect);

        }



        public void Display(int id)

        {

            this.id = id;



            var config = AlchemyConfig.Get(id);



            m_AlchemyName.text = config.AlchemName;



            m_UnGrasp.gameObject.SetActive(!model.IsGraspRecipe(id));



            m_ContainerSelect.gameObject.SetActive(model.selectAlchemy == id);

        }



        private void OnSelect()

        {

            model.selectAlchemy = id;

        }

    }

}


 System/Alchemy/AlchemyRecipeCell.cs.meta

copy from Lua/Gen/AlchemyConfigWrap.cs.meta
copy to System/Alchemy/AlchemyRecipeCell.cs.meta
File was copied from Lua/Gen/AlchemyConfigWrap.cs.meta
@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: 6505f3167ec49824a860a7a3491fb187
timeCreated: 1550122890
guid: 839a1604f72201b40b9ef629f1ecf608
timeCreated: 1555484746
licenseType: Pro
MonoImporter:
  serializedVersion: 2

 System/Alchemy/AlchemyScrollBehaviour.cs

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

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

{

    public class AlchemyScrollBehaviour : MonoBehaviour

    {

        [SerializeField] ScrollerController m_Controller;



        int alchemyType = 0;



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



        private void Awake()

        {

            m_Controller.OnRefreshCell += OnRefreshCell;

        }



        public void Display(int type)

        {

            alchemyType = type;



            DisplayRecipes();



            model.selectQualityRefresh += SelectQualityRefresh;

            model.selectAlchemyRefresh += SelectAlchemyRefresh;

        }



        void DisplayRecipes()

        {

            var qualities = AlchemyConfig.GetAlchemyQualities(alchemyType);

            foreach (var quality in qualities)

            {

                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);

                    }

                }

            }

        }



        private void OnRefreshCell(ScrollerDataType type, CellView cell)

        {

            if (type == ScrollerDataType.Header)

            {

                var qualityCell = cell as AlchemyQualityCell;

                qualityCell.Display(cell.index);

            }

            else if (type == ScrollerDataType.Normal)

            {

                var recipeCell = cell as AlchemyRecipeCell;

                recipeCell.Display(cell.index);

            }

        }



        private void SelectQualityRefresh()

        {

            DisplayRecipes();

        }



        private void SelectAlchemyRefresh()

        {

            m_Controller.m_Scorller.RefreshActiveCellViews();

        }



        public void Dispose()

        {

            model.selectQualityRefresh -= SelectQualityRefresh;

            model.selectAlchemyRefresh -= SelectAlchemyRefresh;

        }

    }

}


 System/Alchemy/AlchemyScrollBehaviour.cs.meta

copy from Lua/Gen/AlchemyConfigWrap.cs.meta
copy to System/Alchemy/AlchemyScrollBehaviour.cs.meta
File was copied from Lua/Gen/AlchemyConfigWrap.cs.meta
@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: 6505f3167ec49824a860a7a3491fb187
timeCreated: 1550122890
guid: df2a59fcddbd1e44688ea53023de4bf7
timeCreated: 1555483025
licenseType: Pro
MonoImporter:
  serializedVersion: 2

 System/Alchemy/AlchemyStoveBehaviour.cs

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

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



namespace Snxxz.UI

{

    public class AlchemyStoveBehaviour : MonoBehaviour

    {

        [SerializeField] AlchemyMaterial[] m_AlchemyMaterials;



        [SerializeField] Transform m_ContainerAlcheming;

        [SerializeField] Text m_AlchemyTime;

        [SerializeField] Transform m_ContainerComplete;

        [SerializeField] Transform m_ContainerNormal;

        [SerializeField] Text m_StoveLevel;

        [SerializeField] Text m_StoveExp;

        [SerializeField] Slider m_StoveExpSlider;



        [SerializeField] Text m_LuckValue;

        [SerializeField] Transform m_ContainerGrasp;

        [SerializeField] Button m_Func;

        [SerializeField] Text m_FuncLabel;

        [SerializeField] Transform m_ContainerUnGrasp;



        int m_State = 0; //0-正常状态 1-炼丹中 2-炼丹结束

        int state

        {

            get { return m_State; }

            set

            {

                if (m_State != value)

                {

                    m_State = value;

                    DisplayStove();

                }

            }

        }



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



        private void Awake()

        {

            m_Func.SetListener(OnFunc);

        }



        public void Display()

        {

            model.selectAlchemyRefresh += SelectAlchemyRefresh;

            GlobalTimeEvent.Instance.secondEvent += PerSecond;

            model.alchemyStateRefresh += AlchemyStateRefresh;

            PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshEvent;



            m_State = GetStoveState();



            DisplayAlchemyMaterials();

            DisplayStove();

            DisplayLuckValue();

        }



        void DisplayAlchemyMaterials()

        {

            var grasp = model.IsGraspRecipe(model.selectAlchemy);



            List<Item> materials;

            model.TryGetAlchemyMaterials(model.selectAlchemy, out materials);



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

            {

                if (grasp && materials != null && i < materials.Count)

                {

                    m_AlchemyMaterials[i].SetLock(true);

                    m_AlchemyMaterials[i].Display(materials[i]);

                }

                else

                {

                    m_AlchemyMaterials[i].SetLock(false);

                }

            }

        }



        void DisplayStove()

        {

            m_ContainerAlcheming.gameObject.SetActive(state == 1);

            m_ContainerNormal.gameObject.SetActive(state == 0);

            m_ContainerComplete.gameObject.SetActive(state == 2);



            switch (state)

            {

                case 0:

                    m_StoveLevel.text = StringUtility.Contact("Lv.", model.stoveLevel);

                    var isMax = !RefineStoveConfig.Has(model.stoveLevel + 1);

                    var stoveConfig = RefineStoveConfig.Get(model.stoveLevel);

                    if (isMax)

                    {

                        m_StoveExp.text = "已满级";

                        m_StoveExpSlider.value = 1;

                    }

                    else

                    {

                        m_StoveExp.text = StringUtility.Contact(model.stoveExp, "/", stoveConfig.Exp);

                        var progress = Mathf.Clamp01((float)model.stoveExp / stoveConfig.Exp);

                        m_StoveExpSlider.value = progress;

                    }

                    break;

                case 1:

                    uint tick = 0;

                    if (model.TryGetAlchemyStartTime(model.selectAlchemy, out tick))

                    {

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

                        var startTime = TimeUtility.GetTime(tick);

                        var seconds = Mathf.CeilToInt(config.NeedTime - (float)(TimeUtility.ServerNow - startTime).TotalSeconds);

                        m_AlchemyTime.text = TimeUtility.SecondsToHMS(seconds);

                    }

                    break;

                case 2:

                    break;

            }



            var grasp = model.IsGraspRecipe(model.selectAlchemy);

            m_ContainerGrasp.gameObject.SetActive(grasp);

            m_ContainerUnGrasp.gameObject.SetActive(!grasp);

            if (grasp)

            {

                switch (state)

                {

                    case 0:

                        m_FuncLabel.text = "开始炼丹";

                        break;

                    case 1:

                        m_FuncLabel.text = "停止炼丹";

                        break;

                    case 2:

                        m_FuncLabel.text = "开炉取丹";

                        break;

                }

            }

        }



        void DisplayLuckValue()

        {

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

        }



        int GetStoveState()

        {

            uint tick = 0;

            if (model.TryGetAlchemyStartTime(model.selectAlchemy, out tick)

                && tick > 0)

            {

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

                var startTime = TimeUtility.GetTime(tick);

                var seconds = Mathf.CeilToInt(config.NeedTime - (float)(TimeUtility.ServerNow - startTime).TotalSeconds);

                return seconds > 0 ? 1 : 2;

            }

            return 0;

        }



        private void SelectAlchemyRefresh()

        {

            DisplayAlchemyMaterials();

        }



        private void AlchemyStateRefresh()

        {

            m_State = GetStoveState();

            DisplayStove();

        }



        private void PlayerDataRefreshEvent(PlayerDataType dataType)

        {

            if (dataType == PlayerDataType.LuckValue)

            {

                DisplayLuckValue();

            }

        }



        private void PerSecond()

        {

            var _state = GetStoveState();



            if (_state == state)

            {

                if (state == 1)

                {

                    DisplayStove();

                }

            }

            else

            {

                state = _state;

            }

        }



        private void OnFunc()

        {

            var pak = new CA576_tagCMPlayerRefine();

            pak.AlchemyID = (uint)model.selectAlchemy;

            switch (state)

            {

                case 0:

                    pak.DoType = 1;

                    break;

                case 1:

                    pak.DoType = 2;

                    break;

                case 2:

                    pak.DoType = 3;

                    break;

            }

            GameNetSystem.Instance.SendInfo(pak);

        }



        public void Dispose()

        {

            model.selectAlchemyRefresh -= SelectAlchemyRefresh;

            GlobalTimeEvent.Instance.secondEvent -= PerSecond;

            model.alchemyStateRefresh -= AlchemyStateRefresh;

            PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshEvent;

        }

    }



    [Serializable]

    public class AlchemyMaterial

    {

        [SerializeField] Transform m_ContainerItem;

        [SerializeField] Image m_Icon;

        [SerializeField] Text m_Count;

        [SerializeField] Transform m_ContainerLock;



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



        public void Display(Item item)

        {

            Display(item.id, item.count);

        }



        public void Display(int id, int count)

        {

            var itemConfig = ItemConfig.Get(id);

            m_Icon.SetSprite(itemConfig.IconKey);



            var packCount = packModel.GetItemCountByID(PackType.Item, id);

            var enough = packCount >= count;

            var label = UIHelper.AppendColor(enough ? TextColType.Green : TextColType.Red, packCount.ToString());

            m_Count.text = StringUtility.Contact(label, "/", count);

        }



        public void SetLock(bool _lock)

        {

            m_ContainerLock.gameObject.SetActive(_lock);

            m_ContainerItem.gameObject.SetActive(!_lock);

        }

    }

}


 System/Alchemy/AlchemyStoveBehaviour.cs.meta

copy from Lua/Gen/AlchemyConfigWrap.cs.meta
copy to System/Alchemy/AlchemyStoveBehaviour.cs.meta
File was copied from Lua/Gen/AlchemyConfigWrap.cs.meta
@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: 6505f3167ec49824a860a7a3491fb187
timeCreated: 1550122890
guid: 318da5e8e0250734c8be86940bd2d5c4
timeCreated: 1555551888
licenseType: Pro
MonoImporter:
  serializedVersion: 2

 System/Alchemy/AlchemyStudyBehaviour.cs

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

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



namespace Snxxz.UI

{

    public class AlchemyStudyBehaviour : MonoBehaviour

    {

        [SerializeField] ItemBehaviour m_Item;

        [SerializeField] Text m_StoveCondition;

        [SerializeField] Text m_PropertyCondition;

        [SerializeField] Button m_Func;

        [SerializeField] Text m_FuncLabel;



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

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



        private void Awake()

        {

            m_Func.SetListener(Learn);

        }



        public void Display()

        {

            DisplayItem();

            DisplayStoveCondition();

            DisplayPropertyCondition();

            DisplayFuncState();

        }



        void DisplayItem()

        {

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

            m_Item.SetItem(config.LearnNeedItemID, 1);

        }



        void DisplayStoveCondition()

        {

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

            m_StoveCondition.gameObject.SetActive(config.LearnNeedAlchemLV > 0);

            if (config.LearnNeedAlchemLV > 0)

            {

                var satisfy = model.stoveLevel >= config.LearnNeedAlchemLV;

                m_StoveCondition.text = string.Format("炼丹炉达到{0}级", config.LearnNeedAlchemLV);

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

            }

        }



        void DisplayPropertyCondition()

        {

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

            m_PropertyCondition.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 = string.Format("{0}达到{1}级", propertyConfig.Name, config.LearnNeedLuck);

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

            }

        }



        void DisplayFuncState()

        {

            var error = 0;

            var satisfyLearn = TryLearn(out error);

            m_Func.SetColorful(m_FuncLabel, satisfyLearn);

        }



        private void Learn()

        {

            var error = 0;

            if (TryLearn(out error))

            {

                var pak = new CA576_tagCMPlayerRefine();

                pak.AlchemyID = (uint)model.selectAlchemy;

                pak.DoType = 0;

                GameNetSystem.Instance.SendInfo(pak);

            }

            else

            {

                DisplayErrorTip(error);

            }

        }



        bool TryLearn(out int error)

        {

            error = 0;

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

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

            if (count <= 0)

            {

                error = 1;

                return false;

            }

            if (model.stoveLevel < config.LearnNeedAlchemLV)

            {

                error = 2;

                return false;

            }

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

            {

                error = 3;

                return false;

            }

            return true;

        }



        void DisplayErrorTip(int error)

        {

            switch (error)

            {

                case 1:

                    SysNotifyMgr.Instance.ShowTip("AlchemyLearnError_1");

                    break;

                case 2:

                    SysNotifyMgr.Instance.ShowTip("AlchemyLearnError_2");

                    break;

                case 3:

                    SysNotifyMgr.Instance.ShowTip("AlchemyLearnError_3");

                    break;

            }

        }



        public void Dispose()

        {

        }

    }

}


 System/Alchemy/AlchemyStudyBehaviour.cs.meta

copy from Lua/Gen/AlchemyConfigWrap.cs.meta
copy to System/Alchemy/AlchemyStudyBehaviour.cs.meta
File was copied from Lua/Gen/AlchemyConfigWrap.cs.meta
@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: 6505f3167ec49824a860a7a3491fb187
timeCreated: 1550122890
guid: 99a3f66156f9e174aa2a7af35d1d6d14
timeCreated: 1555486605
licenseType: Pro
MonoImporter:
  serializedVersion: 2

 System/Auction/AuctionLogicUtil.cs

@@ -150,12 +150,12 @@
                return false;

            }



            var itemConfig = ItemConfig.Get(item.itemId);

            if (itemConfig.EquipPlace == 0)

            if (!ItemLogicUtility.Instance.IsEquip(item.itemId))

            {

                return false;

            }



            var itemConfig = ItemConfig.Get(item.itemId);

            if (itemConfig.JobLimit != 0 && itemConfig.JobLimit != PlayerDatas.Instance.baseData.Job)

            {

                return false;


 System/BlastFurnace/BlastFurnaceModel.cs

@@ -116,19 +116,19 @@
    {

        alchemyDataDict = new Dictionary<int, AlchemyData>();

        alchemyModellist = AlchemyConfig.GetValues();

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

        {

            var alchemyConfig = alchemyModellist[i];

            AlchemyData alchemyData = new AlchemyData();

            alchemyData.id = alchemyConfig.AlchemyID;

            alchemyData.alchemyConfig = alchemyConfig;

            alchemyData.normalMatDic = ConfigParse.GetDic<int, int>(alchemyConfig.MaterialAll);

            alchemyData.previewDict = GetPreviewDict(alchemyConfig.AlchemPreviewItem);

            if (!alchemyDataDict.ContainsKey(alchemyConfig.AlchemyID))

            {

                alchemyDataDict.Add(alchemyConfig.AlchemyID, alchemyData);

            }

        }

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

        //{

        //    var alchemyConfig = alchemyModellist[i];

        //    AlchemyData alchemyData = new AlchemyData();

        //    alchemyData.id = alchemyConfig.AlchemyID;

        //    alchemyData.alchemyConfig = alchemyConfig;

        //    alchemyData.normalMatDic = ConfigParse.GetDic<int, int>(alchemyConfig.MaterialAll);

        //    alchemyData.previewDict = GetPreviewDict(alchemyConfig.AlchemPreviewItem);

        //    if (!alchemyDataDict.ContainsKey(alchemyConfig.AlchemyID))

        //    {

        //        alchemyDataDict.Add(alchemyConfig.AlchemyID, alchemyData);

        //    }

        //}

    }

    public Dictionary<int, AlchemySpecData> alchemySpecDataDict { get; private set; }

    private void ParseAlchemySpecConfig()

@@ -456,11 +456,11 @@
    /// </summary>

    public Dictionary<int, int> GetPreviewMakeDruglist(AlchemyConfig alchemyModel)

    {

        if (alchemyModel == null) return null;

        var alchmeyData = GetAlchemyData(alchemyModel.AlchemyID);

        if (alchmeyData == null) return null;

        //if (alchemyModel == null) return null;

        //var alchmeyData = GetAlchemyData(alchemyModel.AlchemyID);

        //if (alchmeyData == null) return null;



        return alchmeyData.previewDict;

        return null;

    }



    public Dictionary<int, int> GetPreviewSpecMakeDruglist(AlchemySpecConfig alchemyModel)

@@ -520,10 +520,10 @@
    #region 发送请求

    public void SendMakerDrugQuest(ushort drugId, uint specConfigID)

    {

        CA576_tagCMPlayerRefine cMPlayerRefine = new CA576_tagCMPlayerRefine();

        cMPlayerRefine.RefineNum = drugId;

        cMPlayerRefine.UseRateItem = specConfigID;

        GameNetSystem.Instance.SendInfo(cMPlayerRefine);

        //CA576_tagCMPlayerRefine cMPlayerRefine = new CA576_tagCMPlayerRefine();

        //cMPlayerRefine.RefineNum = drugId;

        //cMPlayerRefine.UseRateItem = specConfigID;

        //GameNetSystem.Instance.SendInfo(cMPlayerRefine);

    }



    #endregion

@@ -686,45 +686,45 @@
        if (alchemyModellist == null || !FuncOpen.Instance.IsFuncOpen((int)FuncOpenEnum.BlastFurnace)) return;





        for (int i = alchemyModellist.Count - 1; i > -1; i--)

        {

            if (StoveLV >= alchemyModellist[i].BlastFurnaceLV)

            {

                if (IsSpecMatEnough(alchemyModellist[i]) && IsNormalMatEnough(alchemyModellist[i])

                    && !CheckIsHavePetOrMount(alchemyModellist[i]))

                {

                    danDrugRedPointlist[i].state = RedPointState.Simple;

                    return;

                }

            }

        }

        //for (int i = alchemyModellist.Count - 1; i > -1; i--)

        //{

        //    if (StoveLV >= alchemyModellist[i].BlastFurnaceLV)

        //    {

        //        if (IsSpecMatEnough(alchemyModellist[i]) && IsNormalMatEnough(alchemyModellist[i])

        //            && !CheckIsHavePetOrMount(alchemyModellist[i]))

        //        {

        //            danDrugRedPointlist[i].state = RedPointState.Simple;

        //            return;

        //        }

        //    }

        //}

        //

        //for (int i = alchemyModellist.Count - 1; i > -1; i--)

        //{

        //    if (StoveLV >= alchemyModellist[i].BlastFurnaceLV)

        //    {

        //        if (IsSpecMatEnough(alchemyModellist[i]) && IsNormalMatEnough(alchemyModellist[i]))

        //        {

        //            danDrugRedPointlist[i].state = RedPointState.Simple;

        //            return;

        //        }

        //    }

        //}



        for (int i = alchemyModellist.Count - 1; i > -1; i--)

        {

            if (StoveLV >= alchemyModellist[i].BlastFurnaceLV)

            {

                if (IsSpecMatEnough(alchemyModellist[i]) && IsNormalMatEnough(alchemyModellist[i]))

                {

                    danDrugRedPointlist[i].state = RedPointState.Simple;

                    return;

                }

            }

        }



        for (int i = alchemyModellist.Count - 1; i > -1; i--)

        {

            if (StoveLV >= alchemyModellist[i].BlastFurnaceLV)

            {

                if (!CheckNormalAlchemyIsReachMaxUse(alchemyModellist[i]))

                {

                    if (IsNormalMatEnough(alchemyModellist[i]) && !IsHaveReachFull(alchemyModellist[i]))

                    {

                        danDrugRedPointlist[i].state = RedPointState.Simple;

                        return;

                    }

                }

            }

        }

        //for (int i = alchemyModellist.Count - 1; i > -1; i--)

        //{

        //    if (StoveLV >= alchemyModellist[i].BlastFurnaceLV)

        //    {

        //        if (!CheckNormalAlchemyIsReachMaxUse(alchemyModellist[i]))

        //        {

        //            if (IsNormalMatEnough(alchemyModellist[i]) && !IsHaveReachFull(alchemyModellist[i]))

        //            {

        //                danDrugRedPointlist[i].state = RedPointState.Simple;

        //                return;

        //            }

        //        }

        //    }

        //}



    }



@@ -767,60 +767,61 @@


    public bool IsSpecMatEnough(AlchemyConfig alchemyConfig)

    {

        if (alchemyConfig == null) return false;

        if (alchemyConfig.SpecialItem == null || alchemyConfig.SpecialItem.Length < 1) return false;



        bool isEnough = false;

        for (int i = 0; i < alchemyConfig.SpecialItem.Length; i++)

        {

            AlchemySpecConfig specConfig = AlchemySpecConfig.Get(alchemyConfig.SpecialItem[i]);

            int haveCnt = playerPack.GetItemCountByID(PackType.Item, specConfig.SpecialMaterialD);

            if (haveCnt >= specConfig.SpecialMateriaNUM)

            {

                isEnough = true;

                break;

            }

        }

        return isEnough;

        //if (alchemyConfig == null) return false;

        //if (alchemyConfig.SpecialItem == null || alchemyConfig.SpecialItem.Length < 1) return false;

        //

        //bool isEnough = false;

        //for (int i = 0; i < alchemyConfig.SpecialItem.Length; i++)

        //{

        //    AlchemySpecConfig specConfig = AlchemySpecConfig.Get(alchemyConfig.SpecialItem[i]);

        //    int haveCnt = playerPack.GetItemCountByID(PackType.Item, specConfig.SpecialMaterialD);

        //    if (haveCnt >= specConfig.SpecialMateriaNUM)

        //    {

        //        isEnough = true;

        //        break;

        //    }

        //}

        return false;

    }



    public bool IsSpecMatEnough(AlchemyConfig alchemyConfig, out Dictionary<int, List<int>> specDurgDict)

    {

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

        if (alchemyConfig == null) return false;



        if (alchemyConfig.SpecialItem == null || alchemyConfig.SpecialItem.Length < 1) return false;



        bool isEnough = false;

        for (int i = 0; i < alchemyConfig.SpecialItem.Length; i++)

        {

            AlchemySpecConfig specConfig = AlchemySpecConfig.Get(alchemyConfig.SpecialItem[i]);

            int haveCnt = playerPack.GetItemCountByID(PackType.Item, specConfig.SpecialMaterialD);

            if (haveCnt >= specConfig.SpecialMateriaNUM)

            {

                isEnough = true;

                List<int> specIdlist = GetSpecPreviewIdlist(specConfig);

                specDurgDict.Add(specConfig.SpecialMaterialD, specIdlist);

            }

        }

        return isEnough;

        specDurgDict = null;

        //specDurgDict = new Dictionary<int, List<int>>();

        //if (alchemyConfig == null) return false;

        //

        //if (alchemyConfig.SpecialItem == null || alchemyConfig.SpecialItem.Length < 1) return false;

        //

        //bool isEnough = false;

        //for (int i = 0; i < alchemyConfig.SpecialItem.Length; i++)

        //{

        //    AlchemySpecConfig specConfig = AlchemySpecConfig.Get(alchemyConfig.SpecialItem[i]);

        //    int haveCnt = playerPack.GetItemCountByID(PackType.Item, specConfig.SpecialMaterialD);

        //    if (haveCnt >= specConfig.SpecialMateriaNUM)

        //    {

        //        isEnough = true;

        //        List<int> specIdlist = GetSpecPreviewIdlist(specConfig);

        //        specDurgDict.Add(specConfig.SpecialMaterialD, specIdlist);

        //    }

        //}

        return false;

    }



    public bool IsNormalMatEnough(AlchemyConfig alchemyConfig)

    {

        if (alchemyConfig == null) return false;

        bool isEnough = true;

        var matDict = GetAlchemyData(alchemyConfig.AlchemyID).normalMatDic;

        foreach (var id in matDict.Keys)

        {

            int haveCnt = playerPack.GetItemCountByID(PackType.Item, id);

            if (haveCnt < matDict[id])

            {

                isEnough = false;

                break;

            }

        }

        return isEnough;

        //if (alchemyConfig == null) return false;

        //bool isEnough = true;

        //var matDict = GetAlchemyData(alchemyConfig.AlchemyID).normalMatDic;

        //foreach (var id in matDict.Keys)

        //{

        //    int haveCnt = playerPack.GetItemCountByID(PackType.Item, id);

        //    if (haveCnt < matDict[id])

        //    {

        //        isEnough = false;

        //        break;

        //    }

        //}

        return false;

    }



    public bool IsHaveReachFull(AlchemyConfig alchemyConfig)

@@ -866,14 +867,14 @@
    {

        if (alchemyConfig == null) return;



        specMatRedpoint.state = RedPointState.None;

        if (isShow)

        {

            if (IsSpecMatEnough(alchemyConfig) && alchemyConfig.BlastFurnaceLV <= StoveLV)

            {

                specMatRedpoint.state = RedPointState.Simple;

            }

        }

        //specMatRedpoint.state = RedPointState.None;

        //if (isShow)

        //{

        //    if (IsSpecMatEnough(alchemyConfig) && alchemyConfig.BlastFurnaceLV <= StoveLV)

        //    {

        //        specMatRedpoint.state = RedPointState.Simple;

        //    }

        //}

    }



    public void CheckRecycleStoreRed()


 System/BlastFurnace/DandrugCell.cs

@@ -41,30 +41,30 @@
    {

        AlchemyConfig alchemyModel = FurnaceModel.alchemyModellist[index];

        Redpoint.redpointId = FurnaceModel.danDrugRedPointlist[index].id;

        danIcon.SetSprite(alchemyModel.ICONID);

        //danIcon.SetSprite(alchemyModel.ICONID);

        danBgIcon.SetItemBackGround(alchemyModel.AlchemyQuality);

        nameText.text = alchemyModel.AlchemName;

        if (FurnaceModel.StoveLV < alchemyModel.BlastFurnaceLV)

        {

           lockText.gameObject.SetActive(true);

           lockText.text = Language.Get("BlastFurnace104", alchemyModel.BlastFurnaceLV);

            progressObj.SetActive(false);

        }

        else

        {

            progressObj.SetActive(true);

            lockText.gameObject.SetActive(false);

            float progress = (float)Math.Round(playerPack.GetAlchemyProgress(alchemyModel), 2);

            if(progress > 0)

            {

                progressValue.text = UIHelper.AppendColor(TextColType.Green, StringUtility.Contact(progress, "%"));

            }

            else

            {

                progressValue.text = StringUtility.Contact(progress, "%");

                progressValue.color = colorBlack;

            }

        }

        //if (FurnaceModel.StoveLV < alchemyModel.BlastFurnaceLV)

        //{

        //   lockText.gameObject.SetActive(true);

        //   lockText.text = Language.Get("BlastFurnace104", alchemyModel.BlastFurnaceLV);

        //    progressObj.SetActive(false);

        //}

        //else

        //{

        //    progressObj.SetActive(true);

        //    lockText.gameObject.SetActive(false);

        //    float progress = (float)Math.Round(playerPack.GetAlchemyProgress(alchemyModel), 2);

        //    if(progress > 0)

        //    {

        //        progressValue.text = UIHelper.AppendColor(TextColType.Green, StringUtility.Contact(progress, "%"));

        //    }

        //    else

        //    {

        //        progressValue.text = StringUtility.Contact(progress, "%");

        //        progressValue.color = colorBlack;

        //    }

        //}

     

        if (index == selectIndex)

        {

@@ -77,17 +77,17 @@
            selectImg.SetActive(false);

        }

         bool isReach = FurnaceModel.IsHaveReachFull(alchemyModel);

        int alchemyLv = alchemyModel.AlchemyID % 10;

        if(isReach)

        {

            progressObj.SetActive(false);

            achieveReachText.text = Language.Get("BlastFurnace116",Language.Get(StringUtility.Contact("Num_CHS_", alchemyLv)));

            achieveReach.SetActive(true);

        }

        else

        {

            achieveReach.SetActive(false);

        }

        //int alchemyLv = alchemyModel.AlchemyID % 10;

        //if(isReach)

        //{

        //    progressObj.SetActive(false);

        //    achieveReachText.text = Language.Get("BlastFurnace116",Language.Get(StringUtility.Contact("Num_CHS_", alchemyLv)));

        //    achieveReach.SetActive(true);

        //}

        //else

        //{

        //    achieveReach.SetActive(false);

        //}

    }



}


 System/BlastFurnace/LingDanTips.cs

@@ -143,7 +143,7 @@
                {

                    if (FurnaceModel.danDrugRedPointlist[i].state == RedPointState.Simple)

                    {

                        isJumpToId = FurnaceModel.alchemyModellist[i].AlchemyID;

                        //isJumpToId = FurnaceModel.alchemyModellist[i].AlchemyID;

                        isMakeDan = true;

                        presentIndex = i;

                        int jumpIndex = presentIndex - 1 < 0 ? 0 : presentIndex - 1;

@@ -170,11 +170,11 @@
                {

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

                    {

                        if (FurnaceModel.jumpToPrescripe == FurnaceModel.alchemyModellist[i].AlchemyID)

                        {

                            presentIndex = i;

                            break;

                        }

                        //if (FurnaceModel.jumpToPrescripe == FurnaceModel.alchemyModellist[i].AlchemyID)

                        //{

                        //    presentIndex = i;

                        //    break;

                        //}

                    }

                    FurnaceModel.jumpToPrescripe = 0;

                }

@@ -184,7 +184,7 @@
                    {

                        if (FurnaceModel.danDrugRedPointlist[i].state == RedPointState.Simple)

                        {

                            isJumpToId = FurnaceModel.alchemyModellist[i].AlchemyID;

                            //isJumpToId = FurnaceModel.alchemyModellist[i].AlchemyID;

                            presentIndex = i;

                            break;

                        }

@@ -293,22 +293,22 @@
            AlchemyConfig alchemyModel = FurnaceModel.alchemyModellist[index];

            noEnoughMatID = 0;

            curAlchemyModel = alchemyModel;

            if(curAlchemyModel.AlchemyID != isJumpToId)

            {

                isJumpToId = 0;

                if(guideEffect != null)

                {

                    AchievementGuideEffectPool.Recycle(guideEffect);

                    guideEffect = null;

                }

            }

            //if(curAlchemyModel.AlchemyID != isJumpToId)

            //{

            //    isJumpToId = 0;

            //    if(guideEffect != null)

            //    {

            //        AchievementGuideEffectPool.Recycle(guideEffect);

            //        guideEffect = null;

            //    }

            //}

            int i = 0;

            int length = _materiallist.Count;

            for( i = 0;i < length;i++)

            {

                ItemCell itemCell = _materiallist[i].transform.Find("ItemCell").GetComponent<ItemCell>();

                GameObject lockImage = _materiallist[i].transform.Find("LockImage").gameObject;

                FurnaceModel.SetAlchemyMaterial(alchemyModel.AlchemyID);

                //FurnaceModel.SetAlchemyMaterial(alchemyModel.AlchemyID);

                FurnaceModel.GetAlchemyMaterial(i);

                int materialId = FurnaceModel.materialId;

                int materialNum = FurnaceModel.materialNum;

@@ -352,16 +352,16 @@
            }

            _noEnoughLVText.SetActive(false);



            if (FurnaceModel.StoveLV < alchemyModel.BlastFurnaceLV)

            {

                _makeDanBtn.gameObject.SetActive(false);

                //_noEnoughLVText.SetActive(true);

            }

            else

            {

                _makeDanBtn.gameObject.SetActive(true);

             
            }

            //if (FurnaceModel.StoveLV < alchemyModel.BlastFurnaceLV)

            //{

            //    _makeDanBtn.gameObject.SetActive(false);

            //    //_noEnoughLVText.SetActive(true);

            //}

            //else

            //{

            //    _makeDanBtn.gameObject.SetActive(true);

            // 
            //}

            if(presentIndex != index)

            {

                chooseSpecModel = null;

@@ -379,9 +379,9 @@
            _addExp = 0;

            if (chooseSpecModel == null)

            {

                _addExp = curAlchemyModel.AlchemyEXP;

                _addSpecMatItemCell.gameObject.SetActive(false);

                FurnaceModel.SetAlchemySpecModellist(curAlchemyModel.SpecialItem);

                //_addExp = curAlchemyModel.AlchemyEXP;

                //_addSpecMatItemCell.gameObject.SetActive(false);

                //FurnaceModel.SetAlchemySpecModellist(curAlchemyModel.SpecialItem);

                if (FurnaceModel.GetAlchemySpecModellist().Count > 0)

                {

                    _addSpecMatText.gameObject.SetActive(true);

@@ -401,8 +401,8 @@
            {



                FurnaceModel.SpecMatRedPointCtrl(curAlchemyModel,false);

                _addExp = specModel.AlchemyEXP + curAlchemyModel.AlchemyEXP;

                RefreshVirtualFill(curAlchemyModel.AlchemyEXP);

                //_addExp = specModel.AlchemyEXP + curAlchemyModel.AlchemyEXP;

                //RefreshVirtualFill(curAlchemyModel.AlchemyEXP);

                _addSpecMatText.gameObject.SetActive(false);

                _addSpecLockObj.SetActive(false);

                _addSpecMatItemCell.gameObject.SetActive(true);

@@ -543,14 +543,14 @@
                    {

                        //ChangeMakeDanBtn(false);

                        makeDrugEffect.Play();

                        FurnaceModel.SendMakerDrugQuest((ushort)curAlchemyModel.AlchemyID, (uint)chooseSpecModel.ID);

                        //FurnaceModel.SendMakerDrugQuest((ushort)curAlchemyModel.AlchemyID, (uint)chooseSpecModel.ID);

                    }

                }

                else

                {

                    //ChangeMakeDanBtn(false);

                    makeDrugEffect.Play();

                    FurnaceModel.SendMakerDrugQuest((ushort)curAlchemyModel.AlchemyID, 0);

                    //FurnaceModel.SendMakerDrugQuest((ushort)curAlchemyModel.AlchemyID, 0);

                }

            }

        }


 System/BlastFurnace/PrayForDurgModel.cs

@@ -239,19 +239,19 @@
            {

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

                {

                    if (blastModel.StoveLV >= configs[i].BlastFurnaceLV)

                    {

                        List<int> idlist = blastModel.GetPreviewIdlist(configs[i]);

                        if(idlist.Contains(key))

                        {

                            AttrFruitConfig fruitConfig = AttrFruitConfig.Get(key);

                            if (!playerPack.IsReachMaxUseDrug(fruitConfig))

                            {

                                prayIdlist.Add(key);

                            }

                            break;

                        }

                    }

                    //if (blastModel.StoveLV >= configs[i].BlastFurnaceLV)

                    //{

                    //    List<int> idlist = blastModel.GetPreviewIdlist(configs[i]);

                    //    if(idlist.Contains(key))

                    //    {

                    //        AttrFruitConfig fruitConfig = AttrFruitConfig.Get(key);

                    //        if (!playerPack.IsReachMaxUseDrug(fruitConfig))

                    //        {

                    //            prayIdlist.Add(key);

                    //        }

                    //        break;

                    //    }

                    //}

                }

            }

            return prayIdlist;


 System/BlastFurnace/StoveRecipeCell.cs

@@ -14,7 +14,7 @@
            AlchemyConfig alchemy = AlchemyConfig.Get(alchemyId);

            if (alchemy == null) return;



            icon.SetSprite(alchemy.ICONID);

            //icon.SetSprite(alchemy.ICONID);

            bgIcon.SetItemBackGround(alchemy.AlchemyQuality);

            recipeNameText.text = alchemy.AlchemName;

        }


 System/DailyQuest/DailyQuestWin.cs

@@ -470,7 +470,7 @@
        private void GotoBlastStove()

        {

            WindowCenter.Instance.Close<DailyQuestWin>();

            WindowCenter.Instance.Open<BlastFurnaceWin>();

            WindowCenter.Instance.Open<AlchemyBaseWin>();

        }



        private void GotoBountyMission()


 System/Dungeon/DungeonModel.cs

@@ -23,6 +23,7 @@
        Dictionary<int, DateTime> dungeonCountRemainTimes = new Dictionary<int, DateTime>();

        Dictionary<int, List<DungeonInspireConfig>> dungeonInspireDict = new Dictionary<int, List<DungeonInspireConfig>>();

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

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

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



        public event Action<DungeonCoolDownType> dungeonCoolDownEvent;

@@ -40,6 +41,7 @@
        public event Action<Dungeon> kylinDifficultySelectedEvent;

        public event Action<DungeonFightStage> dungeonFightStageChangeEevent;

        public event Action onCollectNpcInfoRefresh;

        public event Action onAttackNpcInfoRefresh;



        List<Item> sweepResultRewards = new List<Item>();

        List<Item> sweepResultItems = new List<Item>();

@@ -141,6 +143,7 @@
            dungeonCountRemainTimes.Clear();

            dungeonInspireCounts.Clear();

            dungeonCollectNpcInfos.Clear();

            dungeonNpcAttackInfos.Clear();

        }



        public void OnAfterPlayerDataInitialize()

@@ -648,12 +651,29 @@
            }

        }



        public void UpdateDungeonCollectNpcInfo(int npcId,int count)

        public void UpdateDungeonCollectNpcInfo(HA326_tagMCNPCIDCollectionCntInfo package)

        {

            dungeonCollectNpcInfos[npcId] = count;

            for (int i = 0; i < package.CollNPCCnt; i++)

            {

                var data = package.NPCCollCntList[i];

                dungeonCollectNpcInfos[(int)data.NPCID] = data.CollectionCnt;

            }

            if (onCollectNpcInfoRefresh != null)

            {

                onCollectNpcInfoRefresh();

            }

        }



        public void UpdateDungeonAttackNpcInfo(HA325_tagMCNPCAttackCountInfo package)

        {

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

            {

                var data = package.NPCAttackCountList[i];

                dungeonNpcAttackInfos[(int)data.NPCID] = data.AttackCount;

            }

            if (onAttackNpcInfoRefresh != null)

            {

                onAttackNpcInfoRefresh();

            }

        }



@@ -768,6 +788,15 @@
            return 0;

        }



        public int GetDungeonNpcAttackCount(int npcId)

        {

            if (dungeonNpcAttackInfos.ContainsKey(npcId))

            {

                return dungeonNpcAttackInfos[npcId];

            }

            return 0;

        }



        public void UpdateMission(string _mission)

        {

            var mapId = GetDataMapIdByMapId(PlayerDatas.Instance.baseData.MapID);


 System/Dungeon/DungeonTargetBehaviour.cs

@@ -177,6 +177,15 @@
                        break;
                    }
                    m_TargetNums[_index].text = collectCount.ToString();
                    break;

                case DungeonTargetType.AttackCount:
                    var attackCount = model.GetDungeonNpcAttackCount(npcId);
                    if (_targetValue > 0)

                    {
                        m_TargetNums[_index].text = StringUtility.Contact(attackCount, "/", _targetValue);
                        break;
                    }
                    m_TargetNums[_index].text = attackCount.ToString();
                    break;
            }
        }

 System/EquipTrain/EquipTrainPropertyBarBehaviour.cs

@@ -98,7 +98,7 @@
                {
                    if (operateType == EquipTrainModel.TrainOperateType.Train)
                    {
                        m_DeltaValue.text = inevitable ? "必增" : "";
                        m_DeltaValue.text = inevitable ? "最大" : "";
                        m_DeltaValue.color = UIHelper.GetUIColor(TextColType.Green, true);
                    }
                    else if (operateType == EquipTrainModel.TrainOperateType.Save)

 System/ItemTip/EquipTipUtility.cs

@@ -116,7 +116,8 @@
        static EquipTrainModel trainModel { get { return ModelCenter.Instance.GetModel<EquipTrainModel>(); } }
        static EquipStrengthModel strengthenModel { get { return ModelCenter.Instance.GetModel<EquipStrengthModel>(); } }
        static MountModel mountModel { get { return ModelCenter.Instance.GetModel<MountModel>(); } }
        static PetModel perModel { get { return ModelCenter.Instance.GetModel<PetModel>(); } }
        static PetModel petModel { get { return ModelCenter.Instance.GetModel<PetModel>(); } }
        static ComposeWinModel composeModel { get { return ModelCenter.Instance.GetModel<ComposeWinModel>(); } }

        public static TipType tipType { get; private set; }
        public static TipData mainTipData { get; private set; }
@@ -373,6 +374,15 @@
                case ItemOperateType.split:
                    ItemOperateUtility.Instance.OnClickSplitBtn(guid);
                    break;
                case ItemOperateType.compose:
                    var wannaComposeItem = packModel.GetItemByGuid(guid);
                    var jumpId = 0;
                    var isUnlock = composeModel.CheckComposeItemById(wannaComposeItem.itemId, out jumpId);
                    if (isUnlock)
                    {
                        ItemOperateUtility.Instance.GotoComposeItem(jumpId);
                    }
                    break;
            }
        }

@@ -499,7 +509,7 @@
            {
                case 26:
                    var petId = PetInfoConfig.GetItemUnLockPet(itemId);
                    properties = perModel.GetPetAttrAddDict(petId);
                    properties = petModel.GetPetAttrAddDict(petId);
                    break;
                case 41:
                case 42:
@@ -892,6 +902,15 @@
                operates.Add(ItemOperateType.inlay);
            }

            if (!config.JumpComposeCondi.IsNullOrEmpty())
            {
                var jumpId = 0;
                if (composeModel.CheckComposeItemById(itemId, out jumpId))
                {
                    operates.Add(ItemOperateType.compose);
                }
            }

            return operates;
        }


 System/ItemTip/ItemTipWin.cs

@@ -200,6 +200,9 @@
                    case ItemOperateType.putIn:
                        this.m_Title.text = "放入";
                        break;
                    case ItemOperateType.compose:
                        this.m_Title.text = "合成";
                        break;
                    default:
                        this.m_Title.text = "";
                        break;

 System/ItemTip/PetMountTipWin.cs

@@ -232,7 +232,7 @@

                m_Button.SetListener(() =>
                {
                    WindowCenter.Instance.Close<ItemTipWin>();
                    WindowCenter.Instance.Close<PetMountTipWin>();
                    EquipTipUtility.Operate(operateType, this.guid);
                });
            }

 System/MainInterfacePanel/HighSettingTip.cs

@@ -204,14 +204,15 @@
            }

            else

            {

                if (PlayerDatas.Instance.baseData.LV < limitlv)

                {

                    SysNotifyMgr.Instance.ShowTip("CrossMatching14", limitlv);

                }

                else

                {

                    SysNotifyMgr.Instance.ShowTip("CrossMatching15", crossServerModel.afterOpenDayOpenCross);

                }

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

                //if (PlayerDatas.Instance.baseData.LV < limitlv)

                //{

                //    SysNotifyMgr.Instance.ShowTip("CrossMatching14", limitlv);

                //}

                //else

                //{

                //    SysNotifyMgr.Instance.ShowTip("CrossMatching15", crossServerModel.afterOpenDayOpenCross);

                //}

            }

        }




 System/MainInterfacePanel/LowSettingTip.cs

@@ -74,7 +74,7 @@
        void OnClickBagualuBtn()

        {

            WindowCenter.Instance.Close<MainInterfaceWin>();

            WindowCenter.Instance.Open<BlastFurnaceWin>();

            WindowCenter.Instance.Open<AlchemyBaseWin>();

        }



        void SkillButton()


 System/Realm/ActivateShow.cs

@@ -163,10 +163,10 @@
            var model = ModelCenter.Instance.GetModel<BlastFurnaceModel>();

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

            {

                if(stoveLv == model.alchemyModellist[i].BlastFurnaceLV)

                {

                    skills.Add(model.alchemyModellist[i].AlchemyID);

                }

                //if(stoveLv == model.alchemyModellist[i].BlastFurnaceLV)

                //{

                //    skills.Add(model.alchemyModellist[i].AlchemyID);

                //}

            }



            var _beforeConfig = RefineStoveConfig.Get(beforeLv);


 System/Tip/PromoteDetailsWin.cs

@@ -110,7 +110,7 @@
                    //WindowCenter.Instance.Open<EquipReinforceWin>(false, 1);

                    break;

                case RolePromoteModel.PromoteDetailType.BlastFurnace:

                    WindowCenter.Instance.Open<BlastFurnaceWin>(false, 1);

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

                    break;

            }

            CloseClick();


 System/Treasure/FairyTreasureCollectPanelPattern5.cs

@@ -401,7 +401,7 @@
        {

            WindowCenter.Instance.Close<TreasureBaseWin>();

            WindowCenter.Instance.Close<MainInterfaceWin>();

            WindowCenter.Instance.Open<BlastFurnaceWin>();

            WindowCenter.Instance.Open<AlchemyBaseWin>();

        }



        private void Active()


 System/WindowBase/ModelCenter.cs

@@ -235,6 +235,7 @@
            RegisterModel<HazyDemonKingModel>();

            RegisterModel<HazyGrassModel>();

            RegisterModel<DungeonUseBuffModel>();

            RegisterModel<AlchemyModel>();

            inited = true;

        }




 System/WindowBase/WindowCenter.cs

@@ -77,6 +77,11 @@
            }

        }



        public WindowType GetWindowType(string name)

        {

            return windows.GetWindowType(name);

        }



        public void OpenFromLocal<T>() where T : Window

        {

            var command = new OpenCommand()

@@ -768,6 +773,18 @@
                windowKeys.Remove(key);

            }



            public WindowType GetWindowType(string key)

            {

                if (windows.ContainsKey(key))

                {

                    return windows[key].windowInfo.windowType;

                }

                else

                {

                    return WindowType.Flag;

                }

            }



        }



    }


 System/WindowJump/WindowJumpMgr.cs

@@ -80,6 +80,12 @@
        for (int i = 0; i < windowKeys.Count; i++)

        {

            var key = windowKeys[i];

            var type = WindowCenter.Instance.GetWindowType(key);

            if (type >= WindowType.Tip && type <= WindowType.Loading)

            {

                continue;

            }



            if (WindowCenter.Instance.IsOpen(key) && key != "NewBieWin")

            {

                if (!openWindows.ContainsKey(jumpPhase))

@@ -382,7 +388,7 @@
                SetJumpLogic<LootPreciousFrameWin>(_tagWinSearchModel.TABID);

                break;

            case JumpUIType.BlastFurnaceFunc1:

                SetJumpLogic<BlastFurnaceWin>(_tagWinSearchModel.TABID);

                SetJumpLogic<AlchemyBaseWin>(_tagWinSearchModel.TABID);

                break;

            case JumpUIType.MyTeamType1:

            case JumpUIType.TeamListType1:

@@ -498,7 +504,7 @@
                {

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

                }

                SetJumpLogic<BlastFurnaceWin>(_tagWinSearchModel.TABID);

                SetJumpLogic<AlchemyBaseWin>(_tagWinSearchModel.TABID);

                break;

            case JumpUIType.SevenDaysTour281:

            case JumpUIType.SevenDaysTour282:

@@ -535,7 +541,7 @@
            case JumpUIType.Alchemyrescripte104:

            case JumpUIType.Alchemyrescripte105:

                ModelCenter.Instance.GetModel<BlastFurnaceModel>().jumpToPrescripe = int.Parse(_tagWinSearchModel.SelectActive);

                SetJumpLogic<BlastFurnaceWin>(_tagWinSearchModel.TABID);

                SetJumpLogic<AlchemyBaseWin>(_tagWinSearchModel.TABID);

                break;

            case JumpUIType.AttackMagicianType1:

            case JumpUIType.AttackMagicianType2:


 System/WorldMap/LocalMapEventPointToggle.cs

@@ -14,11 +14,9 @@
    public class LocalMapEventPointToggle : ScrollItem

    {

        [SerializeField] RectTransform m_LayoutLeft;

        [SerializeField] RectTransform m_LayoutRight;

        [SerializeField] ButtonEx m_Button;

        [SerializeField] Image m_Icon;

        [SerializeField] TextEx m_Title;

        [SerializeField] Text m_Level;

        [SerializeField] Text m_Description;

        [SerializeField] Transform m_Selected;

        [SerializeField] Button m_FlyBoot;

        [SerializeField] Image m_MonsterType;

@@ -37,7 +35,7 @@
            var mapConfig = MapConfig.Get(PlayerDatas.Instance.baseData.MapID);

            m_LayoutLeft.gameObject.SetActive(mapConfig.MapFBType == (int)MapType.OpenCountry);



            DrawEventInfo();

            DisplayEventInfo();

            OnSelected(model.selectedMapEventPoint);

            model.selectMapEventPointEvent += OnSelected;

        }

@@ -50,41 +48,57 @@


        private void Awake()

        {

            this.m_Button.AddListener(SelectEventPoint);

            this.m_FlyBoot.AddListener(FlyToEventPoint);

            this.m_Button.SetListener(SelectEventPoint);

            this.m_FlyBoot.SetListener(FlyToEventPoint);

        }



        private void DrawEventInfo()

        private void DisplayEventInfo()

        {

            var config = MapEventPointConfig.Get(this.m_EventId);

            var tagChinNpcMod = NPCConfig.Get(config.NPCID);

            this.m_Title.text = tagChinNpcMod != null ? tagChinNpcMod.charName : "";

            if (config.LowLV == config.HighestLV)

            var npcConfig = NPCConfig.Get(config.NPCID);

            this.m_Title.text = npcConfig != null ? npcConfig.charName : "";



            if (npcConfig.NPCType == 0)

            {

                this.m_Level.text = Language.Get("Z1024", config.LowLV);

                this.m_Description.text = config.NpcDescription;

                this.m_MonsterType.gameObject.SetActive(true);

            }

            else

            {

                this.m_Level.text = StringUtility.Contact(Language.Get("Z1024", config.LowLV), "-", config.HighestLV);

                if (config.LowLV == config.HighestLV)

                {

                    this.m_Description.text = Language.Get("Z1024", config.LowLV);

                }

                else

                {

                    this.m_Description.text = StringUtility.Contact(Language.Get("Z1024", config.LowLV), "-", config.HighestLV);

                }



                this.m_MonsterType.gameObject.SetActive(false);

                this.m_MonsterType.SetSprite(StringUtility.Contact("MapNPC_Colour_", config.Colour));

            }



            this.m_MonsterType.SetSprite(StringUtility.Contact("MapNPC_Colour_", config.Colour));

        }



        private void FlyToEventPoint()

        {

            var flyBootOwn = playerPack.GetItemCountByID(PackType.Item, GeneralDefine.flyBootItemId);

            var isVipFreeTransfer = ModelCenter.Instance.GetModel<VipModel>().GetVipPrivilegeCnt(VipPrivilegeType.FreeTransfer) > 0;

            if (isVipFreeTransfer || flyBootOwn > 0)

            var free = ModelCenter.Instance.GetModel<VipModel>().GetVipPrivilegeCnt(VipPrivilegeType.FreeTransfer) > 0;

            if (free)

            {

                MoveToNpc();

                return;

            }

            else



            var hasFlyBoot = playerPack.GetItemCountByID(PackType.Item, GeneralDefine.flyBootItemId) > 0;

            if (hasFlyBoot)

            {

                FlyShoseConfirmwin.useEnvironment = FlyShoseConfirmwin.UseEnvironment.LocalMap;

                FlyShoseConfirmwin.confirmCallBack = MoveToNpc;

                WindowCenter.Instance.Open<FlyShoseConfirmwin>();

                MoveToNpc();

                return;

            }



            FlyShoseConfirmwin.useEnvironment = FlyShoseConfirmwin.UseEnvironment.LocalMap;

            FlyShoseConfirmwin.confirmCallBack = MoveToNpc;

            WindowCenter.Instance.Open<FlyShoseConfirmwin>();

        }



        private void MoveToNpc()

@@ -106,7 +120,7 @@
        {

            var selected = _event == m_EventId;

            m_Selected.gameObject.SetActive(selected);

            this.m_Title.color = this.m_Level.color = m_FontColor.GetColorSize(selected ? "Selected" : "Normal").color;

            this.m_Title.color = this.m_Description.color = m_FontColor.GetColorSize(selected ? "Selected" : "Normal").color;

        }



    }


 System/WorldMap/LocalMapFindPath.cs

@@ -404,9 +404,19 @@


        private void FoucsEventPoint(int _eventPoint)

        {

            var config = MapEventPointConfig.Get(_eventPoint);

            if (config != null)

            {

                var npcConfig = NPCConfig.Get(config.NPCID);

                if (npcConfig.NPCType == 0)

                {

                    m_EventPointInstroduce.gameObject.SetActive(false);

                    return;

                }

            }



            if (model.selectedMapEventPoint != -1)

            {

                var config = MapEventPointConfig.Get(_eventPoint);

                var monsterRefreshConfig = MonsterRefreshPointConfig.Get(config.NPCID);

                var position = new Vector3(monsterRefreshConfig.Position.x * 0.5f, 0, monsterRefreshConfig.Position.y * 0.5f);




 System/WorldMap/LocalMapTag.cs

@@ -18,40 +18,28 @@
        [SerializeField] TextEx m_Level;

        [SerializeField] Button m_Moveto;

        [SerializeField] Image m_TaskState;

        [SerializeField] UIEffect m_Effect;



        TagType m_TagType;

        public TagType tagType {

            get {

                return m_TagType;

            }

            set {

                m_TagType = value;

            }

            get { return m_TagType; }

            set { m_TagType = value; }

        }



        LocalMapFindPath localMapFindPath;

        Vector3 worldPosition = Vector3.zero;

        int npcId = 0;

        int index = 0;

        TaskModel taskmodel {

            get {

                return ModelCenter.Instance.GetModel<TaskModel>();

            }

        }



        FairyLeagueModel fairyLeagueModel {

            get {

                return ModelCenter.Instance.GetModel<FairyLeagueModel>();

            }

        }

        MapModel mapModel { get { return ModelCenter.Instance.GetModel<MapModel>(); } }

        TaskModel taskModel { get { return ModelCenter.Instance.GetModel<TaskModel>(); } }

        FairyLeagueModel fairyLeagueModel { get { return ModelCenter.Instance.GetModel<FairyLeagueModel>(); } }



        public void Display(int _npcId, TextColType _colorType)

        public void Display(int npcId, TextColType colorType)

        {

            npcId = _npcId;

            this.npcId = npcId;

            switch (m_TagType)

            {

                case TagType.Function:

                    var status = taskmodel.StatusLightQuery(npcId);

                    var status = this.taskModel.StatusLightQuery(this.npcId);

                    if (status > 0)

                    {

                        m_TaskState.SetSprite(StringUtility.Contact("LocalMapTaskState_", status));

@@ -64,6 +52,10 @@
                    m_TaskState.SetNativeSize();

                    TaskModel.Event_TaskResponse -= OnTaskStateChange;

                    TaskModel.Event_TaskResponse += OnTaskStateChange;



                    OnSelectEvent(mapModel.selectedMapEventPoint);

                    mapModel.selectMapEventPointEvent -= OnSelectEvent;

                    mapModel.selectMapEventPointEvent += OnSelectEvent;

                    break;

                case TagType.WayPoint:

                    break;

@@ -71,61 +63,88 @@
                    break;

                case TagType.Elite:

                case TagType.Monster:

                    var config = NPCConfig.Get(npcId);

                    var config = NPCConfig.Get(this.npcId);

                    m_NpcName.text = config.charName;

                    m_NpcName.colorType = _colorType;

                    m_NpcName.colorType = colorType;

                    break;

                case TagType.Crystal:

                    OnCrystalStateChange(npcId);

                    this.OnCrystalStateChange(this.npcId);

                    m_Moveto.RemoveAllListeners();

                    m_Moveto.AddListener(MoveTo);

                    PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshInfoEvent;

                    PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshInfoEvent;

                    PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshEvent;

                    PlayerDatas.Instance.playerDataRefreshEvent += PlayerDataRefreshEvent;

                    fairyLeagueModel.UpdateWarCrystalEvent -= OnCrystalStateChange;

                    fairyLeagueModel.UpdateWarCrystalEvent += OnCrystalStateChange;

                    break;

            }

        }



        public void Display(int _npcId, TextColType _colorType, Vector3 _position)

        public void Display(int npcId, TextColType colorType, Vector3 _position)

        {

            worldPosition = _position;

            npcId = _npcId;



            this.npcId = npcId;

            switch (m_TagType)

            {

                case TagType.Boss:

                    var config = NPCConfig.Get(npcId);

                    var config = NPCConfig.Get(this.npcId);

                    m_NpcName.text = config.charName;

                    m_Level.text = Language.Get("HeadUpName_Monster", config.NPCLV);

                    m_NpcName.colorType = _colorType;

                    m_NpcName.colorType = colorType;

                    var dangerous = PlayerDatas.Instance.baseData.LV <= config.NPCLV;

                    m_Level.color = UIHelper.GetUIColor(dangerous ? TextColType.Red : TextColType.Green, false);

                    m_Moveto.RemoveAllListeners();

                    m_Moveto.AddListener(MoveTo);

                    m_Moveto.SetListener(MoveTo);

                    break;

                default:

                    break;

            }

        }



        public void Display(int _index)

        public void Display(int index)

        {

            index = _index;

            this.index = index;

            switch (m_TagType)

            {

                case TagType.FairyLeagueBuff:

                    m_Moveto.RemoveAllListeners();

                    m_Moveto.AddListener(MoveTo);

                    m_Moveto.SetListener(MoveTo);

                    break;

            }

        }



        public void Dispose()

        {

            mapModel.selectMapEventPointEvent += OnSelectEvent;

            TaskModel.Event_TaskResponse -= OnTaskStateChange;

            fairyLeagueModel.UpdateWarCrystalEvent -= OnCrystalStateChange;

            PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshInfoEvent;

            PlayerDatas.Instance.playerDataRefreshEvent -= PlayerDataRefreshEvent;

        }



        private void OnSelectEvent(int eventId)

        {

            var config = MapEventPointConfig.Get(eventId);



            var isFunctionNpc = false;

            if (config != null && config.NPCID == this.npcId)

            {

                var npcConfig = NPCConfig.Get(config.NPCID);

                if (npcConfig.NPCType == 0)

                {

                    isFunctionNpc = true;

                }

            }



            if (isFunctionNpc)

            {

                if (!m_Effect.IsPlaying)

                {

                    m_Effect.Play();

                }

            }

            else

            {

                if (m_Effect.IsPlaying)

                {

                    m_Effect.Stop();

                }

            }

        }



        private void MoveTo()

@@ -134,33 +153,31 @@
            {

                case TagType.FairyLeagueBuff:

                    {

                        var _help = fairyLeagueModel.fairyLeagueHelp;

                        Vector2 _buffPos = fairyLeagueModel.crystalPosList[index];

                        var _hero = PlayerDatas.Instance.hero;

                        if (_hero != null)

                        var buffPos = fairyLeagueModel.crystalPosList[index];

                        var hero = PlayerDatas.Instance.hero;

                        if (hero != null)

                        {

                            _hero.MoveToPosition(new Vector3(_buffPos.x, _hero.Pos.y, _buffPos.y));

                            hero.MoveToPosition(new Vector3(buffPos.x, hero.Pos.y, buffPos.y));

                        }

                    }

                    break;

                default:

                    {

                        var model = ModelCenter.Instance.GetModel<MapModel>();

                        WindowCenter.Instance.Close<WorldMapWin>();

                        WindowCenter.Instance.Close<LocalMapWin>();

                        WindowCenter.Instance.Open<MainInterfaceWin>();

                        MapTransferUtility.Instance.MoveToNPC(npcId);

                        model.selectedMapEventPoint = -1;

                        mapModel.selectedMapEventPoint = -1;

                    }

                    break;

            }

        }



        private void OnTaskStateChange(int _nowNPCid, int _nPCLamp, Dictionary<int, int> _dic)

        private void OnTaskStateChange(int nowNpcId, int npcLamp, Dictionary<int, int> dic)

        {

            if (npcId == _nowNPCid)

            if (npcId == nowNpcId)

            {

                var status = taskmodel.StatusLightQuery(npcId);

                var status = taskModel.StatusLightQuery(npcId);

                if (status > 0)

                {

                    m_TaskState.SetSprite(StringUtility.Contact("LocalMapTaskState_", status));

@@ -178,31 +195,34 @@
            OnCrystalStateChange(npcId);

        }



        private void PlayerDataRefreshInfoEvent(PlayerDataType _type)

        private void PlayerDataRefreshEvent(PlayerDataType type)

        {

            if (_type == PlayerDataType.Faction)

            if (type == PlayerDataType.Faction)

            {

                OnCrystalStateChange();

            }

        }



        private void OnCrystalStateChange(int _npcId)

        private void OnCrystalStateChange(int npcId)

        {

            if (npcId != _npcId)

            if (this.npcId != npcId)

            {

                return;

            }

            var _index = fairyLeagueModel.GetCrystalIndex(_npcId);

            m_NpcName.text = (_index + 1).ToString();

            var _camp = fairyLeagueModel.fairyLeagueHelp.GetCrystalBelongCamp(_npcId);

            if (_camp == 0)



            var index = fairyLeagueModel.GetCrystalIndex(npcId);

            m_NpcName.text = (index + 1).ToString();

            var camp = fairyLeagueModel.fairyLeagueHelp.GetCrystalBelongCamp(npcId);

            if (camp == 0)

            {

                m_TaskState.SetSprite("GrayCrystal");

                m_Moveto.image.SetSprite("GreyBottom");

                return;

            }

            m_TaskState.SetSprite((FairyCampType)_camp == FairyCampType.Blue ? "BlueCrystal" : "RedCrystal");

            m_Moveto.image.SetSprite((FairyCampType)_camp == FairyCampType.Blue ? "BlueBottom" : "RedBottom");



            var isBlue = (FairyCampType)camp == FairyCampType.Blue;

            m_TaskState.SetSprite(isBlue ? "BlueCrystal" : "RedCrystal");

            m_Moveto.image.SetSprite(isBlue ? "BlueBottom" : "RedBottom");

        }



        public enum TagType

@@ -222,13 +242,13 @@
    {

        static Dictionary<int, GameObjectPoolManager.GameObjectPool> pools = new Dictionary<int, GameObjectPoolManager.GameObjectPool>();



        public static LocalMapTag Require(LocalMapTag.TagType _pattern)

        public static LocalMapTag Require(LocalMapTag.TagType pattern)

        {

            GameObjectPoolManager.GameObjectPool pool = null;

            var poolKey = (int)_pattern;

            var poolKey = (int)pattern;

            if (!pools.ContainsKey(poolKey))

            {

                var prefab = UILoader.LoadPrefab(StringUtility.Contact("LocalMap_", _pattern));

                var prefab = UILoader.LoadPrefab(StringUtility.Contact("LocalMap_", pattern));

                if (prefab != null)

                {

                    pool = GameObjectPoolManager.Instance.RequestPool(prefab);

@@ -244,7 +264,7 @@
            {

                var instance = pool.Request();

                var npcBehaviour = instance.GetComponent<LocalMapTag>();

                npcBehaviour.tagType = _pattern;

                npcBehaviour.tagType = pattern;

                npcBehaviour.enabled = true;

                return npcBehaviour;

            }

@@ -254,14 +274,14 @@
            }

        }



        public static void Recycle(LocalMapTag _npcBehaviour)

        public static void Recycle(LocalMapTag behaviour)

        {

            var pattern = _npcBehaviour.tagType;

            var pattern = behaviour.tagType;

            GameObjectPoolManager.GameObjectPool pool;

            if (pools.TryGetValue((int)pattern, out pool))

            {

                _npcBehaviour.enabled = false;

                pool.Release(_npcBehaviour.gameObject);

                behaviour.enabled = false;

                pool.Release(behaviour.gameObject);

            }

        }




 Utility/ConfigInitiator.cs

@@ -243,7 +243,6 @@
        normalTasks.Add(new ConfigInitTask("EquipDeComposeConfig", () => { EquipDeComposeConfig.Init(); }, () => { return EquipDeComposeConfig.inited; }));
        normalTasks.Add(new ConfigInitTask("EquipGSParamConfig", () => { EquipGSParamConfig.Init(); }, () => { return EquipGSParamConfig.inited; }));
        normalTasks.Add(new ConfigInitTask("EquipSuitAttrConfig", () => { EquipSuitAttrConfig.Init(); }, () => { return EquipSuitAttrConfig.inited; }));
        normalTasks.Add(new ConfigInitTask("EquipSuitCompoundConfig", () => { EquipSuitCompoundConfig.Init(); }, () => { return EquipSuitCompoundConfig.inited; }));
        normalTasks.Add(new ConfigInitTask("EquipWashConfig", () => { EquipWashConfig.Init(); }, () => { return EquipWashConfig.inited; }));
        normalTasks.Add(new ConfigInitTask("EquipWashSpecConfig", () => { EquipWashSpecConfig.Init(); }, () => { return EquipWashSpecConfig.inited; }));
        normalTasks.Add(new ConfigInitTask("FaceConfig", () => { FaceConfig.Init(); }, () => { return FaceConfig.inited; }));
@@ -292,7 +291,8 @@
        normalTasks.Add(new ConfigInitTask("HazyRegionConfig", () => { HazyRegionConfig.Init(); }, () => { return HazyRegionConfig.inited; }));

        normalTasks.Add(new ConfigInitTask("AdventureDialogueConfig", () => { AdventureDialogueConfig.Init(); }, () => { return AdventureDialogueConfig.inited; }));
        normalTasks.Add(new ConfigInitTask("MapNpcRefreshConfig", () => { MapNpcRefreshConfig.Init(); }, () => { return MapNpcRefreshConfig.inited; }));

        normalTasks.Add(new ConfigInitTask("DungeonUseBuffConfig", () => { DungeonUseBuffConfig.Init(); }, () => { return DungeonUseBuffConfig.inited; }));
        normalTasks.Add(new ConfigInitTask("DungeonUseBuffConfig", () => { DungeonUseBuffConfig.Init(); }, () => { return DungeonUseBuffConfig.inited; }));

        normalTasks.Add(new ConfigInitTask("AlchemyCountConfig", () => { AlchemyCountConfig.Init(); }, () => { return AlchemyCountConfig.inited; }));
    }

    static List<ConfigInitTask> doingTasks = new List<ConfigInitTask>();

 Utility/EnumHelper.cs

@@ -139,6 +139,8 @@
    Tip = 3,

    System = 4,

    Loading = 5,



    Flag=99,

}



public enum GestureType

@@ -1186,7 +1188,8 @@
    NPCDialogue = 8,    //npc对话

    VictorySumCnt = 9, //（仙魔胜利总场数）

    StageVictoryCnt = 10, //（阶段胜利场数）

    Collect,

    Collect = 11,

    AttackCount = 12,

}



public enum AchievementType