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

client_linchunjie

2019-01-28 e0872807ff52affb0cf7dec2796481ef3fcffe40

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

 Core/GameEngine/DataToCtl/PackageRegedit.cs

@@ -440,6 +440,10 @@
        Register(typeof(HA806_tagMCMysticalShopTimeInfo), typeof(DTCA806_tagMCMysticalShopTimeInfo));

        Register(typeof(HAA0A_tagMCWeekPartyInfo), typeof(DTCAA0A_tagMCWeekPartyInfo));

        Register(typeof(HAA0B_tagMCWeekPartyPlayerInfo), typeof(DTCAA0B_tagMCWeekPartyPlayerInfo));

        Register(typeof(HAA0C_tagMCActLoginAwardInfo), typeof(DTCAA0C_tagMCActLoginAwardInfo));

        Register(typeof(HAA0D_tagMCActLoginAwardPlayerInfo), typeof(DTCAA0D_tagMCActLoginAwardPlayerInfo));

        Register(typeof(HAA20_tagMCFeastWeekPartyInfo), typeof(DTCAA20_tagMCFeastWeekPartyInfo));

        Register(typeof(HAA21_tagMCFeastWeekPartyPlayerInfo), typeof(DTCAA21_tagMCFeastWeekPartyPlayerInfo));

    }



    private static void Register(Type _pack, Type _business)


 Core/GameEngine/Model/Config/FashionDressConfig.cs

@@ -1,6 +1,6 @@
//--------------------------------------------------------
//    [Author]:            第二世界
//    [  Date ]:           Tuesday, January 08, 2019
//    [  Date ]:           Monday, January 28, 2019
//--------------------------------------------------------

using UnityEngine;
@@ -14,6 +14,7 @@
        public int CoatID { get ; private set ; }

        public string name { get ; private set; } 

        public int type { get ; private set ; }

        public int FashionSuitType { get ; private set ; }

        public int quality { get ; private set ; }

        public string getWay { get ; private set; } 

        public int[] EquipItemID;

@@ -36,29 +37,31 @@
            

                type=IsNumeric(rawContents[2]) ? int.Parse(rawContents[2]):0; 

            

                quality=IsNumeric(rawContents[3]) ? int.Parse(rawContents[3]):0; 
                FashionSuitType=IsNumeric(rawContents[3]) ? int.Parse(rawContents[3]):0; 
            

                getWay = rawContents[4].Trim();

                quality=IsNumeric(rawContents[4]) ? int.Parse(rawContents[4]):0; 
            

                string[] EquipItemIDStringArray = rawContents[5].Trim().Split(StringUtility.splitSeparator,StringSplitOptions.RemoveEmptyEntries);
                getWay = rawContents[5].Trim();

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

            

                UnlockItemID=IsNumeric(rawContents[6]) ? int.Parse(rawContents[6]):0; 
                UnlockItemID=IsNumeric(rawContents[7]) ? int.Parse(rawContents[7]):0; 
            

                MaxLV=IsNumeric(rawContents[7]) ? int.Parse(rawContents[7]):0; 
                MaxLV=IsNumeric(rawContents[8]) ? int.Parse(rawContents[8]):0; 
            

                string[] CostItemCntStringArray = rawContents[8].Trim().Split(StringUtility.splitSeparator,StringSplitOptions.RemoveEmptyEntries);
                string[] CostItemCntStringArray = rawContents[9].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]);
                }

            

                StarAttr = rawContents[9].Trim();
                StarAttr = rawContents[10].Trim();
            }
            catch (Exception ex)
            {

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

@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: 5ac2a701b6eaba844b1082c87758125e
timeCreated: 1546945768
timeCreated: 1548676001
licenseType: Pro
MonoImporter:
  serializedVersion: 2

 Core/GameEngine/Model/Config/HolidayHomingConfig.cs

New file
@@ -0,0 +1,56 @@
//--------------------------------------------------------
//    [Author]:            第二世界
//    [  Date ]:           Monday, January 28, 2019
//--------------------------------------------------------

using UnityEngine;
using System;

namespace TableConfig {

    
    public partial class HolidayHomingConfig : ConfigBase {

        public int Id { get ; private set ; }

        public int ActionType { get ; private set ; }

        public string Description { get ; private set; } 
        public int jump { get ; private set ; }

        public int order { get ; private set ; }

        public int DailyQusetId { get ; private set ; }

        public int SpecialDisplayType { get ; private set ; }

        public override string getKey()
        {
            return Id.ToString();
        }

        public override void Parse() {
            try
            {
                Id=IsNumeric(rawContents[0]) ? int.Parse(rawContents[0]):0; 
			
                ActionType=IsNumeric(rawContents[1]) ? int.Parse(rawContents[1]):0; 
			
                Description = rawContents[2].Trim();

			
                jump=IsNumeric(rawContents[3]) ? int.Parse(rawContents[3]):0; 
			
                order=IsNumeric(rawContents[4]) ? int.Parse(rawContents[4]):0; 
			
                DailyQusetId=IsNumeric(rawContents[5]) ? int.Parse(rawContents[5]):0; 
			
                SpecialDisplayType=IsNumeric(rawContents[6]) ? int.Parse(rawContents[6]):0; 
            }
            catch (Exception ex)
            {
                DebugEx.Log(ex);
            }
        }
	
    }

}





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

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

 Core/GameEngine/Model/Config/HolidayHomingPointConfig.cs

New file
@@ -0,0 +1,47 @@
//--------------------------------------------------------
//    [Author]:            第二世界
//    [  Date ]:           Monday, January 28, 2019
//--------------------------------------------------------

using UnityEngine;
using System;

namespace TableConfig {

    
    public partial class HolidayHomingPointConfig : ConfigBase {

        public int Id { get ; private set ; }

        public string ImageType1 { get ; private set; } 
        public string ImageType2 { get ; private set; } 
        public string name { get ; private set; } 

        public override string getKey()
        {
            return Id.ToString();
        }

        public override void Parse() {
            try
            {
                Id=IsNumeric(rawContents[0]) ? int.Parse(rawContents[0]):0; 
			
                ImageType1 = rawContents[1].Trim();

			
                ImageType2 = rawContents[2].Trim();

			
                name = rawContents[3].Trim();
            }
            catch (Exception ex)
            {
                DebugEx.Log(ex);
            }
        }
	
    }

}





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

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

 Core/GameEngine/Model/ConfigManager.cs

@@ -232,7 +232,8 @@
        AddAsyncTask<JadeDynastyBossConfig>();

        AddAsyncTask<JadeDynastySuitAttrConfig>();

        AddAsyncTask<SkillFrameAnimationConfig>();



        AddAsyncTask<HolidayHomingConfig>();

        AddAsyncTask<HolidayHomingPointConfig>();

        while (!AllCompleted())

        {

            var completedCount = 0;


 Core/NetworkPackage/DTCFile/ServerPack/HAA_SaleActivity/DTCAA0A_tagMCWeekPartyInfo.cs

@@ -15,6 +15,7 @@
        {

            return;

        }

        OperationTimeHepler.Instance.OpenServiceAchievement(vNetData);

        model.WeekPartyInfo(vNetData);

    }


}



 Core/NetworkPackage/DTCFile/ServerPack/HAA_SaleActivity/DTCAA0C_tagMCActLoginAwardInfo.cs

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

using System.Collections;

using Snxxz.UI;



// AA 0C 登录奖励活动信息 #tagMCActLoginAwardInfo







public class DTCAA0C_tagMCActLoginAwardInfo : DtcBasic {



    LoginRewardModel m_LoginRewardModel;

    LoginRewardModel loginRewardModel { get { return m_LoginRewardModel ?? (m_LoginRewardModel = ModelCenter.Instance.GetModel<LoginRewardModel>()); } }

    public override void Done(GameNetPackBasic vNetPack) {

        base.Done(vNetPack);

        HAA0C_tagMCActLoginAwardInfo vNetData = vNetPack as HAA0C_tagMCActLoginAwardInfo;
        if (vNetData == null)

        {

            return;

        }

        OperationTimeHepler.Instance.RefreshLoginReward(vNetData);
        loginRewardModel.LoginAwardInfo(vNetData);

    }

}


 Core/NetworkPackage/DTCFile/ServerPack/HAA_SaleActivity/DTCAA0C_tagMCActLoginAwardInfo.cs.meta

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

 Core/NetworkPackage/DTCFile/ServerPack/HAA_SaleActivity/DTCAA0D_tagMCActLoginAwardPlayerInfo.cs

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

using System.Collections;

using Snxxz.UI;



// AA 0D 登录奖励玩家活动信息 #tagMCActLoginAwardPlayerInfo







public class DTCAA0D_tagMCActLoginAwardPlayerInfo : DtcBasic {

    LoginRewardModel m_LoginRewardModel;

    LoginRewardModel loginRewardModel { get { return m_LoginRewardModel ?? (m_LoginRewardModel = ModelCenter.Instance.GetModel<LoginRewardModel>()); } }

    public override void Done(GameNetPackBasic vNetPack) {

        base.Done(vNetPack);

        HAA0D_tagMCActLoginAwardPlayerInfo vNetData = vNetPack as HAA0D_tagMCActLoginAwardPlayerInfo;
        if (vNetData == null)

        {

            return;

        }

        loginRewardModel.LoginAwardPlayerInfo(vNetData);

    }

}


 Core/NetworkPackage/DTCFile/ServerPack/HAA_SaleActivity/DTCAA0D_tagMCActLoginAwardPlayerInfo.cs.meta

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

 Core/NetworkPackage/DTCFile/ServerPack/HAA_SaleActivity/DTCAA20_tagMCFeastWeekPartyInfo.cs

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

using System.Collections;

using Snxxz.UI;



// AA 20 节日巡礼活动信息 #tagMCFeastWeekPartyInfo







public class DTCAA20_tagMCFeastWeekPartyInfo : DtcBasic

{

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

    public override void Done(GameNetPackBasic vNetPack)

    {

        base.Done(vNetPack);

        HAA20_tagMCFeastWeekPartyInfo vNetData = vNetPack as HAA20_tagMCFeastWeekPartyInfo;
        if (vNetData == null)

        {

            return;

        }

        OperationTimeHepler.Instance.SpringFestival(vNetData);

        model.SpringFestivalTemplate(vNetData);

    }

}


 Core/NetworkPackage/DTCFile/ServerPack/HAA_SaleActivity/DTCAA20_tagMCFeastWeekPartyInfo.cs.meta

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

 Core/NetworkPackage/DTCFile/ServerPack/HAA_SaleActivity/DTCAA21_tagMCFeastWeekPartyPlayerInfo.cs

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

using System.Collections;

using Snxxz.UI;



// AA 21 节日巡礼玩家活动信息 #tagMCFeastWeekPartyPlayerInfo







public class DTCAA21_tagMCFeastWeekPartyPlayerInfo : DtcBasic

{

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

    public override void Done(GameNetPackBasic vNetPack)

    {

        base.Done(vNetPack);

        HAA21_tagMCFeastWeekPartyPlayerInfo vNetData = vNetPack as HAA21_tagMCFeastWeekPartyPlayerInfo;

        if (vNetData == null)

        {

            return;

        }

        model.SpringFestivalInfo(vNetData);

    }

}


 Core/NetworkPackage/DTCFile/ServerPack/HAA_SaleActivity/DTCAA21_tagMCFeastWeekPartyPlayerInfo.cs.meta

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

 Core/NetworkPackage/ServerPack/HAA_SaleActivity/HAA0C_tagMCActLoginAwardInfo.cs

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

using System.Collections;



// AA 0C 登录奖励活动信息 #tagMCActLoginAwardInfo



public class HAA0C_tagMCActLoginAwardInfo : GameNetPackBasic {

    public string StartDate;    // 开始日期 y-m-d

    public string EndtDate;    // 结束日期 y-m-d

    public ushort AdvanceMinutes;    // 提前显示分钟

    public byte IsDayReset;    //是否每天重置

    public byte ResetType;    // 重置类型，0-0点重置；1-5点重置

    public ushort LimitLV;    // 限制等级

    public byte DayCnt;    // 天数

    public  tagMCActLoginAwardDayInfo[] DayInfoList;    // 每天模板

    public byte TCount;    // 模板数

    public  tagMCActLoginAwardAction[] ActionInfo;    // 活动模板信息



    public HAA0C_tagMCActLoginAwardInfo () {

        _cmd = (ushort)0xAA0C;

    }



    public override void ReadFromBytes (byte[] vBytes) {

        TransBytes (out StartDate, vBytes, NetDataType.Chars, 10);

        TransBytes (out EndtDate, vBytes, NetDataType.Chars, 10);

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

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

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

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

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

        DayInfoList = new tagMCActLoginAwardDayInfo[DayCnt];

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

            DayInfoList[i] = new tagMCActLoginAwardDayInfo();

            TransBytes (out DayInfoList[i].ActCnt, vBytes, NetDataType.BYTE);

            TransBytes (out DayInfoList[i].TemplateList, vBytes, NetDataType.WORD, DayInfoList[i].ActCnt);

        }

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

        ActionInfo = new tagMCActLoginAwardAction[TCount];

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

            ActionInfo[i] = new tagMCActLoginAwardAction();

            TransBytes (out ActionInfo[i].TemplateID, vBytes, NetDataType.DWORD);

            TransBytes (out ActionInfo[i].ActionType, vBytes, NetDataType.WORD);

            TransBytes (out ActionInfo[i].TotalTimes, vBytes, NetDataType.DWORD);

            TransBytes (out ActionInfo[i].SingleTimes, vBytes, NetDataType.DWORD);

            TransBytes (out ActionInfo[i].Count, vBytes, NetDataType.BYTE);

            ActionInfo[i].ItemInfo = new tagMCActLoginAwardItem[ActionInfo[i].Count];

            for (int j = 0; j < ActionInfo[i].Count; j ++) {

                ActionInfo[i].ItemInfo[j] = new tagMCActLoginAwardItem();

                TransBytes (out ActionInfo[i].ItemInfo[j].ItemID, vBytes, NetDataType.DWORD);

                TransBytes (out ActionInfo[i].ItemInfo[j].ItemCnt, vBytes, NetDataType.WORD);

                TransBytes (out ActionInfo[i].ItemInfo[j].IsBind, vBytes, NetDataType.BYTE);

            }

        }

    }



    public struct tagMCActLoginAwardItem {

        public uint ItemID;        // 物品ID

        public ushort ItemCnt;        // 物品数量

        public byte IsBind;        // 是否绑定

    }



    public struct tagMCActLoginAwardAction {

        public uint TemplateID;        // 模板ID

        public ushort ActionType;        // 活动类别

        public uint TotalTimes;        // 可完成的总次数，0表示不限次数

        public uint SingleTimes;        // 单次领奖需要的次数

        public byte Count;        // 物品数

        public  tagMCActLoginAwardItem[] ItemInfo;        // 物品信息

    }



    public struct tagMCActLoginAwardDayInfo {

        public byte ActCnt;        // 数量

        public  ushort[] TemplateList;        // 模板列表

    }



}


 Core/NetworkPackage/ServerPack/HAA_SaleActivity/HAA0C_tagMCActLoginAwardInfo.cs.meta

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

 Core/NetworkPackage/ServerPack/HAA_SaleActivity/HAA0D_tagMCActLoginAwardPlayerInfo.cs

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

using System.Collections;



// AA 0D 登录奖励玩家活动信息 #tagMCActLoginAwardPlayerInfo



public class HAA0D_tagMCActLoginAwardPlayerInfo : GameNetPackBasic {

    public byte Count;

    public  tagMCActLoginAwardDayPlayerInfo[] DayInfoList;    //活动完成次数信息



    public HAA0D_tagMCActLoginAwardPlayerInfo () {

        _cmd = (ushort)0xAA0D;

    }



    public override void ReadFromBytes (byte[] vBytes) {

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

        DayInfoList = new tagMCActLoginAwardDayPlayerInfo[Count];

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

            DayInfoList[i] = new tagMCActLoginAwardDayPlayerInfo();

            TransBytes (out DayInfoList[i].DayIndex, vBytes, NetDataType.DWORD);

            TransBytes (out DayInfoList[i].ACount, vBytes, NetDataType.DWORD);

            DayInfoList[i].TaskList = new tagMCActLoginAwardTaskInfo[DayInfoList[i].ACount];

            for (int j = 0; j < DayInfoList[i].ACount; j ++) {

                DayInfoList[i].TaskList[j] = new tagMCActLoginAwardTaskInfo();

                TransBytes (out DayInfoList[i].TaskList[j].TemplateID, vBytes, NetDataType.WORD);

                TransBytes (out DayInfoList[i].TaskList[j].CurTimes, vBytes, NetDataType.WORD);

                TransBytes (out DayInfoList[i].TaskList[j].GotTimes, vBytes, NetDataType.WORD);

            }

        }

    }



    public struct tagMCActLoginAwardDayPlayerInfo {

        public uint DayIndex;        //第X天

        public uint ACount;        //任务条目数

        public  tagMCActLoginAwardTaskInfo[] TaskList;        //活动完成次数信息

    }



    public struct tagMCActLoginAwardTaskInfo {

        public ushort TemplateID;        // 模板ID

        public ushort CurTimes;        //已完成次数

        public ushort GotTimes;        //已领取次数

    }



}


 Core/NetworkPackage/ServerPack/HAA_SaleActivity/HAA0D_tagMCActLoginAwardPlayerInfo.cs.meta

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

 Core/NetworkPackage/ServerPack/HAA_SaleActivity/HAA20_tagMCFeastWeekPartyInfo.cs

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

using System.Collections;



// AA 20 节日巡礼活动信息 #tagMCFeastWeekPartyInfo



public class HAA20_tagMCFeastWeekPartyInfo : GameNetPackBasic {

    public string StartDate;    // 开始日期 y-m-d

    public string EndtDate;    // 结束日期 y-m-d

    public ushort AdvanceMinutes;    // 提前显示分钟

    public byte IsDayReset;    //是否每天重置

    public byte ResetType;    // 重置类型，0-0点重置；1-5点重置

    public ushort LimitLV;    // 限制等级

    public byte DayCnt;    // 天数

    public  tagMCFeastWeekPartyDayInfo[] DayInfoList;    // 每天模板

    public byte TCount;    // 模板数

    public  tagMCFeastWeekPartyAction[] ActionInfo;    // 活动模板信息



    public HAA20_tagMCFeastWeekPartyInfo () {

        _cmd = (ushort)0xAA20;

    }



    public override void ReadFromBytes (byte[] vBytes) {

        TransBytes (out StartDate, vBytes, NetDataType.Chars, 10);

        TransBytes (out EndtDate, vBytes, NetDataType.Chars, 10);

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

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

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

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

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

        DayInfoList = new tagMCFeastWeekPartyDayInfo[DayCnt];

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

            DayInfoList[i] = new tagMCFeastWeekPartyDayInfo();

            TransBytes (out DayInfoList[i].ActCnt, vBytes, NetDataType.BYTE);

            TransBytes (out DayInfoList[i].TemplateList, vBytes, NetDataType.WORD, DayInfoList[i].ActCnt);

            TransBytes (out DayInfoList[i].PCount, vBytes, NetDataType.BYTE);

            DayInfoList[i].PItemInfo = new tagMCFeastWeekPartyItem[DayInfoList[i].PCount];

            for (int j = 0; j < DayInfoList[i].PCount; j ++) {

                DayInfoList[i].PItemInfo[j] = new tagMCFeastWeekPartyItem();

                TransBytes (out DayInfoList[i].PItemInfo[j].NeedPoint, vBytes, NetDataType.WORD);

                TransBytes (out DayInfoList[i].PItemInfo[j].ItemID, vBytes, NetDataType.DWORD);

                TransBytes (out DayInfoList[i].PItemInfo[j].ItemCnt, vBytes, NetDataType.WORD);

                TransBytes (out DayInfoList[i].PItemInfo[j].IsBind, vBytes, NetDataType.BYTE);

            }

        }

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

        ActionInfo = new tagMCFeastWeekPartyAction[TCount];

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

            ActionInfo[i] = new tagMCFeastWeekPartyAction();

            TransBytes (out ActionInfo[i].TemplateID, vBytes, NetDataType.DWORD);

            TransBytes (out ActionInfo[i].ActionType, vBytes, NetDataType.WORD);

            TransBytes (out ActionInfo[i].TotalTimes, vBytes, NetDataType.DWORD);

            TransBytes (out ActionInfo[i].SingleTimes, vBytes, NetDataType.DWORD);

            TransBytes (out ActionInfo[i].Point, vBytes, NetDataType.DWORD);

            TransBytes (out ActionInfo[i].Count, vBytes, NetDataType.BYTE);

            ActionInfo[i].ItemInfo = new tagMCFeastWeekPartyItem[ActionInfo[i].Count];

            for (int j = 0; j < ActionInfo[i].Count; j ++) {

                ActionInfo[i].ItemInfo[j] = new tagMCFeastWeekPartyItem();

                TransBytes (out ActionInfo[i].ItemInfo[j].NeedPoint, vBytes, NetDataType.WORD);

                TransBytes (out ActionInfo[i].ItemInfo[j].ItemID, vBytes, NetDataType.DWORD);

                TransBytes (out ActionInfo[i].ItemInfo[j].ItemCnt, vBytes, NetDataType.WORD);

                TransBytes (out ActionInfo[i].ItemInfo[j].IsBind, vBytes, NetDataType.BYTE);

            }

        }

    }



    public struct tagMCFeastWeekPartyAction {

        public uint TemplateID;        // 模板ID

        public ushort ActionType;        // 活动类别

        public uint TotalTimes;        // 可完成的总次数，0表示不限次数

        public uint SingleTimes;        // 单次领奖需要的次数

        public uint Point;        // 单次领奖积分

        public byte Count;        // 物品数

        public  tagMCFeastWeekPartyItem[] ItemInfo;        // 物品信息

    }



    public struct tagMCFeastWeekPartyItem {

        public ushort NeedPoint;        // 领奖需要积分

        public uint ItemID;        // 物品ID

        public ushort ItemCnt;        // 物品数量

        public byte IsBind;        // 是否绑定

    }



    public struct tagMCFeastWeekPartyDayInfo {

        public byte ActCnt;        // 数量

        public  ushort[] TemplateList;        // 模板列表

        public byte PCount;        // 物品数

        public  tagMCFeastWeekPartyItem[] PItemInfo;        // 物品信息

    }



}


 Core/NetworkPackage/ServerPack/HAA_SaleActivity/HAA20_tagMCFeastWeekPartyInfo.cs.meta

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

 Core/NetworkPackage/ServerPack/HAA_SaleActivity/HAA21_tagMCFeastWeekPartyPlayerInfo.cs

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

