少年修仙传客户端代码仓库
client_linchunjie
2019-02-19 5fdcc5ca68ea7fb1722555281e45f29db5157ae9
6242 子 【开发】【2.0】法宝界面调整 / 【前端】【2.0】法宝调整
10个文件已删除
19个文件已修改
5623 ■■■■■ 已修改文件
Core/NetworkPackage/DTCFile/ServerPack/H03_MainCharacter/DTC0310_tagRoleSkillChange.cs 2 ●●● 补丁 | 查看 | 原始文档 | blame | 历史
Fight/Actor/Skill/SkillHelper.cs 1 ●●●● 补丁 | 查看 | 原始文档 | blame | 历史
Lua/Gen/DelegatesGensBridge.cs 137 ●●●● 补丁 | 查看 | 原始文档 | blame | 历史
Lua/Gen/SnxxzUITreasureModelWrap.cs 1207 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/Achievement/AchievementGotoPart1.cs 80 ●●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/Achievement/AchievementModel.cs 42 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/MainInterfacePanel/FlyingShoesTask.cs 2 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/MainInterfacePanel/PlayerMainDate.cs 4 ●●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/RolePromote/RolePromoteModel.cs 37 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/Tip/PromoteDetailsWin.cs 18 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/Treasure/PotentialItemBehaviour.cs 2 ●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/Treasure/PotentialItemUseWin.cs 28 ●●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/Treasure/TreasureAchievement.cs 3 ●●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/Treasure/TreasureAnimation.cs 843 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/Treasure/TreasureAnimation.cs.meta 12 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/Treasure/TreasureCollectBriefInfoBehaviour.cs 7 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/Treasure/TreasureComponent.cs 232 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/Treasure/TreasureData.cs 127 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/Treasure/TreasureMeridianBehaviour.cs 353 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/Treasure/TreasureMeridianBehaviour.cs.meta 12 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/Treasure/TreasureModel.cs 809 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/Treasure/TreasurePotentialBriefInfo.cs 214 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/Treasure/TreasurePotentialBriefInfo.cs.meta 12 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/Treasure/TreasurePotentialLines.cs 42 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/Treasure/TreasurePotentialLines.cs.meta 12 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/Treasure/TreasurePotentialPanel.cs 1229 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/Treasure/TreasurePotentialPanel.cs.meta 12 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/Treasure/TreasureSelectWin.cs 53 ●●●● 补丁 | 查看 | 原始文档 | blame | 历史
System/Treasure/UI3DTreasureSelectStage.cs 91 ●●●●● 补丁 | 查看 | 原始文档 | blame | 历史
Core/NetworkPackage/DTCFile/ServerPack/H03_MainCharacter/DTC0310_tagRoleSkillChange.cs
@@ -39,7 +39,7 @@
            onMainModel.XpSkill(vNetData.NewSkillID, vNetData.RemainTime);
        model.UpdateTreasurePotentialInfo(vNetData.OldSkillID, vNetData.NewSkillID);
        //model.UpdateTreasurePotentialInfo(vNetData.OldSkillID, vNetData.NewSkillID);
        ModelCenter.Instance.GetModel<TalentModel>().UpdateTalentSkill(vNetData.OldSkillID, vNetData.NewSkillID);
        ModelCenter.Instance.GetModel<JadeDynastySkillModel>().OnReceivePackage(vNetData);
        if (vNetData != null)
Fight/Actor/Skill/SkillHelper.cs
@@ -26,7 +26,6 @@
        }
        Snxxz.UI.TreasureModel _model = Snxxz.UI.ModelCenter.Instance.GetModel<Snxxz.UI.TreasureModel>();
        _model.potentialLevelUpdate += OnSpSkillChange;
    }
    public void OnSpSkillChange(int skillTypeID, int level)
Lua/Gen/DelegatesGensBridge.cs
@@ -6711,30 +6711,7 @@
#endif
        }
        
        public UnityEngine.Vector3 __Gen_Delegate_Imp290(object p0, int p1)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
            {
#endif
                RealStatePtr L = luaEnv.rawL;
                int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference);
                ObjectTranslator translator = luaEnv.translator;
                translator.PushAny(L, p0);
                LuaAPI.xlua_pushinteger(L, p1);
                PCall(L, 2, 1, errFunc);
                UnityEngine.Vector3 __gen_ret;translator.Get(L, errFunc + 1, out __gen_ret);
                LuaAPI.lua_settop(L, errFunc - 1);
                return  __gen_ret;
#if THREAD_SAFE || HOTFIX_ENABLE
            }
#endif
        }
        public UnityEngine.Vector3 __Gen_Delegate_Imp291(object p0, UnityEngine.Vector3 p1)
        public UnityEngine.Vector3 __Gen_Delegate_Imp290(object p0, UnityEngine.Vector3 p1)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6757,78 +6734,7 @@
#endif
        }
        
        public void __Gen_Delegate_Imp292(object p0, bool p1, bool p2)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
            {
#endif
                RealStatePtr L = luaEnv.rawL;
                int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference);
                ObjectTranslator translator = luaEnv.translator;
                translator.PushAny(L, p0);
                LuaAPI.lua_pushboolean(L, p1);
                LuaAPI.lua_pushboolean(L, p2);
                PCall(L, 3, 0, errFunc);
                LuaAPI.lua_settop(L, errFunc - 1);
#if THREAD_SAFE || HOTFIX_ENABLE
            }
#endif
        }
        public void __Gen_Delegate_Imp293(object p0, Snxxz.UI.TreasureAnimation.TreasureShowStep p1)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
            {
#endif
                RealStatePtr L = luaEnv.rawL;
                int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference);
                ObjectTranslator translator = luaEnv.translator;
                translator.PushAny(L, p0);
                translator.Push(L, p1);
                PCall(L, 2, 0, errFunc);
                LuaAPI.lua_settop(L, errFunc - 1);
#if THREAD_SAFE || HOTFIX_ENABLE
            }
#endif
        }
        public void __Gen_Delegate_Imp294(object p0, bool p1, int p2)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
            {
#endif
                RealStatePtr L = luaEnv.rawL;
                int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference);
                ObjectTranslator translator = luaEnv.translator;
                translator.PushAny(L, p0);
                LuaAPI.lua_pushboolean(L, p1);
                LuaAPI.xlua_pushinteger(L, p2);
                PCall(L, 3, 0, errFunc);
                LuaAPI.lua_settop(L, errFunc - 1);
#if THREAD_SAFE || HOTFIX_ENABLE
            }
#endif
        }
        public UnityEngine.Vector3 __Gen_Delegate_Imp295(object p0)
        public UnityEngine.Vector3 __Gen_Delegate_Imp291(object p0)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6850,7 +6756,7 @@
#endif
        }
        
        public Treasure3DConfig.TreasureParam __Gen_Delegate_Imp296(object p0)
        public Treasure3DConfig.TreasureParam __Gen_Delegate_Imp292(object p0)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6872,7 +6778,7 @@
#endif
        }
        
        public Snxxz.UI.UI3DTreasureSelectStage __Gen_Delegate_Imp297()
        public Snxxz.UI.UI3DTreasureSelectStage __Gen_Delegate_Imp293()
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6893,7 +6799,7 @@
#endif
        }
        
        public TreasureCategory __Gen_Delegate_Imp298(object p0)
        public TreasureCategory __Gen_Delegate_Imp294(object p0)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6915,7 +6821,7 @@
#endif
        }
        
        public void __Gen_Delegate_Imp299(object p0, bool p1, TreasureCategory p2)
        public void __Gen_Delegate_Imp295(object p0, bool p1, TreasureCategory p2)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6939,7 +6845,7 @@
#endif
        }
        
        public System.Collections.IEnumerator __Gen_Delegate_Imp300(object p0, TreasureCategory p1, object p2)
        public System.Collections.IEnumerator __Gen_Delegate_Imp296(object p0, TreasureCategory p1, object p2)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6963,7 +6869,7 @@
#endif
        }
        
        public void __Gen_Delegate_Imp301(object p0, TreasureCategory p1, bool p2)
        public void __Gen_Delegate_Imp297(object p0, TreasureCategory p1, bool p2)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -6987,7 +6893,30 @@
#endif
        }
        
        public System.Collections.IEnumerator __Gen_Delegate_Imp302(object p0, object p1, float p2)
        public UnityEngine.Vector3 __Gen_Delegate_Imp298(object p0, int p1)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
            {
#endif
                RealStatePtr L = luaEnv.rawL;
                int errFunc = LuaAPI.pcall_prepare(L, errorFuncRef, luaReference);
                ObjectTranslator translator = luaEnv.translator;
                translator.PushAny(L, p0);
                LuaAPI.xlua_pushinteger(L, p1);
                PCall(L, 2, 1, errFunc);
                UnityEngine.Vector3 __gen_ret;translator.Get(L, errFunc + 1, out __gen_ret);
                LuaAPI.lua_settop(L, errFunc - 1);
                return  __gen_ret;
#if THREAD_SAFE || HOTFIX_ENABLE
            }
#endif
        }
        public System.Collections.IEnumerator __Gen_Delegate_Imp299(object p0, object p1, float p2)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
@@ -7011,7 +6940,7 @@
#endif
        }
        
        public Snxxz.UI.SignInModel __Gen_Delegate_Imp303(object p0)
        public Snxxz.UI.SignInModel __Gen_Delegate_Imp300(object p0)
        {
#if THREAD_SAFE || HOTFIX_ENABLE
            lock (luaEnv.luaEnvLock)
Lua/Gen/SnxxzUITreasureModelWrap.cs
@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(Snxxz.UI.TreasureModel);
            Utils.BeginObjectRegister(type, L, translator, 0, 63, 31, 20);
            Utils.BeginObjectRegister(type, L, translator, 0, 37, 20, 12);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnInit", _m_UnInit);
@@ -30,16 +30,8 @@
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPlayerLoginOk", _m_OnPlayerLoginOk);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "CheckReguluPop", _m_CheckReguluPop);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTreasureUnlockShow", _m_GetTreasureUnlockShow);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPotentialUnlockShow", _m_GetPotentialUnlockShow);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetPotentialUnlockShow", _m_SetPotentialUnlockShow);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSpAnim", _m_GetSpAnim);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetSpAnim", _m_SetSpAnim);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTreasureFinishAnim", _m_GetTreasureFinishAnim);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTreasureFinishAnim", _m_SetTreasureFinishAnim);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryGetUnlockShowTreasure", _m_TryGetUnlockShowTreasure);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTreasureUnlockShow", _m_SetTreasureUnlockShow);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetTreasureStageShow", _m_SetTreasureStageShow);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTreasureStageShow", _m_GetTreasureStageShow);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryGetTreasure", _m_TryGetTreasure);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryGetTreasureDungeon", _m_TryGetTreasureDungeon);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryGetTreasureUnlockAchievement", _m_TryGetTreasureUnlockAchievement);
@@ -47,97 +39,60 @@
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTreasureCategory", _m_GetTreasureCategory);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetActiveTreasureCategory", _m_GetActiveTreasureCategory);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTreasureIdByMapIdAndLineId", _m_GetTreasureIdByMapIdAndLineId);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSkillLevelUpType", _m_GetSkillLevelUpType);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "RequestPotentialUpgrade", _m_RequestPotentialUpgrade);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateTreasureCollectState", _m_UpdateTreasureCollectState);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateTreasurePotentialInfo", _m_UpdateTreasurePotentialInfo);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSkillLevelUpRedpointTreasure", _m_GetSkillLevelUpRedpointTreasure);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "TreasureStageUpLimit", _m_TreasureStageUpLimit);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "CheckOpenTreasureNewGot", _m_CheckOpenTreasureNewGot);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SatisfyLevelUpUnlock", _m_SatisfyLevelUpUnlock);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SatisyPotentialLevelUp", _m_SatisyPotentialLevelUp);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateTreasureLevelInfo", _m_UpdateTreasureLevelInfo);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "HumanTreasureStateChange", _m_HumanTreasureStateChange);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetFurnacesAchievements", _m_GetFurnacesAchievements);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsVersionUnOpenTreasure", _m_IsVersionUnOpenTreasure);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetMapIdByTreasure", _m_GetMapIdByTreasure);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTreasureFightPower", _m_GetTreasureFightPower);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetExtensionPower", _m_GetExtensionPower);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryGetPotentialGetSkill", _m_TryGetPotentialGetSkill);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsPotentialUnlock", _m_IsPotentialUnlock);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPotentialInitialPower", _m_GetPotentialInitialPower);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SatisfyEntranceOpen", _m_SatisfyEntranceOpen);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "DisplayEntranceLimitHint", _m_DisplayEntranceLimitHint);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPotentialNextTargetLevel", _m_GetPotentialNextTargetLevel);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "DemonDungeonChallengeNext", _m_DemonDungeonChallengeNext);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTreasureBySkillId", _m_GetTreasureBySkillId);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "treasureCollectProgressUpdateEvent", _e_treasureCollectProgressUpdateEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "treasureSelectedEvent", _e_treasureSelectedEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "potentialBookSelectEvent", _e_potentialBookSelectEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "collectingTreasureChangeEvent", _e_collectingTreasureChangeEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "treasureStateChangeEvent", _e_treasureStateChangeEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "onPotentialLevelUpResultEvent", _e_onPotentialLevelUpResultEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "potentialLevelChangeEvent", _e_potentialLevelChangeEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "potentialLevelUpdate", _e_potentialLevelUpdate);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "vipKillNPCTreasureEvent", _e_vipKillNPCTreasureEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "treasureLevelProgressUpdateEvent", _e_treasureLevelProgressUpdateEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "treasureStageUpEvent", _e_treasureStageUpEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "humanTreasureStateChangeEvent", _e_humanTreasureStateChangeEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "demonTreasureDungeonUpdate", _e_demonTreasureDungeonUpdate);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "skillLevelUpRedpointUpdate", _e_skillLevelUpRedpointUpdate);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "demonDungeonChallengeNext", _e_demonDungeonChallengeNext);
            
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "stoveRedpoint", _g_get_stoveRedpoint);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "selectedTreasure", _g_get_selectedTreasure);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "selectedPotential", _g_get_selectedPotential);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "treasureStepUpShow", _g_get_treasureStepUpShow);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "treasureStageUpShow", _g_get_treasureStageUpShow);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "currentCategory", _g_get_currentCategory);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "collectingHuman", _g_get_collectingHuman);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "collectingDemon", _g_get_collectingDemon);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "selectedPotentialBook", _g_get_selectedPotentialBook);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "fairyTreasureGetDict", _g_get_fairyTreasureGetDict);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "serverInited", _g_get_serverInited);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "newGotTreasureId", _g_get_newGotTreasureId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "newGotShowing", _g_get_newGotShowing);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "treasureEntranceShowId", _g_get_treasureEntranceShowId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "treasureCollectingShowId", _g_get_treasureCollectingShowId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "treasureGotoId", _g_get_treasureGotoId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "openFromTreasureSoul", _g_get_openFromTreasureSoul);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "openFromTreasureUnlockShow", _g_get_openFromTreasureUnlockShow);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "openFromTreasureCollect", _g_get_openFromTreasureCollect);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "openFromTreasureList", _g_get_openFromTreasureList);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "openFromTaskId", _g_get_openFromTaskId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "inPotentialModifyPower", _g_get_inPotentialModifyPower);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "castSoulGuideTaskIds", _g_get_castSoulGuideTaskIds);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "guideTreasures", _g_get_guideTreasures);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "treasureBackLvLimit", _g_get_treasureBackLvLimit);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "treasureBackPercent", _g_get_treasureBackPercent);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "treasureExitLvLimit", _g_get_treasureExitLvLimit);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "exitRecord", _g_get_exitRecord);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "entranceOpenCondition", _g_get_entranceOpenCondition);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "cacheGotAchievements", _g_get_cacheGotAchievements);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "vipKillNPCTreasure", _g_get_vipKillNPCTreasure);
            
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "selectedTreasure", _s_set_selectedTreasure);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "selectedPotential", _s_set_selectedPotential);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "treasureStepUpShow", _s_set_treasureStepUpShow);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "treasureStageUpShow", _s_set_treasureStageUpShow);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "currentCategory", _s_set_currentCategory);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "collectingHuman", _s_set_collectingHuman);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "collectingDemon", _s_set_collectingDemon);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "selectedPotentialBook", _s_set_selectedPotentialBook);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "newGotTreasureId", _s_set_newGotTreasureId);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "treasureEntranceShowId", _s_set_treasureEntranceShowId);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "treasureCollectingShowId", _s_set_treasureCollectingShowId);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "treasureGotoId", _s_set_treasureGotoId);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "openFromTreasureSoul", _s_set_openFromTreasureSoul);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "openFromTreasureUnlockShow", _s_set_openFromTreasureUnlockShow);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "openFromTreasureCollect", _s_set_openFromTreasureCollect);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "openFromTreasureList", _s_set_openFromTreasureList);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "openFromTaskId", _s_set_openFromTaskId);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "inPotentialModifyPower", _s_set_inPotentialModifyPower);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "exitRecord", _s_set_exitRecord);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "vipKillNPCTreasure", _s_set_vipKillNPCTreasure);
            
