using System.Collections; 
 | 
using System.Collections.Generic; 
 | 
using UnityEngine; 
 | 
using LitJson; 
 | 
using System; 
 | 
using System.Text.RegularExpressions; 
 | 
using System.Linq; 
 | 
  
 | 
public class GeneralDefine 
 | 
{ 
 | 
    public const int CrossBattleFieldMapID = 32060; 
 | 
    public const int CrossFamilyBattleMapID = 32090; 
 | 
    public static int initDepotGridCount { get; private set; } 
 | 
    public static int maxDepotGridCount { get; private set; } 
 | 
    public static int initBagGridCount { get; private set; } 
 | 
    public static int maxBagGridCount { get; private set; } 
 | 
    public static int maxXBGridCount { get; private set; } 
 | 
    public static int playerMaxLevel { get; private set; } 
 | 
    public static int[] kylinHomeCollectItems; 
 | 
    public static List<int> dailyQuestOpenTime; 
 | 
    public static int flyBootItemId { get; private set; } 
 | 
    public static int flyBootItemMoney { 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 int MasteryLoadingLevelLimit1 { get; private set; } 
 | 
    public static int MasteryLoadingLevelLimit2 { get; private set; } 
 | 
  
 | 
    public static float mainWinSkillResetTime { 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[] ImportantItemType { get; private set; } 
 | 
    public static int[] ImportantItemID { 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; set; } 
 | 
    public static int crossServerBattleFieldOpenDay { get; private set; } 
 | 
    public static int UISpringDecorate { get; private set; } 
 | 
    public static Dictionary<int, List<int>> skillAttrIDDict { get; private set; } 
 | 
    public static int mixServerCustomDays { get; private set; } 
 | 
    public static float ClientPvpAttributePer { get; private set; } 
 | 
    public static int openServerCustomDays { get; private set; } 
 | 
  
 | 
    public static int mysteryShopRefreshItem { get; private set; } 
 | 
    public static Dictionary<int, int> mysteryShopRefreshItemCount { get; private set; } 
 | 
    public static int mysteryShopRefreshItemValue { get; private set; } 
 | 
    public static int mysteryShopRefreshInterval { get; private set; } 
 | 
    public static Dictionary<int, Dictionary<int, int>> equipStarLimit { get; private set; } 
 | 
    public static int equipTrainMustItemId { get; private set; } 
 | 
    public static int acutionItemHour { get; private set; } 
 | 
  
 | 
    public static int mainWinTopCloseTime { get; private set; } 
 | 
    public static List<int> equipDecomposeScreen = new List<int>(); 
 | 
    public static Dictionary<int, float> AtkTypeIncreasePushDis = new Dictionary<int, float>(); 
 | 
    // public static Dictionary<int, CameraController.LookAtData> NpcDieSetCamera = new Dictionary<int, CameraController.LookAtData>(); 
 | 
    public static int BlueEquipJumpLevel { get; private set; } 
 | 
    public static int[] defenseGetWays { get; private set; } 
 | 
    public static Dictionary<int, int> skillYinjis { get; private set; } 
 | 
    public static List<int> onlyUsedAtBackpackItems { get; private set; } 
 | 
    public static List<int> signInPromoteSkills = new List<int>(); 
 | 
    public static List<int> chestDisplayItems = new List<int>(); 
 | 
  
 | 
    public static int equipStarUpAmendFactor { get; private set; } 
 | 
    public static int equipStarDownAmendFactor { get; private set; } 
 | 
  
 | 
    public static int normalEquipStarUpgradeRateCeiling { get; private set; } 
 | 
    public static int normalEquipStarUpgradeRateFloor { get; private set; } 
 | 
  
 | 
    public static int suitEquipStarUpgradeRateCeiling { get; private set; } 
 | 
    public static int suitEquipStarUpgradeRateFloor { get; private set; } 
 | 
  
 | 
    public static Dictionary<int, List<int>> BossAssistAward { get; private set; } 
 | 
    public static Dictionary<int, List<int>> FBAssistAward { get; private set; } 
 | 
  
 | 
    //检测是否在systemsetwin prefab显示切换区服和切换账号 
 | 
    public static List<string> checkShowSwitchAccount = new List<string>(); 
 | 
    //竞技场 初始积分|最高积分 
 | 
    public static List<int> ArenaSetList { get; private set; } 
 | 
    //培养对应物品列表 1.培养丹2.养神石3.特殊培养 
 | 
    public static int[] HorseTrainIDList { get; private set; } 
 | 
    public static int[] PetTrainIDList { get; private set; } 
 | 
    public static Dictionary<int, List<int>> LingQiTrainIDList { get; private set; } 
 | 
  
 | 
    //数值1:可对敌方使用的附加技能列表 
 | 
    //数值2:可对自己使用的附加技能列表 
 | 
    //数值3:不可释放的技能 
 | 
    public static int[] WorkForEnemySkills { get; private set; } 
 | 
    public static int[] WorkForMeSkills { get; private set; } 
 | 
    public static int[] WorkNotSkills { get; private set; } 
 | 
    public static Dictionary<int, List<int>> ZhanLingCtgIdDict { get; private set; } 
 | 
    public static Dictionary<int, List<int>> ZhanLingCtgIdHDict { get; private set; } 
 | 
    public static Dictionary<int, int> OldZhanLingCtgIdDict { get; private set; } 
 | 
  
 | 
    public static float fightPowerMore; //战力超过比例才可快速挑战 
 | 
    public static int[] flashOpenArr; //开启雷诛层 [天星塔,境界塔,符印塔(按第几个塔算)] 
 | 
    public static int[] flashCntMoreArr; //雷诛更多次数层需求 [天星塔,境界塔,符印塔(按第几个塔算)] 
 | 
    public static int flashKillMaxCount; //雷诛最大次数 
 | 
  
 | 
    public static void Init() 
 | 
    { 
 | 
        try 
 | 
        { 
 | 
            equipStarUpAmendFactor = GetIntArray("EquipStarRate")[0]; 
 | 
            equipStarDownAmendFactor = GetIntArray("EquipStarRate")[1]; 
 | 
  
 | 
            normalEquipStarUpgradeRateFloor = GetIntArray("EquipStarRate", 2)[0]; 
 | 
            normalEquipStarUpgradeRateCeiling = GetIntArray("EquipStarRate", 2)[1]; 
 | 
  
 | 
            suitEquipStarUpgradeRateFloor = GetIntArray("EquipStarRate", 3)[0]; 
 | 
            suitEquipStarUpgradeRateCeiling = GetIntArray("EquipStarRate", 3)[1]; 
 | 
  
 | 
            BlueEquipJumpLevel = GetInt("BlueEquipJumpLevel"); 
 | 
            initDepotGridCount = GetInt("InitDepotCellCount"); 
 | 
            maxDepotGridCount = GetInt("MaxDepotCellCount"); 
 | 
            initBagGridCount = GetInt("InitBagCellCount"); 
 | 
            maxBagGridCount = GetInt("MaxBagCellCount"); 
 | 
            maxXBGridCount = GetInt("TreasureSet", 3); 
 | 
  
 | 
            CompareEquipPlaces = GetIntArray("EquipUpType"); 
 | 
            playerMaxLevel = GetInt("PlayerMaxLV"); 
 | 
            kylinHomeCollectItems = GetIntArray("KirinNpc", 2); 
 | 
            dailyQuestOpenTime = GetTimeArray("ActionTime", 1); 
 | 
            flyBootItemId = GetInt("TransportPay"); 
 | 
            flyBootItemMoney = GetInt("TransportPay", 2); 
 | 
            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")); 
 | 
            ArenaSetList = new List<int>(GetIntArray("ArenaSet")); 
 | 
            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 = FuncConfigConfig.Get("Job1Head"); 
 | 
            jobHeadPortrait[1] = ConfigParse.GetDic<int, string>(jobHeadPortraitConfig1.Numerical1); 
 | 
            otherjobHeadPortrait[1] = ConfigParse.GetDic<int, string>(jobHeadPortraitConfig1.Numerical2); 
 | 
  
 | 
            var jobHeadPortraitConfig2 = FuncConfigConfig.Get("Job2Head"); 
 | 
            jobHeadPortrait[2] = ConfigParse.GetDic<int, string>(jobHeadPortraitConfig2.Numerical1); 
 | 
            otherjobHeadPortrait[2] = ConfigParse.GetDic<int, string>(jobHeadPortraitConfig2.Numerical2); 
 | 
  
 | 
            var jobHeadPortraitConfig3 = FuncConfigConfig.Get("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 
 | 
                { 
 | 
                    Debug.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()); 
 | 
                } 
 | 
            } 
 | 
            FuncConfigConfig HorseTrainConfig = FuncConfigConfig.Get("HorseTrain"); 
 | 
            HorseTrainIDList = LitJson.JsonMapper.ToObject<int[]>(HorseTrainConfig.Numerical1); 
 | 
            FuncConfigConfig PetTrainConfig = FuncConfigConfig.Get("PetUpItem"); 
 | 
            PetTrainIDList = LitJson.JsonMapper.ToObject<int[]>(PetTrainConfig.Numerical3); 
 | 
            FuncConfigConfig LingQiTrainConfig = FuncConfigConfig.Get("HorseTrain"); 
 | 
            var LingQiTrainJson = LitJson.JsonMapper.ToObject(GetInputString("LingQiTrain", 1)); 
 | 
            LingQiTrainIDList = new Dictionary<int, List<int>>(); 
 | 
            foreach (var key in LingQiTrainJson.Keys) 
 | 
            { 
 | 
                int attrId = int.Parse(key); 
 | 
                var skillIds = LingQiTrainJson[key]; 
 | 
                foreach (var skillId in skillIds) 
 | 
                { 
 | 
                    int id = int.Parse(skillId.ToString()); 
 | 
                    if (!LingQiTrainIDList.ContainsKey(attrId)) 
 | 
                    { 
 | 
                        List<int> list = new List<int>(); 
 | 
                        list.Add(id); 
 | 
                        LingQiTrainIDList.Add(attrId, list); 
 | 
                    } 
 | 
                    else 
 | 
                    { 
 | 
                        LingQiTrainIDList[attrId].Add(id); 
 | 
                    } 
 | 
                } 
 | 
  
 | 
            } 
 | 
  
 | 
            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 BossAssistAwardJson = LitJson.JsonMapper.ToObject(GetInputString("AssistAward", 1)); 
 | 
            BossAssistAward = new Dictionary<int, List<int>>(); 
 | 
            foreach (var key in BossAssistAwardJson.Keys) 
 | 
            { 
 | 
                int bossID = int.Parse(key); 
 | 
                var awards = BossAssistAwardJson[key]; 
 | 
                if (!BossAssistAward.ContainsKey(bossID)) 
 | 
                { 
 | 
                    BossAssistAward[bossID] = new List<int>(); 
 | 
                } 
 | 
                foreach (var award in awards) 
 | 
                { 
 | 
                    BossAssistAward[bossID].Add(int.Parse(award.ToString())); 
 | 
                } 
 | 
  
 | 
            } 
 | 
  
 | 
            var FBAssistAwardJson = LitJson.JsonMapper.ToObject(GetInputString("AssistAward", 2)); 
 | 
            FBAssistAward = new Dictionary<int, List<int>>(); 
 | 
            foreach (var key in FBAssistAwardJson.Keys) 
 | 
            { 
 | 
                int mapID = int.Parse(key); 
 | 
                var awards = FBAssistAwardJson[key]; 
 | 
                if (!FBAssistAward.ContainsKey(mapID)) 
 | 
                { 
 | 
                    FBAssistAward[mapID] = new List<int>(); 
 | 
                } 
 | 
                foreach (var award in awards) 
 | 
                { 
 | 
                    FBAssistAward[mapID].Add(int.Parse(award.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 = FuncConfigConfig.Get("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])); 
 | 
            } 
 | 
            //checkShowSwitchAccount 
 | 
            var showSwitchAccount = FuncConfigConfig.Get("ShowSwitchAccount"); 
 | 
            LitJson.JsonData itemShowSwitchAccount = LitJson.JsonMapper.ToObject(showSwitchAccount.Numerical1); 
 | 
            checkShowSwitchAccount = new List<string>(); 
 | 
            foreach(var item in itemShowSwitchAccount) 
 | 
            { 
 | 
                checkShowSwitchAccount.Add(item.ToString()); 
 | 
            } 
 | 
  
 | 
            var putInItemPack = FuncConfigConfig.Get("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]; 
 | 
                int packType = int.Parse(_key); 
 | 
                List<int> itemTypes = new List<int>(); 
 | 
                itemPutInPackDict.Add(packType, itemTypes); 
 | 
                if (itemTypeData.IsArray) 
 | 
                { 
 | 
                    for (i = 0; i < itemTypeData.Count; i++) 
 | 
                    { 
 | 
                        int itemType = int.Parse(itemTypeData[i].ToString()); 
 | 
                        itemTypes.Add(itemType); 
 | 
                    } 
 | 
                } 
 | 
            } 
 | 
  
 | 
            //拾取贵重物品 
 | 
            FuncConfigConfig importantItemType = FuncConfigConfig.Get("AutoBuyDrug"); 
 | 
            ImportantItemType = LitJson.JsonMapper.ToObject<int[]>(importantItemType.Numerical2); 
 | 
            ImportantItemID = LitJson.JsonMapper.ToObject<int[]>(importantItemType.Numerical3); 
 | 
  
 | 
            FuncConfigConfig nxxdImg = FuncConfigConfig.Get("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 = FuncConfigConfig.Get("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 = FuncConfigConfig.Get("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 = FuncConfigConfig.Get("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 = FuncConfigConfig.Get("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 = FuncConfigConfig.Get("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"); 
 | 
            heroDialogueOffset = GetInputString("NpcHalfLength", 1).Vector3Parse(); 
 | 
            heroDialogueRotation = GetInputString("NpcHalfLength", 2).Vector3Parse(); 
 | 
            heroDialogueScale = GetFloat("NpcHalfLength", 3); 
 | 
  
 | 
            var ancientConfig = FuncConfigConfig.Get("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 = FuncConfigConfig.Get("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 = FuncConfigConfig.Get("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 = FuncConfigConfig.Get("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 = FuncConfigConfig.Get("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 = FuncConfigConfig.Get("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], 
 | 
                    // }); 
 | 
                } 
 | 
            } 
 | 
  
 | 
            func = FuncConfigConfig.Get("QualityEffectConfig"); 
 | 
            lowQualityEffectCount = int.Parse(func.Numerical1); 
 | 
            medQualityEffectCount = int.Parse(func.Numerical2); 
 | 
            highQualityEffectCount = int.Parse(func.Numerical3); 
 | 
  
 | 
            func = FuncConfigConfig.Get("QualityPetCountConfig"); 
 | 
            lowQualityPetCount = int.Parse(func.Numerical1); 
 | 
            medQualityPetCount = int.Parse(func.Numerical2); 
 | 
            highQualityPetCount = int.Parse(func.Numerical3); 
 | 
  
 | 
            func = FuncConfigConfig.Get("QualityGuardCountConfig"); 
 | 
            lowQualityGuardCount = int.Parse(func.Numerical1); 
 | 
            medQualityGuardCount = int.Parse(func.Numerical2); 
 | 
            highQualityGuardCount = int.Parse(func.Numerical3); 
 | 
  
 | 
            func = FuncConfigConfig.Get("QualityPetEffectCount"); 
 | 
            lowQualityPetEffectCount = int.Parse(func.Numerical1); 
 | 
            medQualityPetEffectCount = int.Parse(func.Numerical2); 
 | 
            highQualityPetEffectCount = int.Parse(func.Numerical3); 
 | 
  
 | 
            func = FuncConfigConfig.Get("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 = FuncConfigConfig.Get("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); 
 | 
  
 | 
            //     } 
 | 
            // } 
 | 
  
 | 
  
 | 
            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]); 
 | 
                } 
 | 
            } 
 | 
  
 | 
            crossServerBattleFieldOpenDay = GetInt("CrossRealmCfg", 2); 
 | 
            UISpringDecorate = GetInt("UISpringDecorate"); 
 | 
  
 | 
            mixServerCustomDays = GetInt("MixServer"); 
 | 
            openServerCustomDays = GetInt("OperationAction"); 
 | 
            ClientPvpAttributePer = GetInt("ClientPvPAttributePer") * Constants.F_DELTA; 
 | 
  
 | 
            mysteryShopRefreshItem = GetInt("MysteryShopRefresh"); 
 | 
            mysteryShopRefreshItemCount = new Dictionary<int, int>(); 
 | 
            var mysteryShopJson = JsonMapper.ToObject(GetInputString("MysteryShopRefresh", 2)); 
 | 
            foreach (var key in mysteryShopJson.Keys) 
 | 
            { 
 | 
                var time = int.Parse(key); 
 | 
                mysteryShopRefreshItemCount[time] = (int)mysteryShopJson[key]; 
 | 
            } 
 | 
  
 | 
            mysteryShopRefreshItemValue = GetInt("MysteryShopRefresh", 3); 
 | 
            mysteryShopRefreshInterval = GetInt("MysteryShopRefresh", 4); 
 | 
  
 | 
            var equipStarConfig = FuncConfigConfig.Get("EquipPartStar"); 
 | 
            var equipStarJson = LitJson.JsonMapper.ToObject(equipStarConfig.Numerical1); 
 | 
            equipStarLimit = new Dictionary<int, Dictionary<int, int>>(); 
 | 
            foreach (var itemColorKey in equipStarJson.Keys) 
 | 
            { 
 | 
                var itemColor = int.Parse(itemColorKey); 
 | 
                Dictionary<int, int> dict = new Dictionary<int, int>(); 
 | 
                foreach (var itemLevelKey in equipStarJson[itemColorKey].Keys) 
 | 
                { 
 | 
                    var itemLevel = int.Parse(itemLevelKey); 
 | 
                    var starLimit = int.Parse(equipStarJson[itemColorKey][itemLevelKey].ToString()); 
 | 
                    dict.Add(itemLevel, starLimit); 
 | 
                } 
 | 
                equipStarLimit.Add(itemColor, dict); 
 | 
            } 
 | 
  
 | 
            equipTrainMustItemId = GetInt("EquipWashMustID"); 
 | 
            acutionItemHour = GetInt("AuctionItem"); 
 | 
            mainWinTopCloseTime = GetInt("AutomaticSwitch"); 
 | 
  
 | 
            equipDecomposeScreen.AddRange(GetIntArray("EquipDecomposeScreen", 2)); 
 | 
  
 | 
            func = FuncConfigConfig.Get("AtkTypeIncreasePushDis"); 
 | 
            var _ks = func.Numerical1.Split('|'); 
 | 
            var _vs = func.Numerical2.Split('|'); 
 | 
            for (i = 0; i < _ks.Length; ++i) 
 | 
            { 
 | 
                AtkTypeIncreasePushDis[int.Parse(_ks[i])] = int.Parse(_vs[i]) * Constants.F_DELTA; 
 | 
            } 
 | 
  
 | 
            func = FuncConfigConfig.Get("NpcDieSetCamera"); 
 | 
            if (func != null) 
 | 
            { 
 | 
                var _jsonData = LitJson.JsonMapper.ToObject(func.Numerical1); 
 | 
                for (i = 0; i < _jsonData.Count; ++i) 
 | 
                { 
 | 
                    var _child = _jsonData[i]; 
 | 
                    // var _lookAtData = new CameraController.LookAtData(); 
 | 
                    // _lookAtData.position = new Vector3(MathUtility.GetFloatFromLitJson(_child[1][0]), 
 | 
                    //                                    MathUtility.GetFloatFromLitJson(_child[1][1]), 
 | 
                    //                                    MathUtility.GetFloatFromLitJson(_child[1][2])); 
 | 
                    // _lookAtData.rotX = (int)_child[2]; 
 | 
                    // _lookAtData.rotY = (int)_child[3]; 
 | 
                    // _lookAtData.lastTime = MathUtility.GetFloatFromLitJson(_child[4]); 
 | 
  
 | 
                    // NpcDieSetCamera[(int)_child[0]] = _lookAtData; 
 | 
                } 
 | 
            } 
 | 
            WorkForEnemySkills = GetIntArray("ArenaSetSkills", 1); 
 | 
            WorkForMeSkills = GetIntArray("ArenaSetSkills", 2); 
 | 
            WorkNotSkills = GetIntArray("ArenaSetSkills", 3); 
 | 
            defenseGetWays = GetIntArray("DefenseGetWays", 1); 
 | 
            skillYinjis = ConfigParse.GetDic<int, int>(GetInputString("SkillYinji", 1)); 
 | 
            onlyUsedAtBackpackItems = new List<int>(GetIntArray("ItemPush", 2)); 
 | 
  
 | 
            var signInSkillArray = GetIntArray("SignInPromoteSkill", 1); 
 | 
            if (signInSkillArray != null) 
 | 
            { 
 | 
                signInPromoteSkills.AddRange(signInSkillArray); 
 | 
            } 
 | 
  
 | 
            MasteryLoadingLevelLimit1 = GetInt("MasteryLoadingLevelLimit"); 
 | 
            MasteryLoadingLevelLimit2 = GetInt("MasteryLoadingLevelLimit", 2); 
 | 
  
 | 
            chestDisplayItems = new List<int>(GetIntArray("ChestShowItems")); 
 | 
  
 | 
            func = FuncConfigConfig.Get("Zhanling"); 
 | 
            if (func != null) 
 | 
            { 
 | 
                OldZhanLingCtgIdDict = new Dictionary<int, int>(); 
 | 
                ZhanLingCtgIdDict = new Dictionary<int, List<int>>(); 
 | 
                var tempDict = JsonMapper.ToObject(func.Numerical1); 
 | 
                var keyList = tempDict.Keys.ToList(); 
 | 
                for (int j = 0; j < keyList.Count; j++) 
 | 
                { 
 | 
                    OldZhanLingCtgIdDict[int.Parse(keyList[j])] = JsonMapper.ToObject<List<int>>(tempDict[keyList[j]].ToJson())[0]; 
 | 
                    ZhanLingCtgIdDict[int.Parse(keyList[j])] = JsonMapper.ToObject<List<int>>(tempDict[keyList[j]].ToJson()); 
 | 
                } 
 | 
  
 | 
                ZhanLingCtgIdHDict = new Dictionary<int, List<int>>(); 
 | 
                tempDict = JsonMapper.ToObject(func.Numerical3); 
 | 
                keyList = tempDict.Keys.ToList(); 
 | 
                for (int k = 0; k < keyList.Count; k++) 
 | 
                { 
 | 
                    ZhanLingCtgIdHDict[int.Parse(keyList[k])] = JsonMapper.ToObject<List<int>>(tempDict[keyList[k]].ToJson()); 
 | 
                } 
 | 
            } 
 | 
  
 | 
            func = FuncConfigConfig.Get("FBQuickPass"); 
 | 
            fightPowerMore = float.Parse(func.Numerical1) + 0.01f; //疑似玩家无法雷诛是C/S计算不对等问题,所以加0.01f 
 | 
            flashOpenArr = JsonMapper.ToObject<int[]>(func.Numerical2); 
 | 
            flashCntMoreArr = JsonMapper.ToObject<int[]>(func.Numerical3); 
 | 
            flashKillMaxCount = int.Parse(func.Numerical4); 
 | 
  
 | 
        } 
 | 
        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) 
 | 
        { 
 | 
            var types = itemPutInPackDict[key]; 
 | 
            if (types.Contains(itemType)) 
 | 
            { 
 | 
                return (PackType)key; 
 | 
            } 
 | 
        } 
 | 
        return PackType.Item; 
 | 
    } 
 | 
  
 | 
    public static int GetInt(string _key, int _index = 1) 
 | 
    { 
 | 
        var result = 0; 
 | 
        int.TryParse(GetInputString(_key, _index), out result); 
 | 
        return result; 
 | 
    } 
 | 
  
 | 
    public static float GetFloat(string _key, int _index = 1) 
 | 
    { 
 | 
        var result = 0f; 
 | 
        float.TryParse(GetInputString(_key, _index), out result); 
 | 
        return result; 
 | 
    } 
 | 
  
 | 
    public static bool GetBool(string _key, int _index = 1) 
 | 
    { 
 | 
        var result = false; 
 | 
        bool.TryParse(GetInputString(_key, _index), out result); 
 | 
        return result; 
 | 
    } 
 | 
  
 | 
    public 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; 
 | 
    } 
 | 
  
 | 
    public 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; 
 | 
    } 
 | 
  
 | 
  
 | 
    public 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; 
 | 
    } 
 | 
  
 | 
    public 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; 
 | 
    } 
 | 
  
 | 
    public 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; 
 | 
    } 
 | 
  
 | 
    public static string GetInputString(string _key, int _index = 1) 
 | 
    { 
 | 
        var config = FuncConfigConfig.Get(_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; 
 | 
    } 
 | 
  
 | 
  
 | 
} 
 |