using System.Collections;



// AA 21 节日巡礼玩家活动信息 #tagMCFeastWeekPartyPlayerInfo



public class HAA21_tagMCFeastWeekPartyPlayerInfo : GameNetPackBasic {

    public byte Count;

    public  tagMCFeastWeekPartyDayPlayerInfo[] DayInfoList;    //活动完成次数信息



    public HAA21_tagMCFeastWeekPartyPlayerInfo () {

        _cmd = (ushort)0xAA21;

    }



    public override void ReadFromBytes (byte[] vBytes) {

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

        DayInfoList = new tagMCFeastWeekPartyDayPlayerInfo[Count];

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

            DayInfoList[i] = new tagMCFeastWeekPartyDayPlayerInfo();

            TransBytes (out DayInfoList[i].DayIndex, vBytes, NetDataType.DWORD);

            TransBytes (out DayInfoList[i].Point, vBytes, NetDataType.DWORD);

            TransBytes (out DayInfoList[i].AwardRecord, vBytes, NetDataType.DWORD);

            TransBytes (out DayInfoList[i].ACount, vBytes, NetDataType.DWORD);

            DayInfoList[i].TaskList = new tagMCFeastWeekPartyTaskInfo[DayInfoList[i].ACount];

            for (int j = 0; j < DayInfoList[i].ACount; j ++) {

                DayInfoList[i].TaskList[j] = new tagMCFeastWeekPartyTaskInfo();

                TransBytes (out DayInfoList[i].TaskList[j].TemplateID, vBytes, NetDataType.WORD);

                TransBytes (out DayInfoList[i].TaskList[j].CurTimes, vBytes, NetDataType.DWORD);

                TransBytes (out DayInfoList[i].TaskList[j].GotTimes, vBytes, NetDataType.DWORD);

            }

        }

    }



    public struct tagMCFeastWeekPartyDayPlayerInfo {

        public uint DayIndex;        //第X天

        public uint Point;        //积分

        public uint AwardRecord;        //积分领奖记录

        public uint ACount;        //任务条目数

        public  tagMCFeastWeekPartyTaskInfo[] TaskList;        //活动完成次数信息

    }



    public struct tagMCFeastWeekPartyTaskInfo {

        public ushort TemplateID;        // 模板ID

        public uint CurTimes;        //已完成次数

        public uint GotTimes;        //已领取次数

    }



}


 Core/NetworkPackage/ServerPack/HAA_SaleActivity/HAA21_tagMCFeastWeekPartyPlayerInfo.cs.meta

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

 Core/NetworkPackage/ServerPack/HB2_ActionMap/HB213_tagMCZhuXianTowerInfo.cs

@@ -5,6 +5,7 @@



public class HB213_tagMCZhuXianTowerInfo : GameNetPackBasic {


    public uint Floor;    // 已通关层


    public uint LastFloor;    // 上次挑战层




    public HB213_tagMCZhuXianTowerInfo () {


        _cmd = (ushort)0xB213;


@@ -12,6 +13,7 @@



    public override void ReadFromBytes (byte[] vBytes) {


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


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

    }





}



 Fight/Actor/HeroBehaviour.cs

@@ -477,7 +477,7 @@
            else if (m_Hero.SelectTarget != null)

            {

                GActorNpcFight _npcFight = m_Hero.SelectTarget as GActorNpcFight;

                if (_npcFight != null && _fight.CanAtked())

                if (_npcFight != null && _npcFight.CanAtked())

                {

                    _radius = _npcFight.NpcConfig.ModelRadius;

                }


 Fight/Actor/Skill/AttackHandler.cs

@@ -491,6 +491,14 @@
        }



        _aAtkSkillPer = _aAtkSkillPer * Constants.F_DELTA;

        Dictionary<int, int> _attrValues;

        if (Snxxz.UI.CalculateSkillGetAttrHurtUtility.Instance.TryGetAttrDictBySkill(skill.id, out _attrValues))

        {

            foreach (var _per in _attrValues.Values)

            {

                _aAtkSkillPer += (_per * Constants.F_DELTA);

            }

        }



        // -------------- 公式计算 --------------

        float _value1;


 Fight/Stage/Dungeon/JadeDynastyTowerDungeonStage.cs

@@ -47,12 +47,13 @@

        var isBottom = model.IsBottomFloor(model.currentFloor);

        if (!isBottom && model.currentFloor > model.highestPassFloor)
        if (!isBottom && model.currentFloor > model.lastChallengeFloor)
        {
            PerformChallengeNextLevel();
        }
        else
        {
            WindowCenter.Instance.Open<JadeDynastyTowerHintWin>();
            model.RequestRefreshMonster();
        }
    }

 System/FakeDungeon/FakeDemonJarDungeonStage.cs

@@ -250,7 +250,7 @@


        mission.lineID = PlayerDatas.Instance.baseData.dungeonLineId;

        mission.hurtInfo = hurts;

        mission.remainHPPer = (int)(surplusTime / totalTime * 100f);

        mission.remainHPPer = (int)(surplusTime / totalTime * 1000000f);

        mission.hpReduceSpeed = (int)(10000 / totalTime);



        dungeonModel.UpdateFakeDungeonMission(DemonJarModel.DEMONJAR_MAPID, mission);


 System/FindPrecious/DemonJarBossLifeBarWin.cs