@@ -145,9 +100,8 @@
            Utils.EndObjectRegister(type, L, translator, null, null,
                null, null, null);
            Utils.BeginClassRegister(type, L, __CreateInstance, 6, 1, 1);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetSkillLevelUpId", _m_GetSkillLevelUpId_xlua_st_);
            Utils.BeginClassRegister(type, L, __CreateInstance, 5, 1, 1);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TREASURE_DATAMAPID", Snxxz.UI.TreasureModel.TREASURE_DATAMAPID);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TREASURE_MAPID", Snxxz.UI.TreasureModel.TREASURE_MAPID);
@@ -384,222 +338,6 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetPotentialUnlockShow(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                {
                    int __treasureId = LuaAPI.xlua_tointeger(L, 2);
                        bool gen_ret = gen_to_be_invoked.GetPotentialUnlockShow( __treasureId );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    return 1;
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetPotentialUnlockShow(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                int gen_param_count = LuaAPI.lua_gettop(L);
                if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3))
                {
                    int __treasureId = LuaAPI.xlua_tointeger(L, 2);
                    bool __value = LuaAPI.lua_toboolean(L, 3);
                    gen_to_be_invoked.SetPotentialUnlockShow( __treasureId, __value );
                    return 0;
                }
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2))
                {
                    int __treasureId = LuaAPI.xlua_tointeger(L, 2);
                    gen_to_be_invoked.SetPotentialUnlockShow( __treasureId );
                    return 0;
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return LuaAPI.luaL_error(L, "invalid arguments to Snxxz.UI.TreasureModel.SetPotentialUnlockShow!");
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetSpAnim(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                {
                    int __treasureId = LuaAPI.xlua_tointeger(L, 2);
                        bool gen_ret = gen_to_be_invoked.GetSpAnim( __treasureId );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    return 1;
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetSpAnim(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                int gen_param_count = LuaAPI.lua_gettop(L);
                if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3))
                {
                    int __treasureId = LuaAPI.xlua_tointeger(L, 2);
                    bool _anim = LuaAPI.lua_toboolean(L, 3);
                    gen_to_be_invoked.SetSpAnim( __treasureId, _anim );
                    return 0;
                }
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2))
                {
                    int __treasureId = LuaAPI.xlua_tointeger(L, 2);
                    gen_to_be_invoked.SetSpAnim( __treasureId );
                    return 0;
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return LuaAPI.luaL_error(L, "invalid arguments to Snxxz.UI.TreasureModel.SetSpAnim!");
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetTreasureFinishAnim(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                {
                    int __treasureId = LuaAPI.xlua_tointeger(L, 2);
                        bool gen_ret = gen_to_be_invoked.GetTreasureFinishAnim( __treasureId );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    return 1;
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetTreasureFinishAnim(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                int gen_param_count = LuaAPI.lua_gettop(L);
                if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3))
                {
                    int __treasureId = LuaAPI.xlua_tointeger(L, 2);
                    bool _anim = LuaAPI.lua_toboolean(L, 3);
                    gen_to_be_invoked.SetTreasureFinishAnim( __treasureId, _anim );
                    return 0;
                }
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2))
                {
                    int __treasureId = LuaAPI.xlua_tointeger(L, 2);
                    gen_to_be_invoked.SetTreasureFinishAnim( __treasureId );
                    return 0;
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return LuaAPI.luaL_error(L, "invalid arguments to Snxxz.UI.TreasureModel.SetTreasureFinishAnim!");
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_TryGetUnlockShowTreasure(RealStatePtr L)
        {
            try {
@@ -651,64 +389,6 @@
                    
                    
                    return 0;
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetTreasureStageShow(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                {
                    int __id = LuaAPI.xlua_tointeger(L, 2);
                    int __stage = LuaAPI.xlua_tointeger(L, 3);
                    gen_to_be_invoked.SetTreasureStageShow( __id, __stage );
                    return 0;
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetTreasureStageShow(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                {
                    int __id = LuaAPI.xlua_tointeger(L, 2);
                        int gen_ret = gen_to_be_invoked.GetTreasureStageShow( __id );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
@@ -949,65 +629,6 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetSkillLevelUpType(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                {
                    int __skillId = LuaAPI.xlua_tointeger(L, 2);
                        int gen_ret = gen_to_be_invoked.GetSkillLevelUpType( __skillId );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    return 1;
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_RequestPotentialUpgrade(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                {
                    int __treasureId = LuaAPI.xlua_tointeger(L, 2);
                    int __potentialId = LuaAPI.xlua_tointeger(L, 3);
                    int __costIndex = LuaAPI.xlua_tointeger(L, 4);
                    gen_to_be_invoked.RequestPotentialUpgrade( __treasureId, __potentialId, __costIndex );
                    return 0;
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdateTreasureCollectState(RealStatePtr L)
        {
            try {
@@ -1020,9 +641,9 @@
            
                
                {
                    uint[] __gotTreasures = (uint[])translator.GetObject(L, 2, typeof(uint[]));
                    uint[] _collecteds = (uint[])translator.GetObject(L, 2, typeof(uint[]));
                    
                    gen_to_be_invoked.UpdateTreasureCollectState( __gotTreasures );
                    gen_to_be_invoked.UpdateTreasureCollectState( _collecteds );
                    
                    
                    
@@ -1032,108 +653,6 @@
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdateTreasurePotentialInfo(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                {
                    int __oldSkillId = LuaAPI.xlua_tointeger(L, 2);
                    int __newSkillId = LuaAPI.xlua_tointeger(L, 3);
                    gen_to_be_invoked.UpdateTreasurePotentialInfo( __oldSkillId, __newSkillId );
                    return 0;
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetSkillLevelUpRedpointTreasure(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                {
                        int gen_ret = gen_to_be_invoked.GetSkillLevelUpRedpointTreasure(  );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    return 1;
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_TreasureStageUpLimit(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                int gen_param_count = LuaAPI.lua_gettop(L);
                if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 3))
                {
                    int __treasureId = LuaAPI.xlua_tointeger(L, 2);
                    bool __tip = LuaAPI.lua_toboolean(L, 3);
                        bool gen_ret = gen_to_be_invoked.TreasureStageUpLimit( __treasureId, __tip );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    return 1;
                }
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2))
                {
                    int __treasureId = LuaAPI.xlua_tointeger(L, 2);
                        bool gen_ret = gen_to_be_invoked.TreasureStageUpLimit( __treasureId );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    return 1;
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return LuaAPI.luaL_error(L, "invalid arguments to Snxxz.UI.TreasureModel.TreasureStageUpLimit!");
            
        }
        
@@ -1165,69 +684,6 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SatisfyLevelUpUnlock(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                {
                    int _treasureId = LuaAPI.xlua_tointeger(L, 2);
                    int _index = LuaAPI.xlua_tointeger(L, 3);
                        bool gen_ret = gen_to_be_invoked.SatisfyLevelUpUnlock( _treasureId, _index );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    return 1;
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SatisyPotentialLevelUp(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                {
                    int _treasureId = LuaAPI.xlua_tointeger(L, 2);
                    int _potentialId = LuaAPI.xlua_tointeger(L, 3);
                    Snxxz.UI.Item _item;
                        bool gen_ret = gen_to_be_invoked.SatisyPotentialLevelUp( _treasureId, _potentialId, out _item );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    translator.Push(L, _item);
                    return 2;
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdateTreasureLevelInfo(RealStatePtr L)
        {
            try {
@@ -1243,34 +699,6 @@
                    HA352_tagMCMagicWeaponLVInfo _package = (HA352_tagMCMagicWeaponLVInfo)translator.GetObject(L, 2, typeof(HA352_tagMCMagicWeaponLVInfo));
                    
                    gen_to_be_invoked.UpdateTreasureLevelInfo( _package );
                    return 0;
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_HumanTreasureStateChange(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                {
                    int __id = LuaAPI.xlua_tointeger(L, 2);
                    gen_to_be_invoked.HumanTreasureStateChange( __id );
                    
                    
                    
@@ -1328,32 +756,6 @@
                    
                        bool gen_ret = gen_to_be_invoked.IsVersionUnOpenTreasure( __id );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    return 1;
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetSkillLevelUpId_xlua_st_(RealStatePtr L)
        {
            try {
                {
                    int __type = LuaAPI.xlua_tointeger(L, 1);
                    int __level = LuaAPI.xlua_tointeger(L, 2);
                        int gen_ret = Snxxz.UI.TreasureModel.GetSkillLevelUpId( __type, __level );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
@@ -1470,98 +872,6 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_TryGetPotentialGetSkill(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                {
                    int __skillTypeId = LuaAPI.xlua_tointeger(L, 2);
                    int[] __array;
                        bool gen_ret = gen_to_be_invoked.TryGetPotentialGetSkill( __skillTypeId, out __array );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    translator.Push(L, __array);
                    return 2;
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsPotentialUnlock(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                {
                    int _treasureId = LuaAPI.xlua_tointeger(L, 2);
                    int _potentialId = LuaAPI.xlua_tointeger(L, 3);
                        bool gen_ret = gen_to_be_invoked.IsPotentialUnlock( _treasureId, _potentialId );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    return 1;
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetPotentialInitialPower(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                {
                    int _treasureId = LuaAPI.xlua_tointeger(L, 2);
                    int _index = LuaAPI.xlua_tointeger(L, 3);
                        int gen_ret = gen_to_be_invoked.GetPotentialInitialPower( _treasureId, _index );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    return 1;
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SatisfyEntranceOpen(RealStatePtr L)
        {
            try {
@@ -1608,35 +918,6 @@
                    
                    
                    return 0;
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetPotentialNextTargetLevel(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                {
                    int _level = LuaAPI.xlua_tointeger(L, 2);
                        int gen_ret = gen_to_be_invoked.GetPotentialNextTargetLevel( _level );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
@@ -1734,20 +1015,6 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_selectedPotential(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.selectedPotential);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_treasureStepUpShow(RealStatePtr L)
        {
            try {
@@ -1818,20 +1085,6 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_selectedPotentialBook(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.selectedPotentialBook);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_fairyTreasureGetDict(RealStatePtr L)
        {
            try {
@@ -1888,20 +1141,6 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_treasureEntranceShowId(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.treasureEntranceShowId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_treasureCollectingShowId(RealStatePtr L)
        {
            try {
@@ -1930,48 +1169,6 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_openFromTreasureSoul(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.openFromTreasureSoul);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_openFromTreasureUnlockShow(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.openFromTreasureUnlockShow);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_openFromTreasureCollect(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.openFromTreasureCollect);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_openFromTreasureList(RealStatePtr L)
        {
            try {
@@ -1979,48 +1176,6 @@
            
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.openFromTreasureList);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_openFromTaskId(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.openFromTaskId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_inPotentialModifyPower(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.inPotentialModifyPower);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_castSoulGuideTaskIds(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.castSoulGuideTaskIds);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
@@ -2049,34 +1204,6 @@
            
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.treasureBackLvLimit);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_treasureBackPercent(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushnumber(L, gen_to_be_invoked.treasureBackPercent);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_treasureExitLvLimit(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.treasureExitLvLimit);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
@@ -2169,21 +1296,6 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_selectedPotential(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.selectedPotential = LuaAPI.xlua_tointeger(L, 2);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_treasureStepUpShow(RealStatePtr L)
        {
            try {
@@ -2260,21 +1372,6 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_selectedPotentialBook(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.selectedPotentialBook = LuaAPI.xlua_tointeger(L, 2);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_newGotTreasureId(RealStatePtr L)
        {
            try {
@@ -2282,21 +1379,6 @@
            
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.newGotTreasureId = LuaAPI.xlua_tointeger(L, 2);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_treasureEntranceShowId(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.treasureEntranceShowId = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
@@ -2335,51 +1417,6 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_openFromTreasureSoul(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.openFromTreasureSoul = LuaAPI.lua_toboolean(L, 2);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_openFromTreasureUnlockShow(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.openFromTreasureUnlockShow = LuaAPI.lua_toboolean(L, 2);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_openFromTreasureCollect(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.openFromTreasureCollect = LuaAPI.lua_toboolean(L, 2);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_openFromTreasureList(RealStatePtr L)
        {
            try {
@@ -2387,36 +1424,6 @@
            
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.openFromTreasureList = LuaAPI.lua_toboolean(L, 2);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_openFromTaskId(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.openFromTaskId = LuaAPI.xlua_tointeger(L, 2);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_inPotentialModifyPower(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.inPotentialModifyPower = LuaAPI.lua_toboolean(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
@@ -2539,40 +1546,6 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_potentialBookSelectEvent(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
            Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                System.Action<int> gen_delegate = translator.GetDelegate<System.Action<int>>(L, 3);
                if (gen_delegate == null) {
                    return LuaAPI.luaL_error(L, "#3 need System.Action<int>!");
                }
                if (gen_param_count == 3)
                {
                    if (LuaAPI.xlua_is_eq_str(L, 2, "+")) {
                        gen_to_be_invoked.potentialBookSelectEvent += gen_delegate;
                        return 0;
                    }
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.potentialBookSelectEvent -= gen_delegate;
                        return 0;
                    }
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            LuaAPI.luaL_error(L, "invalid arguments to Snxxz.UI.TreasureModel.potentialBookSelectEvent!");
            return 0;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_collectingTreasureChangeEvent(RealStatePtr L)
        {
            try {
@@ -2637,108 +1610,6 @@
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            LuaAPI.luaL_error(L, "invalid arguments to Snxxz.UI.TreasureModel.treasureStateChangeEvent!");
            return 0;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_onPotentialLevelUpResultEvent(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
            Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                System.Action<int, int, bool> gen_delegate = translator.GetDelegate<System.Action<int, int, bool>>(L, 3);
                if (gen_delegate == null) {
                    return LuaAPI.luaL_error(L, "#3 need System.Action<int, int, bool>!");
                }
                if (gen_param_count == 3)
                {
                    if (LuaAPI.xlua_is_eq_str(L, 2, "+")) {
                        gen_to_be_invoked.onPotentialLevelUpResultEvent += gen_delegate;
                        return 0;
                    }
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.onPotentialLevelUpResultEvent -= gen_delegate;
                        return 0;
                    }
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            LuaAPI.luaL_error(L, "invalid arguments to Snxxz.UI.TreasureModel.onPotentialLevelUpResultEvent!");
            return 0;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_potentialLevelChangeEvent(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
            Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                System.Action<int, int> gen_delegate = translator.GetDelegate<System.Action<int, int>>(L, 3);
                if (gen_delegate == null) {
                    return LuaAPI.luaL_error(L, "#3 need System.Action<int, int>!");
                }
                if (gen_param_count == 3)
                {
                    if (LuaAPI.xlua_is_eq_str(L, 2, "+")) {
                        gen_to_be_invoked.potentialLevelChangeEvent += gen_delegate;
                        return 0;
                    }
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.potentialLevelChangeEvent -= gen_delegate;
                        return 0;
                    }
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            LuaAPI.luaL_error(L, "invalid arguments to Snxxz.UI.TreasureModel.potentialLevelChangeEvent!");
            return 0;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_potentialLevelUpdate(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
            Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                System.Action<int, int> gen_delegate = translator.GetDelegate<System.Action<int, int>>(L, 3);
                if (gen_delegate == null) {
                    return LuaAPI.luaL_error(L, "#3 need System.Action<int, int>!");
                }
                if (gen_param_count == 3)
                {
                    if (LuaAPI.xlua_is_eq_str(L, 2, "+")) {
                        gen_to_be_invoked.potentialLevelUpdate += gen_delegate;
                        return 0;
                    }
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.potentialLevelUpdate -= gen_delegate;
                        return 0;
                    }
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            LuaAPI.luaL_error(L, "invalid arguments to Snxxz.UI.TreasureModel.potentialLevelUpdate!");
            return 0;
        }
        
@@ -2845,40 +1716,6 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_humanTreasureStateChangeEvent(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
            Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                System.Action<int> gen_delegate = translator.GetDelegate<System.Action<int>>(L, 3);
                if (gen_delegate == null) {
                    return LuaAPI.luaL_error(L, "#3 need System.Action<int>!");
                }
                if (gen_param_count == 3)
                {
                    if (LuaAPI.xlua_is_eq_str(L, 2, "+")) {
                        gen_to_be_invoked.humanTreasureStateChangeEvent += gen_delegate;
                        return 0;
                    }
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.humanTreasureStateChangeEvent -= gen_delegate;
                        return 0;
                    }
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            LuaAPI.luaL_error(L, "invalid arguments to Snxxz.UI.TreasureModel.humanTreasureStateChangeEvent!");
            return 0;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_demonTreasureDungeonUpdate(RealStatePtr L)
        {
            try {
@@ -2909,40 +1746,6 @@
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            LuaAPI.luaL_error(L, "invalid arguments to Snxxz.UI.TreasureModel.demonTreasureDungeonUpdate!");
            return 0;
        }
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_skillLevelUpRedpointUpdate(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
            Snxxz.UI.TreasureModel gen_to_be_invoked = (Snxxz.UI.TreasureModel)translator.FastGetCSObj(L, 1);
                System.Action gen_delegate = translator.GetDelegate<System.Action>(L, 3);
                if (gen_delegate == null) {
                    return LuaAPI.luaL_error(L, "#3 need System.Action!");
                }
                if (gen_param_count == 3)
                {
                    if (LuaAPI.xlua_is_eq_str(L, 2, "+")) {
                        gen_to_be_invoked.skillLevelUpRedpointUpdate += gen_delegate;
                        return 0;
                    }
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.skillLevelUpRedpointUpdate -= gen_delegate;
                        return 0;
                    }
                }
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            LuaAPI.luaL_error(L, "invalid arguments to Snxxz.UI.TreasureModel.skillLevelUpRedpointUpdate!");
            return 0;
        }
        
System/Achievement/AchievementGotoPart1.cs
@@ -313,46 +313,46 @@
        public static void GotoSpSkillLevelUp(int _achievementId)
        {
            var config = SuccessConfig.Get(_achievementId);
            var index = PlayerDatas.Instance.baseData.Job - 1;
            var skillId = index < config.Condition.Length ? config.Condition[index] : config.Condition[0];
            var treasureId = 0;
            var humanTreasures = treasureModel.GetTreasureCategory(TreasureCategory.Human);
            foreach (var id in humanTreasures)
            {
                Treasure treasure;
                treasureModel.TryGetTreasure(id, out treasure);
                if (treasure.GetPotential(skillId) != null)
                {
                    treasureId = treasure.id;
                    break;
                }
            }
            var skillConfig = SkillConfig.Get(skillId);
            var treasureConfig = TreasureConfig.Get(treasureId);
            if (treasureId != 0)
            {
                if (!FuncOpen.Instance.IsFuncOpen(82))
                {
                    FuncOpen.Instance.ProcessorFuncErrorTip(82);
                    return;
                }
                Treasure treasure;
                if (treasureModel.TryGetTreasure(treasureId, out treasure))
                {
                    if (!treasure.IsHighestStage)
                    {
                        SysNotifyMgr.Instance.ShowTip("TreasureSkillUnGet", skillConfig.SkillName, treasureConfig.Name);
                        return;
                    }
                    guideAchievementId = _achievementId;
                }
            }
            //var config = SuccessConfig.Get(_achievementId);
            //var index = PlayerDatas.Instance.baseData.Job - 1;
            //var skillId = index < config.Condition.Length ? config.Condition[index] : config.Condition[0];
            //
            //var treasureId = 0;
            //var humanTreasures = treasureModel.GetTreasureCategory(TreasureCategory.Human);
            //
            //foreach (var id in humanTreasures)
            //{
            //    Treasure treasure;
            //    treasureModel.TryGetTreasure(id, out treasure);
            //    if (treasure.GetPotential(skillId) != null)
            //    {
            //        treasureId = treasure.id;
            //        break;
            //    }
            //}
            //
            //var skillConfig = SkillConfig.Get(skillId);
            //var treasureConfig = TreasureConfig.Get(treasureId);
            //
            //if (treasureId != 0)
            //{
            //    if (!FuncOpen.Instance.IsFuncOpen(82))
            //    {
            //        FuncOpen.Instance.ProcessorFuncErrorTip(82);
            //        return;
            //    }
            //
            //    Treasure treasure;
            //    if (treasureModel.TryGetTreasure(treasureId, out treasure))
            //    {
            //        if (!treasure.IsHighestStage)
            //        {
            //            SysNotifyMgr.Instance.ShowTip("TreasureSkillUnGet", skillConfig.SkillName, treasureConfig.Name);
            //            return;
            //        }
            //        guideAchievementId = _achievementId;
            //    }
            //}
        }
System/Achievement/AchievementModel.cs
@@ -450,48 +450,6 @@
                    case 116:
                        getItemPathModel.SetChinItemModel(config.Condition[0]);
                        break;
                    case 91:
                        var index = PlayerDatas.Instance.baseData.Job - 1;
                        var potentialId = index < config.Condition.Length ? config.Condition[index] : config.Condition[0];
                        var treasureModel = ModelCenter.Instance.GetModel<TreasureModel>();
                        var treasureId = 0;
                        var treasures = treasureModel.GetTreasureCategory(TreasureCategory.Human);
                        foreach (var id in treasures)
                        {
                            Treasure treasure;
                            treasureModel.TryGetTreasure(id, out treasure);
                            if (treasure.GetPotential(potentialId) != null)
                            {
                                treasureId = treasure.id;
                                break;
                            }
                        }
                        var skillConfig = SkillConfig.Get(potentialId);
                        var treasureConfig = TreasureConfig.Get(treasureId);
                        if (treasureId != 0)
                        {
                            if (!FuncOpen.Instance.IsFuncOpen(82))
                            {
                                return;
                            }
                            Treasure treasure;
                            if (treasureModel.TryGetTreasure(treasureId, out treasure))
                            {
                                if (!treasure.IsHighestStage)
                                {
                                    return;
                                }
                                treasureModel.currentCategory = TreasureCategory.Human;
                                treasureModel.selectedTreasure = treasureId;
                                if (!WindowCenter.Instance.IsOpen<TreasureBaseWin>())
                                {
                                    WindowJumpMgr.Instance.WindowJumpTo(JumpUIType.TreasureCollectSoul);
                                }
                            }
                        }
                        break;
                    default:
                        WindowCenter.Instance.Close<TreasureBaseWin>();
System/MainInterfacePanel/FlyingShoesTask.cs
@@ -196,7 +196,6 @@
                        else
                        {
                            treasureModel.selectedTreasure = _treasureId;
                            treasureModel.openFromTaskId = Task_ID;
                            WindowCenter.Instance.Open<TreasureBaseWin>();
                        }
                        return;
@@ -218,7 +217,6 @@
                        else
                        {
                            treasureModel.selectedTreasure = _treasureId;
                            treasureModel.openFromTaskId = Task_ID;
                            WindowCenter.Instance.Open<TreasureBaseWin>();
                        }
                    }
System/MainInterfacePanel/PlayerMainDate.cs
@@ -379,10 +379,6 @@
    public void PowerAdd(int power)
    {
        if (ModelCenter.Instance.GetModel<TreasureModel>().inPotentialModifyPower)
        {
            return;
        }
        if (prowBool)
        {
            prowNum = power;
System/RolePromote/RolePromoteModel.cs
@@ -536,33 +536,10 @@
                _id == methodData.fairyHeartRedpoint.id ||
                _id == realmModel.realmRedpoint.id ||
                _id == gemModel.gemTagRedPoint.id ||
                _id == rolePointModel.redpoint.id ||
                IsTreasureRedpoint(_id))
                _id == rolePointModel.redpoint.id)
            {
                CheckPromoteDetailEffect();
            }
        }
        private bool IsTreasureRedpoint(int _id)
        {
            for (int k = 1; k < (int)TreasureCategory.Zerg; k++)
            {
                var list = treasureModel.GetTreasureCategory((TreasureCategory)k);
                if (list == null)
                {
                    continue;
                }
                for (int j = 0; j < list.Count; j++)
                {
                    Treasure treasure;
                    if (treasureModel.TryGetTreasure(list[j], out treasure)
                        && treasure.skillLevelUpRedpoint != null && treasure.skillLevelUpRedpoint.id == _id)
                    {
                        return true;
                    }
                }
            }
            return false;
        }
        public bool GetPromoteDetailShow(PromoteDetailType _type)
@@ -585,17 +562,7 @@
                case PromoteDetailType.GodWeapon:
                    return magicianModel.magicianRedpoint.state == RedPointState.Simple;
                case PromoteDetailType.TreasurePotential:
                    var list = treasureModel.GetTreasureCategory(TreasureCategory.Human);
                    for (int j = 0; j < list.Count; j++)
                    {
                        Treasure treasure;
                        if (treasureModel.TryGetTreasure(list[j], out treasure) && treasure.state == TreasureState.Collected
                            && treasure.skillLevelUpRedpoint != null && treasure.skillLevelUpRedpoint.state == RedPointState.Simple)
                        {
                            return true;
                        }
                    }
                    break;
                    return false;
                case PromoteDetailType.Gem:
                    return gemModel.gemTagRedPoint.state == RedPointState.Simple;
                case PromoteDetailType.Wash:
System/Tip/PromoteDetailsWin.cs
@@ -96,24 +96,6 @@
                    WindowCenter.Instance.Open<RolePanel>(false, 3);
                    break;
                case RolePromoteModel.PromoteDetailType.TreasurePotential:
                    treasureModel.currentCategory = TreasureCategory.Human;
                    var list = treasureModel.GetTreasureCategory(TreasureCategory.Human);
                    var gotoId = list[0];
                    for (int i = 0; i < list.Count; i++)
                    {
                        Treasure treasure;
                        if (treasureModel.TryGetTreasure(list[i], out treasure))
                        {
                            if (treasure.state == TreasureState.Collected && treasure.skillLevelUpRedpoint != null &&
                                treasure.skillLevelUpRedpoint.state == RedPointState.Simple)
                            {
                                gotoId = list[i];
                                break;
                            }
                        }
                    }
                    treasureModel.selectedTreasure = gotoId;
                    WindowCenter.Instance.Open<TreasureBaseWin>();
                    break;
                case RolePromoteModel.PromoteDetailType.RolePromote:
                    WindowCenter.Instance.Open<RolePromoteWin>();
System/Treasure/PotentialItemBehaviour.cs
@@ -63,7 +63,7 @@
        {
            //if (own >= need)
            //{
                model.selectedPotentialBook = potentialBook.itemId;
                //model.selectedPotentialBook = potentialBook.itemId;
                WindowCenter.Instance.Close<PotentialItemUseWin>();
            //}
            //else
System/Treasure/PotentialItemUseWin.cs
@@ -64,20 +64,20 @@
                return;
            }
            var potential = treasure.GetPotential(model.selectedPotential);
            var levelUpType = model.GetSkillLevelUpType(potential.id);
            var levelupId = TreasureModel.GetSkillLevelUpId(levelUpType, potential.level + 1);
            var config = TreasureSkillConfig.Get(levelupId);
            var books = new List<PotentialBook>();
            for (int i = 0; i < config.Meterial2ID.Length; i++)
            {
                var itemId = config.Meterial2ID[i];
                var needCount = config.MeterialNum2[i];
                var rate = config.Rate[i];
                books.Add(new PotentialBook(itemId, needCount, rate, levelupId));
            }
            m_PotentialScroll.Init(books);
            //var potential = treasure.GetPotential(model.selectedPotential);
            //var levelUpType = model.GetSkillLevelUpType(potential.id);
            //var levelupId = TreasureModel.GetSkillLevelUpId(levelUpType, potential.level + 1);
            //var config = TreasureSkillConfig.Get(levelupId);
            //
            //var books = new List<PotentialBook>();
            //for (int i = 0; i < config.Meterial2ID.Length; i++)
            //{
            //    var itemId = config.Meterial2ID[i];
            //    var needCount = config.MeterialNum2[i];
            //    var rate = config.Rate[i];
            //    books.Add(new PotentialBook(itemId, needCount, rate, levelupId));
            //}
            //m_PotentialScroll.Init(books);
        }
    }
System/Treasure/TreasureAchievement.cs
@@ -126,8 +126,7 @@
        private void GotoComplete()
        {
            if (m_TreasureCyclicScroll.showing || treasureModel.treasureStepUpShow
                || treasureModel.TreasureStageUpLimit(treasureModel.selectedTreasure))
            if (m_TreasureCyclicScroll.showing || treasureModel.treasureStepUpShow)
            {
                return;
            }
System/Treasure/TreasureAnimation.cs
File was deleted
System/Treasure/TreasureAnimation.cs.meta
File was deleted
System/Treasure/TreasureCollectBriefInfoBehaviour.cs
@@ -92,15 +92,11 @@
            achievementModel.achievementAwardableEvent -= OnAchievementAwardable;
            achievementModel.achievementCompletedEvent -= OnAchievementCompleted;
            model.treasureStageUpEvent -= OnCastSoul;
            model.humanTreasureStateChangeEvent -= OnHumanTreasureStateChange;
            model.potentialLevelChangeEvent -= OnPotentialLevelChange;
            RedpointCenter.Instance.redpointValueChangeEvent -= OnRedpointUpdate;
            achievementModel.achievementAwardableEvent += OnAchievementAwardable;
            achievementModel.achievementCompletedEvent += OnAchievementCompleted;
            model.treasureStageUpEvent += OnCastSoul;
            model.humanTreasureStateChangeEvent += OnHumanTreasureStateChange;
            model.potentialLevelChangeEvent += OnPotentialLevelChange;
            RedpointCenter.Instance.redpointValueChangeEvent += OnRedpointUpdate;
        }
@@ -111,8 +107,6 @@
            achievementModel.achievementAwardableEvent -= OnAchievementAwardable;
            achievementModel.achievementCompletedEvent -= OnAchievementCompleted;
            model.treasureStageUpEvent -= OnCastSoul;
            model.humanTreasureStateChangeEvent -= OnHumanTreasureStateChange;
            model.potentialLevelChangeEvent -= OnPotentialLevelChange;
            RedpointCenter.Instance.redpointValueChangeEvent -= OnRedpointUpdate;
        }
@@ -383,7 +377,6 @@
                var config = TreasureConfig.Get(displayTreasureId);
                model.selectedTreasure = displayTreasureId;
                model.currentCategory = (TreasureCategory)config.Category;
                model.openFromTreasureCollect = true;
                WindowCenter.Instance.Open<TreasureBaseWin>();
            }
        }
System/Treasure/TreasureComponent.cs
@@ -81,13 +81,9 @@
                RequestTreasure();
                RequestBottom();
                RequestBackLight();
                RequestRedpoint();
                RequestHighestEffect();
                RequestTreasureCanva();
                UpdateTreasureState();
                UpdateParam();
                RedpointCenter.Instance.redpointValueChangeEvent -= RedpointValueChangeEvent;
                RedpointCenter.Instance.redpointValueChangeEvent += RedpointValueChangeEvent;
                model.demonTreasureDungeonUpdate -= DemonTreasureDungeonUpdate;
                model.demonTreasureDungeonUpdate += DemonTreasureDungeonUpdate;
            }
@@ -99,12 +95,9 @@
                RecycleBackLight();
                RecycleLockEffect();
                RecycleCollectingSfx();
                RecycleRedpoint();
                RecycleCondition();
                RecycleTreasureLabel();
                RecycleHighestEffect();
                RecycleTreasureCanva();
                RedpointCenter.Instance.redpointValueChangeEvent -= RedpointValueChangeEvent;
                model.demonTreasureDungeonUpdate -= DemonTreasureDungeonUpdate;
            }
            interactProcessor.SetActive(_active);
@@ -244,28 +237,6 @@
                {
                    lockEffect.transform.localPosition = paramConfig.lockSfxParam.position;
                }
                var count = 0;
                if (stageUpRed != null)
                {
                    var _param = UI3DTreasureSelectStage.Instance.stageUpParam;
                    count++;
                    stageUpRed.transform.localPosition = GetRedpointPosition(count);
                    stageUpRed.transform.localScale = _param.scale;
                }
                if (achievementRed != null)
                {
                    var _param = UI3DTreasureSelectStage.Instance.achievementParam;
                    count++;
                    achievementRed.transform.localPosition = GetRedpointPosition(count);
                    achievementRed.transform.localScale = _param.scale;
                }
                if (potentialRed != null)
                {
                    var _param = UI3DTreasureSelectStage.Instance.potentialParam;
                    count++;
                    potentialRed.transform.localPosition = GetRedpointPosition(count);
                    potentialRed.transform.localScale = _param.scale;
                }
            }
        }
@@ -360,11 +331,6 @@
            UpdateParam();
        }
        public void UpdateTreasureStage()
        {
            RequestHighestEffect();
        }
        private void RequestBackLight()
        {
            RecycleBackLight();
@@ -455,135 +421,6 @@
            {
                SFXPlayUtility.Instance.Release(lockEffect);
                lockEffect = null;
            }
        }
        public void RequestRedpoint()
        {
            RecycleRedpoint();
            Treasure _treasure;
            model.TryGetTreasure(treasureId, out _treasure);
            if (_treasure == null || category != TreasureCategory.Human)
            {
                return;
            }
            //var count = 0;
            //if (_human.castSoulRedpoint.state == RedPointState.Simple)
            //{
            //    if (m_StageUpRedpool == null)
            //    {
            //        var _prefab = UILoader.LoadPrefab("Dian_JueXing");
            //        m_StageUpRedpool = GameObjectPoolManager.Instance.RequestPool(_prefab);
            //    }
            //    stageUpRed = m_StageUpRedpool.Request().transform;
            //    stageUpRed.gameObject.SetActive(true);
            //    stageUpRed.SetParent(root);
            //    stageUpRed.transform.localPosition = Vector3.zero;
            //    stageUpRed.LookAt(UI3DTreasureSelectStage.Instance.center);
            //    if (stageUpRed != null)
            //    {
            //        var _param = UI3DTreasureSelectStage.Instance.stageUpParam;
            //        count++;
            //        stageUpRed.transform.localPosition = GetRedpointPosition(count);
            //        stageUpRed.transform.localScale = _param.scale;
            //    }
            //    LayerUtility.SetLayer(stageUpRed.gameObject, LayerUtility.UILayer, true);
            //}
            //if (_human.achievementRedpoint.state == RedPointState.Simple)
            //{
            //    if (m_AchievementRedpool == null)
            //    {
            //        var _prefab = UILoader.LoadPrefab("Dian_JiHun");
            //        m_AchievementRedpool = GameObjectPoolManager.Instance.RequestPool(_prefab);
            //    }
            //    achievementRed = m_AchievementRedpool.Request().transform;
            //    achievementRed.gameObject.SetActive(true);
            //    achievementRed.SetParent(root);
            //    achievementRed.transform.localPosition = Vector3.zero;
            //    achievementRed.LookAt(UI3DTreasureSelectStage.Instance.center);
            //    if (achievementRed != null)
            //    {
            //        var _param = UI3DTreasureSelectStage.Instance.achievementParam;
            //        count++;
            //        achievementRed.transform.localPosition = GetRedpointPosition(count);
            //        achievementRed.transform.localScale = _param.scale;
            //    }
            //    LayerUtility.SetLayer(achievementRed.gameObject, LayerUtility.UILayer, true);
            //}
            //if (_human.skillLevelUpRedpoint.state == RedPointState.Simple)
            //{
            //    if (m_PotentialRedpool == null)
            //    {
            //        var _prefab = UILoader.LoadPrefab("Dian_Gong");
            //        m_PotentialRedpool = GameObjectPoolManager.Instance.RequestPool(_prefab);
            //    }
            //    potentialRed = m_PotentialRedpool.Request().transform;
            //    potentialRed.gameObject.SetActive(true);
            //    potentialRed.SetParent(root);
            //    potentialRed.transform.localPosition = Vector3.zero;
            //    potentialRed.LookAt(UI3DTreasureSelectStage.Instance.center);
            //    if (potentialRed != null)
            //    {
            //        var _param = UI3DTreasureSelectStage.Instance.potentialParam;
            //        count++;
            //        potentialRed.transform.localPosition = GetRedpointPosition(count);
            //        potentialRed.transform.localScale = _param.scale;
            //    }
            //    LayerUtility.SetLayer(potentialRed.gameObject, LayerUtility.UILayer, true);
            //}
        }
        public Vector3 GetRedpointPosition(int _count)
        {
            if (_count == 1)
            {
                return UI3DTreasureSelectStage.Instance.achievementParam.position;
            }
            else if (_count == 2)
            {
                return UI3DTreasureSelectStage.Instance.potentialParam.position;
            }
            else
            {
                return UI3DTreasureSelectStage.Instance.stageUpParam.position;
            }
        }
        private void RedpointValueChangeEvent(int _id)
        {
            if (UI3DTreasureSelectStage.Instance.IsCloser)
            {
                return;
            }
            Treasure _treasure;
            model.TryGetTreasure(treasureId, out _treasure);
            if (_treasure == null || category != TreasureCategory.Human)
            {
                return;
            }
            bool _update = false;
            if (_update)
            {
                RequestRedpoint();
            }
        }
        public void RecycleRedpoint()
        {
            if (m_PotentialRedpool != null && potentialRed != null)
            {
                m_PotentialRedpool.Release(potentialRed.gameObject);
                potentialRed = null;
            }
            if (m_AchievementRedpool != null && achievementRed != null)
            {
                m_AchievementRedpool.Release(achievementRed.gameObject);
                achievementRed = null;
            }
            if (m_StageUpRedpool != null && stageUpRed != null)
            {
                m_StageUpRedpool.Release(stageUpRed.gameObject);
                stageUpRed = null;
            }
        }
@@ -825,40 +662,6 @@
            }
        }
        public void RequestHighestEffect()
        {
            RecycleHighestEffect();
            Treasure _treasure;
            if (category == TreasureCategory.Human &&
                model.TryGetTreasure(treasureId, out _treasure) && _treasure.IsHighestStage && _treasure.state == TreasureState.Collected
                && !model.GetTreasureFinishAnim(treasureId) && model.GetTreasureUnlockShow(TreasureCategory.Human) != treasureId)
            {
                highestSfx = SFXPlayUtility.Instance.Play(5197, root);
                if (highestSfx != null)
                {
                    var animator = highestSfx.GetComponentInChildren<Animator>(true);
                    if (animator != null)
                    {
                        animator.Play(HUMAN_HIGHEST_STAGE_1, 0, UI3DTreasureSelectStage.sync_normalizedTime);
                    }
                    highestSfx.duration = 0;
                    LayerUtility.SetLayer(highestSfx.gameObject, LayerUtility.UILayer, true);
                    highestSfx.transform.localPosition = Vector3.zero;
                    highestSfx.transform.LookAt(UI3DTreasureSelectStage.Instance.center);
                }
            }
        }
        public void RecycleHighestEffect()
        {
            if (highestSfx != null)
            {
                highestSfx.gameObject.SetActive(false);
                SFXPlayUtility.Instance.Release(highestSfx);
                highestSfx = null;
            }
        }
        public void RequestTreasureCanva()
        {
            RecycleTreasureCanva();
@@ -909,10 +712,8 @@
            RecycleName();
            RecycleBackLight();
            RecycleLockEffect();
            RecycleRedpoint();
            RecycleCondition();
            RecycleTreasureLabel();
            RecycleHighestEffect();
            RecycleTreasureCanva();
            RequestSpecialEffect();
@@ -946,8 +747,6 @@
        {
            RequestBottom();
            RequestName();
            RequestRedpoint();
            RequestHighestEffect();
            RequestTreasureCanva();
            UpdateTreasureState();
            RecycleSpecialEffect();
@@ -995,42 +794,11 @@
            }
            if (model.treasureGotoId != 0 && model.treasureGotoId != 101)
            {
                model.openFromTreasureUnlockShow = true;
                UI3DTreasureSelectStage.Instance.OnPointDownTreasure(model.treasureGotoId);
                model.treasureGotoId = 0;
            }
            UI3DTreasureSelectStage.Instance.CompleteUnlock();
            model.treasureGotoId = 0;
        }
        public void PlayHighestShow()
        {
            RecycleHighestEffect();
            var _effect = SFXPlayUtility.Instance.Play(5197, root);
            if (_effect != null)
            {
                var animator = _effect.GetComponentInChildren<Animator>(true);
                if (animator != null)
                {
                    animator.Play(HUMAN_HIGHEST_STAGE_2, 0, 0);
                }
                LayerUtility.SetLayer(_effect.gameObject, LayerUtility.UILayer, true);
                _effect.transform.LookAt(UI3DTreasureSelectStage.Instance.center);
                _effect.transform.localPosition = Vector3.zero;
                _effect.duration = 3.0f;
            }
            SnxxzGame.Instance.StartCoroutine(Co_HighestShow());
        }
        IEnumerator Co_HighestShow()
        {
            yield return WaitingForSecondConst.GetWaitForSeconds(2.2f);
            model.SetTreasureFinishAnim(treasureId, false);
            if (display)
            {
                UpdateTreasureStage();
            }
            UI3DTreasureSelectStage.Instance.ReCheckTreasureHighest();
        }
        bool RequireGrayTreasureSkin()
System/Treasure/TreasureData.cs
@@ -73,36 +73,17 @@
            }
        }
        public int autoSelectPotential { get; set; }
        Dictionary<int, List<TreasurePotential>> jobToPotentials = new Dictionary<int, List<TreasurePotential>>();
        public List<TreasureStage> treasureStages = new List<TreasureStage>();
        public List<TreasurePotential> potentials
        {
            get
            {
                if (jobToPotentials.ContainsKey(PlayerDatas.Instance.baseData.Job))
                {
                    return jobToPotentials[PlayerDatas.Instance.baseData.Job];
                }
                else
                {
                    return null;
                }
            }
        }
        public List<int> achievements = new List<int>();
        public Dictionary<int, AchievementGroup> achievementGroups = new Dictionary<int, AchievementGroup>();
        public Redpoint skillLevelUpRedpoint { get; private set; }
        public Redpoint achievementRedpoint { get; private set; }
        public Treasure(int _id, int[] _potentialIds, Redpoint _skillLevelUpRedpoint, Redpoint _achievementPoint)
        {
            this.id = _id;
            this.skillLevelUpRedpoint = _skillLevelUpRedpoint;
            this.achievementRedpoint = _achievementPoint;
            var config = TreasureConfig.Get(this.id);
@@ -133,100 +114,7 @@
            {
                group.Sort();
            }
            for (int i = 0; i < _potentialIds.Length; i++)
            {
                var skillId = _potentialIds[i];
                var skillConfig = SkillConfig.Get(skillId);
                if (skillConfig == null)
                {
                    continue;
                }
                for (int j = 0; j < GeneralDefine.openJobs.Length; j++)
                {
                    var job = GeneralDefine.openJobs[j];
                    List<TreasurePotential> tempPotentials;
                    if (jobToPotentials.ContainsKey(job))
                    {
                        tempPotentials = jobToPotentials[job];
                    }
                    else
                    {
                        jobToPotentials[job] = tempPotentials = new List<TreasurePotential>();
                    }
                    if (skillConfig.UseType == 0 || skillConfig.UseType == 1 << job)
                    {
                        tempPotentials.Add(new TreasurePotential(skillId, 0));
                    }
                }
            }
        }
        public TreasurePotential GetPotential(int _potentialId)
        {
            if (potentials == null)
            {
                return null;
            }
            else
            {
                for (int i = 0; i < potentials.Count; i++)
                {
                    var potential = potentials[i];
                    if (potential.id == _potentialId)
                    {
                        return potential;
                    }
                }
                return null;
            }
        }
        public TreasurePotential GetPotentialByIndex(int index)
        {
            if (potentials == null)
            {
                return null;
            }
            else
            {
                if (index >= 0 && index < potentials.Count)
                {
                    return potentials[index];
                }
                return null;
            }
        }
        public void ResetPotentialLevel()
        {
            var list = potentials;
            if (list != null)
            {
                for (int i = 0; i < list.Count; i++)
                {
                    list[i].level = 0;
                }
            }
        }
        public void UpdatePotentialLevel(int _potentialId, int _level)
        {
            for (int i = 0; i < potentials.Count; i++)
            {
                var potential = potentials[i];
                if (potential.id == _potentialId)
                {
                    potential.level = _level;
                    break;
                }
            }
        }
        public AchievementGroup FindAchievementGroup(int _achievementId)
        {
            foreach (var key in achievementGroups.Keys)
@@ -260,21 +148,6 @@
            stage = level;
            this.exp = exp;
            hasClickChallenge = _hasClickChallenge;
            if ((this is HumanTreasure))
            {
                (this as HumanTreasure).UpdateTreasureState();
            }
        }
        public bool IsHighestStage
        {
            get
            {
                return treasureStages.FindIndex((x) =>
                {
                    return x.stage >= stage + 1;
                }) == -1;
            }
        }
        public int GetStageId(int _stageIndex)
System/Treasure/TreasureMeridianBehaviour.cs
File was deleted
System/Treasure/TreasureMeridianBehaviour.cs.meta
File was deleted
System/Treasure/TreasureModel.cs
@@ -36,18 +36,12 @@
        public event Action<int> treasureCollectProgressUpdateEvent;
        public event Action<int> treasureSelectedEvent;
        public event Action<int> potentialBookSelectEvent;
        public event Action<TreasureCategory> collectingTreasureChangeEvent;
        public event Action<int> treasureStateChangeEvent;
        public event Action<int, int, bool> onPotentialLevelUpResultEvent;
        public event Action<int, int> potentialLevelChangeEvent;
        public event Action<int, int> potentialLevelUpdate;
        public event Action vipKillNPCTreasureEvent;
        public event Action<int> treasureLevelProgressUpdateEvent;
        public event Action<int> treasureStageUpEvent;
        public event Action<int> humanTreasureStateChangeEvent;
        public event Action<int> demonTreasureDungeonUpdate;
        public event Action skillLevelUpRedpointUpdate;
        public event Action demonDungeonChallengeNext;
        int m_SelectedTreasure = 0;
@@ -61,17 +55,6 @@
                    {
                        treasureSelectedEvent(m_SelectedTreasure);
                    }
                }
            }
        }
        int m_SelectedPotential = 0;
        public int selectedPotential {
            get { return m_SelectedPotential; }
            set {
                if (m_SelectedPotential != value)
                {
                    m_SelectedPotential = value;
                }
            }
        }
@@ -116,25 +99,6 @@
            }
        }
        int m_SelectedPotentialBook = 0;
        public int selectedPotentialBook {
            get { return m_SelectedPotentialBook; }
            set {
                if (m_SelectedPotentialBook != value)
                {
                    m_SelectedPotentialBook = value;
                    if (potentialBookSelectEvent != null)
                    {
                        potentialBookSelectEvent(m_SelectedPotentialBook);
                    }
                }
            }
        }
        int levelUpTreasureIdBuf = 0;
        int levelUpPotentialBuf = 0;
        Dictionary<int, List<int>> skillLevelUpTypes = new Dictionary<int, List<int>>();
        Dictionary<int, Treasure> treasures = new Dictionary<int, Treasure>();
        Dictionary<TreasureCategory, List<int>> treasureCategory = new Dictionary<TreasureCategory, List<int>>();
        Dictionary<int, int> treasureMapDict = new Dictionary<int, int>();
@@ -143,9 +107,7 @@
        List<int> m_CacheGotAchievements = new List<int>();
        Dictionary<int, int> treasureStageShowDict = new Dictionary<int, int>();
        List<int> treasureUnOpens = new List<int>();//版本未开放法宝
        Dictionary<int, int[]> potentialInitialPowers = new Dictionary<int, int[]>();
        Dictionary<int, TreasureDungeon> treasureDungeons = new Dictionary<int, TreasureDungeon>();
        List<int> potentialNextTargetLevels = new List<int>();
        public Dictionary<int, int> fairyTreasureGetDict { get; private set; }
@@ -159,40 +121,23 @@
            get { return newGotTreasureId > 0; }
        }
        public int treasureEntranceShowId {
            get { return LocalSave.GetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "_TreasureEntranceShowId")); }
            set { LocalSave.SetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "_TreasureEntranceShowId"), value); }
        }
        public int treasureCollectingShowId {
            get { return LocalSave.GetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "_TreasureCollectingShowId")); }
            set { LocalSave.SetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "_TreasureCollectingShowId"), value); }
        }
        bool potentialFuncOpen { get; set; }
        public int treasureGotoId { get; set; }
        public bool openFromTreasureSoul { get; set; }
        public bool openFromTreasureUnlockShow { get; set; }
        public bool openFromTreasureCollect { get; set; }
        public bool openFromTreasureList { get; set; }
        public int openFromTaskId { get; set; }
        public bool inPotentialModifyPower { get; set; }
        public List<int> castSoulGuideTaskIds { get; private set; }
        public List<int> guideTreasures { get; private set; }
        public int treasureBackLvLimit { get; private set; }
        public float treasureBackPercent { get; private set; }
        public int treasureExitLvLimit { get; private set; }
        public int exitRecord { get; set; }
        public int entranceOpenCondition { get; private set; }
        public List<int> cacheGotAchievements { get { return m_CacheGotAchievements; } }
        AchievementModel achievementModel { get { return ModelCenter.Instance.GetModel<AchievementModel>(); } }
        PlayerPackModel packageModel { get { return ModelCenter.Instance.GetModel<PlayerPackModel>(); } }
        VIPKillNPCTreasure m_VIPKillNPCTreasure;
        public VIPKillNPCTreasure vipKillNPCTreasure {
@@ -211,17 +156,11 @@
        public override void Init()
        {
            ParseConfigs();
            ParseSkillLevelUpConfig();
            ParsePotentialSkillConfig();
            achievementModel.achievementProgressUpdateEvent += OnAchievementProgressUpdate;
            achievementModel.achievementAwardableEvent += OnAchievementAwardable;
            achievementModel.achievementCompletedEvent += OnAchievementCompleted;
            DTC0721_tagMakeItemAnswer.MakeItemAnswerEvent += OnGetSkillLevelUpResult;
            PlayerDatas.Instance.PlayerDataRefreshInfoEvent += OnTreasurePotentialSPChange;
            FuncOpen.Instance.OnFuncStateChangeEvent += OnFunctionStateChange;
            packageModel.RefreshItemCountAct += OnPackageItemChange;
            PlayerDatas.Instance.PlayerDataRefreshInfoEvent += PlayerDataRefreshInfoEvent;
            WindowCenter.Instance.windowAfterOpenEvent += OnWindowOpen;
            WindowCenter.Instance.windowAfterCloseEvent += OnWindowClose;
            NewBieCenter.Instance.guideCompletedEvent += GuideComplete;
@@ -232,14 +171,10 @@
        public override void UnInit()
        {
            achievementModel.achievementProgressUpdateEvent -= OnAchievementProgressUpdate;
            achievementModel.achievementAwardableEvent -= OnAchievementAwardable;
            achievementModel.achievementCompletedEvent -= OnAchievementCompleted;
            NewBieCenter.Instance.guideCompletedEvent -= GuideComplete;
            DTC0721_tagMakeItemAnswer.MakeItemAnswerEvent -= OnGetSkillLevelUpResult;
            PlayerDatas.Instance.PlayerDataRefreshInfoEvent -= OnTreasurePotentialSPChange;
            FuncOpen.Instance.OnFuncStateChangeEvent -= OnFunctionStateChange;
            packageModel.RefreshItemCountAct -= OnPackageItemChange;
            PlayerDatas.Instance.PlayerDataRefreshInfoEvent -= PlayerDataRefreshInfoEvent;
            WindowCenter.Instance.windowAfterOpenEvent -= OnWindowOpen;
            WindowCenter.Instance.windowAfterCloseEvent -= OnWindowClose;
            StageLoad.Instance.onStageLoadFinish -= OnStageLoadFinish;
@@ -252,7 +187,6 @@
            {
                if (playerLevelRefresh)
                {
                    UpdateAchievementRedpoints();
                    playerLevelRefresh = false;
                }
            }
@@ -269,19 +203,12 @@
            serverInited = false;
            playerLevelRefresh = false;
            needDisplayReguluLevelUp = false;
            potentialFuncOpen = false;
            treasureUnlockShowDict.Clear();
            cacheGotAchievements.Clear();
            foreach (var treasure in treasures.Values)
            {
                treasure.state = TreasureState.Locked;
                treasure.UpdateTreasureLevelExp(0, 0, false);
                treasure.ResetPotentialLevel();
                if ((treasure is HumanTreasure))
                {
                    var humanTreasure = treasure as HumanTreasure;
                    humanTreasure.UpdateTreasureState();
                }
            }
            foreach (var treasureDungeon in treasureDungeons.Values)
            {
@@ -292,9 +219,6 @@
        public void OnPlayerLoginOk()
        {
            serverInited = true;
            UpdateAchievementRedpoints();
            UpdateCastSoulRedpoints();
            UpdateSkillLevelUpRedpoints();
            UpdateDemonDungeonRedpoints();
        }
@@ -338,98 +262,6 @@
            return treasureUnlockShowDict[_type];
        }
        public bool GetPotentialUnlockShow(int _treasureId)
        {
            Treasure treasure;
            if (TryGetTreasure(_treasureId, out treasure))
            {
                var potential = treasure.GetPotentialByIndex(1);
                if (potential != null && IsPotentialUnlock(_treasureId, potential.id))
                {
                    SetPotentialUnlockShow(_treasureId);
                    return false;
                }
            }
            var _playerId = PlayerDatas.Instance.baseData.PlayerID;
            return LocalSave.GetBool(StringUtility.Contact(_playerId, "_PotentialUnlockShow_", _treasureId));
        }
        public void SetPotentialUnlockShow(int _treasureId, bool _value = false)
        {
            var _playerId = PlayerDatas.Instance.baseData.PlayerID;
            LocalSave.SetBool(StringUtility.Contact(_playerId, "_PotentialUnlockShow_", _treasureId), _value);
        }
        public bool GetSpAnim(int _treasureId)
        {
            var list = GetTreasureCategory(TreasureCategory.Human);
            var index = list.IndexOf(_treasureId);
            if (index == -1)
            {
                return false;
            }
            Treasure treasure;
            if (TryGetTreasure(_treasureId, out treasure))
            {
                var potential = treasure.GetPotentialByIndex(1);
                if (potential != null && IsPotentialUnlock(_treasureId, potential.id))
                {
                    SetSpAnim(_treasureId);
                    return true;
                }
            }
            uint value = 0;
            uint.TryParse(QuickSetting.Instance.GetQuickSetting(QuickSetting.QuickSettingType.SpAnim, 0), out value);
            return MathUtility.GetBitValue(value, (ushort)index);
        }
        public void SetSpAnim(int _treasureId, bool anim = true)
        {
            var list = GetTreasureCategory(TreasureCategory.Human);
            var index = list.IndexOf(_treasureId);
            if (index == -1)
            {
                return;
            }
            uint value = 0;
            uint.TryParse(QuickSetting.Instance.GetQuickSetting(QuickSetting.QuickSettingType.SpAnim, 0), out value);
            int bitValue = MathUtility.SetBitValue((int)value, (ushort)index, anim);
            QuickSetting.Instance.SetQuickSetting(QuickSetting.QuickSettingType.SpAnim, bitValue);
            QuickSetting.Instance.SendPackage();
        }
        public bool GetTreasureFinishAnim(int _treasureId)
        {
            if (_treasureId == 101)
            {
                return false;
            }
            var list = GetTreasureCategory(TreasureCategory.Human);
            var index = list.IndexOf(_treasureId);
            if (index == -1)
            {
                return false;
            }
            uint value = 0;
            uint.TryParse(QuickSetting.Instance.GetQuickSetting(QuickSetting.QuickSettingType.TreasureHighestAnim, 0), out value);
            return MathUtility.GetBitValue(value, (ushort)index);
        }
        public void SetTreasureFinishAnim(int _treasureId, bool anim = true)
        {
            var list = GetTreasureCategory(TreasureCategory.Human);
            var index = list.IndexOf(_treasureId);
            if (index == -1)
            {
                return;
            }
            uint value = 0;
            uint.TryParse(QuickSetting.Instance.GetQuickSetting(QuickSetting.QuickSettingType.TreasureHighestAnim, 0), out value);
            int bitValue = MathUtility.SetBitValue((int)value, (ushort)index, anim);
            QuickSetting.Instance.SetQuickSetting(QuickSetting.QuickSettingType.TreasureHighestAnim, bitValue);
            QuickSetting.Instance.SendPackage();
        }
        public bool TryGetUnlockShowTreasure(out int _id)
        {
            _id = 0;
@@ -456,19 +288,6 @@
            }
            var _playerId = PlayerDatas.Instance.baseData.PlayerID;
            LocalSave.SetInt(StringUtility.Contact(_playerId, _type, "_TreasureUnlockShow"), _id);
        }
        public void SetTreasureStageShow(int _id, int _stage)
        {
            LocalSave.SetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID,
                "_TreasureStageShow_", _id), _stage);
        }
        public int GetTreasureStageShow(int _id)
        {
            var _stage = LocalSave.GetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID,
                "_TreasureStageShow_", _id), -1);
            return _stage;
        }
        public bool TryGetTreasure(int _id, out Treasure _treasure)
@@ -564,62 +383,29 @@
            return 0;
        }
        /// <summary>
        /// 获得技能的升级类型
        /// </summary>
        /// <param name="_skillId"></param>
        /// <returns></returns>
        public int GetSkillLevelUpType(int _skillId)
        public void UpdateTreasureCollectState(uint[] collecteds)
        {
            foreach (var key in skillLevelUpTypes.Keys)
            for (int i = 0; i < collecteds.Length; i++)
            {
                if (skillLevelUpTypes[key].Contains(_skillId))
                {
                    return key;
                }
            }
            return 0;
        }
        public void RequestPotentialUpgrade(int _treasureId, int _potentialId, int _costIndex)
        {
            levelUpTreasureIdBuf = _treasureId;
            levelUpPotentialBuf = _potentialId;
            var info = new CA50D_tagCMMagicWeaponSkillUp();
            info.SkillTypeID = (ushort)_potentialId;
            info.CostIndex = (byte)_costIndex;
            GameNetSystem.Instance.SendInfo(info);
        }
        public void UpdateTreasureCollectState(uint[] _gotTreasures)
        {
            for (int i = 0; i < _gotTreasures.Length; i++)
            {
                var id = (int)_gotTreasures[i];
                var id = (int)collecteds[i];
                Treasure treasure;
                if (TryGetTreasure(id, out treasure))
                {
                    var config = TreasureConfig.Get(id);
                    if (treasure.state != TreasureState.Collected)
                    {
                        treasure.state = TreasureState.Collected;
                        if (treasure is HumanTreasure)
                        if (config.Category == (int)TreasureCategory.Human)
                        {
                            var humanTreasure = treasure as HumanTreasure;
                            humanTreasure.UpdateTreasureState();
                            UpdateCastSoulRedpoint(treasure.id);
                            if (GetTreasureUnlockShow(TreasureCategory.Human) == treasure.id)
                            {
                                SetTreasureUnlockShow(TreasureCategory.Human, 0);
                            }
                        }
                        if (serverInited)
                        {
                            newGotTreasureId = id;
                            treasureEntranceShowId = id;
                            OpenTreasureNewGot();
                        }
@@ -667,10 +453,6 @@
                                    }
                                    treasure.state = TreasureState.Collecting;
                                    UpdateDemonDungeonRedpoint(treasure.id);
                                    if ((TreasureCategory)config.Category == TreasureCategory.Human)
                                    {
                                        (treasure as HumanTreasure).UpdateTreasureState();
                                    }
                                    if ((TreasureCategory)config.Category == TreasureCategory.Demon)
                                    {
                                        collectingDemon = key;
@@ -694,35 +476,6 @@
            }
            UpdateStoveRedpoint();
            UpdateSkillLevelUpRedpoints();
        }
        public void UpdateTreasurePotentialInfo(int _oldSkillId, int _newSkillId)
        {
            var config = SkillConfig.Get(_newSkillId);
            foreach (var key in treasures.Keys)
            {
                var treasure = treasures[key];
                if (treasure.GetPotential(config.SkillTypeID) != null)
                {
                    treasure.UpdatePotentialLevel(config.SkillTypeID, config.SkillLV);
                    if (treasure is HumanTreasure)
                    {
                        (treasure as HumanTreasure).UpdateTreasureState();
                    }
                    if (potentialLevelUpdate != null)
                    {
                        potentialLevelUpdate(config.SkillTypeID, config.SkillLV);
                    }
                    if (potentialLevelChangeEvent != null)
                    {
                        potentialLevelChangeEvent(key, config.SkillTypeID);
                    }
                    UpdateSkillLevelUpRedpoints();
                    break;
                }
            }
        }
        private void OnAchievementProgressUpdate(int _achievement)
@@ -800,30 +553,10 @@
            }
        }
        private void OnGetSkillLevelUpResult(H0721_tagMakeItemAnswer _result)
        {
            switch ((MakeType)_result.MakeType)
            {
                case MakeType.Def_treasureSkillEquip:
                    if (onPotentialLevelUpResultEvent != null)
                    {
                        onPotentialLevelUpResultEvent(levelUpTreasureIdBuf, levelUpPotentialBuf, _result.Result == 1);
                    }
                    levelUpTreasureIdBuf = 0;
                    levelUpPotentialBuf = 0;
                    break;
            }
        }
        private void OnTreasurePotentialSPChange(PlayerDataRefresh refreshType)
        private void PlayerDataRefreshInfoEvent(PlayerDataRefresh refreshType)
        {
            switch (refreshType)
            {
                case PlayerDataRefresh.ExAttr7:
                case PlayerDataRefresh.ExAttr8:
                    UpdateSkillLevelUpRedpoints();
                    break;
                case PlayerDataRefresh.LV:
                    playerLevelRefresh = true;
                    break;
@@ -831,141 +564,6 @@
                case PlayerDataRefresh.FightPower:
                    UpdateDemonDungeonRedpoints();
                    break;
            }
        }
        private void OnPackageItemChange(PackType _type, int _index, int _itemId)
        {
            if (_type == PackType.rptItem)
            {
                var config = ItemConfig.Get(_itemId);
                if (config.Type == 6)
                {
                    UpdateSkillLevelUpRedpoints();
                }
            }
        }
        private void OnFunctionStateChange(int _functionId)
        {
            if (_functionId == 82)
            {
                UpdateSkillLevelUpRedpoints();
                bool requireCheckUnlockShow = false;
                if (!potentialFuncOpen && FuncOpen.Instance.IsFuncOpen(82))
                {
                    requireCheckUnlockShow = true;
                }
                potentialFuncOpen = FuncOpen.Instance.IsFuncOpen(82);
                var list = treasureCategory[TreasureCategory.Human];
                for (int i = 0; i < list.Count; i++)
                {
                    Treasure treasure;
                    TryGetTreasure(list[i], out treasure);
                    var humanTreasure = treasure as HumanTreasure;
                    humanTreasure.UpdateTreasureState();
                    if (!serverInited || !treasure.IsHighestStage || !requireCheckUnlockShow)
                    {
                        continue;
                    }
                    if (IsPotentialUnlock(list[i], treasure.potentials[0].id))
                    {
                        SetPotentialUnlockShow(list[i], true);
                    }
                }
            }
        }
        private void UpdateSkillLevelUpRedpoints()
        {
            var list = GetTreasureCategory(TreasureCategory.Human);
            for (int i = 0; i < list.Count; i++)
            {
                var id = list[i];
                if (treasures[id].skillLevelUpRedpoint != null)
                {
                    treasures[id].skillLevelUpRedpoint.state = RedPointState.None;
                }
            }
            var functionOpen = FuncOpen.Instance.IsFuncOpen(82);
            if (functionOpen)
            {
                for (int k = 0; k < 3; k++)
                {
                    for (int i = 0; i < list.Count; i++)
                    {
                        var treasure = treasures[list[i]];
                        if (k < treasure.potentials.Count)
                        {
                            var potential = treasure.potentials[k];
                            Item item;
                            if (SatisfyLevelUpUnlock(list[i], k)
                                && SatisyPotentialLevelUp(list[i], potential.id, out item))
                            {
                                treasure.skillLevelUpRedpoint.state = RedPointState.Simple;
                                treasure.autoSelectPotential = k;
                                if (skillLevelUpRedpointUpdate != null)
                                {
                                    skillLevelUpRedpointUpdate();
                                }
                                return;
                            }
                        }
                    }
                }
                int minCostTreasure = 0;
                int minCostPotentialIndex = 0;
                int minCostItemColor = 0;
                int minCostItemCount = 0;
                bool step = false;
                for (int i = 0; i < list.Count; i++)
                {
                    var treasure = treasures[list[i]];
                    if (treasure.state != TreasureState.Collected || !treasure.IsHighestStage)
                    {
                        continue;
                    }
                    for (int k = 0; k < treasure.potentials.Count; k++)
                    {
                        Item item;
                        if (SatisyPotentialLevelUp(treasure.id, treasure.potentials[k].id, out item))
                        {
                            if (item.id != 0)
                            {
                                var itemConfig = ItemConfig.Get(item.id);
                                var itemColor = itemConfig.ItemColor;
                                if (minCostItemColor == 0 || itemColor < minCostItemColor ||
                                    (itemColor == minCostItemColor && item.count < minCostItemCount))
                                {
                                    minCostItemColor = itemColor;
                                    minCostItemCount = item.count;
                                    minCostTreasure = treasure.id;
                                    minCostPotentialIndex = k;
                                }
                            }
                            else
                            {
                                minCostTreasure = treasure.id;
                                minCostPotentialIndex = k;
                                step = true;
                                break;
                            }
                        }
                    }
                    if (step)
                    {
                        break;
                    }
                }
                if (minCostTreasure != 0)
                {
                    treasures[minCostTreasure].skillLevelUpRedpoint.state = RedPointState.Simple;
                    treasures[minCostTreasure].autoSelectPotential = minCostPotentialIndex;
                }
            }
            if (skillLevelUpRedpointUpdate != null)
            {
                skillLevelUpRedpointUpdate();
            }
        }
@@ -1000,37 +598,6 @@
            }
        }
        public int GetSkillLevelUpRedpointTreasure()
        {
            var list = GetTreasureCategory(TreasureCategory.Human);
            for (int i = 0; i < list.Count; i++)
            {
                var treasure = treasures[list[i]];
                if (treasure.skillLevelUpRedpoint != null &&
                    treasure.skillLevelUpRedpoint.state == RedPointState.Simple)
                {
                    return list[i];
                }
            }
            return 0;
        }
        private void UpdateAchievementRedpoints()
        {
            foreach (var id in treasures.Keys)
            {
                UpdateAchievementRedpoint(id);
            }
        }
        private void UpdateCastSoulRedpoints()
        {
            foreach (var id in treasures.Keys)
            {
                UpdateCastSoulRedpoint(id);
            }
        }
        private void UpdateStoveRedpoint()
        {
            Treasure treasure;
@@ -1039,28 +606,6 @@
                stoveRedpoint.state = RedPointState.None;
                return;
            }
        }
        public bool TreasureStageUpLimit(int _treasureId, bool _tip = true)
        {
            if (PlayerDatas.Instance.baseData.LV >= treasureExitLvLimit)
            {
                return false;
            }
            Treasure _treasure;
            if (TryGetTreasure(_treasureId, out _treasure))
            {
                var human = _treasure as HumanTreasure;
                if (human != null && human.castSoulRedpoint.state == RedPointState.Simple)
                {
                    if (_tip)
                    {
                        SysNotifyMgr.Instance.ShowTip("FabaoAwaken");
                    }
                    return true;
                }
            }
            return false;
        }
        private void OnWindowOpen(Window _window)
@@ -1124,136 +669,10 @@
            WindowCenter.Instance.Open<TreasureNewGotWin>();
        }
        public bool SatisfyLevelUpUnlock(int treasureId, int index)
        {
            if (treasures.ContainsKey(treasureId))
            {
                var treasure = treasures[treasureId];
                if (treasure.state == TreasureState.Collected && treasure.IsHighestStage)
                {
                    if (index >= 0 && index < treasure.potentials.Count - 1)
                    {
                        var potential = treasure.potentials[index];
                        var nextPotential = treasure.potentials[index + 1];
                        var skillConfig = SkillConfig.Get(nextPotential.id);
                        if (skillConfig.LearnSkillReq > 0)
                        {
                            if (potential.level < skillConfig.LearnSkillLV)
                            {
                                return true;
                            }
                        }
                    }
                    else if (index == treasure.potentials.Count - 1)
                    {
                        var potential = treasure.GetPotentialByIndex(index);
                        var config = SkillConfig.Get(potential.id);
                        int[] _getSkillArray;
                        if (TryGetPotentialGetSkill(config.SkillTypeID, out _getSkillArray))
                        {
                            if (potential.level < _getSkillArray[0])
                            {
                                return true;
                            }
                        }
                    }
                }
            }
            return false;
        }
        public bool SatisyPotentialLevelUp(int treasureId, int potentialId, out Item item)
        {
            item = default(Item);
            var treasure = treasures[treasureId];
            var potential = treasure.GetPotential(potentialId);
            if (potential == null)
            {
                return false;
            }
            var config = SkillConfig.Get(potential.id);
            if (potential.level >= config.SkillMaxLV)
            {
                return false;
            }
            if (config.LearnSkillReq > 0)
            {
                var preSkillLevelRequirement = config.LearnSkillLV;
                var preSkill = PlayerDatas.Instance.skill.GetSkillBySkillTypeID(config.LearnSkillReq);
                var preSkillLevel = preSkill == null ? 0 : preSkill.level;
                if (preSkillLevel < preSkillLevelRequirement)
                {
                    return false;
                }
            }
            if (PlayerDatas.Instance.baseData.LV < config.LearnLVReq)
            {
                return false;
            }
            var levelUpType = GetSkillLevelUpType(potential.id);
            var levelupId = GetSkillLevelUpId(levelUpType, potential.level + 1);
            var treasureSkillConfig = TreasureSkillConfig.Get(levelupId);
            var spOwn = PlayerDatas.Instance.baseData.treasurePotentialSp;
            var spNeed = treasureSkillConfig.MeterialNum1;
            if (spOwn < spNeed)
            {
                return false;
            }
            if (treasureSkillConfig.InitialRate >= 8000)
            {
                return true;
            }
            else
            {
                for (int j = 0; j < treasureSkillConfig.MeterialNum2.Length; j++)
                {
                    var rate = treasureSkillConfig.Rate[j];
                    if (rate >= 6000)
                    {
                        var itemId = treasureSkillConfig.Meterial2ID[j];
                        var own = packageModel.GetItemCountByID(PackType.rptItem, itemId);
                        if (own >= treasureSkillConfig.MeterialNum2[j])
                        {
                            item = new Item()
                            {
                                id = itemId,
                                count = treasureSkillConfig.MeterialNum2[j],
                            };
                            return true;
                        }
                    }
                }
            }
            return false;
        }
        private void OnAchievementAwardable(int _achievementId)
        {
            foreach (var treasure in treasures.Values)
            {
                if (treasure.achievements.Contains(_achievementId))
                {
                    UpdateAchievementRedpoint(treasure.id);
                }
            }
        }
        private void OnAchievementCompleted(int _achievementId)
        {
            foreach (var treasure in treasures.Values)
            {
                if (treasure.achievements.Contains(_achievementId))
                {
                    UpdateAchievementRedpoint(treasure.id);
                }
                var config = TreasureConfig.Get(treasure.id);
                if (treasure.achievements.Contains(_achievementId))
                {
@@ -1277,7 +696,6 @@
                                    if (_pretreasure == null || _pretreasure.state == TreasureState.Collected)
                                    {
                                        treasure.state = TreasureState.Collecting;
                                        (treasure as HumanTreasure).UpdateTreasureState();
                                        collectingHuman = treasure.id;
                                        if (serverInited)
                                        {
@@ -1317,76 +735,6 @@
            }
        }
        private void UpdateAchievementRedpoint(int _treasureId)
        {
            if (!treasures.ContainsKey(_treasureId))
            {
                return;
            }
            var treasure = treasures[_treasureId];
            var config = TreasureConfig.Get(_treasureId);
            treasure.achievementRedpoint.state = RedPointState.None;
            if ((TreasureCategory)config.Category == TreasureCategory.Human && treasure.state != TreasureState.Collected)
            {
                return;
            }
            if ((TreasureCategory)config.Category == TreasureCategory.Demon && !FuncOpen.Instance.IsFuncOpen(107))
            {
                return;
            }
            if((TreasureCategory)config.Category == TreasureCategory.Human && treasure.IsHighestStage)
            {
                return;
            }
            foreach (var achievementGroup in treasure.achievementGroups.Values)
            {
                if (achievementGroup.IsAwardable())
                {
                    treasure.achievementRedpoint.state = RedPointState.Simple;
                    break;
                }
                treasure.achievementRedpoint.state = RedPointState.None;
            }
        }
        private void UpdateCastSoulRedpoint(int _treasureId)
        {
            if (!treasures.ContainsKey(_treasureId))
            {
                return;
            }
            var treasure = treasures[_treasureId] as HumanTreasure;
            if (treasure == null)
            {
                return;
            }
            treasure.castSoulRedpoint.state = RedPointState.None;
            if (treasure.state != TreasureState.Collected ||
                treasure.humanState != HumanTreasureState.CastSoul)
            {
                return;
            }
            var _nextStage = treasure.treasureStages.Find((x) =>
            {
                return x.stage == treasure.stage + 1;
            });
            if (_nextStage != null)
            {
                if (treasure.exp >= _nextStage.exp)
                {
                    treasure.castSoulRedpoint.state = RedPointState.Simple;
                }
            }
        }
        public void UpdateTreasureLevelInfo(HA352_tagMCMagicWeaponLVInfo package)
        {
            for (int i = 0; i < package.Count; i++)
@@ -1400,16 +748,10 @@
                        _up = true;
                    }
                    treasure.UpdateTreasureLevelExp(package.InfoList[i].LV, (int)package.InfoList[i].Exp, package.InfoList[i].State == 1);
                    if (serverInited && treasure.IsHighestStage)
                    {
                        SetTreasureFinishAnim(treasure.id);
                    }
                    if (treasureLevelProgressUpdateEvent != null)
                    {
                        treasureLevelProgressUpdateEvent(treasure.id);
                    }
                    UpdateCastSoulRedpoint(treasure.id);
                    UpdateAchievementRedpoint(treasure.id);
                    if (serverInited && _up && treasureStageUpEvent != null)
                    {
                        treasureStageUpEvent(treasure.id);
@@ -1425,15 +767,6 @@
                        demonTreasureDungeonUpdate(treasureDungeon.treasureId);
                    }
                }
            }
            UpdateSkillLevelUpRedpoints();
        }
        public void HumanTreasureStateChange(int _id)
        {
            if (humanTreasureStateChangeEvent != null)
            {
                humanTreasureStateChangeEvent(_id);
            }
        }
@@ -1469,9 +802,7 @@
                Treasure treasure;
                if (category == TreasureCategory.Human)
                {
                    var caseSoulRedpoint = new Redpoint(CATEGORY_REDPOINTIDS[config.Category - 1], TREASURE_REDPOINTBASE + redpointIndex++);
                    treasure = new HumanTreasure(config.ID, config.Potentials, skillLevelUpRedpoint, achievementRedpoint, caseSoulRedpoint);
                    potentialInitialPowers.Add(config.ID, config.SkillPower);
                    treasure = new Treasure(config.ID, config.Potentials, skillLevelUpRedpoint, achievementRedpoint);
                }
                else
                {
@@ -1499,10 +830,6 @@
                        treasureAchievementDict.Add(config.ID, config.Achievements[i]);
                        break;
                    }
                    //else if (config.Category == (int)TreasureCategory.Fairy && config.ID == 301)
                    //{
                    //    eightFurnacesAchievements.Add(config.Achievements[i]);
                    //}
                }
                if (treasure.state == TreasureState.Locked && config.PreTreasure == 0)
@@ -1546,8 +873,6 @@
            }
            var funcConfig = FuncConfigConfig.Get("GuideMission");
            castSoulGuideTaskIds = new List<int>();
            castSoulGuideTaskIds.AddRange(ConfigParse.GetMultipleStr<int>(funcConfig.Numerical1));
            guideTreasures = new List<int>();
            guideTreasures.AddRange(ConfigParse.GetMultipleStr<int>(funcConfig.Numerical2));
@@ -1556,9 +881,6 @@
            funcConfig = FuncConfigConfig.Get("TreasureSkip");
            treasureBackLvLimit = int.Parse(funcConfig.Numerical1);
            treasureBackPercent = float.Parse(funcConfig.Numerical2);
            funcConfig = FuncConfigConfig.Get("TreasureExitLimit");
            treasureExitLvLimit = int.Parse(funcConfig.Numerical1);
            funcConfig = FuncConfigConfig.Get("TreasureNoOpen");
            treasureUnOpens.AddRange(ConfigParse.GetMultipleStr<int>(funcConfig.Numerical1));
@@ -1581,44 +903,6 @@
                }
                treasureDungeon.ParseDungeonInfo(config);
            }
            funcConfig = FuncConfigConfig.Get("TreasureSpTarget");
            potentialNextTargetLevels.AddRange(ConfigParse.GetMultipleStr<int>(funcConfig.Numerical1));
        }
        const string pattern = "\\\"[0-9]+\\\":\\[[0-9|,]*\\]";
        private void ParseSkillLevelUpConfig()
        {
            try
            {
                var config = FuncConfigConfig.Get("SPSkillType");
                var matches = Regex.Matches(config.Numerical1, pattern);
                for (int i = 0; i < matches.Count; i++)
                {
                    var match = matches[i].Value;
                    var stringArray = match.Split(':');
                    var key = 0;
                    int.TryParse(Regex.Match(stringArray[0], "[0-9]+").Value, out key);
                    var skillList = skillLevelUpTypes[key] = new List<int>();
                    var skillMatches = Regex.Matches(stringArray[1], "[0-9]{2,}");
                    for (int j = 0; j < skillMatches.Count; j++)
                    {
                        skillList.Add(int.Parse(skillMatches[j].Value));
                    }
                }
            }
            catch (Exception ex)
            {
                DebugEx.Log(ex);
            }
        }
        public static int GetSkillLevelUpId(int _type, int _level)
        {
            return _type * 100 + _level;
        }
        public int GetMapIdByTreasure(int _treasureId)
@@ -1676,62 +960,6 @@
            return 0;
        }
        Dictionary<int, int[]> m_TreasurePotentialGetSkills = new Dictionary<int, int[]>();
        private void ParsePotentialSkillConfig()
        {
            var _cfg = FuncConfigConfig.Get("PotentialSkillLearn");
            var _jsonData = LitJson.JsonMapper.ToObject(_cfg.Numerical1);
            foreach (var _key in _jsonData.Keys)
            {
                var _typeId = int.Parse(_key);
                m_TreasurePotentialGetSkills.Add(_typeId, LitJson.JsonMapper.ToObject<int[]>(_jsonData[_key].ToJson()));
            }
        }
        public bool TryGetPotentialGetSkill(int _skillTypeId, out int[] _array)
        {
            return m_TreasurePotentialGetSkills.TryGetValue(_skillTypeId, out _array);
        }
        public bool IsPotentialUnlock(int treasureId, int potentialId)
        {
            if (!FuncOpen.Instance.IsFuncOpen(82))
            {
                return false;
            }
            Treasure treasure;
            if (TryGetTreasure(treasureId, out treasure))
            {
                var potential = treasure.GetPotential(potentialId);
                if (potential != null)
                {
                    var skillConfig = SkillConfig.Get(potential.id);
                    if (skillConfig.LearnSkillReq > 0)
                    {
                        var prepotential = treasure.GetPotential(skillConfig.LearnSkillReq);
                        if (prepotential != null && prepotential.level < skillConfig.LearnSkillLV)
                        {
                            return false;
                        }
                    }
                }
            }
            return true;
        }
        public int GetPotentialInitialPower(int treasureId, int index)
        {
            if (potentialInitialPowers.ContainsKey(treasureId))
            {
                var powerArray = potentialInitialPowers[treasureId];
                if (powerArray != null && index < powerArray.Length && index >= 0)
                {
                    return powerArray[index];
                }
            }
            return 0;
        }
        public bool SatisfyEntranceOpen()
        {
            var list = GetTreasureCategory(TreasureCategory.Human);
@@ -1772,23 +1000,6 @@
            {
                SysNotifyMgr.Instance.ShowTip("OpenFabaoHint", taskConfig.lv);
            }
        }
        public int GetPotentialNextTargetLevel(int level)
        {
            var list = potentialNextTargetLevels;
            for (int i = 0; i < list.Count; i++)
            {
                if (level < list[i])
                {
                    if (level < list[i] - 1)
                    {
                        return list[i];
                    }
                    break;
                }
            }
            return 0;
        }
        public void DemonDungeonChallengeNext(int lineId)
System/Treasure/TreasurePotentialBriefInfo.cs
File was deleted
System/Treasure/TreasurePotentialBriefInfo.cs.meta
File was deleted
System/Treasure/TreasurePotentialLines.cs
File was deleted
System/Treasure/TreasurePotentialLines.cs.meta
File was deleted
System/Treasure/TreasurePotentialPanel.cs
File was deleted
System/Treasure/TreasurePotentialPanel.cs.meta
File was deleted
System/Treasure/TreasureSelectWin.cs
@@ -45,8 +45,7 @@
            m_HumanBtn.onClick.AddListener(() =>
            {
                if (UI3DTreasureSelectStage.Instance.currentCategory == TreasureCategory.Human
                || UI3DTreasureSelectStage.Instance.UnlockShowing || UI3DTreasureSelectStage.Instance.IsCloser
                || UI3DTreasureSelectStage.Instance.treasureFinishShowing)
                || UI3DTreasureSelectStage.Instance.UnlockShowing || UI3DTreasureSelectStage.Instance.IsCloser)
                {
                    return;
                }
@@ -57,8 +56,7 @@
            m_DemonBtn.onClick.AddListener(() =>
            {
                if (UI3DTreasureSelectStage.Instance.currentCategory == TreasureCategory.Demon
                || UI3DTreasureSelectStage.Instance.UnlockShowing || UI3DTreasureSelectStage.Instance.IsCloser
                || UI3DTreasureSelectStage.Instance.treasureFinishShowing)
                || UI3DTreasureSelectStage.Instance.UnlockShowing || UI3DTreasureSelectStage.Instance.IsCloser)
                {
                    return;
                }
@@ -69,8 +67,7 @@
            m_FairyBtn.onClick.AddListener(() =>
            {
                if (UI3DTreasureSelectStage.Instance.currentCategory == TreasureCategory.Fairy
                || UI3DTreasureSelectStage.Instance.UnlockShowing || UI3DTreasureSelectStage.Instance.IsCloser
                || UI3DTreasureSelectStage.Instance.treasureFinishShowing)
                || UI3DTreasureSelectStage.Instance.UnlockShowing || UI3DTreasureSelectStage.Instance.IsCloser)
                {
                    return;
                }
@@ -79,8 +76,7 @@
            m_KingBtn.onClick.AddListener(() =>
            {
                if (UI3DTreasureSelectStage.Instance.currentCategory == TreasureCategory.King
                || UI3DTreasureSelectStage.Instance.UnlockShowing || UI3DTreasureSelectStage.Instance.IsCloser
                || UI3DTreasureSelectStage.Instance.treasureFinishShowing)
                || UI3DTreasureSelectStage.Instance.UnlockShowing || UI3DTreasureSelectStage.Instance.IsCloser)
                {
                    return;
                }
@@ -88,7 +84,7 @@
            });
            m_BackBtn.onClick.AddListener(() =>
            {
                if (UI3DTreasureSelectStage.Instance.UnlockShowing || UI3DTreasureSelectStage.Instance.treasureFinishShowing)
                if (UI3DTreasureSelectStage.Instance.UnlockShowing)
                {
                    return;
                }
@@ -116,7 +112,6 @@
        protected override void OnPreOpen()
        {
            UI3DTreasureSelectStage.Instance.UnlockShowing = false;
            UI3DTreasureSelectStage.Instance.treasureFinishShowing = false;
            if (!UI3DTreasureSelectStage.Instance.IsOpen)
            {
                UI3DTreasureSelectStage.Instance.Open(false, model.currentCategory);
@@ -124,7 +119,6 @@
            UI3DTreasureSelectStage.Instance.OnCameraStartEvent += OnCameraStartEvent;
            UI3DTreasureSelectStage.Instance.OnCameraBackComplete += OnCameraBackComplete;
            UI3DTreasureSelectStage.Instance.OnUnlockComplete += OnUnlockComplete;
            UI3DTreasureSelectStage.Instance.OnHighestComplete += OnHighestComplete;
            UI3DTreasureSelectStage.Instance.startAnimation += StartAnimation;
            m_TreasureDrag.OnValueChange += OnValueChange;
            m_TreasureDrag.OnDragComplete += OnDragComplete;
@@ -153,7 +147,6 @@
            UI3DTreasureSelectStage.Instance.OnCameraStartEvent -= OnCameraStartEvent;
            UI3DTreasureSelectStage.Instance.OnCameraBackComplete -= OnCameraBackComplete;
            UI3DTreasureSelectStage.Instance.OnUnlockComplete -= OnUnlockComplete;
            UI3DTreasureSelectStage.Instance.OnHighestComplete -= OnHighestComplete;
            UI3DTreasureSelectStage.Instance.startAnimation -= StartAnimation;
            m_TreasureDrag.OnValueChange -= OnValueChange;
            m_TreasureDrag.OnDragComplete -= OnDragComplete;
@@ -227,9 +220,8 @@
        private void UpdateButtonState()
        {
            var _closer = UI3DTreasureSelectStage.Instance.IsCloser 
                || UI3DTreasureSelectStage.Instance.UnlockShowing|| UI3DTreasureSelectStage.Instance.treasureFinishShowing;
            if (UI3DTreasureSelectStage.Instance.UnlockShowing
                || UI3DTreasureSelectStage.Instance.treasureFinishShowing)
                || UI3DTreasureSelectStage.Instance.UnlockShowing;
            if (UI3DTreasureSelectStage.Instance.UnlockShowing)
            {
                m_BackBtn.gameObject.SetActive(false);
            }
@@ -270,8 +262,7 @@
        private void ReclickSelect(TreasureCategory category)
        {
            if (UI3DTreasureSelectStage.Instance.jumping
                || UI3DTreasureSelectStage.Instance.UnlockShowing || UI3DTreasureSelectStage.Instance.IsCloser
                || UI3DTreasureSelectStage.Instance.treasureFinishShowing)
                || UI3DTreasureSelectStage.Instance.UnlockShowing || UI3DTreasureSelectStage.Instance.IsCloser)
            {
                return;
            }
@@ -279,34 +270,6 @@
            var gotoId = 0;
            switch (category)
            {
                case TreasureCategory.Human:
                    for (int i = 0; i < list.Count; i++)
                    {
                        Treasure treasure;
                        if (model.TryGetTreasure(list[i], out treasure))
                        {
                            var humanTreasure = treasure as HumanTreasure;
                            if (treasure.achievementRedpoint.state == RedPointState.Simple
                                || treasure.skillLevelUpRedpoint.state == RedPointState.Simple
                                || humanTreasure.castSoulRedpoint.state == RedPointState.Simple
                                || humanTreasure.humanState == HumanTreasureState.Challenge)
                            {
                                if (list[i] > UI3DTreasureSelectStage.Instance.selectTreasure)
                                {
                                    if (rightSelect || gotoId == 0)
                                    {
                                        gotoId = list[i];
                                        break;
                                    }
                                }
                                else if (list[i] < UI3DTreasureSelectStage.Instance.selectTreasure)
                                {
                                    gotoId = list[i];
                                }
                            }
                        }
                    }
                    break;
                case TreasureCategory.Demon:
                    for (int i = 0; i < list.Count; i++)
                    {
System/Treasure/UI3DTreasureSelectStage.cs
@@ -159,7 +159,6 @@
        public bool CloserComplete { get; private set; }
        public int jumpTreasure { get; private set; }
        public bool UnlockShowing { get; set; }
        public bool treasureFinishShowing { get; set; }
        public bool Preloading { get; private set; }
        public GameObject currentTreasureTitle
@@ -218,7 +217,6 @@
        public event Action OnCameraCloserComplete;
        public event Action OnCameraBackEvent;
        public event Action OnUnlockComplete;
        public event Action OnHighestComplete;
        public event Action startAnimation;
        Dictionary<TreasureCategory, List<TreasureComponent>> m_Treasures = new Dictionary<TreasureCategory, List<TreasureComponent>>();
@@ -340,7 +338,6 @@
            IsCloser = false;
            CloserComplete = false;
            UnlockShowing = false;
            treasureFinishShowing = false;
            IsOpen = false;
            jumping = false;
            Preloading = false;
@@ -398,7 +395,6 @@
            });
            if (_component != null && _component.display)
            {
                _component.UpdateTreasureStage();
                _component.SetLayer(CloserComplete ? LayerUtility.DefaultLayer : LayerUtility.UILayer);
            }
        }
@@ -409,7 +405,6 @@
            presentSelectIndex = 0;
            UnlockShowing = false;
            treasureFinishShowing = false;
            currentCategory = _type;
            model.currentCategory = currentCategory;
@@ -486,11 +481,7 @@
        {
            var _treasure = 0;
            int _index = -1;
            if (CheckTreasureFinish(out _treasure))
            {
                treasureFinishShowing = true;
            }
            else if (model.GetTreasureUnlockShow(currentCategory) != 0)
            if (model.GetTreasureUnlockShow(currentCategory) != 0)
            {
                _treasure = model.GetTreasureUnlockShow(currentCategory);
                model.treasureGotoId = _treasure;
@@ -519,31 +510,6 @@
            return _index;
        }
        private bool CheckTreasureFinish(out int treasureId)
        {
            treasureId = 0;
            if (currentCategory != TreasureCategory.Human)
            {
                return false;
            }
            var list = model.GetTreasureCategory(TreasureCategory.Human);
            for (int i = 0; i < list.Count; i++)
            {
                if (list[i] == 101)
                {
                    continue;
                }
                Treasure treasure;
                if (model.TryGetTreasure(list[i], out treasure)
                    && treasure.IsHighestStage && model.GetTreasureFinishAnim(list[i]))
                {
                    treasureId = list[i];
                    return true;
                }
            }
            return false;
        }
        int Compare(int x, int y)
        {
            Treasure treasure_x;
@@ -557,29 +523,6 @@
            if (collect_x != collect_y)
            {
                return -collect_x.CompareTo(collect_y);
            }
            if ((treasure_x is HumanTreasure) && (treasure_y is HumanTreasure))
            {
                var humanTreasure_x = treasure_x as HumanTreasure;
                var humanTreasure_y = treasure_y as HumanTreasure;
                bool castSoul_x = humanTreasure_x.castSoulRedpoint.state == RedPointState.Simple;
                bool castSoul_y = humanTreasure_y.castSoulRedpoint.state == RedPointState.Simple;
                if (castSoul_x != castSoul_y)
                {
                    return -castSoul_x.CompareTo(castSoul_y);
                }
                bool achieve_x = humanTreasure_x.achievementRedpoint.state == RedPointState.Simple;
                bool achieve_y = humanTreasure_y.achievementRedpoint.state == RedPointState.Simple;
                if (achieve_x != achieve_y)
                {
                    return -achieve_x.CompareTo(achieve_y);
                }
                bool skillUp_x = humanTreasure_x.skillLevelUpRedpoint.state == RedPointState.Simple;
                bool skillUp_y = humanTreasure_y.skillLevelUpRedpoint.state == RedPointState.Simple;
                if (skillUp_x != skillUp_y)
                {
                    return -skillUp_x.CompareTo(skillUp_y);
                }
            }
            TreasureDungeon treasureDungeonx;
@@ -685,8 +628,7 @@
        public bool AllowPointClick()
        {
            if (IsCloser || UnlockShowing || jumping
                || draging || BossShowModel.Instance.BossShowing
                || treasureFinishShowing)
                || draging || BossShowModel.Instance.BossShowing)
            {
                return false;
            }
@@ -737,11 +679,6 @@
                var _component = m_Treasures[currentCategory][presentSelectIndex];
                _component.PlayUnlockShow();
            }
            else if (treasureFinishShowing)
            {
                var _component = m_Treasures[currentCategory][presentSelectIndex];
                _component.PlayHighestShow();
            }
            else
            {
                TreasureDungeon treasureDungeon;
@@ -772,7 +709,7 @@
        public void BegineDrag()
        {
            if (IsCloser || UnlockShowing || treasureFinishShowing)
            if (IsCloser || UnlockShowing)
            {
                return;
            }
@@ -1057,11 +994,11 @@
        private void CameraBackComplete()
        {
            IsCloser = false;
            if (OnCameraBackComplete != null)
            {
                OnCameraBackComplete();
            }
            IsCloser = false;
            if (!IsOpen)
            {
                return;
@@ -1130,7 +1067,6 @@
        }
        #endregion
        #region 解锁动画播放完成
        public void CompleteUnlock()
        {
            if (OnUnlockComplete != null)
@@ -1138,21 +1074,15 @@
                OnUnlockComplete();
            }
        }
        #endregion
        public void ReCheckTreasureHighest()
        {
            treasureFinishShowing = false;
            if (!IsOpen)
            {
                return;
            }
            var treasureId = 0;
            if (CheckTreasureFinish(out treasureId))
            {
                treasureFinishShowing = true;
            }
            else if (model.GetTreasureUnlockShow(currentCategory) != 0)
            if (model.GetTreasureUnlockShow(currentCategory) != 0)
            {
                UnlockShowing = true;
                treasureId = model.GetTreasureUnlockShow(currentCategory);
@@ -1171,10 +1101,6 @@
                    {
                        _component.PlayUnlockShow();
                    }
                    else if (treasureFinishShowing)
                    {
                        _component.PlayHighestShow();
                    }
                }
                else
                {
@@ -1183,13 +1109,6 @@
                if (startAnimation != null)
                {
                    startAnimation();
                }
            }
            else
            {
                if (OnHighestComplete != null)
                {
                    OnHighestComplete();
                }
            }
        }