@@ -79,7 +79,7 @@
        {

            if (inited)

            {

                var deltaHp = (long)(Time.deltaTime * model.mission.hpReduceSpeed * 0.0001f * BOSSHP_TOTAL);

                var deltaHp = (long)(Time.deltaTime * model.mission.hpReduceSpeed * 0.0001d * BOSSHP_TOTAL);

                currentHp = currentHp - deltaHp;

                if (currentHp <= 0)

                {

@@ -109,16 +109,15 @@
        {

            m_BossLifeBar.gameObject.SetActive(true);

            var npcConfig = Config.Instance.Get<NPCConfig>(TargetBriefInfo.selectedNpcId);

            currentHp = (long)(model.mission.remainHPPer * 0.01f * BOSSHP_TOTAL);

            m_BossLifeBar.SetBaseInfo(TargetBriefInfo.selectedNpcId, (ulong)currentHp, BOSSHP_TOTAL, npcConfig.NPCLV);

            currentHp = (long)(model.mission.remainHPPer * 0.000001d * BOSSHP_TOTAL);



            m_BossLifeBar.SetBaseInfo(TargetBriefInfo.selectedNpcId, (ulong)currentHp, BOSSHP_TOTAL, npcConfig.NPCLV);

            inited = true;

        }





        private void UpdateServerRemainHP()

        {

            currentHp = (long)(model.mission.remainHPPer * 0.01f * BOSSHP_TOTAL);

            currentHp = (long)(model.mission.remainHPPer * 0.000001d * BOSSHP_TOTAL);

        }



        public void RefreshBossLifeBar()


 System/GeneralConfig/GeneralDefine.cs

@@ -1,289 +1,314 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using TableConfig;
using System;
using System.Text.RegularExpressions;
using System.Linq;
using Snxxz.UI;

public class GeneralDefine
{
    public static int greatMasterStartLV { get; private set; }
    public static int playerMaxLevel { get; private set; }
    public static float potentialUpSuccessRecommend { get; private set; }
    public static int[] kylinHomeCollectItems;
    public static List<int> dailyQuestOpenTime;
    public static int flyBootItemId { get; private set; }
    public static int teamReadyTime { get; private set; }
    public static int elderGodAreaAngerTotal { get; private set; }
    public static float petRandomSpeak { get; private set; }
    public static int[] openJobs { get; private set; }
    public static int playerNameLength { get; private set; }
    public static int guardDungeonCageNPCID { get; private set; }
    public static float guardBubbleInterval { get; private set; }
    public static List<int> autoOnHookMap { get; private set; }
    public static float autoRideHorse { get; private set; }
    public static Dictionary<int, string> equipPlaceNameDict { get; private set; }
    public static Dictionary<int, int> moneyDisplayIds { get; private set; }
    public static int expDisplayId { get; private set; }
    public static float xpGuideDelay { get; private set; }
    public static float xpGuideDuration { get; private set; }
    public static Dictionary<int, string> trailBossHeadIcons { get; private set; }
    public static Dictionary<int, string> godWeaponMobs { get; private set; }
    public static float ResetComAtkTime { get; private set; }
    public static int RotateSpeed { get; private set; }
    public static float CloseNpcDist { get; private set; }
    public static float FarawayNpcDist { get; private set; }
    public static List<int> SpecialNpcIDs { get; private set; }
    public static Dictionary<int, int> wingEquipLimits { get; private set; }
    public static float PetDanceInterval { get; private set; }
    public static float FuncNpcDanceInterval { get; private set; }
    public static float audioScaleWhenFullScreenOn { get; private set; }
    public static int ruinsTranscriptMapId { get; private set; }
    public static List<int> GuardianPickUpID { get; private set; }
    public static List<int> EarlierGetTreasure { get; private set; }
    public static int BossSound { get; private set; }
    public static Dictionary<int, int> iceCrystalMonsterScores { get; private set; }
    public static float PlayBossHurtInterval { get; private set; }
    public static List<int> NoXpDungeons { get; private set; }
    public static List<int> RandomJobs { get; private set; }
    public static int elderGodTalkingTime { get; private set; }
    public static int elderGodBigBoss { get; private set; }
    public static List<int> PassiveSkillShow { get; private set; }
    public static List<int> bossShuntMaps { get; private set; }
    public static int bossShuntDays { get; private set; }
    public static Dictionary<int, int[]> itemDropEffect = new Dictionary<int, int[]>();
    public static Dictionary<int, int[]> xllyDropEffect = new Dictionary<int, int[]>();
    public static Dictionary<int, int[]> xqryDropEffect = new Dictionary<int, int[]>();
    public static Dictionary<int, List<int[]>> customDropEffect = new Dictionary<int, List<int[]>>();
    public static Dictionary<int, int> dropEffectQuality = new Dictionary<int, int>();
    public static Dictionary<int, int> BuffToHitEffect = new Dictionary<int, int>();

    //参数int，int ，string 分别表示职业，转生等级，icon
    static Dictionary<int, Dictionary<int, string>> jobHeadPortrait = new Dictionary<int, Dictionary<int, string>>();
    static Dictionary<int, Dictionary<int, string>> otherjobHeadPortrait = new Dictionary<int, Dictionary<int, string>>();
    public static Dictionary<int, int> bossWearyValues = new Dictionary<int, int>();
    public static Dictionary<int, Vector3> NpcPosOffset = new Dictionary<int, Vector3>();
    public static Dictionary<int, string> propertyIconDict = new Dictionary<int, string>();

    public static int demonJarHintLevelLimit { get; private set; }
    public static int demonJarHintLineId { get; private set; }
    public static int skillPanelUnLock { get; private set; }
    public static int dailyQuestRedpointLevelLimit { get; private set; }
    public static int lowHpRemind { get; private set; }
    public static int munekadolockLimit { get; private set; }
    public static int maxItemDropEffectCount { get; private set; }

    public static int[] autoBuyItemIds;
    public static int[] autoBuyItemPrices;

    public static List<int> neutralMaps = new List<int>();
    public static List<int> neutralBossMaps = new List<int>();

    public static int demonJarRedPoint { get; private set; }
    public static string LoadLV { get; private set; }

    public static float mainWinSkillResetTime { get; private set; }
    public static int OffLineTimeLackRemendLevelLimit { get; private set; }
    public static Vector3 heroDialogueOffset { get; private set; }
    public static Vector3 heroDialogueRotation { get; private set; }
    public static float heroDialogueScale { get; private set; }

    public static List<int> ancientGrandTotalAchievements { get; private set; }
    public static List<int> ancientContinueKillAchievements { get; private set; }

    public static int trialDungeonGroupChallengeTipLv { get; private set; }
    public static int prayerRedpointLimitLv { get; private set; }

    public static int demonJarLevelLimit { get; private set; }

    public static int fairyLandGuideId = 82;

    public static int specialGuide41Mission { get; private set; }
    public static int specialGuide41Achievement { get; private set; }

    public static int supremeRechargeVipLv { get; private set; }

    public static int rechargeRedpointLv { get; private set; }
    public static int rechargeRedpointMinLv { get; private set; }

    public static int runeTowerSweepBuyTimes { get; private set; }
    public static int runeTowerSweepBuyPrice { get; private set; }

    public static int teamMatchingTimeOut { get; private set; }
    public static List<int> inGameDownLoadLevelCheckPoints = null;
    public static List<int> inGameDownLoadTaskCheckPoints = null;
    public static int inGameDownLoadHighLevel { get; private set; }
    public static List<int> worldBossNoRebornRemindMaps = null;
    public static List<int> bossHomeNoRebornRemindMaps = null;
    public static List<int> elderGodNoRebornRemindMaps = null;
    public static List<int> demonJarNoRebornRemindMaps = null;
    public static List<int> dogzNoRebornRemindMaps = null;

    public static string[][] ModeDefaultConfig { get; private set; }
    public static int[][] PreloadSkillEffect { get; private set; }
    public static int[] RealmGroup { get; private set; }
    public static float PrefightAtkRange { get; private set; }

    public static Dictionary<int, string> multipleRealmImgDict { get; private set; }

    public static int inGameDownLoadHighestLevelPoint { get; private set; }

    public static List<int> dungeonCanUseMoneyIds { get; private set; }
    public static int dogzBoxLimit { get; private set; }

    public static Dictionary<int, int> dungeonRebornClientTimes { get; private set; }
    public static int[] CompareEquipPlaces { get; private set; }
    public static Dictionary<int, int> fairyGrabBossMapLines { get; private set; }

    public static Dictionary<int, List<int>> DropItemEffectMapID { get; private set; }
    public static Dictionary<int, List<int>> itemPutInPackDict { get; private set; }
    public static List<int> RebornAutoFightMapID { get; private set; }

    public static string teamWorldCall;
    public static int teamWorldCallInviteCount;

    public static List<Item> ancientKingAwards = new List<Item>();

    public static int lowQualityEffectCount { get; private set; }
    public static int medQualityEffectCount { get; private set; }
    public static int highQualityEffectCount { get; private set; }
    public static int lowQualityPetCount { get; private set; }
    public static int medQualityPetCount { get; private set; }
    public static int highQualityPetCount { get; private set; }
    public static int lowQualityGuardCount { get; private set; }
    public static int medQualityGuardCount { get; private set; }
    public static int highQualityGuardCount { get; private set; }
    public static int lowQualityPetEffectCount { get; private set; }
    public static int medQualityPetEffectCount { get; private set; }
    public static int highQualityPetEffectCount { get; private set; }
    public static int lowQualityHorseEffectCount { get; private set; }
    public static int medQualityHorseEffectCount { get; private set; }
    public static int highQualityHorseEffectCount { get; private set; }

    public static int GatherSoulDZ { get; private set; }

    public static int fairyLandBuffCondition { get; private set; }
    public static int fairyLandBuffId { get; private set; }
    public static int achievementEarlierStageLevel { get; private set; }
    public static int DemonJarAutoTime { get; private set; }
    public static Dictionary<int, Dictionary<int, GA_NpcFightSgzcZZ.EquipRandomInfo>> SgzzRobotEquipDict { get; private set; }
    public static Dictionary<int, int> SgzcRealm { get; private set; }

    public static int crossServerOneVsOneOpenDay { get; private set; }
    public static int UISpringDecorate { get; private set; }

    public static void Init()
    {
        try
        {
            CompareEquipPlaces = GetIntArray("EquipUpType");
            greatMasterStartLV = GetInt("GreatMasterStartLV");
            playerMaxLevel = GetInt("PlayerMaxLV");
            potentialUpSuccessRecommend = GetFloat("SPSkillType", 2) * 0.0001f;
            kylinHomeCollectItems = GetIntArray("KirinNpc", 2);
            dailyQuestOpenTime = GetTimeArray("ActionTime", 1);
            flyBootItemId = GetInt("TransportPay");
            teamReadyTime = GetInt("TeamReadyTime");
            playerNameLength = GetInt("RoleNameLength");
            elderGodAreaAngerTotal = GetInt("AngryAdd", 4);
            petRandomSpeak = GetFloat("PetRandomSpeak");
            guardDungeonCageNPCID = GetInt("GuardFBCageNPCID");
            guardBubbleInterval = GetFloat("GuardFBCageNPCID", 3);
            autoRideHorse = GetFloat("AutoRideHorseTime") * Constants.F_DELTA;
            moneyDisplayIds = ConfigParse.GetDic<int, int>(GetInputString("MoneyDisplayModel", 1));
            expDisplayId = GetInt("MoneyDisplayModel", 2);
            openJobs = GetIntArray("OpenJob");
            xpGuideDelay = GetFloat("GuideConfig");
            xpGuideDuration = GetFloat("GuideConfig", 2);
            ResetComAtkTime = GetFloat("AtkWaitingTime");
            autoOnHookMap = new List<int>(GetIntArray("AutoOnHookMap"));
            GuardianPickUpID = new List<int>(GetIntArray("GuardianPickUpID"));
            RotateSpeed = GetInt("RoleTurnedAngle");
            CloseNpcDist = GetFloat("ConversationDistanc", 2);
            FarawayNpcDist = GetFloat("ConversationDistanc");
            SpecialNpcIDs = new List<int>(GetIntArray("SpecialCollectNpcs", 1));
            PetDanceInterval = GetInt("PetDanceInterval") * Constants.F_GAMMA;
            FuncNpcDanceInterval = GetInt("PetDanceInterval", 2) * Constants.F_GAMMA;
            ruinsTranscriptMapId = GetInt("SpRewardMapID");
            EarlierGetTreasure = new List<int>(GetIntArray("EarlierGetTreasure"));
            BossSound = GetInt("BossSound");
            PlayBossHurtInterval = GetFloat("BossSound", 2);
            var jobHeadPortraitConfig1 = Config.Instance.Get<FuncConfigConfig>("Job1Head");
            jobHeadPortrait[1] = ConfigParse.GetDic<int, string>(jobHeadPortraitConfig1.Numerical1);
            otherjobHeadPortrait[1] = ConfigParse.GetDic<int, string>(jobHeadPortraitConfig1.Numerical2);

            var jobHeadPortraitConfig2 = Config.Instance.Get<FuncConfigConfig>("Job2Head");
            jobHeadPortrait[2] = ConfigParse.GetDic<int, string>(jobHeadPortraitConfig2.Numerical1);
            otherjobHeadPortrait[2] = ConfigParse.GetDic<int, string>(jobHeadPortraitConfig2.Numerical2);

            var jobHeadPortraitConfig3 = Config.Instance.Get<FuncConfigConfig>("Job3Head");
            jobHeadPortrait[3] = ConfigParse.GetDic<int, string>(jobHeadPortraitConfig3.Numerical1);
            otherjobHeadPortrait[3] = ConfigParse.GetDic<int, string>(jobHeadPortraitConfig3.Numerical2);

            bossWearyValues = ConfigParse.GetDic<int, int>(GetInputString("KillBossCntLimit", 2));
            wingEquipLimits = ConfigParse.GetDic<int, int>(GetInputString("WingRealmLimit", 1));
            int i = 0;
            int[] equipPlaces = GetIntArray("EquipArea", 1);
            string[] equipPlacesNames = GetStringArray("EquipArea", 2);
            equipPlaceNameDict = new Dictionary<int, string>();
            for (i = 0; i < equipPlaces.Length; i++)
            {
                if (!equipPlaceNameDict.ContainsKey(equipPlaces[i]))
                {
                    equipPlaceNameDict.Add(equipPlaces[i], equipPlacesNames[i]);
                }
                else
                {
                    DebugEx.LogError("EquipArea : 装备位置重复");
                }
            }
            var _trailBossJson = LitJson.JsonMapper.ToObject(GetInputString("MuneKadoTrialBossHead", 1));
            trailBossHeadIcons = new Dictionary<int, string>();
            foreach (var _key in _trailBossJson.Keys)
            {
                var _npcId = int.Parse(_key);
                if (!trailBossHeadIcons.ContainsKey(_npcId))
                {
                    trailBossHeadIcons.Add(_npcId, _trailBossJson[_key].ToString());
                }
            }
            var _godWeaponJson = LitJson.JsonMapper.ToObject(GetInputString("GodModel", 1));
            godWeaponMobs = new Dictionary<int, string>();
            foreach (var _key in _godWeaponJson.Keys)
            {
                var _godWeaponType = int.Parse(_key);
                if (!godWeaponMobs.ContainsKey(_godWeaponType))
                {
                    godWeaponMobs.Add(_godWeaponType, _godWeaponJson[_key].ToString());
                }
            }

            audioScaleWhenFullScreenOn = GetFloat("AudioSound");

            iceCrystalMonsterScores = ConfigParse.GetDic<int, int>(GetInputString("IceLodeNeedPoint", 2));

            NoXpDungeons = new List<int>(GetIntArray("XpNoUseDungeon"));
            RandomJobs = new List<int>(GetIntArray("RandomJob"));
            elderGodTalkingTime = GetInt("ElderGodTalkingTime");
            elderGodBigBoss = GetInt("ElderGodBigBoss");
            PassiveSkillShow = new List<int>(GetIntArray("PassiveSkillShow"));

            FuncConfigConfig func = Config.Instance.Get<FuncConfigConfig>("NpcPosOffset");
            LitJson.JsonData _data = LitJson.JsonMapper.ToObject(func.Numerical1);
            foreach (var _key in _data.Keys)
            {
                int _npcID = int.Parse(_key);
                double[] _pos = new double[2];
                _pos[0] = (double)_data[_key][0];
                _pos[1] = (double)_data[_key][1];
                NpcPosOffset.Add(_npcID, new Vector3((float)_pos[0], 0, (float)_pos[1]));
            }

            var putInItemPack = Config.Instance.Get<FuncConfigConfig>("PutInItemPack");
            LitJson.JsonData itemPutInData = LitJson.JsonMapper.ToObject(putInItemPack.Numerical1);
            itemPutInPackDict = new Dictionary<int, List<int>>();
using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using TableConfig;

using System;

using System.Text.RegularExpressions;

using System.Linq;

using Snxxz.UI;



public class GeneralDefine

{

    public static int greatMasterStartLV { get; private set; }

    public static int playerMaxLevel { get; private set; }

    public static float potentialUpSuccessRecommend { get; private set; }

    public static int[] kylinHomeCollectItems;

    public static List<int> dailyQuestOpenTime;

    public static int flyBootItemId { get; private set; }

    public static int teamReadyTime { get; private set; }

    public static int elderGodAreaAngerTotal { get; private set; }

    public static float petRandomSpeak { get; private set; }

    public static int[] openJobs { get; private set; }

    public static int playerNameLength { get; private set; }

    public static int guardDungeonCageNPCID { get; private set; }

    public static float guardBubbleInterval { get; private set; }

    public static List<int> autoOnHookMap { get; private set; }

    public static float autoRideHorse { get; private set; }

    public static Dictionary<int, string> equipPlaceNameDict { get; private set; }

    public static Dictionary<int, int> moneyDisplayIds { get; private set; }

    public static int expDisplayId { get; private set; }

    public static float xpGuideDelay { get; private set; }

    public static float xpGuideDuration { get; private set; }

    public static Dictionary<int, string> trailBossHeadIcons { get; private set; }

    public static Dictionary<int, string> godWeaponMobs { get; private set; }

    public static float ResetComAtkTime { get; private set; }

    public static int RotateSpeed { get; private set; }

    public static float CloseNpcDist { get; private set; }

    public static float FarawayNpcDist { get; private set; }

    public static List<int> SpecialNpcIDs { get; private set; }

    public static Dictionary<int, int> wingEquipLimits { get; private set; }

    public static float PetDanceInterval { get; private set; }

    public static float FuncNpcDanceInterval { get; private set; }

    public static float audioScaleWhenFullScreenOn { get; private set; }

    public static int ruinsTranscriptMapId { get; private set; }

    public static List<int> GuardianPickUpID { get; private set; }

    public static List<int> EarlierGetTreasure { get; private set; }

    public static int BossSound { get; private set; }

    public static Dictionary<int, int> iceCrystalMonsterScores { get; private set; }

    public static float PlayBossHurtInterval { get; private set; }

    public static List<int> NoXpDungeons { get; private set; }

    public static List<int> RandomJobs { get; private set; }

    public static int elderGodTalkingTime { get; private set; }

    public static int elderGodBigBoss { get; private set; }

    public static List<int> PassiveSkillShow { get; private set; }

    public static List<int> bossShuntMaps { get; private set; }

    public static int bossShuntDays { get; private set; }

    public static Dictionary<int, int[]> itemDropEffect = new Dictionary<int, int[]>();

    public static Dictionary<int, int[]> xllyDropEffect = new Dictionary<int, int[]>();

    public static Dictionary<int, int[]> xqryDropEffect = new Dictionary<int, int[]>();

    public static Dictionary<int, List<int[]>> customDropEffect = new Dictionary<int, List<int[]>>();

    public static Dictionary<int, int> dropEffectQuality = new Dictionary<int, int>();

    public static Dictionary<int, int> BuffToHitEffect = new Dictionary<int, int>();



    //参数int，int ，string 分别表示职业，转生等级，icon

    static Dictionary<int, Dictionary<int, string>> jobHeadPortrait = new Dictionary<int, Dictionary<int, string>>();

    static Dictionary<int, Dictionary<int, string>> otherjobHeadPortrait = new Dictionary<int, Dictionary<int, string>>();

    public static Dictionary<int, int> bossWearyValues = new Dictionary<int, int>();

    public static Dictionary<int, Vector3> NpcPosOffset = new Dictionary<int, Vector3>();

    public static Dictionary<int, string> propertyIconDict = new Dictionary<int, string>();



    public static int demonJarHintLevelLimit { get; private set; }

    public static int demonJarHintLineId { get; private set; }

    public static int skillPanelUnLock { get; private set; }

    public static int dailyQuestRedpointLevelLimit { get; private set; }

    public static int lowHpRemind { get; private set; }

    public static int munekadolockLimit { get; private set; }

    public static int maxItemDropEffectCount { get; private set; }



    public static int[] autoBuyItemIds;

    public static int[] autoBuyItemPrices;



    public static List<int> neutralMaps = new List<int>();

    public static List<int> neutralBossMaps = new List<int>();



    public static int demonJarRedPoint { get; private set; }

    public static string LoadLV { get; private set; }



    public static float mainWinSkillResetTime { get; private set; }

    public static int OffLineTimeLackRemendLevelLimit { get; private set; }

    public static Vector3 heroDialogueOffset { get; private set; }

    public static Vector3 heroDialogueRotation { get; private set; }

    public static float heroDialogueScale { get; private set; }



    public static List<int> ancientGrandTotalAchievements { get; private set; }

    public static List<int> ancientContinueKillAchievements { get; private set; }



    public static int trialDungeonGroupChallengeTipLv { get; private set; }

    public static int prayerRedpointLimitLv { get; private set; }



    public static int demonJarLevelLimit { get; private set; }



    public static int fairyLandGuideId = 82;



    public static int specialGuide41Mission { get; private set; }

    public static int specialGuide41Achievement { get; private set; }



    public static int supremeRechargeVipLv { get; private set; }



    public static int rechargeRedpointLv { get; private set; }

    public static int rechargeRedpointMinLv { get; private set; }



    public static int runeTowerSweepBuyTimes { get; private set; }

    public static int runeTowerSweepBuyPrice { get; private set; }



    public static int teamMatchingTimeOut { get; private set; }

    public static List<int> inGameDownLoadLevelCheckPoints = null;

    public static List<int> inGameDownLoadTaskCheckPoints = null;

    public static int inGameDownLoadHighLevel { get; private set; }

    public static List<int> worldBossNoRebornRemindMaps = null;

    public static List<int> bossHomeNoRebornRemindMaps = null;

    public static List<int> elderGodNoRebornRemindMaps = null;

    public static List<int> demonJarNoRebornRemindMaps = null;

    public static List<int> dogzNoRebornRemindMaps = null;



    public static string[][] ModeDefaultConfig { get; private set; }

    public static int[][] PreloadSkillEffect { get; private set; }

    public static int[] RealmGroup { get; private set; }

    public static float PrefightAtkRange { get; private set; }



    public static Dictionary<int, string> multipleRealmImgDict { get; private set; }



    public static int inGameDownLoadHighestLevelPoint { get; private set; }



    public static List<int> dungeonCanUseMoneyIds { get; private set; }

    public static int dogzBoxLimit { get; private set; }



    public static Dictionary<int, int> dungeonRebornClientTimes { get; private set; }

    public static int[] CompareEquipPlaces { get; private set; }

    public static Dictionary<int, int> fairyGrabBossMapLines { get; private set; }



    public static Dictionary<int, List<int>> DropItemEffectMapID { get; private set; }

    public static Dictionary<int, List<int>> itemPutInPackDict { get; private set; }

    public static List<int> RebornAutoFightMapID { get; private set; }



    public static string teamWorldCall;

    public static int teamWorldCallInviteCount;



    public static List<Item> ancientKingAwards = new List<Item>();



    public static int lowQualityEffectCount { get; private set; }

    public static int medQualityEffectCount { get; private set; }

    public static int highQualityEffectCount { get; private set; }

    public static int lowQualityPetCount { get; private set; }

    public static int medQualityPetCount { get; private set; }

    public static int highQualityPetCount { get; private set; }

    public static int lowQualityGuardCount { get; private set; }

    public static int medQualityGuardCount { get; private set; }

    public static int highQualityGuardCount { get; private set; }

    public static int lowQualityPetEffectCount { get; private set; }

    public static int medQualityPetEffectCount { get; private set; }

    public static int highQualityPetEffectCount { get; private set; }

    public static int lowQualityHorseEffectCount { get; private set; }

    public static int medQualityHorseEffectCount { get; private set; }

    public static int highQualityHorseEffectCount { get; private set; }



    public static int GatherSoulDZ { get; private set; }



    public static int fairyLandBuffCondition { get; private set; }

    public static int fairyLandBuffId { get; private set; }

    public static int achievementEarlierStageLevel { get; private set; }

    public static int DemonJarAutoTime { get; private set; }

    public static Dictionary<int, Dictionary<int, GA_NpcFightSgzcZZ.EquipRandomInfo>> SgzzRobotEquipDict { get; private set; }

    public static Dictionary<int, int> SgzcRealm { get; private set; }



    public static int crossServerOneVsOneOpenDay { get; private set; }

    public static int UISpringDecorate { get; private set; }

    public static Dictionary<int, List<int>> skillAttrIDDict { get; private set; }



    public static void Init()

    {

        try

        {

            CompareEquipPlaces = GetIntArray("EquipUpType");

            greatMasterStartLV = GetInt("GreatMasterStartLV");

            playerMaxLevel = GetInt("PlayerMaxLV");

            potentialUpSuccessRecommend = GetFloat("SPSkillType", 2) * 0.0001f;

            kylinHomeCollectItems = GetIntArray("KirinNpc", 2);

            dailyQuestOpenTime = GetTimeArray("ActionTime", 1);

            flyBootItemId = GetInt("TransportPay");

            teamReadyTime = GetInt("TeamReadyTime");

            playerNameLength = GetInt("RoleNameLength");

            elderGodAreaAngerTotal = GetInt("AngryAdd", 4);

            petRandomSpeak = GetFloat("PetRandomSpeak");

            guardDungeonCageNPCID = GetInt("GuardFBCageNPCID");

            guardBubbleInterval = GetFloat("GuardFBCageNPCID", 3);

            autoRideHorse = GetFloat("AutoRideHorseTime") * Constants.F_DELTA;

            moneyDisplayIds = ConfigParse.GetDic<int, int>(GetInputString("MoneyDisplayModel", 1));

            expDisplayId = GetInt("MoneyDisplayModel", 2);

            openJobs = GetIntArray("OpenJob");

            xpGuideDelay = GetFloat("GuideConfig");

            xpGuideDuration = GetFloat("GuideConfig", 2);

            ResetComAtkTime = GetFloat("AtkWaitingTime");

            autoOnHookMap = new List<int>(GetIntArray("AutoOnHookMap"));

            GuardianPickUpID = new List<int>(GetIntArray("GuardianPickUpID"));

            RotateSpeed = GetInt("RoleTurnedAngle");

            CloseNpcDist = GetFloat("ConversationDistanc", 2);

            FarawayNpcDist = GetFloat("ConversationDistanc");

            SpecialNpcIDs = new List<int>(GetIntArray("SpecialCollectNpcs", 1));

            PetDanceInterval = GetInt("PetDanceInterval") * Constants.F_GAMMA;

            FuncNpcDanceInterval = GetInt("PetDanceInterval", 2) * Constants.F_GAMMA;

            ruinsTranscriptMapId = GetInt("SpRewardMapID");

            EarlierGetTreasure = new List<int>(GetIntArray("EarlierGetTreasure"));

            BossSound = GetInt("BossSound");

            PlayBossHurtInterval = GetFloat("BossSound", 2);

            var jobHeadPortraitConfig1 = Config.Instance.Get<FuncConfigConfig>("Job1Head");

            jobHeadPortrait[1] = ConfigParse.GetDic<int, string>(jobHeadPortraitConfig1.Numerical1);

            otherjobHeadPortrait[1] = ConfigParse.GetDic<int, string>(jobHeadPortraitConfig1.Numerical2);



            var jobHeadPortraitConfig2 = Config.Instance.Get<FuncConfigConfig>("Job2Head");

            jobHeadPortrait[2] = ConfigParse.GetDic<int, string>(jobHeadPortraitConfig2.Numerical1);

            otherjobHeadPortrait[2] = ConfigParse.GetDic<int, string>(jobHeadPortraitConfig2.Numerical2);



            var jobHeadPortraitConfig3 = Config.Instance.Get<FuncConfigConfig>("Job3Head");

            jobHeadPortrait[3] = ConfigParse.GetDic<int, string>(jobHeadPortraitConfig3.Numerical1);

            otherjobHeadPortrait[3] = ConfigParse.GetDic<int, string>(jobHeadPortraitConfig3.Numerical2);



            bossWearyValues = ConfigParse.GetDic<int, int>(GetInputString("KillBossCntLimit", 2));

            wingEquipLimits = ConfigParse.GetDic<int, int>(GetInputString("WingRealmLimit", 1));

            int i = 0;

            int[] equipPlaces = GetIntArray("EquipArea", 1);

            string[] equipPlacesNames = GetStringArray("EquipArea", 2);

            equipPlaceNameDict = new Dictionary<int, string>();

            for (i = 0; i < equipPlaces.Length; i++)

            {

                if (!equipPlaceNameDict.ContainsKey(equipPlaces[i]))

                {

                    equipPlaceNameDict.Add(equipPlaces[i], equipPlacesNames[i]);

                }

                else

                {

                    DebugEx.LogError("EquipArea : 装备位置重复");

                }

            }

            var _trailBossJson = LitJson.JsonMapper.ToObject(GetInputString("MuneKadoTrialBossHead", 1));

            trailBossHeadIcons = new Dictionary<int, string>();

            foreach (var _key in _trailBossJson.Keys)

            {

                var _npcId = int.Parse(_key);

                if (!trailBossHeadIcons.ContainsKey(_npcId))

                {

                    trailBossHeadIcons.Add(_npcId, _trailBossJson[_key].ToString());

                }

            }



            var skillPlusAttrIDJson = LitJson.JsonMapper.ToObject(GetInputString("SkillPlusAttrID", 2));

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

            foreach(var key in skillPlusAttrIDJson.Keys)

            {

                int attrId = int.Parse(key);

                var skillIds = skillPlusAttrIDJson[key];

                foreach (var skillId in skillIds)

                {

                    int id = int.Parse(skillId.ToString());

                    if(!skillAttrIDDict.ContainsKey(id))

                    {

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

                        list.Add(attrId);

                        skillAttrIDDict.Add(id,list);

                    }

                    else

                    {

                        skillAttrIDDict[id].Add(attrId);

                    }

                }



            }



            var _godWeaponJson = LitJson.JsonMapper.ToObject(GetInputString("GodModel", 1));

            godWeaponMobs = new Dictionary<int, string>();

            foreach (var _key in _godWeaponJson.Keys)

            {

                var _godWeaponType = int.Parse(_key);

                if (!godWeaponMobs.ContainsKey(_godWeaponType))

                {

                    godWeaponMobs.Add(_godWeaponType, _godWeaponJson[_key].ToString());

                }

            }



            audioScaleWhenFullScreenOn = GetFloat("AudioSound");



            iceCrystalMonsterScores = ConfigParse.GetDic<int, int>(GetInputString("IceLodeNeedPoint", 2));



            NoXpDungeons = new List<int>(GetIntArray("XpNoUseDungeon"));

            RandomJobs = new List<int>(GetIntArray("RandomJob"));

            elderGodTalkingTime = GetInt("ElderGodTalkingTime");

            elderGodBigBoss = GetInt("ElderGodBigBoss");

            PassiveSkillShow = new List<int>(GetIntArray("PassiveSkillShow"));



            FuncConfigConfig func = Config.Instance.Get<FuncConfigConfig>("NpcPosOffset");

            LitJson.JsonData _data = LitJson.JsonMapper.ToObject(func.Numerical1);

            foreach (var _key in _data.Keys)

            {

                int _npcID = int.Parse(_key);

                double[] _pos = new double[2];

                _pos[0] = (double)_data[_key][0];

                _pos[1] = (double)_data[_key][1];

                NpcPosOffset.Add(_npcID, new Vector3((float)_pos[0], 0, (float)_pos[1]));

            }



            var putInItemPack = Config.Instance.Get<FuncConfigConfig>("PutInItemPack");

            LitJson.JsonData itemPutInData = LitJson.JsonMapper.ToObject(putInItemPack.Numerical1);

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

            foreach(var _key in itemPutInData.Keys)

            {

                var itemTypeData = itemPutInData[_key];

@@ -298,418 +323,427 @@
                        itemTypes.Add(itemType);

                    }

                }

            }

            FuncConfigConfig nxxdImg = Config.Instance.Get<FuncConfigConfig>("NXXDPicture");
            LitJson.JsonData nxxdData = LitJson.JsonMapper.ToObject(nxxdImg.Numerical1);
            multipleRealmImgDict = new Dictionary<int, string>();
            if (nxxdData.IsArray)
            {
                for (i = 0; i < nxxdData.Count; i++)
                {
                    if (nxxdData[i].IsArray)
                    {
                        multipleRealmImgDict.Add(int.Parse(nxxdData[i][0].ToString()), nxxdData[i][1].ToString());
                    }
                }
            }

            bossShuntMaps = new List<int>(GetIntArray("BossShunt"));
            bossShuntDays = GetInt("BossShunt", 3);

            itemDropEffect.Clear();
            func = Config.Instance.Get<FuncConfigConfig>("ItemEquipmentEffect");
            _data = LitJson.JsonMapper.ToObject(func.Numerical1);
            List<string> _keys = new List<string>(_data.Keys);
            for (i = 0; i < _keys.Count; ++i)
            {
                int[] _props = new int[3];
                for (int j = 0; j < 3; ++j)
                {
                    _props[j] = (int)_data[_keys[i]][j];
                }
                itemDropEffect[int.Parse(_keys[i])] = _props;
            }

            xllyDropEffect.Clear();
            _data = LitJson.JsonMapper.ToObject(func.Numerical2);
            _keys.Clear();
            _keys.AddRange(_data.Keys);
            for (i = 0; i < _keys.Count; ++i)
            {
                int[] _props = new int[3];
                for (int j = 0; j < 3; ++j)
                {
                    _props[j] = (int)_data[_keys[i]][j];
                }
                xllyDropEffect[int.Parse(_keys[i])] = _props;
            }

            xqryDropEffect.Clear();
            _data = LitJson.JsonMapper.ToObject(func.Numerical3);
            _keys.Clear();
            _keys.AddRange(_data.Keys);
            for (i = 0; i < _keys.Count; ++i)
            {
                int[] _props = new int[3];
                for (int j = 0; j < 3; ++j)
                {
                    _props[j] = (int)_data[_keys[i]][j];
                }
                xqryDropEffect[int.Parse(_keys[i])] = _props;
            }

            dropEffectQuality.Clear();
            func = Config.Instance.Get<FuncConfigConfig>("IeemEquipmentEffectQuality");
            _data = LitJson.JsonMapper.ToObject(func.Numerical1);
            _keys.Clear();
            _keys.AddRange(_data.Keys);
            for (i = 0; i < _keys.Count; ++i)
            {
                dropEffectQuality[int.Parse(_keys[i])] = (int)_data[_keys[i]];
            }

            customDropEffect.Clear();
            func = Config.Instance.Get<FuncConfigConfig>("ItemEquipmentEffectItem");
            _data = LitJson.JsonMapper.ToObject(func.Numerical1);
            _keys.Clear();
            _keys.AddRange(_data.Keys);
            int[] _tmp = null;
            List<int[]> _content = null;
            for (i = 0; i < _keys.Count; ++i)
            {
                _content = new List<int[]>();
                foreach (LitJson.JsonData _values in _data[_keys[i]])
                {
                    if (_values.IsArray)
                    {
                        _tmp = new int[2];
                        _tmp[0] = (int)_values[0];
                        _tmp[1] = (int)_values[1];
                    }
                    else
                    {
                        _tmp = new int[1];
                        _tmp[0] = (int)_values;
                    }
                    _content.Add(_tmp);
                }
                customDropEffect.Add(int.Parse(_keys[i]), _content);
            }

            BuffToHitEffect.Clear();
            func = Config.Instance.Get<FuncConfigConfig>("BuffToHitEffect");
            if (!string.IsNullOrEmpty(func.Numerical1) && !string.IsNullOrEmpty(func.Numerical2))
            {
                string[] _buffs = func.Numerical1.Split('|');
                string[] _effects = func.Numerical2.Split('|');
                for (i = 0; i < _buffs.Length; ++i)
                {
                    BuffToHitEffect[int.Parse(_buffs[i])] = int.Parse(_effects[i]);
                }
            }

            demonJarHintLevelLimit = GetInt("DemonJarFirstRemin");
            demonJarHintLineId = GetInt("DemonJarFirstRemin", 2);
            skillPanelUnLock = GetInt("SkillPanelUnlock");
            dailyQuestRedpointLevelLimit = GetInt("DailyQuestRedPoint");
            lowHpRemind = GetInt("LowHpRemind");
            autoBuyItemIds = GetIntArray("BuyItemPrice", 1);
            autoBuyItemPrices = GetIntArray("BuyItemPrice", 2);
            neutralMaps.AddRange(GetIntArray("MapLine", 4));
            neutralBossMaps.AddRange(GetIntArray("BossListMapID"));

            var _propertyIconCfg = Config.Instance.Get<FuncConfigConfig>("PropertyIcon");
            var _propertyIconJson = LitJson.JsonMapper.ToObject(_propertyIconCfg.Numerical1);
            foreach (var _key in _propertyIconJson.Keys)
            {
                var _property = int.Parse(_key);
                propertyIconDict.Add(_property, _propertyIconJson[_key].ToString());
            }

            munekadolockLimit = GetInt("MunekadoLockLimit");
            demonJarRedPoint = GetInt("DemonJarRedPoint");
            LoadLV = GetInputString("LoadLV");

            mainWinSkillResetTime = GetFloat("AutomaticSwitch");
            OffLineTimeLackRemendLevelLimit = GetInt("TJGLevelLimit");
            heroDialogueOffset = GetInputString("NpcHalfLength", 1).Vector3Parse();
            heroDialogueRotation = GetInputString("NpcHalfLength", 2).Vector3Parse();
            heroDialogueScale = GetFloat("NpcHalfLength", 3);

            var ancientConfig = Config.Instance.Get<FuncConfigConfig>("ElderBattleTarget");
            ancientGrandTotalAchievements = new List<int>();
            ancientGrandTotalAchievements.AddRange(ConfigParse.GetMultipleStr<int>(ancientConfig.Numerical1));
            ancientContinueKillAchievements = new List<int>();
            ancientContinueKillAchievements.AddRange(ConfigParse.GetMultipleStr<int>(ancientConfig.Numerical2));

            trialDungeonGroupChallengeTipLv = GetInt("SingleIntoFB");
            prayerRedpointLimitLv = GetInt("PrayRedPoint");
            demonJarLevelLimit = GetInt("DemonJarLevelLimit");
            maxItemDropEffectCount = GetInt("ItemMaskEffect");

            specialGuide41Mission = GetInt("SpecialGuide41", 1);
            specialGuide41Achievement = GetInt("SpecialGuide41", 2);

            supremeRechargeVipLv = GetInt("SupremeCTGVipLimit", 1);

            rechargeRedpointLv = GetInt("FirstPayRedPoint", 1);
            rechargeRedpointMinLv = GetInt("FirstPayRedPoint", 2);
            runeTowerSweepBuyTimes = GetInt("RuneTowerSweepBuy");
            runeTowerSweepBuyPrice = GetInt("RuneTowerSweepBuy", 2);
            teamMatchingTimeOut = GetInt("TeamMatchingTimeOut");
            inGameDownLoadLevelCheckPoints = new List<int>(GetIntArray("InGameDownLoad"));
            inGameDownLoadTaskCheckPoints = new List<int>(GetIntArray("InGameDownLoad", 2));
            inGameDownLoadHighLevel = GetInt("InGameDownLoad", 3);

            worldBossNoRebornRemindMaps = new List<int>(GetIntArray("NoRebornRemindMap", 1));
            bossHomeNoRebornRemindMaps = new List<int>(GetIntArray("NoRebornRemindMap", 2));
            elderGodNoRebornRemindMaps = new List<int>(GetIntArray("NoRebornRemindMap", 3));
            demonJarNoRebornRemindMaps = new List<int>(GetIntArray("NoRebornRemindMap", 4));
            dogzNoRebornRemindMaps = new List<int>(GetIntArray("NoRebornRemindMap", 5));

            if (ModeDefaultConfig == null)
            {
                func = Config.Instance.Get<FuncConfigConfig>("ModeDefault");

                string[] _funcNpc = func.Numerical1.Split('|');
                string[] _fightNpc = func.Numerical2.Split('|');
                string[] _pet = func.Numerical3.Split('|');
                string[] _horse = func.Numerical4.Split('|');

                ModeDefaultConfig = new string[4][];
                ModeDefaultConfig[0] = _funcNpc;
                ModeDefaultConfig[1] = _fightNpc;
                ModeDefaultConfig[2] = _pet;
                ModeDefaultConfig[3] = _horse;
            }

            if (RealmGroup == null)
            {
                func = Config.Instance.Get<FuncConfigConfig>("RealmGroup");
                string[] _group = func.Numerical1.Split('|');
                RealmGroup = new int[_group.Length];
                for (int j = 0; j < _group.Length; ++j)
                {
                    int.TryParse(_group[j], out RealmGroup[j]);
                }
            }

            func = Config.Instance.Get<FuncConfigConfig>("PrefightAtkRange");
            PrefightAtkRange = float.Parse(func.Numerical1);
            inGameDownLoadHighestLevelPoint = GetInt("DownReward", 2);

            dungeonCanUseMoneyIds = new List<int>(GetIntArray("FBEnterTickeyAuto", 1));
            dungeonRebornClientTimes = ConfigParse.GetDic<int, int>(GetInputString("DuplicatesRebornTime", 2));
            dogzBoxLimit = GetInt("DogzBoxLimit");

            fairyGrabBossMapLines = ConfigParse.GetDic<int, int>(GetInputString("MapLine", 2));
            var grabBossMaps = fairyGrabBossMapLines.Keys.ToList();
            foreach (var _key in grabBossMaps)
            {
                fairyGrabBossMapLines[_key] = fairyGrabBossMapLines[_key] - 1;
            }

            if (DropItemEffectMapID == null)
            {
                DropItemEffectMapID = new Dictionary<int, List<int>>();
            }
            DropItemEffectMapID.Clear();
            func = Config.Instance.Get<FuncConfigConfig>("DropItemEffectMapID");
            _data = LitJson.JsonMapper.ToObject(func.Numerical1);
            int _itemID;
            _keys.Clear();
            _keys.AddRange(_data.Keys);
            for (int j = 0; j < _keys.Count; ++j)
            {
                if (int.TryParse(_keys[j].ToString(), out _itemID))
                {
                    if (!DropItemEffectMapID.ContainsKey(_itemID))
                    {
                        DropItemEffectMapID.Add(_itemID, new List<int>());
                    }
                    var _jsonMapIDs = _data[_keys[j]];
                    foreach (var _jsonMapID in _jsonMapIDs)
                    {
                        var _mapID = ((LitJson.IJsonWrapper)_jsonMapID).GetInt();
                        if (!DropItemEffectMapID[_itemID].Contains(_mapID))
                        {
                            DropItemEffectMapID[_itemID].Add(_mapID);
                        }
                    }
                }
            }

            int[] mapIDs = GetIntArray("RebornAutoFightDungeon");
            RebornAutoFightMapID = new List<int>(mapIDs);

            teamWorldCall = GetInputString("TeamWorldCall");
            teamWorldCallInviteCount = GetInt("TeamWorldCall", 2);

            var ancientKingAwradConfig = Config.Instance.Get<FuncConfigConfig>("ElderBattlefieldTopAward");
            if (ancientKingAwradConfig != null)
            {
                var itemArray = LitJson.JsonMapper.ToObject<int[][]>(ancientKingAwradConfig.Numerical1);
                for (int k = 0; k < itemArray.Length; k++)
                {
                    ancientKingAwards.Add(new Item()
                    {
                        id = itemArray[k][0],
                        count = itemArray[k][1],
                        bind = itemArray[k][2] == 1,
                    });
                }
            }

            func = Config.Instance.Get<FuncConfigConfig>("QualityEffectConfig");
            lowQualityEffectCount = int.Parse(func.Numerical1);
            medQualityEffectCount = int.Parse(func.Numerical2);
            highQualityEffectCount = int.Parse(func.Numerical3);

            func = Config.Instance.Get<FuncConfigConfig>("QualityPetCountConfig");
            lowQualityPetCount = int.Parse(func.Numerical1);
            medQualityPetCount = int.Parse(func.Numerical2);
            highQualityPetCount = int.Parse(func.Numerical3);

            func = Config.Instance.Get<FuncConfigConfig>("QualityGuardCountConfig");
            lowQualityGuardCount = int.Parse(func.Numerical1);
            medQualityGuardCount = int.Parse(func.Numerical2);
            highQualityGuardCount = int.Parse(func.Numerical3);

            func = Config.Instance.Get<FuncConfigConfig>("QualityPetEffectCount");
            lowQualityPetEffectCount = int.Parse(func.Numerical1);
            medQualityPetEffectCount = int.Parse(func.Numerical2);
            highQualityPetEffectCount = int.Parse(func.Numerical3);

            func = Config.Instance.Get<FuncConfigConfig>("QualityHorseEffectCount");
            lowQualityHorseEffectCount = int.Parse(func.Numerical1);
            medQualityHorseEffectCount = int.Parse(func.Numerical2);
            highQualityHorseEffectCount = int.Parse(func.Numerical3);

            fairyLandBuffCondition = GetInt("XjmjAddHarm", 1);
            fairyLandBuffId = GetInt("XjmjAddHarm", 2);
            achievementEarlierStageLevel = GetInt("AchieveLV");

            func = Config.Instance.Get<FuncConfigConfig>("PreloadSkillEffect");
            PreloadSkillEffect = new int[2][];
            PreloadSkillEffect[0] = GetIntArray("PreloadSkillEffect");
            PreloadSkillEffect[1] = GetIntArray("PreloadSkillEffect", 2);
            DemonJarAutoTime = GetInt("DemonJarAutoTime");

            if (SgzzRobotEquipDict == null)
            {
                SgzzRobotEquipDict = new Dictionary<int, Dictionary<int, GA_NpcFightSgzcZZ.EquipRandomInfo>>();

                for (int job = 1; job <= 3; ++job)
                {
                    string _jsonString = GetInputString("SGZCHelpBattleEquip", job);

                    if (string.IsNullOrEmpty(_jsonString))
                    {
                        continue;
                    }

                    var _jsonData = LitJson.JsonMapper.ToObject(_jsonString);
                    var _jobDict = new Dictionary<int, GA_NpcFightSgzcZZ.EquipRandomInfo>();

                    for (i = 0; i < _jsonData.Count; ++i)
                    {
                        var _lvJson = _jsonData[i];
                        var _lv = (int)_lvJson["LV"];
                        if (!_jobDict.ContainsKey(_lv))
                        {
                            var _equips = _lvJson["Equips"];

                            var _randEquip = new GA_NpcFightSgzcZZ.EquipRandomInfo();

                            _randEquip.randClothesItemIDs = new int[_equips[0].Count];
                            for (int j = 0; j < _equips[0].Count; ++j)
                            {
                                _randEquip.randClothesItemIDs[j] = (int)_equips[0][j];
                            }

                            _randEquip.randWeaponItemIDs = new int[_equips[1].Count];
                            for (int j = 0; j < _equips[1].Count; ++j)
                            {
                                _randEquip.randWeaponItemIDs[j] = (int)_equips[1][j];
                            }

                            _randEquip.randSecondaryItemIDs = new int[_equips[2].Count];
                            for (int j = 0; j < _equips[2].Count; ++j)
                            {
                                _randEquip.randSecondaryItemIDs[j] = (int)_equips[2][j];
                            }

                            _randEquip.randWingItemIDs = new int[_equips[3].Count];
                            for (int j = 0; j < _equips[3].Count; ++j)
                            {
                                _randEquip.randWingItemIDs[j] = (int)_equips[3][j];
                            }

                            _randEquip.godWeaponIDs = new int[_equips[4].Count];
                            for (int j = 0; j < _equips[4].Count; ++j)
                            {
                                _randEquip.godWeaponIDs[j] = (int)_equips[4][j];
                            }

                            _jobDict.Add(_lv, _randEquip);
                        }
                    }

                    SgzzRobotEquipDict.Add(job, _jobDict);

                }
            }

            GatherSoulDZ = GetInt("GatherSoulDZ");

            if (SgzcRealm == null)
            {
                SgzcRealm = new Dictionary<int, int>();

                var _lvArr = GetInputString("SGZCRobotRealm", 1).Split('|');
                var _rLvArr = GetInputString("SGZCRobotRealm", 2).Split('|');

                for (int j = 0; j < _lvArr.Length; ++j)
                {
                    SgzcRealm[int.Parse(_lvArr[j])] = int.Parse(_rLvArr[j]);
                }
            }

            crossServerOneVsOneOpenDay = GetInt("CrossRealmCfg");
            UISpringDecorate = GetInt("UISpringDecorate");
        }
        catch (Exception ex)
        {
            Debug.LogError(ex);
        }

    }

    public static string GetJobHeadPortrait(int _job, int _ReincarnationLv)
    {
        if (jobHeadPortrait.ContainsKey(_job) && jobHeadPortrait[_job].ContainsKey(_ReincarnationLv))
        {
            return jobHeadPortrait[_job][_ReincarnationLv];
        }
        else
        {
            return string.Empty;
        }
    }

    public static string GetOtherJobHeadPortrait(int _job, int _ReincarnationLv)
    {
        if (otherjobHeadPortrait.ContainsKey(_job) && otherjobHeadPortrait[_job].ContainsKey(_ReincarnationLv))
        {
            return otherjobHeadPortrait[_job][_ReincarnationLv];
        }
        else
        {
            return string.Empty;
        }
    }

            }



            FuncConfigConfig nxxdImg = Config.Instance.Get<FuncConfigConfig>("NXXDPicture");

            LitJson.JsonData nxxdData = LitJson.JsonMapper.ToObject(nxxdImg.Numerical1);

            multipleRealmImgDict = new Dictionary<int, string>();

            if (nxxdData.IsArray)

            {

                for (i = 0; i < nxxdData.Count; i++)

                {

                    if (nxxdData[i].IsArray)

                    {

                        multipleRealmImgDict.Add(int.Parse(nxxdData[i][0].ToString()), nxxdData[i][1].ToString());

                    }

                }

            }



            bossShuntMaps = new List<int>(GetIntArray("BossShunt"));

            bossShuntDays = GetInt("BossShunt", 3);



            itemDropEffect.Clear();

            func = Config.Instance.Get<FuncConfigConfig>("ItemEquipmentEffect");

            _data = LitJson.JsonMapper.ToObject(func.Numerical1);

            List<string> _keys = new List<string>(_data.Keys);

            for (i = 0; i < _keys.Count; ++i)

            {

                int[] _props = new int[3];

                for (int j = 0; j < 3; ++j)

                {

                    _props[j] = (int)_data[_keys[i]][j];

                }

                itemDropEffect[int.Parse(_keys[i])] = _props;

            }



            xllyDropEffect.Clear();

            _data = LitJson.JsonMapper.ToObject(func.Numerical2);

            _keys.Clear();

            _keys.AddRange(_data.Keys);

            for (i = 0; i < _keys.Count; ++i)

            {

                int[] _props = new int[3];

                for (int j = 0; j < 3; ++j)

                {

                    _props[j] = (int)_data[_keys[i]][j];

                }

                xllyDropEffect[int.Parse(_keys[i])] = _props;

            }



            xqryDropEffect.Clear();

            _data = LitJson.JsonMapper.ToObject(func.Numerical3);

            _keys.Clear();

            _keys.AddRange(_data.Keys);

            for (i = 0; i < _keys.Count; ++i)

            {

                int[] _props = new int[3];

                for (int j = 0; j < 3; ++j)

                {

                    _props[j] = (int)_data[_keys[i]][j];

                }

                xqryDropEffect[int.Parse(_keys[i])] = _props;

            }



            dropEffectQuality.Clear();

            func = Config.Instance.Get<FuncConfigConfig>("IeemEquipmentEffectQuality");

            _data = LitJson.JsonMapper.ToObject(func.Numerical1);

            _keys.Clear();

            _keys.AddRange(_data.Keys);

            for (i = 0; i < _keys.Count; ++i)

            {

                dropEffectQuality[int.Parse(_keys[i])] = (int)_data[_keys[i]];

            }



            customDropEffect.Clear();

            func = Config.Instance.Get<FuncConfigConfig>("ItemEquipmentEffectItem");

            _data = LitJson.JsonMapper.ToObject(func.Numerical1);

            _keys.Clear();

            _keys.AddRange(_data.Keys);

            int[] _tmp = null;

            List<int[]> _content = null;

            for (i = 0; i < _keys.Count; ++i)

            {

                _content = new List<int[]>();

                foreach (LitJson.JsonData _values in _data[_keys[i]])

                {

                    if (_values.IsArray)

                    {

                        _tmp = new int[2];

                        _tmp[0] = (int)_values[0];

                        _tmp[1] = (int)_values[1];

                    }

                    else

                    {

                        _tmp = new int[1];

                        _tmp[0] = (int)_values;

                    }

                    _content.Add(_tmp);

                }

                customDropEffect.Add(int.Parse(_keys[i]), _content);

            }



            BuffToHitEffect.Clear();

            func = Config.Instance.Get<FuncConfigConfig>("BuffToHitEffect");

            if (!string.IsNullOrEmpty(func.Numerical1) && !string.IsNullOrEmpty(func.Numerical2))

            {

                string[] _buffs = func.Numerical1.Split('|');

                string[] _effects = func.Numerical2.Split('|');

                for (i = 0; i < _buffs.Length; ++i)

                {

                    BuffToHitEffect[int.Parse(_buffs[i])] = int.Parse(_effects[i]);

                }

            }



            demonJarHintLevelLimit = GetInt("DemonJarFirstRemin");

            demonJarHintLineId = GetInt("DemonJarFirstRemin", 2);

            skillPanelUnLock = GetInt("SkillPanelUnlock");

            dailyQuestRedpointLevelLimit = GetInt("DailyQuestRedPoint");

            lowHpRemind = GetInt("LowHpRemind");

            autoBuyItemIds = GetIntArray("BuyItemPrice", 1);

            autoBuyItemPrices = GetIntArray("BuyItemPrice", 2);

            neutralMaps.AddRange(GetIntArray("MapLine", 4));

            neutralBossMaps.AddRange(GetIntArray("BossListMapID"));



            var _propertyIconCfg = Config.Instance.Get<FuncConfigConfig>("PropertyIcon");

            var _propertyIconJson = LitJson.JsonMapper.ToObject(_propertyIconCfg.Numerical1);

            foreach (var _key in _propertyIconJson.Keys)

            {

                var _property = int.Parse(_key);

                propertyIconDict.Add(_property, _propertyIconJson[_key].ToString());

            }



            munekadolockLimit = GetInt("MunekadoLockLimit");

            demonJarRedPoint = GetInt("DemonJarRedPoint");

            LoadLV = GetInputString("LoadLV");



            mainWinSkillResetTime = GetFloat("AutomaticSwitch");

            OffLineTimeLackRemendLevelLimit = GetInt("TJGLevelLimit");

            heroDialogueOffset = GetInputString("NpcHalfLength", 1).Vector3Parse();

            heroDialogueRotation = GetInputString("NpcHalfLength", 2).Vector3Parse();

            heroDialogueScale = GetFloat("NpcHalfLength", 3);



            var ancientConfig = Config.Instance.Get<FuncConfigConfig>("ElderBattleTarget");

            ancientGrandTotalAchievements = new List<int>();

            ancientGrandTotalAchievements.AddRange(ConfigParse.GetMultipleStr<int>(ancientConfig.Numerical1));

            ancientContinueKillAchievements = new List<int>();

            ancientContinueKillAchievements.AddRange(ConfigParse.GetMultipleStr<int>(ancientConfig.Numerical2));



            trialDungeonGroupChallengeTipLv = GetInt("SingleIntoFB");

            prayerRedpointLimitLv = GetInt("PrayRedPoint");

            demonJarLevelLimit = GetInt("DemonJarLevelLimit");

            maxItemDropEffectCount = GetInt("ItemMaskEffect");



            specialGuide41Mission = GetInt("SpecialGuide41", 1);

            specialGuide41Achievement = GetInt("SpecialGuide41", 2);



            supremeRechargeVipLv = GetInt("SupremeCTGVipLimit", 1);



            rechargeRedpointLv = GetInt("FirstPayRedPoint", 1);

            rechargeRedpointMinLv = GetInt("FirstPayRedPoint", 2);

            runeTowerSweepBuyTimes = GetInt("RuneTowerSweepBuy");

            runeTowerSweepBuyPrice = GetInt("RuneTowerSweepBuy", 2);

            teamMatchingTimeOut = GetInt("TeamMatchingTimeOut");

            inGameDownLoadLevelCheckPoints = new List<int>(GetIntArray("InGameDownLoad"));

            inGameDownLoadTaskCheckPoints = new List<int>(GetIntArray("InGameDownLoad", 2));

            inGameDownLoadHighLevel = GetInt("InGameDownLoad", 3);



            worldBossNoRebornRemindMaps = new List<int>(GetIntArray("NoRebornRemindMap", 1));

            bossHomeNoRebornRemindMaps = new List<int>(GetIntArray("NoRebornRemindMap", 2));

            elderGodNoRebornRemindMaps = new List<int>(GetIntArray("NoRebornRemindMap", 3));

            demonJarNoRebornRemindMaps = new List<int>(GetIntArray("NoRebornRemindMap", 4));

            dogzNoRebornRemindMaps = new List<int>(GetIntArray("NoRebornRemindMap", 5));



            if (ModeDefaultConfig == null)

            {

                func = Config.Instance.Get<FuncConfigConfig>("ModeDefault");



                string[] _funcNpc = func.Numerical1.Split('|');

                string[] _fightNpc = func.Numerical2.Split('|');

                string[] _pet = func.Numerical3.Split('|');

                string[] _horse = func.Numerical4.Split('|');



                ModeDefaultConfig = new string[4][];

                ModeDefaultConfig[0] = _funcNpc;

                ModeDefaultConfig[1] = _fightNpc;

                ModeDefaultConfig[2] = _pet;

                ModeDefaultConfig[3] = _horse;

            }



            if (RealmGroup == null)

            {

                func = Config.Instance.Get<FuncConfigConfig>("RealmGroup");

                string[] _group = func.Numerical1.Split('|');

                RealmGroup = new int[_group.Length];

                for (int j = 0; j < _group.Length; ++j)

                {

                    int.TryParse(_group[j], out RealmGroup[j]);

                }

            }



            func = Config.Instance.Get<FuncConfigConfig>("PrefightAtkRange");

            PrefightAtkRange = float.Parse(func.Numerical1);

            inGameDownLoadHighestLevelPoint = GetInt("DownReward", 2);



            dungeonCanUseMoneyIds = new List<int>(GetIntArray("FBEnterTickeyAuto", 1));

            dungeonRebornClientTimes = ConfigParse.GetDic<int, int>(GetInputString("DuplicatesRebornTime", 2));

            dogzBoxLimit = GetInt("DogzBoxLimit");



            fairyGrabBossMapLines = ConfigParse.GetDic<int, int>(GetInputString("MapLine", 2));

            var grabBossMaps = fairyGrabBossMapLines.Keys.ToList();

            foreach (var _key in grabBossMaps)

            {

                fairyGrabBossMapLines[_key] = fairyGrabBossMapLines[_key] - 1;

            }



            if (DropItemEffectMapID == null)

            {

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

            }

            DropItemEffectMapID.Clear();

            func = Config.Instance.Get<FuncConfigConfig>("DropItemEffectMapID");

            _data = LitJson.JsonMapper.ToObject(func.Numerical1);

            int _itemID;

            _keys.Clear();

            _keys.AddRange(_data.Keys);

            for (int j = 0; j < _keys.Count; ++j)

            {

                if (int.TryParse(_keys[j].ToString(), out _itemID))

                {

                    if (!DropItemEffectMapID.ContainsKey(_itemID))

                    {

                        DropItemEffectMapID.Add(_itemID, new List<int>());

                    }

                    var _jsonMapIDs = _data[_keys[j]];

                    foreach (var _jsonMapID in _jsonMapIDs)

                    {

                        var _mapID = ((LitJson.IJsonWrapper)_jsonMapID).GetInt();

                        if (!DropItemEffectMapID[_itemID].Contains(_mapID))

                        {

                            DropItemEffectMapID[_itemID].Add(_mapID);

                        }

                    }

                }

            }



            int[] mapIDs = GetIntArray("RebornAutoFightDungeon");

            RebornAutoFightMapID = new List<int>(mapIDs);



            teamWorldCall = GetInputString("TeamWorldCall");

            teamWorldCallInviteCount = GetInt("TeamWorldCall", 2);



            var ancientKingAwradConfig = Config.Instance.Get<FuncConfigConfig>("ElderBattlefieldTopAward");

            if (ancientKingAwradConfig != null)

            {

                var itemArray = LitJson.JsonMapper.ToObject<int[][]>(ancientKingAwradConfig.Numerical1);

                for (int k = 0; k < itemArray.Length; k++)

                {

                    ancientKingAwards.Add(new Item()

                    {

                        id = itemArray[k][0],

                        count = itemArray[k][1],

                        bind = itemArray[k][2] == 1,

                    });

                }

            }



            func = Config.Instance.Get<FuncConfigConfig>("QualityEffectConfig");

            lowQualityEffectCount = int.Parse(func.Numerical1);

            medQualityEffectCount = int.Parse(func.Numerical2);

            highQualityEffectCount = int.Parse(func.Numerical3);



            func = Config.Instance.Get<FuncConfigConfig>("QualityPetCountConfig");

            lowQualityPetCount = int.Parse(func.Numerical1);

            medQualityPetCount = int.Parse(func.Numerical2);

            highQualityPetCount = int.Parse(func.Numerical3);



            func = Config.Instance.Get<FuncConfigConfig>("QualityGuardCountConfig");

            lowQualityGuardCount = int.Parse(func.Numerical1);

            medQualityGuardCount = int.Parse(func.Numerical2);

            highQualityGuardCount = int.Parse(func.Numerical3);



            func = Config.Instance.Get<FuncConfigConfig>("QualityPetEffectCount");

            lowQualityPetEffectCount = int.Parse(func.Numerical1);

            medQualityPetEffectCount = int.Parse(func.Numerical2);

            highQualityPetEffectCount = int.Parse(func.Numerical3);



            func = Config.Instance.Get<FuncConfigConfig>("QualityHorseEffectCount");

            lowQualityHorseEffectCount = int.Parse(func.Numerical1);

            medQualityHorseEffectCount = int.Parse(func.Numerical2);

            highQualityHorseEffectCount = int.Parse(func.Numerical3);



            fairyLandBuffCondition = GetInt("XjmjAddHarm", 1);

            fairyLandBuffId = GetInt("XjmjAddHarm", 2);

            achievementEarlierStageLevel = GetInt("AchieveLV");



            func = Config.Instance.Get<FuncConfigConfig>("PreloadSkillEffect");

            PreloadSkillEffect = new int[2][];

            PreloadSkillEffect[0] = GetIntArray("PreloadSkillEffect");

            PreloadSkillEffect[1] = GetIntArray("PreloadSkillEffect", 2);

            DemonJarAutoTime = GetInt("DemonJarAutoTime");



            if (SgzzRobotEquipDict == null)

            {

                SgzzRobotEquipDict = new Dictionary<int, Dictionary<int, GA_NpcFightSgzcZZ.EquipRandomInfo>>();



                for (int job = 1; job <= 3; ++job)

                {

                    string _jsonString = GetInputString("SGZCHelpBattleEquip", job);



                    if (string.IsNullOrEmpty(_jsonString))

                    {

                        continue;

                    }



                    var _jsonData = LitJson.JsonMapper.ToObject(_jsonString);

                    var _jobDict = new Dictionary<int, GA_NpcFightSgzcZZ.EquipRandomInfo>();



                    for (i = 0; i < _jsonData.Count; ++i)

                    {

                        var _lvJson = _jsonData[i];

                        var _lv = (int)_lvJson["LV"];

                        if (!_jobDict.ContainsKey(_lv))

                        {

                            var _equips = _lvJson["Equips"];



                            var _randEquip = new GA_NpcFightSgzcZZ.EquipRandomInfo();



                            _randEquip.randClothesItemIDs = new int[_equips[0].Count];

                            for (int j = 0; j < _equips[0].Count; ++j)

                            {

                                _randEquip.randClothesItemIDs[j] = (int)_equips[0][j];

                            }



                            _randEquip.randWeaponItemIDs = new int[_equips[1].Count];

                            for (int j = 0; j < _equips[1].Count; ++j)

                            {

                                _randEquip.randWeaponItemIDs[j] = (int)_equips[1][j];

                            }



                            _randEquip.randSecondaryItemIDs = new int[_equips[2].Count];

                            for (int j = 0; j < _equips[2].Count; ++j)

                            {

                                _randEquip.randSecondaryItemIDs[j] = (int)_equips[2][j];

                            }



                            _randEquip.randWingItemIDs = new int[_equips[3].Count];

                            for (int j = 0; j < _equips[3].Count; ++j)

                            {

                                _randEquip.randWingItemIDs[j] = (int)_equips[3][j];

                            }



                            _randEquip.godWeaponIDs = new int[_equips[4].Count];

                            for (int j = 0; j < _equips[4].Count; ++j)

                            {

                                _randEquip.godWeaponIDs[j] = (int)_equips[4][j];

                            }



                            _jobDict.Add(_lv, _randEquip);

                        }

                    }



                    SgzzRobotEquipDict.Add(job, _jobDict);



                }

            }



            GatherSoulDZ = GetInt("GatherSoulDZ");



            if (SgzcRealm == null)

            {

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



                var _lvArr = GetInputString("SGZCRobotRealm", 1).Split('|');

                var _rLvArr = GetInputString("SGZCRobotRealm", 2).Split('|');



                for (int j = 0; j < _lvArr.Length; ++j)

                {

                    SgzcRealm[int.Parse(_lvArr[j])] = int.Parse(_rLvArr[j]);

                }

            }



            crossServerOneVsOneOpenDay = GetInt("CrossRealmCfg");

            UISpringDecorate = GetInt("UISpringDecorate");

        }

        catch (Exception ex)

        {

            Debug.LogError(ex);

        }



    }



    public static string GetJobHeadPortrait(int _job, int _ReincarnationLv)

    {

        if (jobHeadPortrait.ContainsKey(_job) && jobHeadPortrait[_job].ContainsKey(_ReincarnationLv))

        {

            return jobHeadPortrait[_job][_ReincarnationLv];

        }

        else

        {

            return string.Empty;

        }

    }



    public static List<int> GetAttrIdsBySkill(int _skillId)

    {

        if(skillAttrIDDict.ContainsKey(_skillId))

        {

            return skillAttrIDDict[_skillId];

        }

        return null;

    }



    public static string GetOtherJobHeadPortrait(int _job, int _ReincarnationLv)

    {

        if (otherjobHeadPortrait.ContainsKey(_job) && otherjobHeadPortrait[_job].ContainsKey(_ReincarnationLv))

        {

            return otherjobHeadPortrait[_job][_ReincarnationLv];

        }

        else

        {

            return string.Empty;

        }

    }



    public static PackType GetPackTypeByItemType(int itemType)

    {

        foreach(var key in itemPutInPackDict.Keys)

@@ -721,149 +755,149 @@
            }

        }

        return PackType.rptItem;

    }

    private static int GetInt(string _key, int _index = 1)
    {
        var result = 0;
        int.TryParse(GetInputString(_key, _index), out result);
        return result;
    }

    private static float GetFloat(string _key, int _index = 1)
    {
        var result = 0f;
        float.TryParse(GetInputString(_key, _index), out result);
        return result;
    }

    private static bool GetBool(string _key, int _index = 1)
    {
        var result = false;
        bool.TryParse(GetInputString(_key, _index), out result);
        return result;
    }

    private static int[] GetIntArray(string _key, int _index = 1)
    {
        var inputString = GetInputString(_key, _index);
        var stringArray = inputString.Split(StringUtility.splitSeparator, StringSplitOptions.RemoveEmptyEntries);

        if (stringArray.Length == 0)
        {
            return null;
        }

        var result = new int[stringArray.Length];
        for (int i = 0; i < stringArray.Length; i++)
        {
            int.TryParse(stringArray[i], out result[i]);
        }

        return result;
    }

    private static string[] GetStringArray(string _key, int _index = 1)
    {
        var inputString = GetInputString(_key, _index);
        var stringArray = inputString.Split(StringUtility.splitSeparator, StringSplitOptions.RemoveEmptyEntries);

        if (stringArray.Length == 0)
        {
            return null;
        }

        var result = new string[stringArray.Length];
        for (int i = 0; i < stringArray.Length; i++)
        {
            result[i] = stringArray[i];
        }

        return result;
    }


    private static float[] GetFloatArray(string _key, int _index = 1)
    {
        var inputString = GetInputString(_key, _index);
        var stringArray = inputString.Split(StringUtility.splitSeparator, StringSplitOptions.RemoveEmptyEntries);

        if (stringArray.Length == 0)
        {
            return null;
        }

        var result = new float[stringArray.Length];
        for (int i = 0; i < stringArray.Length; i++)
        {
            float.TryParse(stringArray[i], out result[i]);
        }

        return result;
    }

    private static bool[] GetBoolArray(string _key, int _index = 1)
    {
        var inputString = GetInputString(_key, _index);
        var stringArray = inputString.Split(StringUtility.splitSeparator, StringSplitOptions.RemoveEmptyEntries);

        if (stringArray.Length == 0)
        {
            return null;
        }

        var result = new bool[stringArray.Length];
        for (int i = 0; i < stringArray.Length; i++)
        {
            bool.TryParse(stringArray[i], out result[i]);
        }

        return result;
    }

    private static List<int> GetTimeArray(string _key, int _index = 1)
    {
        var configContent = GetInputString(_key, _index);
        var stringArray = configContent.Split(StringUtility.splitSeparator, StringSplitOptions.RemoveEmptyEntries);
        var timeList = new List<int>();
        for (int i = 0; i < stringArray.Length; i++)
        {
            var input = stringArray[i];
            var matches = Regex.Matches(input, "[0-9]{1,2}");
            var hour = matches.Count > 0 ? int.Parse(matches[0].Value) : 0;
            var minute = matches.Count > 1 ? int.Parse(matches[1].Value) : 0;
            timeList.Add(hour * 60 + minute);
        }

        return timeList;
    }

    private static string GetInputString(string _key, int _index = 1)
    {
        var config = Config.Instance.Get<FuncConfigConfig>(_key);
        var inputString = string.Empty;

        switch (_index)
        {
            case 1:
                inputString = config.Numerical1;
                break;
            case 2:
                inputString = config.Numerical2;
                break;
            case 3:
                inputString = config.Numerical3;
                break;
            case 4:
                inputString = config.Numerical4;
                break;
            case 5:
                inputString = config.Numerical5;
                break;
        }

        return inputString;
    }


}
    }



    private static int GetInt(string _key, int _index = 1)

    {

        var result = 0;

        int.TryParse(GetInputString(_key, _index), out result);

        return result;

    }



    private static float GetFloat(string _key, int _index = 1)

    {

        var result = 0f;

        float.TryParse(GetInputString(_key, _index), out result);

        return result;

    }



    private static bool GetBool(string _key, int _index = 1)

    {

        var result = false;

        bool.TryParse(GetInputString(_key, _index), out result);

        return result;

    }



    private static int[] GetIntArray(string _key, int _index = 1)

    {

        var inputString = GetInputString(_key, _index);

        var stringArray = inputString.Split(StringUtility.splitSeparator, StringSplitOptions.RemoveEmptyEntries);



        if (stringArray.Length == 0)

        {

            return null;

        }



        var result = new int[stringArray.Length];

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

        {

            int.TryParse(stringArray[i], out result[i]);

        }



        return result;

    }



    private static string[] GetStringArray(string _key, int _index = 1)

    {

        var inputString = GetInputString(_key, _index);

        var stringArray = inputString.Split(StringUtility.splitSeparator, StringSplitOptions.RemoveEmptyEntries);



        if (stringArray.Length == 0)

        {

            return null;

        }



        var result = new string[stringArray.Length];

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

        {

            result[i] = stringArray[i];

        }



        return result;

    }





    private static float[] GetFloatArray(string _key, int _index = 1)

    {

        var inputString = GetInputString(_key, _index);

        var stringArray = inputString.Split(StringUtility.splitSeparator, StringSplitOptions.RemoveEmptyEntries);



        if (stringArray.Length == 0)

        {

            return null;

        }



        var result = new float[stringArray.Length];

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

        {

            float.TryParse(stringArray[i], out result[i]);

        }



        return result;

    }



    private static bool[] GetBoolArray(string _key, int _index = 1)

    {

        var inputString = GetInputString(_key, _index);

        var stringArray = inputString.Split(StringUtility.splitSeparator, StringSplitOptions.RemoveEmptyEntries);



        if (stringArray.Length == 0)

        {

            return null;

        }



        var result = new bool[stringArray.Length];

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

        {

            bool.TryParse(stringArray[i], out result[i]);

        }



        return result;

    }



    private static List<int> GetTimeArray(string _key, int _index = 1)

    {

        var configContent = GetInputString(_key, _index);

        var stringArray = configContent.Split(StringUtility.splitSeparator, StringSplitOptions.RemoveEmptyEntries);

        var timeList = new List<int>();

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

        {

            var input = stringArray[i];

            var matches = Regex.Matches(input, "[0-9]{1,2}");

            var hour = matches.Count > 0 ? int.Parse(matches[0].Value) : 0;

            var minute = matches.Count > 1 ? int.Parse(matches[1].Value) : 0;

            timeList.Add(hour * 60 + minute);

        }



        return timeList;

    }



    private static string GetInputString(string _key, int _index = 1)

    {

        var config = Config.Instance.Get<FuncConfigConfig>(_key);

        var inputString = string.Empty;



        switch (_index)

        {

            case 1:

                inputString = config.Numerical1;

                break;

            case 2:

                inputString = config.Numerical2;

                break;

            case 3:

                inputString = config.Numerical3;

                break;

            case 4:

                inputString = config.Numerical4;

                break;

            case 5:

                inputString = config.Numerical5;

                break;

        }



        return inputString;

    }





}


 System/JadeDynastyTower/JadeDynastyTowerModel.cs

@@ -15,6 +15,7 @@
        const int REDPOINTID_03 = 21503;
        const int FUNCTIONID = 164;

        public int lastChallengeFloor { get; private set; }
        public int highestPassFloor { get; private set; }
        public int currentFloor {
            get {
@@ -130,7 +131,7 @@

        public void SetOpenJadeDynastyTowerWinDirty()
        {
            if (specialUnLockFloor==0)
            if (specialUnLockFloor == 0)
            {
                openJadeDynastyTower = true;
            }
@@ -178,6 +179,7 @@

        public void UpdateHighestPassFloor(HB213_tagMCZhuXianTowerInfo info)
        {
            lastChallengeFloor = (int)info.LastFloor;
            var oldRecorder = highestPassFloor;
            highestPassFloor = (int)info.Floor;
            if (serverInited && highestPassFloor > oldRecorder)
@@ -223,12 +225,6 @@

        public void OnMapInitOk()
        {
            switch (PlayerDatas.Instance.baseData.MapID)
            {
                case DATA_MAPID:
                    RequestRefreshMonster();
                    break;
            }
        }

        private void UpateRedpoint()

 System/KnapSack/Logic/SelectBoxItemCell.cs

@@ -33,16 +33,25 @@
            ItemConfig itemConfig = Config.Instance.Get<ItemConfig>(id);

            this.ItemId = id;

            nameText.text = itemConfig.ItemName;

            ItemCellModel cellModel = new ItemCellModel(id, false, (ulong)BoxModel.selectDict[id],0,"",PackType.rptDeleted,true);

            ItemCellModel cellModel = new ItemCellModel(id, true, (ulong)BoxModel.selectDict[id],0,"",PackType.rptDeleted,true);

            itemBaisc.Init(cellModel);

            if (itemConfig.Effect1 == 220)

            {

                id = itemConfig.EffectValueA1;

            }

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

            if(haveCnt <= 0)

            var packType = GeneralDefine.GetPackTypeByItemType(itemConfig.Type);

            int haveCnt = 0;

            switch(packType)

            {

                haveCnt = ModelCenter.Instance.GetModel<RuneModel>().GetRuneCountById(id);

                case PackType.rptRunePack:

                    haveCnt = ModelCenter.Instance.GetModel<RuneModel>().GetRuneCountById(id);

                    break;

                case PackType.rptGatherSoul:

                    haveCnt = ModelCenter.Instance.GetModel<VirtualPackModel>().GetItemCountById(packType,id);

                    break;

                default:

                    haveCnt = playerPack.GetItemCountByID(packType, id);

                    break;

            }

            haveCntText.text = haveCnt.ToString();

            SetIsChoose(false);


 System/MainInterfacePanel/HighSettingFadeInFadeOut.cs

@@ -55,6 +55,7 @@
        CrossServerOneVsOneRewardModel m_CrossServerRewardModel;

        CrossServerOneVsOneRewardModel crossServerRewardModel { get { return m_CrossServerRewardModel ?? (m_CrossServerRewardModel = ModelCenter.Instance.GetModel<CrossServerOneVsOneRewardModel>()); } }

        OpenServiceAchievementModel OpenServerModel { get { return ModelCenter.Instance.GetModel<OpenServiceAchievementModel>(); } }

        SpringFestivalModel springFestival { get { return ModelCenter.Instance.GetModel<SpringFestivalModel>(); } }

        public void Init()

        {

            if (LatencyTimeList.Count <= 0)

@@ -84,6 +85,7 @@
            impactRankModel.inImpactRankUpdate += InImpactRankUpdate;

            OpenServerModel.IsOpenEvent += IsOpenEvent;

            OpenServerModel.IsPreviewTimeUpdate += IsOpenEvent;

            OperationTimeHepler.Instance.operationAdvanceEvent += OperationAdvanceEvent;

        }



        public void Unit()

@@ -100,6 +102,12 @@
            impactRankModel.inImpactRankUpdate -= InImpactRankUpdate;

            OpenServerModel.IsOpenEvent -= IsOpenEvent;

            OpenServerModel.IsPreviewTimeUpdate -= IsOpenEvent;

            OperationTimeHepler.Instance.operationAdvanceEvent -= OperationAdvanceEvent;

        }



        private void OperationAdvanceEvent(Operation obj)

        {

            Classify();

        }



        private void IsOpenEvent()

@@ -119,18 +127,13 @@


        private void operationEndEvent(Operation arg1, int arg2)

        {

            if (arg1 == Operation.FairyCeremony || arg1== Operation.NewYearFairyCeremony)

            {

                Classify();

            }

            Classify();

        }



        private void operationStartEvent(Operation arg1, int arg2)

        {

            if (arg1 == Operation.FairyCeremony || arg1 == Operation.NewYearFairyCeremony)

            {

                Classify();

            }

            Classify();

          
        }



        private void UpdateRedpoint(int redPointID)

@@ -656,8 +659,9 @@
                        }

                        else if (IndexOf == 4)

                        {

                            bool Isopen = OpenServerModel.IsOpen;

                            if (!AnimationFadeOutDicLow.ContainsKey(highBtnRecord.Index) && Isopen)//7天寻礼

                            bool Isopen = OpenServerModel.IsOpenFeatures();

                            bool _isOpen = springFestival.IsOpenFeatures();

                            if (!AnimationFadeOutDicLow.ContainsKey(highBtnRecord.Index) && (Isopen || _isOpen))//7天寻礼

                            {

                                if (AnimationFadeOutDicLow.Count < 6)//------第二层

                                {


 System/OpenServerActivity/AchievementActivityWin.cs

@@ -9,7 +9,8 @@
using UnityEngine;
using UnityEngine.UI;

namespace Snxxz.UI {
namespace Snxxz.UI

{
    //成就活动面板
    public class AchievementActivityWin : Window
    {
@@ -20,6 +21,9 @@
        [SerializeField] Button _LeftBtn;

        [SerializeField] Button _RightBtn;
        [SerializeField] FunctionButton m_OpenServiceAchievementBtn;//周狂欢
        [SerializeField] FunctionButton m_SpringFestival;//春节活动

        OpenServiceAchievementModel openServiceAchievementModel { get { return ModelCenter.Instance.GetModel<OpenServiceAchievementModel>(); } }

        SpringFestivalModel springFestivalModel { get { return ModelCenter.Instance.GetModel<SpringFestivalModel>(); } }
        protected override void BindController()
        {
        }
@@ -30,16 +34,25 @@
            _LeftBtn.AddListener(OnClickLeftBtn);

            _RightBtn.AddListener(OnClickRight);
            m_OpenServiceAchievementBtn.AddListener(OpenServiceAchievementButton);
            m_SpringFestival.AddListener(SpringFestivalButton);
        }

        protected override void OnPreOpen()
        {

            OperationTimeHepler.Instance.operationStartEvent += operationStartEvent;

            IsButtonNumber();

            if (WindowCenter.Instance.IsOpen<MainInterfaceWin>())

            {

                WindowCenter.Instance.Close<MainInterfaceWin>();

            }
            functionOrder = 0;

          
            if (openServiceAchievementModel.IsOpenFeatures())

            {

                functionOrder = 0;

            }

            else if (springFestivalModel.IsOpenFeatures())

            {

                functionOrder = 1;

            }

        }

        protected override void OnActived()

@@ -47,10 +60,18 @@
            FuncBtnGroup.TriggerByOrder(functionOrder);

        }
        protected override void OnAfterOpen()
        {
          
        }

        {

            OperationTimeHepler.Instance.operationStartEvent -= operationStartEvent;

        }



        private void operationStartEvent(Operation arg1, int arg2)

        {

            if (arg1 == Operation.SpringFestival || arg1== Operation.OpenServiceAchievement)

            {

                IsButtonNumber();

            }

        }



        protected override void OnPreClose()
        {

            CloseChild();

@@ -84,6 +105,10 @@
            {

                WindowCenter.Instance.CloseImmediately<OpenServiceAchievementWin>();

            }

            if (WindowCenter.Instance.IsOpen<SpringFestivalWin>())

            {

                WindowCenter.Instance.CloseImmediately<SpringFestivalWin>();

            }

        }

        private void OpenServiceAchievementButton()

@@ -99,8 +124,39 @@
            }

            functionOrder = 0;

        }
        private void SpringFestivalButton()

        {

            CloseChild();

            if (windowState == WindowState.Opened)

            {

                WindowCenter.Instance.OpenWithoutAnimation<SpringFestivalWin>();

            }

            else

            {

                WindowCenter.Instance.Open<SpringFestivalWin>(true);

            }

            functionOrder = 1;

        }
        #endregion


        private void IsButtonNumber()

        {

            if (openServiceAchievementModel.IsOpenFeatures())

            {

                m_OpenServiceAchievementBtn.gameObject.SetActive(true);

            }

            else

            {

                m_OpenServiceAchievementBtn.gameObject.SetActive(false);

            }

            if (springFestivalModel.IsOpenFeatures())

            {

                m_SpringFestival.gameObject.SetActive(true);

            }

            else

            {

                m_SpringFestival.gameObject.SetActive(false);

            }

        }

    }

}

 System/OpenServerActivity/EntryInformationCell.cs

New file
@@ -0,0 +1,34 @@
//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Monday, December 10, 2018
//--------------------------------------------------------
using UnityEngine;
using System.Collections;
using UnityEngine.UI;

namespace Snxxz.UI {
    [XLua.Hotfix]
    public class EntryInformationCell:MonoBehaviour {
        [SerializeField] ItemCell m_ItemCell;
        [SerializeField] Text m_Text1;
        [SerializeField] Text m_Text2;
        [SerializeField] Button m_Button;
        [SerializeField] Text m_ButtonText;

        LoginRewardModel m_LoginRewardModel;
        LoginRewardModel loginRewardModel { get { return m_LoginRewardModel ?? (m_LoginRewardModel = ModelCenter.Instance.GetModel<LoginRewardModel>()); } }
        public Button mButton

        {

            get { return m_Button; }

            set { m_Button = value; }

        }

        public void GetDisplayInformation(int id)

        {



        }
    }

}




 System/OpenServerActivity/EntryInformationCell.cs.meta

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

 System/OpenServerActivity/EventDaysTime.cs

New file
@@ -0,0 +1,23 @@
//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Monday, January 21, 2019
//--------------------------------------------------------
using System;

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

namespace Snxxz.UI {

    public class EventDaysTime: OperationBase

    {
        public int GetInDayNow()

        {

            return base.IndexOfDays(TimeUtility.ServerNow);

        }
    }

}




 System/OpenServerActivity/EventDaysTime.cs.meta

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

 System/OpenServerActivity/HolidayHomingIcon.cs

New file
@@ -0,0 +1,69 @@
//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Monday, January 28, 2019
//--------------------------------------------------------
using UnityEngine;
using System.Collections;
using UnityEngine.UI;
using System;

using TableConfig;



namespace Snxxz.UI

{

    public class HolidayHomingIcon : MonoBehaviour

    {
        [SerializeField] Image m_Icon;
        private string Iconkey1 = string.Empty;

        private string Iconkey2 = string.Empty;

        OpenServiceAchievementModel openServiceAchievementModel { get { return ModelCenter.Instance.GetModel<OpenServiceAchievementModel>(); } }

        SpringFestivalModel springFestivalModel { get { return ModelCenter.Instance.GetModel<SpringFestivalModel>(); } }
        private void Awake()

        {

            OperationTimeHepler.Instance.operationStartEvent -= OperationStartEvent;

            OperationTimeHepler.Instance.dayResetEvent -= DayResetEvent;

            OperationTimeHepler.Instance.operationStartEvent += OperationStartEvent;

            OperationTimeHepler.Instance.dayResetEvent += DayResetEvent;

            var funconfig = Config.Instance.Get<FuncConfigConfig>("HolidayHomingIcon");

            Iconkey1 = funconfig.Numerical1;

            Iconkey2 = funconfig.Numerical2;

        }







        private void OnEnable()

        {

            SetIcon();

        }
        private void SetIcon()

        {

            if (openServiceAchievementModel.IsOpenFeatures())

            {

                m_Icon.SetSprite(Iconkey1);

            }

            else if (springFestivalModel.IsOpenFeatures())

            {

                m_Icon.SetSprite(Iconkey2);

            }

        }
        private void DayResetEvent(int obj)

        {

            if (obj == (int)Operation.OpenServiceAchievement || obj == (int)Operation.SpringFestival)

            {

                SetIcon();

            }

        }



        private void OperationStartEvent(Operation arg1, int arg2)

        {

            if (arg1 == Operation.OpenServiceAchievement || arg1 == Operation.SpringFestival)

            {

                SetIcon();

            }

        }
    }

}




 System/OpenServerActivity/HolidayHomingIcon.cs.meta

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

 System/OpenServerActivity/LogInDayNumber.cs

New file
@@ -0,0 +1,61 @@
//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Friday, December 07, 2018
//--------------------------------------------------------
using UnityEngine;
using System.Collections;
using UnityEngine.UI;

namespace Snxxz.UI {
    //登录奖励天数标签
    [XLua.Hotfix]
    public class LogInDayNumber:MonoBehaviour {

        [SerializeField] Button m_DayNumberBtn;
        [SerializeField] ImageEx m_DayNumberImage;
        [SerializeField] ImageEx m_SelectedImage;
        [SerializeField] GameObject m_Obj1;
        [SerializeField] Text m_DayText1;
        [SerializeField] GameObject m_Obj2;

        [SerializeField] Text m_DayText2;

        LoginRewardModel m_LoginRewardModel;
        LoginRewardModel loginRewardModel { get { return m_LoginRewardModel ?? (m_LoginRewardModel = ModelCenter.Instance.GetModel<LoginRewardModel>()); } }
        public Button DayNumberBtn

        {

            get { return m_DayNumberBtn; }

            set { m_DayNumberBtn = value; }

        }

        public void SetInDayNumber(int day,int clockDayNow)

        {

            if (day == clockDayNow)

            {

                m_SelectedImage.gameObject.SetActive(true);

            }

            else

            {

                m_SelectedImage.gameObject.SetActive(false);

            }

            if (day > loginRewardModel.DayNow)

            {

                m_SelectedImage.gray = true;

                m_DayNumberImage.gray = true;

                m_Obj1.SetActive(false);

                m_Obj2.SetActive(true);

                m_DayText2.text = (day + 1).ToString();

            }

            else

            {

                m_SelectedImage.gray = false;

                m_DayNumberImage.gray = false;

                m_Obj1.SetActive(true);

                m_Obj2.SetActive(false);

                m_DayText1.text= (day + 1).ToString();

            }

        }

    }

}




 System/OpenServerActivity/LogInDayNumber.cs.meta

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

 System/OpenServerActivity/LoginRewardModel.cs

New file
@@ -0,0 +1,278 @@
//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Monday, December 10, 2018
//--------------------------------------------------------
using System;

using System.Collections.Generic;

using TableConfig;

using Snxxz.UI;
//登录奖励
[XLua.LuaCallCSharp]

public class LoginRewardModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk

{

    public event Action LoginAwardInfoUpdate;//领奖记录变更 
    public Dictionary<int, WeekPartyDayInfoClass> LoginAwardInfoDic = new Dictionary<int, WeekPartyDayInfoClass>();//领奖信息

    public Dictionary<int, WeekPartyDayClass> LoginAwardDayDic = new Dictionary<int, WeekPartyDayClass>();//每天的奖励信息

    public Dictionary<int, WeekPartyActionClass> LoginAwardDic = new Dictionary<int, WeekPartyActionClass>();//活动模板信息

    public Dictionary<int, Redpoint> RedPointDic = new Dictionary<int, Redpoint>();//红点

    public int DayNow = 0;//当前天

    public int SelectedNow = 0;//获取选择天

    public int LimitLV = 0;//限制等级

    private const int Redpoint_key = 6666;//登录奖励红点

    public Redpoint redPointStre = new Redpoint(666, Redpoint_key);

    public override void Init()

    {

      
    }



    public void OnBeforePlayerDataInitialize()

    {

        LoginAwardInfoDic.Clear();

    }



    public void OnPlayerLoginOk()

    {

        GetDay();

        SetRedPoint();

    }



    public override void UnInit()

    {

        
    }



    public void LoginAwardInfo(HAA0C_tagMCActLoginAwardInfo info)//登录奖励活动信息

    {

        LimitLV = info.LimitLV;

        LoginAwardDayDic.Clear();

        LoginAwardDic.Clear();

        for (int i = 0; i < info.DayCnt; i++)//每天的奖励信息

        {

            int Index = i;

            var dayInfo = info.DayInfoList[i];

            WeekPartyDayClass loginAwardDay = new WeekPartyDayClass();

            loginAwardDay.TemplateList = new int[dayInfo.ActCnt];

            for (int k = 0; k < dayInfo.ActCnt; k++)

            {

                loginAwardDay.TemplateList[k] = dayInfo.TemplateList[k];

            }

            if (LoginAwardDayDic.ContainsKey(Index))

            {

                LoginAwardDayDic[Index] = loginAwardDay;

            }

            else

            {

                LoginAwardDayDic.Add(Index, loginAwardDay);

            }

        }



        for (int i = 0; i < info.TCount; i++)// 活动模板信息

        {

            var ActionInfo = info.ActionInfo[i];

            var templateID = (int)ActionInfo.TemplateID;

            WeekPartyActionClass loginAward = new WeekPartyActionClass();

            loginAward.TemplateID = (int)ActionInfo.TemplateID;

            loginAward.ActionType = (int)ActionInfo.ActionType;

            loginAward.TotalTimes = (int)ActionInfo.TotalTimes;

            loginAward.SingleTimes = (int)ActionInfo.SingleTimes;

            loginAward.WeekPartyItem = new WeekPartyItemClass[ActionInfo.Count];

            for (int z = 0; z < ActionInfo.Count; z++)

            {

                var item = ActionInfo.ItemInfo[z];

                WeekPartyItemClass loginAwardItem = new WeekPartyItemClass();

                loginAwardItem.ItemID = (int)item.ItemID;

                loginAwardItem.ItemCnt = (int)item.ItemCnt;

                loginAwardItem.IsBind = item.IsBind;

                loginAward.WeekPartyItem[z] = loginAwardItem;

            }

            if (LoginAwardDic.ContainsKey(templateID))

            {

                LoginAwardDic[templateID] = loginAward;

            }

            else

            {

                LoginAwardDic.Add(templateID, loginAward);

            }

        }

    }



    public void LoginAwardPlayerInfo(HAA0D_tagMCActLoginAwardPlayerInfo info)//登录奖励玩家活动信息

    {

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

        {

            var Dayinfo = info.DayInfoList[i];

            WeekPartyDayInfoClass loginAwardPlayerClass = new WeekPartyDayInfoClass();

            var dayindex = (int)Dayinfo.DayIndex;

            loginAwardPlayerClass.DayIndex = dayindex;

            if (LoginAwardInfoDic.ContainsKey(dayindex))

            {

                var dit = LoginAwardInfoDic[dayindex];

                dit.DayIndex = dayindex;

                for (int j = 0; j < Dayinfo.ACount; j++)

                {

                    var taskList = Dayinfo.TaskList[j];

                    int Index = dit.ActionType.FindIndex(s => s.TemplateID == taskList.TemplateID);

                    if (Index != -1)

                    {

                        dit.ActionType[Index].CurTimes = taskList.CurTimes;

                        dit.ActionType[Index].GotTimes = taskList.GotTimes;

                    }

                    else

                    {

                        ActionTypeClass ActionType = new ActionTypeClass();

                        ActionType.TemplateID = taskList.TemplateID;

                        ActionType.CurTimes = taskList.CurTimes;

                        ActionType.GotTimes = taskList.GotTimes;

                        dit.ActionType.Add(ActionType);

                    }

                }

                LoginAwardInfoDic[dayindex] = dit;

            }

            else

            {

                loginAwardPlayerClass.ActionType = new List<ActionTypeClass>();

                for (int k = 0; k < Dayinfo.ACount; k++)

                {

                    var Task = Dayinfo.TaskList[k];

                    ActionTypeClass ActionType = new ActionTypeClass();

                    ActionType.TemplateID = Task.TemplateID;

                    ActionType.CurTimes = Task.CurTimes;

                    ActionType.GotTimes = Task.GotTimes;

                    loginAwardPlayerClass.ActionType.Add(ActionType);

                }

                LoginAwardInfoDic.Add(dayindex, loginAwardPlayerClass);

            }

        }

        SetRedPoint();

        if (LoginAwardInfoUpdate != null)

        {

            LoginAwardInfoUpdate();

        }

    }



    public int GetRewardNumber(int Day, int ID)//获取领奖次数

    {

        int Num = 0;

        if (LoginAwardInfoDic.ContainsKey(Day))

        {

            var loginAward = LoginAwardInfoDic[Day];

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

            {

                var ActionType = loginAward.ActionType[i];

                if (ID == ActionType.TemplateID)

                {

                    Num = ActionType.GotTimes;

                }

            }

        }

        return Num;

    }



    public int GetCarryOutNum(int Day,int ID)//获取已完成次数

    {

        int Num = 0;

        if (LoginAwardInfoDic.ContainsKey(Day))

        {

            var loginAward = LoginAwardInfoDic[Day];

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

            {

                var ActionType = loginAward.ActionType[i];

                if (ID == ActionType.TemplateID)

                {

                    Num = ActionType.CurTimes;

                }

            }

        }

        return Num;

    }



    public void SendLoginAwardInfo(int day, int temdayplateID)//领取奖励

    {

        CA504_tagCMPlayerGetReward getReward = new CA504_tagCMPlayerGetReward();

        getReward.RewardType = (byte)GotServerRewardType.Def_RewardType_ActLoginAwardAct;

        getReward.DataEx = (uint)day;

        string StrID = temdayplateID.ToString();

        getReward.DataExStrLen = (byte)StrID.Length;

        getReward.DataExStr = StrID;

        GameNetSystem.Instance.SendInfo(getReward);

    }



    private void SetRedPoint()//红点设置

    {

        SetRedPointID();

        foreach (var key in RedPointDic.Keys)

        {

            RedPointDic[key].state = RedPointState.None;

        }

        foreach (var key in RedPointDic.Keys)

        {

            RedPointDic[key].state = SetRedPointState(key);

        }

    }

    private void SetRedPointID()//设置红点ID

    {

        if (RedPointDic.Count > 0)

        {

            return;

        }

        foreach (var key in LoginAwardInfoDic.Keys)

        {

            int RedPoint = Redpoint_key * 10 + key;

            if (!RedPointDic.ContainsKey(key))

            {

                Redpoint redPointMountStare = new Redpoint(Redpoint_key, RedPoint);

                RedPointDic.Add(key, redPointMountStare);

            }

        }

    }



    private RedPointState SetRedPointState(int day)//红点状态设置

    {

        if (!LoginAwardDayDic.ContainsKey(day) || !LoginAwardInfoDic.ContainsKey(day))

        {

            return RedPointState.None;

        }

        WeekPartyDayClass loginAward = new WeekPartyDayClass();

        foreach (var key in LoginAwardDayDic.Keys)

        {

            if (key == day)

            {

                loginAward = LoginAwardDayDic[key];

            }

        }

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

        {

            var TemplateID = loginAward.TemplateList[i];

            if (LoginAwardDic.ContainsKey(TemplateID))

            {

                var LoginAward = LoginAwardDic[TemplateID];

                int number = LoginAward.TotalTimes / LoginAward.SingleTimes;

                int rewardNum = GetRewardNumber(day, TemplateID);//已领奖次数

                int carryOutNum = GetCarryOutNum(day, TemplateID);//已完成次数

                int TaypeNumber = 0;

                if (carryOutNum - rewardNum > 0)

                {

                    TaypeNumber = (carryOutNum - rewardNum) / LoginAward.SingleTimes;

                }

                if (TaypeNumber > 0 && rewardNum < number)

                {

                    return RedPointState.GetReward;

                }

            }



        }

        return RedPointState.None;

    }



    private void GetDay()

    {

        OperationBase operationBase;

        if (OperationTimeHepler.Instance.TryGetOperationTime(Operation.LoginReward, out operationBase))

        {

            DayNow = (operationBase as EventDaysTime).GetInDayNow();

        }

    }

}




 System/OpenServerActivity/LoginRewardModel.cs.meta

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

 System/OpenServerActivity/LoginRewardWin.cs

New file
@@ -0,0 +1,148 @@
//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Friday, December 07, 2018
//--------------------------------------------------------

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

namespace Snxxz.UI {
    [XLua.Hotfix]
    public class LoginRewardWin : Window
    {
        //登录奖励
        #region Built-in
        [SerializeField] ScrollerController m_ScrollerController_1;

        [SerializeField] ScrollerController m_ScrollerController_2;

        LoginRewardModel m_LoginRewardModel;
        LoginRewardModel loginRewardModel { get { return m_LoginRewardModel ?? (m_LoginRewardModel = ModelCenter.Instance.GetModel<LoginRewardModel>()); } }

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

        protected override void BindController()
        {

            m_ScrollerController_1.OnRefreshCell += OnRefreshGridCell_1;

            m_ScrollerController_2.OnRefreshCell += OnRefreshGridCell_2;
        }

        protected override void AddListeners()
        {
        }

        protected override void OnPreOpen()
        {
            ChooseDay();
            OnCreateGridLineCell_1(m_ScrollerController_1);

            OnCreateGridLineCell_2(m_ScrollerController_2);
            if (loginRewardModel.SelectedNow >= 3)

            {

                m_ScrollerController_1.JumpIndex(loginRewardModel.SelectedNow);

            }
        }

        protected override void OnAfterOpen()
        {
            loginRewardModel.LoginAwardInfoUpdate += LoginAwardInfoUpdate;
        }

        protected override void OnPreClose()
        {
        }

        protected override void OnAfterClose()
        {

            loginRewardModel.LoginAwardInfoUpdate -= LoginAwardInfoUpdate;
        }



        private void LoginAwardInfoUpdate()

        {

            m_ScrollerController_1.m_Scorller.RefreshActiveCellViews();

            m_ScrollerController_2.m_Scorller.RefreshActiveCellViews();

        }

        #endregion
        void OnCreateGridLineCell_1(ScrollerController gridCtrl)

        {

            gridCtrl.Refresh();

            foreach (var key in loginRewardModel.LoginAwardDayDic.Keys)

            {

                gridCtrl.AddCell(ScrollerDataType.Header, key);

            }

            gridCtrl.Restart();

        }
        private void OnRefreshGridCell_1(ScrollerDataType type, CellView cell)

        {

            int Index = cell.index;

            LogInDayNumber logInDayNumber = cell.GetComponent<LogInDayNumber>();

            logInDayNumber.SetInDayNumber(Index, loginRewardModel.SelectedNow);

            logInDayNumber.DayNumberBtn.SetListener(()=> 
            {

                if (loginRewardModel.SelectedNow != Index)

                {

                    loginRewardModel.SelectedNow = Index;

                    m_ScrollerController_1.m_Scorller.RefreshActiveCellViews();//刷新可见

                    OnCreateGridLineCell_2(m_ScrollerController_2);

                }

            });

        }

        void OnCreateGridLineCell_2(ScrollerController gridCtrl)

        {

            gridCtrl.Refresh();

            for (int i = 0; i < 10; i++)

            {

                gridCtrl.AddCell(ScrollerDataType.Header, i);

            }

            gridCtrl.Restart();

        }

        private void OnRefreshGridCell_2(ScrollerDataType type, CellView cell)

        {

            int Index = cell.index;

            EntryInformationCell entryInformationCell = cell.GetComponent<EntryInformationCell>();

            entryInformationCell.GetDisplayInformation(1);

            entryInformationCell.mButton.SetListener(()=> 
            {

               // m_ScrollerController_2.m_Scorller.RefreshActiveCellViews();//刷新可见

            });

        }
        public void ChooseDay()//选择天

        {

            foreach (var key in loginRewardModel.RedPointDic.Keys)//红点选择可领取的天

            {

                if (loginRewardModel.RedPointDic[key].state == RedPointState.GetReward)

                {

                    loginRewardModel.SelectedNow = key;

                    return;

                }

            }

            loginRewardModel.SelectedNow = loginRewardModel.DayNow;

        }

        private void ToAddSorting()

        {

            SortList.Clear();

            foreach (var key in loginRewardModel.LoginAwardDayDic.Keys)

            {

                if (key == loginRewardModel.SelectedNow)

                {

                    var loginReward = loginRewardModel.LoginAwardDayDic[key];

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

                    {

                        var TemplateId = loginReward.TemplateList[i];

                        SortList.Add(TemplateId);

                    }



                }

            }

            SortList.Sort(Compare);

        }

        int Compare(int x, int y)//数组排列

        {

            return 1;

        }
    }

}





 System/OpenServerActivity/LoginRewardWin.cs.meta

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

 System/OpenServerActivity/OpenServiceAchievementModel.cs

@@ -627,6 +627,13 @@
        }

        return _bool;

    }

    public bool IsOpenFeatures()

    {

        bool Isbool = false;

        Isbool = (OperationTimeHepler.Instance.SatisfyOpenCondition(Operation.OpenServiceAchievement)

            || OperationTimeHepler.Instance.SatisfyAdvanceCondition(Operation.OpenServiceAchievement));

        return Isbool;

    }

}



 System/OpenServerActivity/SpringFestivalCell.cs

New file
@@ -0,0 +1,257 @@
//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Tuesday, January 22, 2019
//--------------------------------------------------------
using EnhancedUI.EnhancedScroller;

using System.Collections;

using System.Collections.Generic;

using TableConfig;

using UnityEngine;

using UnityEngine.UI;
using System;

namespace Snxxz.UI

{

    [XLua.Hotfix]
    public class SpringFestivalCell : ScrollerUI

    {
        [SerializeField] Text m_TextA;

        [SerializeField] Text m_TextB;

        [SerializeField] Text m_TextC;

        [SerializeField] Transform m_ItemList;

        [SerializeField] Button m_Btn;

        [SerializeField] Text m_BtnText;

        [SerializeField] GameObject m_Miss;//错过

        [SerializeField] GameObject m_Reach;//未达成

        [SerializeField] GameObject m_Draw;//已领取

        [SerializeField] Text m_TextNumber;//已领取次数

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

        ItemTipsModel _itemTipsModel;

        ItemTipsModel itemTipsModel { get { return _itemTipsModel ?? (_itemTipsModel = ModelCenter.Instance.GetModel<ItemTipsModel>()); } }

        public override void Refresh(CellView cell)

        {

            int ID = cell.index;

            var config = Config.Instance.Get<WeekPartyConfig>(ID);

            if (config == null || !model.SpringFestivalDic.ContainsKey(ID))

            {

                return;

            }

            var SpringFestival = model.SpringFestivalDic[ID];

            int rewardNum = model.GetRewardNumber(model.SelectedNow, ID);//已领奖次数

            int carryOutNum = model.GetCarryOutNum(model.SelectedNow, ID);//已完成次数

            int number = SpringFestival.TotalTimes / SpringFestival.SingleTimes;

            var RemainingNum = 0;

            if (SpringFestival.TotalTimes - rewardNum > 0)

            {

                RemainingNum = (SpringFestival.TotalTimes - rewardNum) / SpringFestival.SingleTimes;

            }

            if (SpringFestival.TotalTimes - carryOutNum > 0 && RemainingNum > 0)

            {

                m_TextA.text = Language.Get("OSA_1", RemainingNum);

            }

            else

            {

                m_TextA.text = Language.Get("OSA_4");

            }



            if (config.ActionType == 20)

            {

                m_TextB.text = string.Format(config.Description, (model.SelectedNow + 1));

            }

            else

            {

                m_TextB.text = string.Format(config.Description, SpringFestival.SingleTimes);

            }

            m_TextC.text = Language.Get("OSA_2", SpringFestival.Point);

            for (int i = 0; i < m_ItemList.childCount; i++)

            {

                GameObject Obj = m_ItemList.GetChild(i).gameObject;

                ItemCell itemCell = Obj.GetComponent<ItemCell>();

                if (i < SpringFestival.WeekPartyItem.Length)

                {

                    Obj.SetActive(true);

                    var Item = SpringFestival.WeekPartyItem[i];

                    ItemCellModel cellModel = new ItemCellModel(Item.ItemID, true, (ulong)Item.ItemCnt, Item.IsBind);

                    itemCell.Init(cellModel);

                    itemCell.cellBtn.SetListener(() =>

                    {

                        ItemAttrData attrData = new ItemAttrData(Item.ItemID, false, (ulong)Item.ItemCnt, -1, Item.IsBind);

                        itemTipsModel.SetItemTipsModel(attrData);

                    });

                }

                else

                {

                    Obj.SetActive(false);

                }

            }

            bool IsOpenPreviewTime = OperationTimeHepler.Instance.SatisfyAdvanceCondition(Operation.SpringFestival);

            if (model.SelectedNow != model.DayNow || IsOpenPreviewTime)

            {

                if (model.SelectedNow > model.DayNow || IsOpenPreviewTime)//还未到达的天数

                {

                    m_Btn.gameObject.SetActive(false);

                    m_TextNumber.gameObject.SetActive(false);

                    m_Miss.SetActive(false);

                    m_Reach.SetActive(false);

                    m_Draw.SetActive(false);

                }

                else//已过的天数

                {



                    int TaypeNumber = 0;

                    if (carryOutNum - rewardNum > 0)

                    {

                        TaypeNumber = (carryOutNum - rewardNum) / SpringFestival.SingleTimes;

                    }

                    if (TaypeNumber > 0)//可领

                    {



                        m_TextNumber.gameObject.SetActive(true);

                        m_TextNumber.text = SetText(ID);

                        m_Btn.gameObject.SetActive(true);

                        UIEffect uieffect = m_Btn.GetComponent<UIEffect>();

                        uieffect.Play();

                        m_BtnText.text = Language.Get("RealmPractice109");//领取

                        m_Miss.SetActive(false);

                        m_Reach.SetActive(false);

                        m_Draw.SetActive(false);

                        m_Btn.SetListener(() =>

                        {

                            bool _bool = model.IsOpenFeatures();

                            if (_bool)

                            {

                                model.SendGetSpringFestival(model.SelectedNow, ID);

                            }

                            else

                            {

                                SysNotifyMgr.Instance.ShowTip("SevenDayOver2");

                            }

                        });

                    }

                    else

                    {

                        if (rewardNum >= number)//已经领完

                        {

                            m_TextNumber.gameObject.SetActive(false);

                            m_Btn.gameObject.SetActive(false);

                            m_Miss.SetActive(false);

                            m_Reach.SetActive(false);

                            m_Draw.SetActive(true);

                        }

                        else//未到达

                        {

                            m_TextNumber.gameObject.SetActive(false);

                            m_Btn.gameObject.SetActive(false);

                            m_Miss.SetActive(false);

                            m_Reach.SetActive(true);

                            m_Draw.SetActive(false);



                        }



                    }

                }

            }

            else//当前天

            {

                int TaypeNumber = 0;

                if (carryOutNum - rewardNum > 0)

                {

                    TaypeNumber = (carryOutNum - rewardNum) / SpringFestival.SingleTimes;

                }

                if (TaypeNumber > 0)//可领

                {

                    m_TextNumber.gameObject.SetActive(true);

                    m_TextNumber.text = SetText(ID);

                    m_Btn.gameObject.SetActive(true);

                    UIEffect uieffect = m_Btn.GetComponent<UIEffect>();

                    uieffect.Play();

                    m_BtnText.text = Language.Get("RealmPractice109");//领取

                    m_Miss.SetActive(false);

                    m_Reach.SetActive(false);

                    m_Draw.SetActive(false);

                    m_Btn.SetListener(() =>

                    {

                        bool _bool = model.IsOpenFeatures();

                        if (_bool)

                        {

                            model.SendGetSpringFestival(model.SelectedNow, ID);

                        }

                        else

                        {

                            SysNotifyMgr.Instance.ShowTip("SevenDayOver2");

                        }

                    });

                }

                else

                {

                    if (rewardNum >= SpringFestival.TotalTimes)//已经领完

                    {

                        m_TextNumber.gameObject.SetActive(false);

                        m_Btn.gameObject.SetActive(false);

                        m_Miss.SetActive(false);

                        m_Reach.SetActive(false);

                        m_Draw.SetActive(true);

                    }

                    else//未到达(前往)

                    {

                        m_TextNumber.gameObject.SetActive(true);

                        m_TextNumber.text = SetText(ID);

                        m_Btn.gameObject.SetActive(true);

                        m_BtnText.text = Language.Get("RealmPractice108");//前往

                        UIEffect uieffect = m_Btn.GetComponent<UIEffect>();

                        uieffect.Stop();

                        m_Miss.SetActive(false);

                        m_Reach.SetActive(false);

                        m_Draw.SetActive(false);

                        m_Btn.SetListener(() =>

                        {

                            WindowJumpMgr.Instance.WindowJumpTo((JumpUIType)config.jump);

                        });

                    }

                }

            }

        }

        string SetText(int ID)

        {

            string str = string.Empty;

            var SpringFestival = model.SpringFestivalDic[ID];

            int rewardNum = model.GetRewardNumber(model.SelectedNow, ID);//已领奖次数

            int carryOutNum = model.GetCarryOutNum(model.SelectedNow, ID);//已完成次数

            var config = Config.Instance.Get<WeekPartyConfig>(ID);

            if (config != null && config.SpecialDisplayType == 1)

            {



                if (carryOutNum > 0)

                {

                    str = "1/1";

                }

                else

                {

                    str = "0/1";

                }

                return str;

            }

            int TaypeNumber = 0;

            if (carryOutNum - rewardNum > 0)

            {

                TaypeNumber = (carryOutNum - rewardNum) / SpringFestival.SingleTimes;

            }

            if (TaypeNumber > 0)

            {

                str = SpringFestival.SingleTimes + "/" + SpringFestival.SingleTimes;

                return str;

            }

            else

            {

                int type = carryOutNum % SpringFestival.SingleTimes;

                str = type + "/" + SpringFestival.SingleTimes;

            }

            return str;

        }

    }

}




 System/OpenServerActivity/SpringFestivalCell.cs.meta

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

 System/OpenServerActivity/SpringFestivalItem.cs

New file
@@ -0,0 +1,93 @@
//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Tuesday, January 22, 2019
//--------------------------------------------------------
using System;
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using UnityEngine.UI;
using TableConfig;

namespace Snxxz.UI

{

    [XLua.Hotfix]
    public class SpringFestivalItem : MonoBehaviour

    {

        [SerializeField] Text m_Text_A;
        [SerializeField] Image m_BGM;
        [SerializeField] Image m_ImageShow;
        [SerializeField] Text m_TextPoint;
        [SerializeField] Button m_ReceiveBtn;
        [SerializeField] GameObject m_IsReachImage;
        [SerializeField] GameObject m_IsDrawImage;
        SpringFestivalModel model { get { return ModelCenter.Instance.GetModel<SpringFestivalModel>(); } }
        public void SetReward(int day, WeekPartyItemClass item, int index, int Type)

        {

            var holidayHomingPointConfig = Config.Instance.Get<HolidayHomingPointConfig>(item.ItemID);

            if (holidayHomingPointConfig != null)

            {

                m_Text_A.text = holidayHomingPointConfig.name;

                if (Type == 1)

                {

                    m_ImageShow.SetSprite(holidayHomingPointConfig.ImageType1);

                }

                else

                {

                    m_ImageShow.SetSprite(holidayHomingPointConfig.ImageType2);

                }

                m_ImageShow.SetNativeSize();

            }

            int Point = model.GetPoint(day);

            m_TextPoint.text = Language.Get("OSA_3", item.NeedPoint);

            bool IsBool = model.IsDayReward(model.SelectedNow, index);



            if (model.SelectedNow > model.DayNow)

            {

                m_ReceiveBtn.gameObject.SetActive(false);

                m_IsReachImage.SetActive(false);

                m_IsDrawImage.SetActive(false);

            }

            else

            {

                if (Point >= item.NeedPoint && !IsBool)//可领

                {

                    m_ReceiveBtn.gameObject.SetActive(true);

                    m_ReceiveBtn.SetListener(() =>

                    {

                        bool _bool = model.IsOpenFeatures();

                        if (_bool)

                        {

                            model.SendGetSpringFestivalPoint(model.SelectedNow, item.NeedPoint);

                        }

                        else

                        {

                            SysNotifyMgr.Instance.ShowTip("SevenDayOver2");

                        }

                    });

                    m_IsReachImage.SetActive(false);

                    m_IsDrawImage.SetActive(false);



                }

                else if (Point >= item.NeedPoint && IsBool)//已领

                {

                    m_ReceiveBtn.gameObject.SetActive(false);

                    m_IsReachImage.SetActive(false);

                    m_IsDrawImage.SetActive(true);

                }

                else if (item.NeedPoint > Point)

                {

                    m_ReceiveBtn.gameObject.SetActive(false);

                    m_IsReachImage.SetActive(true);

                    m_IsDrawImage.SetActive(false);

                }

            }

        }


    }

}




 System/OpenServerActivity/SpringFestivalItem.cs.meta

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

 System/OpenServerActivity/SpringFestivalModel.cs

New file
@@ -0,0 +1,389 @@
//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Monday, January 21, 2019
//--------------------------------------------------------
using System;

using System.Collections.Generic;

using TableConfig;

using Snxxz.UI;

using System.Linq;


[XLua.LuaCallCSharp]

//春节活动巡礼

public class SpringFestivalModel : Model, IBeforePlayerDataInitialize, IPlayerLoginOk

{

    public Dictionary<int, WeekPartyDayInfoClass> SpringFestivalInfoDic = new Dictionary<int, WeekPartyDayInfoClass>();//每天领取奖励信息

    public event Action SpringFestivalRewardUpdate;//领奖记录变化

    public Dictionary<int, WeekPartyDayClass> SpringFestivalDayDic = new Dictionary<int, WeekPartyDayClass>();//每天的奖励信息

    public Dictionary<int, WeekPartyActionClass> SpringFestivalDic = new Dictionary<int, WeekPartyActionClass>();//活动模板总信息

    public Dictionary<int, Redpoint> RedPointDic = new Dictionary<int, Redpoint>();//红点

    private const int Redpoint_key1 = 21402;//周狂欢红点

    public Redpoint redPointStre1 = new Redpoint(214, Redpoint_key1);

    public int LimitLV = 0;//限制等级

    private int _SelectedNow = 0;

    public int SelectedNow//选中天

    {

        get { return _SelectedNow; }

        set { _SelectedNow = value; }

    }



    private int _DayNow = 0;

    public int DayNow//当前天

    {

        get { return _DayNow; }

        set { _DayNow = value; }

    }

    public override void Init()

    {

       
    }



    public void OnBeforePlayerDataInitialize()

    {

        SpringFestivalInfoDic.Clear();

    }



    public void OnPlayerLoginOk()

    {

        GetDayNow();

        OperationTimeHepler.Instance.operationStartEvent -= OperationStartEvent;

        OperationTimeHepler.Instance.dayResetEvent -= DayResetEvent;

        OperationTimeHepler.Instance.operationStartEvent += OperationStartEvent;

        OperationTimeHepler.Instance.dayResetEvent += DayResetEvent;

    }



   
    public override void UnInit()

    {

       
    }

    private void DayResetEvent(int obj)

    {

        if (obj == (int)Operation.OpenServiceAchievement)

        {

            GetDayNow();

        }

    }



    private void OperationStartEvent(Operation arg1, int arg2)

    {

        if (arg1 == Operation.OpenServiceAchievement)

        {

            GetDayNow();

        }

    }



    public void SpringFestivalInfo(HAA21_tagMCFeastWeekPartyPlayerInfo info)//每天领奖信息

    {

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

        {

            var DayInfo = info.DayInfoList[i];

            WeekPartyDayInfoClass WeekPartyDayInfo = new WeekPartyDayInfoClass();

            WeekPartyDayInfo.DayIndex = (int)DayInfo.DayIndex;

            WeekPartyDayInfo.Point = (int)DayInfo.Point;

            WeekPartyDayInfo.AwardRecord = (int)DayInfo.AwardRecord;



            if (SpringFestivalInfoDic.ContainsKey((int)DayInfo.DayIndex))

            {

                var dit = SpringFestivalInfoDic[(int)DayInfo.DayIndex];

                dit.DayIndex = (int)DayInfo.DayIndex;

                dit.Point = (int)DayInfo.Point;

                dit.AwardRecord = (int)DayInfo.AwardRecord;

                for (int j = 0; j < DayInfo.ACount; j++)

                {

                    var taskList = DayInfo.TaskList[j];

                    int Index = dit.ActionType.FindIndex(s => s.TemplateID == taskList.TemplateID);

                    if (Index != -1)

                    {

                        dit.ActionType[Index].CurTimes = (int)taskList.CurTimes;

                        dit.ActionType[Index].GotTimes = (int)taskList.GotTimes;

                    }

                    else

                    {

                        ActionTypeClass ActionType = new ActionTypeClass();

                        ActionType.TemplateID = taskList.TemplateID;

                        ActionType.CurTimes = (int)taskList.CurTimes;

                        ActionType.GotTimes = (int)taskList.GotTimes;

                        dit.ActionType.Add(ActionType);

                    }

                }

                SpringFestivalInfoDic[(int)DayInfo.DayIndex] = dit;

            }

            else

            {

                WeekPartyDayInfo.ActionType = new List<ActionTypeClass>();

                for (int k = 0; k < DayInfo.ACount; k++)

                {

                    var Task = DayInfo.TaskList[k];

                    ActionTypeClass ActionType = new ActionTypeClass();

                    ActionType.TemplateID = Task.TemplateID;

                    ActionType.CurTimes = (int)Task.CurTimes;

                    ActionType.GotTimes = (int)Task.GotTimes;

                    WeekPartyDayInfo.ActionType.Add(ActionType);

                }

                SpringFestivalInfoDic.Add((int)DayInfo.DayIndex, WeekPartyDayInfo);

            }

        }

        GetDayNow();

        SetRedPoint();

        if (SpringFestivalRewardUpdate != null)

        {

            SpringFestivalRewardUpdate();

        }

    }



    public void SpringFestivalTemplate(HAA20_tagMCFeastWeekPartyInfo info)//每天模板信息

    {

        LimitLV = info.LimitLV;

        for (int i = 0; i < info.DayCnt; i++)

        {

            int Index = i;

            var DayInfo = info.DayInfoList[i];

            WeekPartyDayClass WeekPartyDay = new WeekPartyDayClass();

            WeekPartyDay.TemplateList = new int[DayInfo.ActCnt];

            for (int k = 0; k < DayInfo.ActCnt; k++)

            {

                WeekPartyDay.TemplateList[k] = DayInfo.TemplateList[k];

            }

            WeekPartyDay.WeekPartyItem = new WeekPartyItemClass[DayInfo.PCount];

            for (int p = 0; p < DayInfo.PCount; p++)

            {

                WeekPartyItemClass WeekPartyItem = new WeekPartyItemClass();

                var Item = DayInfo.PItemInfo[p];

                WeekPartyItem.NeedPoint = Item.NeedPoint;

                WeekPartyItem.ItemID = (int)Item.ItemID;

                WeekPartyItem.ItemCnt = (int)Item.ItemCnt;

                WeekPartyItem.IsBind = (int)Item.IsBind;

                WeekPartyDay.WeekPartyItem[p] = WeekPartyItem;

            }

            if (SpringFestivalDayDic.ContainsKey(Index))

            {

                SpringFestivalDayDic[Index] = WeekPartyDay;

            }

            else

            {

                SpringFestivalDayDic.Add(Index, WeekPartyDay);

            }

        }// 每天模板

        for (int i = 0; i < info.TCount; i++)

        {

            var ActionInfo = info.ActionInfo[i];

            WeekPartyActionClass WeekPartyAction = new WeekPartyActionClass();

            WeekPartyAction.TemplateID = (int)ActionInfo.TemplateID;

            WeekPartyAction.ActionType = (int)ActionInfo.ActionType;

            WeekPartyAction.TotalTimes = (int)ActionInfo.TotalTimes;

            WeekPartyAction.SingleTimes = (int)ActionInfo.SingleTimes;

            WeekPartyAction.Point = (int)ActionInfo.Point;

            WeekPartyAction.WeekPartyItem = new WeekPartyItemClass[ActionInfo.Count];

            for (int z = 0; z < ActionInfo.Count; z++)

            {

                var item = ActionInfo.ItemInfo[z];

                WeekPartyItemClass WeekPartyItem = new WeekPartyItemClass();

                WeekPartyItem.ItemID = (int)item.ItemID;

                WeekPartyItem.ItemCnt = (int)item.ItemCnt;

                WeekPartyItem.IsBind = item.IsBind;

                WeekPartyItem.NeedPoint = 0;

                WeekPartyAction.WeekPartyItem[z] = WeekPartyItem;

            }

            if (SpringFestivalDic.ContainsKey((int)ActionInfo.TemplateID))

            {

                SpringFestivalDic[(int)ActionInfo.TemplateID] = WeekPartyAction;

            }

            else

            {

                SpringFestivalDic.Add((int)ActionInfo.TemplateID, WeekPartyAction);

            }

        }// 活动模板信息

        SetRedPoint();

    }



    public int GetRewardNumber(int Day, int ID)//获取领奖次数

    {

        int Num = 0;

        if (SpringFestivalInfoDic.ContainsKey(Day))

        {

            var SpringFestivalDay = SpringFestivalInfoDic[Day];



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

            {

                var ActionType = SpringFestivalDay.ActionType[i];

                if (ID == ActionType.TemplateID)

                {

                    Num = ActionType.GotTimes;

                }

            }

        }

        return Num;



    }

    public int GetCarryOutNum(int Day, int ID)//获取已完成次数

    {

        int Num = 0;

        if (SpringFestivalInfoDic.ContainsKey(Day))

        {

            var SpringFestival = SpringFestivalInfoDic[Day];



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

            {

                var ActionType = SpringFestival.ActionType[i];

                if (ID == ActionType.TemplateID)

                {

                    Num = ActionType.CurTimes;

                }

            }

        }

        return Num;

    }

    public int GetPoint(int day)//获取某一天的积分

    {

        int Point = 0;

        if (SpringFestivalInfoDic.ContainsKey(day))

        {

            Point = SpringFestivalInfoDic[day].Point;

        }

        return Point;

    }

    public void SendGetSpringFestival(int day, int temdayplateID)//领取春节活动奖励

    {

        CA504_tagCMPlayerGetReward getReward = new CA504_tagCMPlayerGetReward();

        getReward.RewardType = (byte)GotServerRewardType.Def_RewardType_FeastWeekPartyAct;

        getReward.DataEx = (uint)day;

        string StrID = temdayplateID.ToString();

        getReward.DataExStrLen = (byte)StrID.Length;

        getReward.DataExStr = StrID;

        GameNetSystem.Instance.SendInfo(getReward);

    }

    public void SendGetSpringFestivalPoint(int day, int point)//领取春节积分奖励

    {

        CA504_tagCMPlayerGetReward getReward = new CA504_tagCMPlayerGetReward();

        getReward.RewardType = (byte)GotServerRewardType.Def_RewardType_FeastWeekPartyPoint;

        getReward.DataEx = (uint)day;

        string StrID = point.ToString();

        getReward.DataExStrLen = (byte)StrID.Length;

        getReward.DataExStr = StrID;

        GameNetSystem.Instance.SendInfo(getReward);

    }

    public bool IsDayReward(int day, int index)//是否领取奖励

    {

        bool _bool = false;

        int AwardRecord = 0;

        foreach (var key in SpringFestivalInfoDic.Keys)

        {

            if (key == day)

            {

                AwardRecord = SpringFestivalInfoDic[key].AwardRecord;

            }

        }

        _bool = MathUtility.GetBitValue((uint)AwardRecord, (ushort)index);

        return _bool;

    }

    private void SetRedPoint()//红点设置

    {

        SetRedPointId();

        foreach (var key in RedPointDic.Keys)

        {

            RedPointDic[key].state = RedPointState.None;

        }

        foreach (var key in RedPointDic.Keys)

        {

            RedPointDic[key].state = SetRedPointState(key);

        }

    }

    private void SetRedPointId()//设置红点ID

    {

        if (RedPointDic.Count >= 7)

        {

            return;

        }

        RedPointDic.Clear();

        foreach (var key in SpringFestivalInfoDic.Keys)

        {

            int RedPoint = Redpoint_key1 * 10 + key;

            if (!RedPointDic.ContainsKey(key))

            {

                Redpoint redPointMountStare = new Redpoint(Redpoint_key1, RedPoint);

                RedPointDic.Add(key, redPointMountStare);

            }

        }



    }

    private RedPointState SetRedPointState(int day)//红点状态设置

    {

        if (!SpringFestivalDayDic.ContainsKey(day) || !SpringFestivalInfoDic.ContainsKey(day) || day>DayNow)

        {

            return RedPointState.None;

        }

        WeekPartyDayClass WeekPartyDay = new WeekPartyDayClass();

        int point = SpringFestivalInfoDic[day].Point;

        foreach (var key in SpringFestivalDayDic.Keys)

        {

            if (key == day)

            {

                WeekPartyDay = SpringFestivalDayDic[key];

            }

        }

        for (int i = 0; i < WeekPartyDay.WeekPartyItem.Length; i++)//积分奖励

        {

            var item = WeekPartyDay.WeekPartyItem[i];

            int type = i;

            bool IsBool = IsDayReward(day, type);

            if (point >= item.NeedPoint && !IsBool)

            {

                return RedPointState.GetReward;

            }

        }

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

        {

            var TemplateID = WeekPartyDay.TemplateList[i];

            if (SpringFestivalDic.ContainsKey(TemplateID))

            {

                var WeekPartyAction = SpringFestivalDic[TemplateID];

                int number = WeekPartyAction.TotalTimes / WeekPartyAction.SingleTimes;

                int rewardNum = GetRewardNumber(day, TemplateID);//已领奖次数

                int carryOutNum = GetCarryOutNum(day, TemplateID);//已完成次数

                int TaypeNumber = 0;

                if (carryOutNum - rewardNum > 0)

                {

                    TaypeNumber = (carryOutNum - rewardNum) / WeekPartyAction.SingleTimes;

                }

                if (TaypeNumber > 0 && rewardNum < number)

                {

                    return RedPointState.GetReward;

                }

            }

        }

        return RedPointState.None;

    }



    public void GetDayNow()

    {

        OperationBase operationBase;

        if (OperationTimeHepler.Instance.TryGetOperationTime(Operation.SpringFestival, out operationBase))

        {

            int inday = (operationBase as EventDaysTime).GetInDayNow();

            if (inday >= 0 && inday < 7)

            {

                _DayNow = inday;

            }

            else if (inday >= 7)

            {

                _DayNow = 6;

            }



        }

    }



    public bool IsOpenFeatures()

    {

        bool Isbool = false;

        Isbool = (OperationTimeHepler.Instance.SatisfyOpenCondition(Operation.SpringFestival) 
            || OperationTimeHepler.Instance.SatisfyAdvanceCondition(Operation.SpringFestival));

        return Isbool;

    }

}






 System/OpenServerActivity/SpringFestivalModel.cs.meta

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

 System/OpenServerActivity/SpringFestivalWin.cs

New file
@@ -0,0 +1,410 @@
//--------------------------------------------------------
//    [Author]:           第二世界
//    [  Date ]:           Monday, January 21, 2019
//--------------------------------------------------------

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

namespace Snxxz.UI

{

    [XLua.Hotfix]
    public class SpringFestivalWin : Window
    {

        //春节巡礼

        #region Built-in      
        [SerializeField]

        ScrollerController m_ScrollerController1;//天
        [SerializeField] ScrollerController m_ScrollerController2;//列表

        [SerializeField] Text m_TextIntegral;//当前积分

        [SerializeField] GameObject m_One;

        [SerializeField] GameObject m_Two;



        [SerializeField] SpringFestivalItem m_SpringFestivalItemA;

        [SerializeField] SpringFestivalItem m_SpringFestivalItemA1;

        [SerializeField] SpringFestivalItem m_SpringFestivalItemB1;

        [SerializeField] Image m_ImgeBgm1;

        [SerializeField] Image m_ImgeBgm2;

        DailyQuestModel dailymodel { get { return ModelCenter.Instance.GetModel<DailyQuestModel>(); } }

        OpenServiceAchievementModel OpenServicemodel { get { return ModelCenter.Instance.GetModel<OpenServiceAchievementModel>(); } }

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

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

        List<WeekPartyItemClass> ItemDayList = new List<WeekPartyItemClass>();
        private string bgmKey1 = string.Empty;

        private string bgmKey2 = string.Empty;
        protected override void BindController()
        {

            m_ScrollerController1.OnRefreshCell += OnRefreshGridCell_1;
            m_ScrollerController2.OnRefreshCell += OnRefreshGridCell_2;

            var config = Config.Instance.Get<FuncConfigConfig>("HolidayTourBackground");
            bgmKey1 = config.Numerical1;
            bgmKey2 = config.Numerical2;
        }

        protected override void AddListeners()
        {
        }

        protected override void OnPreOpen()
        {

            m_ImgeBgm1.SetSprite(bgmKey1);

            m_ImgeBgm2.SetSprite(bgmKey2);

            ChooseDay();

            SetTextIntegral();

            OnCreateGridLineCell1(m_ScrollerController1);

            OnCreateGridLineCell2(m_ScrollerController2);
            if (model.SelectedNow >= 5)

            {

                m_ScrollerController1.JumpIndex(5);

            }
        }

        protected override void OnAfterOpen()
        {
            OperationTimeHepler.Instance.operationStartEvent += OperationStartEvent;

            OperationTimeHepler.Instance.dayResetEvent += DayResetEvent;
            model.SpringFestivalRewardUpdate += SpringFestivalRewardUpdate;
        }

        protected override void OnPreClose()
        {

            OperationTimeHepler.Instance.operationStartEvent -= OperationStartEvent;

            model.SpringFestivalRewardUpdate -= SpringFestivalRewardUpdate;

            OperationTimeHepler.Instance.dayResetEvent -= DayResetEvent;
        }



        private void DayResetEvent(int obj)

        {

            if (obj == (int)Operation.OpenServiceAchievement)

            {

                model.GetDayNow();

                GetPointRewardObj();//获取积分领奖信息

                m_ScrollerController1.m_Scorller.RefreshActiveCellViews();//刷新可见

                m_ScrollerController2.m_Scorller.RefreshActiveCellViews();//刷新可见

            }

        }



        private void OperationStartEvent(Operation arg1, int arg2)

        {

            if (arg1 == Operation.OpenServiceAchievement)

            {

                model.GetDayNow();

                GetPointRewardObj();//获取积分领奖信息

                m_ScrollerController1.m_Scorller.RefreshActiveCellViews();//刷新可见

                m_ScrollerController2.m_Scorller.RefreshActiveCellViews();//刷新可见

            }

          
        }



        protected override void OnAfterClose()
        {
        }

        #endregion
        private void SpringFestivalRewardUpdate()

        {

            model.GetDayNow();

            GetPointRewardObj();//获取积分领奖信息

            m_ScrollerController1.m_Scorller.RefreshActiveCellViews();//刷新可见

            m_ScrollerController2.m_Scorller.RefreshActiveCellViews();//刷新可见

        }


        void OnCreateGridLineCell1(ScrollerController gridCtrl)

        {

            gridCtrl.Refresh();

            foreach (var key in model.SpringFestivalDayDic.Keys)

            {

                gridCtrl.AddCell(ScrollerDataType.Header, key);

            }

            gridCtrl.Restart();

        }
        private void OnRefreshGridCell_1(ScrollerDataType type, CellView cell)

        {

            int Index = cell.index;

            ButtonEx Btn = cell.GetComponent<ButtonEx>();

            GameObject SelectedObj = cell.transform.Find("Image_XZ").gameObject;//选中

            GameObject SelectedObj1 = cell.transform.Find("Image_XZ1").gameObject;//选中

            ImageEx SelectedImageEx = SelectedObj.GetComponent<ImageEx>();





            GameObject Unselected = cell.transform.Find("Image_WXZ").gameObject;//未选中

            ImageEx UnselectedIm = Unselected.GetComponent<ImageEx>();

            GameObject Lock = cell.transform.Find("Lock").gameObject;//锁



            GameObject IsNotGary = cell.transform.Find("Obj1").gameObject;

            Text IsNotGary_text = IsNotGary.transform.Find("DayText").GetComponent<Text>();

            GameObject Gary = cell.transform.Find("Obj2").gameObject;

            Text Gary_text = Gary.transform.Find("DayText").GetComponent<Text>();



            RedpointBehaviour redPoint = cell.transform.Find("RedPoint").GetComponent<RedpointBehaviour>();//红点

            if (model.RedPointDic.ContainsKey(Index))

            {

                redPoint.redpointId = model.RedPointDic[Index].id;

            }

            if (Index <= model.DayNow)

            {

                SelectedImageEx.gray = false;

                Unselected.SetActive(true);

                UnselectedIm.gray = false;

                SelectedObj.SetActive(false);

                SelectedObj1.SetActive(false);

                Lock.SetActive(false);

                IsNotGary.SetActive(true);

                Gary.SetActive(false);

                IsNotGary_text.text = (Index + 1).ToString();

            }

            else

            {

                Unselected.SetActive(true);

                UnselectedIm.gray = true;

                SelectedObj.SetActive(false);

                SelectedObj1.SetActive(false);

                Lock.SetActive(true);

                IsNotGary.SetActive(false);

                Gary.SetActive(true);

                Gary_text.text = (Index + 1).ToString();

            }



            if (Index == model.SelectedNow)

            {

                if (Index > model.DayNow)

                {

                    SelectedImageEx.gray = true;

                    IsNotGary.SetActive(false);

                    Gary.SetActive(true);

                    Lock.SetActive(true);

                }

                else

                {

                    SelectedImageEx.gray = false;

                    IsNotGary.SetActive(true);

                    Gary.SetActive(false);

                    Lock.SetActive(false);

                }

                SelectedObj.SetActive(true);

                SelectedObj1.SetActive(true);

                Unselected.SetActive(false);



                IsNotGary_text.text = (Index + 1).ToString();

            }

            Btn.SetListener(() =>

            {

                if (Index != model.SelectedNow)

                {

                    model.SelectedNow = Index;//选中天

                    SetTextIntegral();

                    OnCreateGridLineCell2(m_ScrollerController2);

                    m_ScrollerController1.m_Scorller.RefreshActiveCellViews();//刷新可见

                }

            });



        }
        private string InDayStr(int Day)

        {

            string DaySte = string.Empty;

            DaySte = Language.Get("SignIn_4", Day);

            return DaySte;

        }

        void OnCreateGridLineCell2(ScrollerController gridCtrl)

        {

            ToAddSorting();//排序

            GetPointRewardObj();//获取积分领奖信息

            gridCtrl.Refresh();

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

            {

                gridCtrl.AddCell(ScrollerDataType.Header, SortList[i]);

            }

            gridCtrl.Restart();

        }

        private void OnRefreshGridCell_2(ScrollerDataType type, CellView cell)

        {



        }

        private void ToAddSorting()

        {

            SortList.Clear();

            int Weekday = OpenServicemodel.GetWeekDay(model.SelectedNow);

            var quests = dailymodel.GetQuestByWeekTime(Weekday);

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

            foreach (var key in quests.Keys)

            {

                var _list = quests[key];

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

                {

                    dailyIdlist.Add(_list[i]);

                }

            }



            foreach (var key in model.SpringFestivalDayDic.Keys)

            {

                if (key == model.SelectedNow)

                {

                    for (int i = 0; i < model.SpringFestivalDayDic[key].TemplateList.Length; i++)

                    {

                        var TemplateId = model.SpringFestivalDayDic[key].TemplateList[i];

                        var config = Config.Instance.Get<HolidayHomingConfig>(TemplateId);

                        if (config == null)

                        {

                            continue;

                        }

                        if (config.DailyQusetId != 0)

                        {

                            if (dailyIdlist.Contains(config.DailyQusetId))

                            {

                                SortList.Add(TemplateId);

                            }

                        }

                        else

                        {

                            SortList.Add(TemplateId);

                        }

                    }

                }

            }

            SortList.Sort(Compare);

        }

        int Compare(int x, int y)//数组排列

        {

            bool havex1 = IsReceive(x);

            bool havey1 = IsReceive(y);

            if (havex1.CompareTo(havey1) != 0)

            {

                return -havex1.CompareTo(havey1);

            }

            bool havex2 = Undone(x);

            bool havey2 = Undone(y);

            if (havex2.CompareTo(havey2) != 0)

            {

                return -havex2.CompareTo(havey2);

            }

            bool havex3 = Completed(x);

            bool havey3 = Completed(y);

            if (havex3.CompareTo(havey3) != 0)

            {

                return -havex3.CompareTo(havey3);

            }

            int havex4 = SizeId(x);

            int havey4 = SizeId(y);

            if (havex4.CompareTo(havey4) != 0)

            {

                return havex4.CompareTo(havey4);

            }

            return 1;

        }

        private bool IsReceive(int ID)//可领取

        {

            bool Bool = false;

            if (model.SpringFestivalDic.ContainsKey(ID))

            {

                var SpringFestival = model.SpringFestivalDic[ID];

                int number = SpringFestival.TotalTimes / SpringFestival.SingleTimes;

                int rewardNum = model.GetRewardNumber(model.SelectedNow, ID);//已领奖次数

                int carryOutNum = model.GetCarryOutNum(model.SelectedNow, ID);//已完成次数

                int TaypeNumber = 0;

                if (carryOutNum - rewardNum > 0)

                {

                    TaypeNumber = (carryOutNum - rewardNum) / SpringFestival.SingleTimes;

                }

                if (TaypeNumber > 0)

                {

                    Bool = true;

                }

            }

            return Bool;

        }

        private bool Undone(int ID)//未完成

        {

            bool Bool = false;

            if (model.SpringFestivalDic.ContainsKey(ID))

            {

                var SpringFestival = model.SpringFestivalDic[ID];

                int number = SpringFestival.TotalTimes / SpringFestival.SingleTimes;

                int rewardNum = model.GetRewardNumber(model.SelectedNow, ID);//已领奖次数

                int carryOutNum = model.GetCarryOutNum(model.SelectedNow, ID);//已完成次数

                if (SpringFestival.TotalTimes > rewardNum)

                {

                    Bool = true;

                }

            }

            return Bool;

        }

        private bool Completed(int ID)//已领取

        {

            bool Bool = false;

            if (model.SpringFestivalDic.ContainsKey(ID))

            {

                var SpringFestival = model.SpringFestivalDic[ID];

                int rewardNum = model.GetRewardNumber(model.SelectedNow, ID);//已领奖次数

                int carryOutNum = model.GetCarryOutNum(model.SelectedNow, ID);//已完成次数

                if (rewardNum >= SpringFestival.TotalTimes)

                {

                    Bool = true;

                }

            }

            return Bool;

        }

        private int SizeId(int ID)

        {

            int index = 1;

            var config = Config.Instance.Get<HolidayHomingConfig>(ID);

            if (config != null)

            {

                index = config.order;

            }

            return index;

        }

        private void SetTextIntegral()//获取当前积分

        {

            int Point = model.GetPoint(model.SelectedNow);

            m_TextIntegral.text = Point.ToString();

        }

        private void GetPointRewardObj()

        {

            ItemDayList.Clear();

            foreach (var key in model.SpringFestivalDayDic.Keys)

            {

                if (key == model.SelectedNow)

                {

                    for (int i = 0; i < model.SpringFestivalDayDic[key].WeekPartyItem.Length; i++)

                    {

                        ItemDayList.Add(model.SpringFestivalDayDic[key].WeekPartyItem[i]);

                    }

                }

            }

            if (ItemDayList.Count > 1)

            {

                m_One.SetActive(false);

                m_Two.SetActive(true);

                m_SpringFestivalItemA1.SetReward(model.SelectedNow, ItemDayList[0], 0, 2);

                m_SpringFestivalItemB1.SetReward(model.SelectedNow, ItemDayList[1], 1, 2);

            }

            else

            {

                m_One.SetActive(true);

                m_Two.SetActive(false);

                m_SpringFestivalItemA.SetReward(model.SelectedNow, ItemDayList[0], 0, 1);

            }

        }

        private void ChooseDay()//选择天

        {

            foreach (var key in model.RedPointDic.Keys)//红点选择可领取的天

            {

                if (model.RedPointDic[key].state == RedPointState.GetReward)

                {

                    model.SelectedNow = key;

                    return;

                }

            }

            model.SelectedNow = model.DayNow;

        }
    }

}





 System/OpenServerActivity/SpringFestivalWin.cs.meta

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

 System/Strengthening/GodBeastSlidingList.cs

@@ -196,6 +196,10 @@
                var itemModel = BackpackDic[key];

                GodBeastBagClass godBeastBagClass = new GodBeastBagClass();

                godBeastBagClass.ItemId = itemModel.itemId;

                if (itemModel.itemId == 5417)

                {

                    continue;

                }

                godBeastBagClass.Index = key;

                if (itemModel.chinItemModel.Type != 70)

                {


 System/Welfare/OperationTimeHepler.cs

@@ -488,7 +488,99 @@
                }

            }

        }

        /// <summary>

        /// 登录奖励

        /// </summary>

        /// <param name="package"></param>

        public void RefreshLoginReward(HAA0C_tagMCActLoginAwardInfo package)

        {

            OperationBase operation = null;

            operationDict.TryGetValue(Operation.LoginReward, out operation);

            if (string.IsNullOrEmpty(package.StartDate) || string.IsNullOrEmpty(package.EndtDate))

            {

                ForceStopOperation(Operation.LoginReward);

            }

            else

            {

                if (operation == null)

                {

                    operation = new EventDaysTime();

                    operationDict.Add(Operation.LoginReward, operation);

                }

                operation.Reset();

                operation.startDate = ParseOperationDate(package.StartDate);

                operation.endDate = ParseOperationDate(package.EndtDate);

                operation.limitLv = package.LimitLV;

                operation.dayReset = package.IsDayReset == 1;

                operation.resetType = package.ResetType;

                operation.inAdvanceMinute = package.AdvanceMinutes;

                if (operationTimeUpdateEvent != null)

                {

                    operationTimeUpdateEvent(Operation.LoginReward);

                }

            }

        }

        /// <summary>

        /// 春节巡礼

        /// </summary>

        /// <param name="package"></param>

        public void SpringFestival(HAA20_tagMCFeastWeekPartyInfo package)

        {

            OperationBase operation = null;

            operationDict.TryGetValue(Operation.SpringFestival, out operation);

            if (string.IsNullOrEmpty(package.StartDate) || string.IsNullOrEmpty(package.EndtDate))

            {

                ForceStopOperation(Operation.SpringFestival);

            }

            else

            {

                if (operation == null)

                {

                    operation = new EventDaysTime();

                    operationDict.Add(Operation.SpringFestival, operation);

                }

                operation.Reset();

                operation.startDate = ParseOperationDate(package.StartDate);

                operation.endDate = ParseOperationDate(package.EndtDate);

                operation.limitLv = package.LimitLV;

                operation.dayReset = package.IsDayReset == 1;

                operation.resetType = package.ResetType;

                operation.inAdvanceMinute = package.AdvanceMinutes;

                if (operationTimeUpdateEvent != null)

                {

                    operationTimeUpdateEvent(Operation.SpringFestival);

                }

            }

        }

        public void OpenServiceAchievement(HAA0A_tagMCWeekPartyInfo package)

        {

            OperationBase operation = null;

            operationDict.TryGetValue(Operation.OpenServiceAchievement, out operation);

            if (string.IsNullOrEmpty(package.StartDate) || string.IsNullOrEmpty(package.EndtDate))

            {

                ForceStopOperation(Operation.OpenServiceAchievement);

            }

            else

            {

                if (operation == null)

                {

                    operation = new EventDaysTime();

                    operationDict.Add(Operation.OpenServiceAchievement, operation);

                }

                operation.Reset();

                operation.startDate = ParseOperationDate(package.StartDate);

                operation.endDate = ParseOperationDate(package.EndtDate);

                operation.limitLv = package.LimitLV;

                operation.dayReset = package.IsDayReset == 1;

                operation.resetType = package.ResetType;

                operation.inAdvanceMinute = package.AdvanceMinutes;

                if (operationTimeUpdateEvent != null)

                {

                    operationTimeUpdateEvent(Operation.OpenServiceAchievement);

                }

            }



        }

        void ForceStopOperation(Operation operationType)

        {

            if (operationDict.ContainsKey(operationType))

@@ -791,7 +883,10 @@
        FlashRushToBuy, //限时抢购

        WishingWellInfo, //许愿池

        AccumulateRecharge,//累计充值

        LoginReward,//登录奖励

        NewYearFairyCeremony, //春节仙界盛典

        SpringFestival,//春节巡礼

        OpenServiceAchievement,//七日巡礼

        max,

    }

}


 System/WindowBase/ModelCenter.cs

@@ -221,6 +221,7 @@
            RegisterModel<CrossServerBossModel>();

            RegisterModel<OpenServiceAchievementModel>();

            RegisterModel<FashionDressModel>();

            RegisterModel<LoginRewardModel>();

            RegisterModel<JadeDynastyBossModel>();

            RegisterModel<JadeDynastyDecomposeModel>();

            RegisterModel<JadeDynastyTowerModel>();


 Utility/CalculateSkillGetAttrHurtUtility.cs

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

using System.Collections.Generic;

using System.Linq;

using System.Text;



namespace Snxxz.UI

{

    public class CalculateSkillGetAttrHurtUtility : Singleton<CalculateSkillGetAttrHurtUtility>

    {

        PlayerPackModel playerPack { get { return ModelCenter.Instance.GetModel<PlayerPackModel>(); } }

        private Dictionary<int, int> legendAttrDict = new Dictionary<int, int>();



        public CalculateSkillGetAttrHurtUtility()

        {

            playerPack.RefreshItemCountAct += UpdateItem;

            UpdateSkillHurt();

        }



        private void UpdateItem(PackType type, int index, int id)

        {

           switch(type)

            {

                case PackType.rptJadeDynastyEquip:

                    UpdateSkillHurt();

                    break;

            }

        }



        private void UpdateSkillHurt()

        {

            legendAttrDict.Clear();

            SinglePackModel singlePack = playerPack.GetSinglePackModel(PackType.rptJadeDynastyEquip);

            if (singlePack == null) return;



            var dict = singlePack.GetPackModelIndexDict();

            foreach (var model in dict.Values)

            {

                var legendIds = model.GetUseDataModel((int)ItemUseDataKey.Def_IudetLegendAttrID);

                var legendValues = model.GetUseDataModel((int)ItemUseDataKey.Def_IudetLegendAttrValue);

                if (legendIds != null && legendValues != null)

                {

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

                    {

                        int attrId = legendIds[i];

                        int attrValue = legendValues[i];

                        switch ((AttrEnum)attrId)

                        {

                            case AttrEnum.SkillAddPerA:

                            case AttrEnum.SkillAddPerB:

                            case AttrEnum.SkillAddPerC:

                            case AttrEnum.SkillAddPerD:

                            case AttrEnum.SkillAddPerE:

                            case AttrEnum.SkillAddPerF:

                            case AttrEnum.SkillAddPerG:

                                legendAttrDict.Add(attrId,attrValue);

                                break;

                        }

                    }

                }

            }

        }



        public bool TryGetAttrDictBySkill(int _skillId,out Dictionary<int,int> attrDict)

        {

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

            var attrIds = GeneralDefine.GetAttrIdsBySkill(_skillId);

            if(attrIds != null)

            {

                foreach(var attrId in attrIds)

                {

                    if(legendAttrDict.ContainsKey(attrId))

                    {

                        int attrValue = legendAttrDict[attrId];

                        attrDict.Add(attrId,attrValue);

                    }

                }

            }

            return attrDict.Count > 0;

        }

    }

}


 Utility/CalculateSkillGetAttrHurtUtility.cs.meta

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

 Utility/EnumHelper.cs

@@ -327,7 +327,7 @@
    GatherSoulDungeon = 30,

    CrossServerPk = 31,

    JadeDynastyBoss = 32,

    JadeDynastyTower=33,

    JadeDynastyTower = 33,

}



public enum ActivityPrepareType

@@ -1261,9 +1261,11 @@
    Def_RewardType_IceLodeStar = 19, //冰晶矿脉星级奖励19

    Def_RewardType_WeekPartyAct = 20, //领取周狂欢活动奖励20

    Def_RewardType_WeekPartyPoint = 21,// 领取周狂欢积分奖励21

    Def_RewardType_ActLoginAwardAct = 22, // 领取登录奖励活动奖励22

    Def_RewardType_ActLoginAwardAct = 22,// 领取登录奖励活动奖励22

    Def_RewardType_NewFairyCRecharge = 23, // 新仙界盛典充值大礼23

    Def_RewardType_NewFairyCParty = 24, // 新仙界盛典全民来嗨24

    Def_RewardType_FeastWeekPartyAct = 25, //领取节日巡礼活动奖励25

    Def_RewardType_FeastWeekPartyPoint = 26, //领取节日巡礼积分奖励26

}



public enum MapType