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

client_Hale

2019-05-25 9816d2f68da3f97a17de918e35243ef500db63d8

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

 Core/NetworkPackage/DTCFile/ServerPack/HAD_SaleActivity.meta

New file
@@ -0,0 +1,9 @@
fileFormatVersion: 2
guid: 3e05761d690b75440a6be79207d0fb01
folderAsset: yes
timeCreated: 1547643019
licenseType: Pro
DefaultImporter:
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Core/NetworkPackage/DTCFile/ServerPack/HAE_Truck.meta

New file
@@ -0,0 +1,9 @@
fileFormatVersion: 2
guid: 1d70ccd06161e0443b7a802ad94292f8
folderAsset: yes
timeCreated: 1547643019
licenseType: Pro
DefaultImporter:
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Core/NetworkPackage/DTCFile/ServerPack/HAF_Merge.meta

New file
@@ -0,0 +1,9 @@
fileFormatVersion: 2
guid: 71e878ac60c49ad4f964dd2dbc725739
folderAsset: yes
timeCreated: 1547643019
licenseType: Pro
DefaultImporter:
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Core/NetworkPackage/DTCFile/ServerPack/HB0_Event.meta

New file
@@ -0,0 +1,9 @@
fileFormatVersion: 2
guid: eed34091b0568664b9fb42f0634496c1
folderAsset: yes
timeCreated: 1547643019
licenseType: Pro
DefaultImporter:
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Core/NetworkPackage/ServerPack/HAD_SaleActivity.meta

New file
@@ -0,0 +1,9 @@
fileFormatVersion: 2
guid: 32ceb8b7faf99f84a8b73ce53c5e3e4d
folderAsset: yes
timeCreated: 1547643019
licenseType: Pro
DefaultImporter:
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Core/NetworkPackage/ServerPack/HAE_Truck.meta

New file
@@ -0,0 +1,9 @@
fileFormatVersion: 2
guid: 77f69c2b862d1704299a32d0d8eeb71e
folderAsset: yes
timeCreated: 1547643019
licenseType: Pro
DefaultImporter:
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Core/NetworkPackage/ServerPack/HAF_Merge.meta

New file
@@ -0,0 +1,9 @@
fileFormatVersion: 2
guid: fa14960fa44b0d1439bab471a764e34f
folderAsset: yes
timeCreated: 1547643019
licenseType: Pro
DefaultImporter:
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Core/NetworkPackage/ServerPack/HB0_Event.meta

New file
@@ -0,0 +1,9 @@
fileFormatVersion: 2
guid: d914565b65f8e8145988734c4d915834
folderAsset: yes
timeCreated: 1547643019
licenseType: Pro
DefaultImporter:
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Lua/Gen/ActorShowConfigWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(ActorShowConfig);
            Utils.BeginObjectRegister(type, L, translator, 0, 1, 25, 0);
            Utils.BeginObjectRegister(type, L, translator, 0, 1, 26, 0);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnConfigParseCompleted", _m_OnConfigParseCompleted);
            
@@ -51,6 +51,7 @@
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "soundId", _g_get_soundId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "soundTime", _g_get_soundTime);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "step", _g_get_step);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "showName", _g_get_showName);
            
            
            
@@ -739,6 +740,20 @@
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_showName(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                ActorShowConfig gen_to_be_invoked = (ActorShowConfig)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.showName);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        
        
        

 Lua/Gen/AnimatorControllerLoaderWrap.cs

New file
@@ -0,0 +1,283 @@
#if USE_UNI_LUA
using LuaAPI = UniLua.Lua;
using RealStatePtr = UniLua.ILuaState;
using LuaCSFunction = UniLua.CSharpFunctionDelegate;
#else
using LuaAPI = XLua.LuaDLL.Lua;
using RealStatePtr = System.IntPtr;
using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
#endif

using XLua;
using System.Collections.Generic;


namespace XLua.CSObjectWrap
{
    using Utils = XLua.Utils;
    public class AnimatorControllerLoaderWrap 
    {
        public static void __Register(RealStatePtr L)
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(AnimatorControllerLoader);
            Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
			
			
			
			
			
			
            Utils.EndObjectRegister(type, L, translator, null, null,
                null, null, null);

            Utils.BeginClassRegister(type, L, __CreateInstance, 12, 0, 0);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadAnimationClip", _m_LoadAnimationClip_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadDefaultMobAnimatorController_Fight", _m_LoadDefaultMobAnimatorController_Fight_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadDefaultMobAnimatorController_Func", _m_LoadDefaultMobAnimatorController_Func_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadDefaultMobAnimatorController_Horse", _m_LoadDefaultMobAnimatorController_Horse_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadDefaultMobAnimatorController_Pet", _m_LoadDefaultMobAnimatorController_Pet_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "Load", _m_Load_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadMobController", _m_LoadMobController_xlua_st_);
            
			
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "controllerSuffix", AnimatorControllerLoader.controllerSuffix);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "controllerUISuffix", AnimatorControllerLoader.controllerUISuffix);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "controllerShowSuffix", AnimatorControllerLoader.controllerShowSuffix);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "controllerRealmSuffix", AnimatorControllerLoader.controllerRealmSuffix);
            
			
			
			
            Utils.EndClassRegister(type, L, translator);
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstance(RealStatePtr L)
        {
            
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                if(LuaAPI.lua_gettop(L) == 1)
                {
					
                    AnimatorControllerLoader gen_ret = new AnimatorControllerLoader();
                    translator.Push(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 AnimatorControllerLoader constructor!");
            
        }
        
		
        
		
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_LoadAnimationClip_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    string _name = LuaAPI.lua_tostring(L, 1);
                    string _clipName = LuaAPI.lua_tostring(L, 2);
                    
                        UnityEngine.AnimationClip gen_ret = AnimatorControllerLoader.LoadAnimationClip( _name, _clipName );
                        translator.Push(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_LoadDefaultMobAnimatorController_Fight_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    
                        UnityEngine.RuntimeAnimatorController gen_ret = AnimatorControllerLoader.LoadDefaultMobAnimatorController_Fight(  );
                        translator.Push(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_LoadDefaultMobAnimatorController_Func_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    
                        UnityEngine.RuntimeAnimatorController gen_ret = AnimatorControllerLoader.LoadDefaultMobAnimatorController_Func(  );
                        translator.Push(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_LoadDefaultMobAnimatorController_Horse_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    
                        UnityEngine.RuntimeAnimatorController gen_ret = AnimatorControllerLoader.LoadDefaultMobAnimatorController_Horse(  );
                        translator.Push(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_LoadDefaultMobAnimatorController_Pet_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    
                        UnityEngine.RuntimeAnimatorController gen_ret = AnimatorControllerLoader.LoadDefaultMobAnimatorController_Pet(  );
                        translator.Push(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_Load_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    string _suffix = LuaAPI.lua_tostring(L, 1);
                    int _id = LuaAPI.xlua_tointeger(L, 2);
                    
                        UnityEngine.RuntimeAnimatorController gen_ret = AnimatorControllerLoader.Load( _suffix, _id );
                        translator.Push(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_LoadMobController_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    string _suffix = LuaAPI.lua_tostring(L, 1);
                    string __name = LuaAPI.lua_tostring(L, 2);
                    
                        UnityEngine.RuntimeAnimatorController gen_ret = AnimatorControllerLoader.LoadMobController( _suffix, __name );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        
        
        
        
        
		
		
		
		
    }
}

 Lua/Gen/AnimatorControllerLoaderWrap.cs.meta

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

 Lua/Gen/DungeonConfigWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(DungeonConfig);
            Utils.BeginObjectRegister(type, L, translator, 0, 0, 22, 0);
            Utils.BeginObjectRegister(type, L, translator, 0, 0, 23, 0);
            
            
            
@@ -40,6 +40,7 @@
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "SweepItemID", _g_get_SweepItemID);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "SweepCostCnt", _g_get_SweepCostCnt);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "StepTime", _g_get_StepTime);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "RefreshNPC", _g_get_RefreshNPC);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "BossActorID", _g_get_BossActorID);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Rewards", _g_get_Rewards);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "RewardCountDescriptions", _g_get_RewardCountDescriptions);
@@ -505,6 +506,20 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_RefreshNPC(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                DungeonConfig gen_to_be_invoked = (DungeonConfig)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushstring(L, gen_to_be_invoked.RefreshNPC);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_BossActorID(RealStatePtr L)
        {
            try {

 Lua/Gen/EnumWrap.cs

@@ -462,7 +462,7 @@
            Utils.BeginObjectRegister(typeof(E_NpcType), L, translator, 0, 0, 0, 0);
            Utils.EndObjectRegister(typeof(E_NpcType), L, translator, null, null, null, null, null);
            
            Utils.BeginClassRegister(typeof(E_NpcType), L, null, 22, 0, 0);
            Utils.BeginClassRegister(typeof(E_NpcType), L, null, 23, 0, 0);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Func", E_NpcType.Func);
            
@@ -503,6 +503,8 @@
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MonsterTime", E_NpcType.MonsterTime);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PersonalEnemy", E_NpcType.PersonalEnemy);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PersonalEnemyPVP", E_NpcType.PersonalEnemyPVP);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenWorldMap", E_NpcType.OpenWorldMap);
            
@@ -602,6 +604,10 @@
                else if (LuaAPI.xlua_is_eq_str(L, 1, "PersonalEnemy"))
                {
                    translator.PushE_NpcType(L, E_NpcType.PersonalEnemy);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "PersonalEnemyPVP"))
                {
                    translator.PushE_NpcType(L, E_NpcType.PersonalEnemyPVP);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenWorldMap"))
                {
@@ -6558,7 +6564,7 @@
            Utils.BeginObjectRegister(typeof(GuideTriggerType), L, translator, 0, 0, 0, 0);
            Utils.EndObjectRegister(typeof(GuideTriggerType), L, translator, null, null, null, null, null);
            
            Utils.BeginClassRegister(typeof(GuideTriggerType), L, null, 28, 0, 0);
            Utils.BeginClassRegister(typeof(GuideTriggerType), L, null, 30, 0, 0);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", GuideTriggerType.None);
            
@@ -6602,17 +6608,21 @@
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "QuestCanAccept", GuideTriggerType.QuestCanAccept);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "QuestCanDo", GuideTriggerType.MainLineQuestCanDo);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MainLineQuestCanDo", GuideTriggerType.MainLineQuestCanDo);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "QuestCanAward", GuideTriggerType.MainLineQuestCanAward);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MainLineQuestCanAward", GuideTriggerType.MainLineQuestCanAward);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "QuestLimit", GuideTriggerType.MainLineQuestLimit);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MainLineQuestLimit", GuideTriggerType.MainLineQuestLimit);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "QuestContinue", GuideTriggerType.MainLineQuestContinue);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MainLineQuestContinue", GuideTriggerType.MainLineQuestContinue);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BranchQuestCando", GuideTriggerType.BranchQuestCando);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BranchQuestCanAward", GuideTriggerType.BranchQuestCanAward);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BranchQuestLimit", GuideTriggerType.BranchQuestLimit);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BranchQuestContinue", GuideTriggerType.BranchQuestContinue);
            
            Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
@@ -6715,19 +6725,19 @@
                {
                    translator.PushGuideTriggerType(L, GuideTriggerType.QuestCanAccept);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "QuestCanDo"))
                else if (LuaAPI.xlua_is_eq_str(L, 1, "MainLineQuestCanDo"))
                {
                    translator.PushGuideTriggerType(L, GuideTriggerType.MainLineQuestCanDo);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "QuestCanAward"))
                else if (LuaAPI.xlua_is_eq_str(L, 1, "MainLineQuestCanAward"))
                {
                    translator.PushGuideTriggerType(L, GuideTriggerType.MainLineQuestCanAward);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "QuestLimit"))
                else if (LuaAPI.xlua_is_eq_str(L, 1, "MainLineQuestLimit"))
                {
                    translator.PushGuideTriggerType(L, GuideTriggerType.MainLineQuestLimit);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "QuestContinue"))
                else if (LuaAPI.xlua_is_eq_str(L, 1, "MainLineQuestContinue"))
                {
                    translator.PushGuideTriggerType(L, GuideTriggerType.MainLineQuestContinue);
                }
@@ -6738,6 +6748,14 @@
                else if (LuaAPI.xlua_is_eq_str(L, 1, "BranchQuestCanAward"))
                {
                    translator.PushGuideTriggerType(L, GuideTriggerType.BranchQuestCanAward);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "BranchQuestLimit"))
                {
                    translator.PushGuideTriggerType(L, GuideTriggerType.BranchQuestLimit);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "BranchQuestContinue"))
                {
                    translator.PushGuideTriggerType(L, GuideTriggerType.BranchQuestContinue);
                }
                else
                {
@@ -7146,7 +7164,7 @@
            Utils.BeginObjectRegister(typeof(HurtAttackType), L, translator, 0, 0, 0, 0);
            Utils.EndObjectRegister(typeof(HurtAttackType), L, translator, null, null, null, null, null);
            
            Utils.BeginClassRegister(typeof(HurtAttackType), L, null, 17, 0, 0);
            Utils.BeginClassRegister(typeof(HurtAttackType), L, null, 19, 0, 0);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", HurtAttackType.Normal);
            
@@ -7179,6 +7197,10 @@
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DeadlyHit", HurtAttackType.DeadlyHit);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ThumpHit", HurtAttackType.ThumpHit);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Yinji", HurtAttackType.Yinji);
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Burning", HurtAttackType.Burning);
            
            Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
            
@@ -7261,6 +7283,14 @@
                {
                    translator.PushHurtAttackType(L, HurtAttackType.ThumpHit);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Yinji"))
                {
                    translator.PushHurtAttackType(L, HurtAttackType.Yinji);
                }
                else if (LuaAPI.xlua_is_eq_str(L, 1, "Burning"))
                {
                    translator.PushHurtAttackType(L, HurtAttackType.Burning);
                }
                else
                {
                    return LuaAPI.luaL_error(L, "invalid string for HurtAttackType!");

 Lua/Gen/GlobalTimeEventWrap.cs

@@ -21,11 +21,12 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(GlobalTimeEvent);
            Utils.BeginObjectRegister(type, L, translator, 0, 8, 0, 0);
            Utils.BeginObjectRegister(type, L, translator, 0, 9, 0, 0);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Begin", _m_Begin);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "secondEvent", _e_secondEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "fiveSecondEvent", _e_fiveSecondEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "minuteEvent", _e_minuteEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "fiveMinuteEvent", _e_fiveMinuteEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "tenMinuteEvent", _e_tenMinuteEvent);
@@ -148,6 +149,40 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_fiveSecondEvent(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
            GlobalTimeEvent gen_to_be_invoked = (GlobalTimeEvent)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.fiveSecondEvent += gen_delegate;
                        return 0;
                    } 
					
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.fiveSecondEvent -= 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 GlobalTimeEvent.fiveSecondEvent!");
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_minuteEvent(RealStatePtr L)
        {
            try {

 Lua/Gen/GuideConfigWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(GuideConfig);
            Utils.BeginObjectRegister(type, L, translator, 0, 0, 9, 0);
            Utils.BeginObjectRegister(type, L, translator, 0, 0, 12, 0);
            
            
            
@@ -29,11 +29,14 @@
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Type", _g_get_Type);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "TriggerType", _g_get_TriggerType);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Condition", _g_get_Condition);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "SupplementCondition", _g_get_SupplementCondition);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "PreGuideId", _g_get_PreGuideId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Steps", _g_get_Steps);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "CanSkip", _g_get_CanSkip);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "RemoveWhenOtherGuide", _g_get_RemoveWhenOtherGuide);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "CannotCompleteByClick", _g_get_CannotCompleteByClick);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "UnfoldAreas", _g_get_UnfoldAreas);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "AutoCompleteTime", _g_get_AutoCompleteTime);
            
            
            
@@ -338,6 +341,20 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_SupplementCondition(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                GuideConfig gen_to_be_invoked = (GuideConfig)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.SupplementCondition);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_PreGuideId(RealStatePtr L)
        {
            try {
@@ -407,6 +424,34 @@
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_UnfoldAreas(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                GuideConfig gen_to_be_invoked = (GuideConfig)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.UnfoldAreas);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_AutoCompleteTime(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                GuideConfig gen_to_be_invoked = (GuideConfig)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.AutoCompleteTime);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        
        
        

 Lua/Gen/HazyRegionConfigWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(HazyRegionConfig);
            Utils.BeginObjectRegister(type, L, translator, 0, 0, 12, 0);
            Utils.BeginObjectRegister(type, L, translator, 0, 0, 13, 0);
            
            
            
@@ -31,11 +31,13 @@
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "dungeonId", _g_get_dungeonId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "lineId", _g_get_lineId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "npcId", _g_get_npcId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "dungeonType", _g_get_dungeonType);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "point", _g_get_point);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "alchemyLevel", _g_get_alchemyLevel);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "reward", _g_get_reward);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "rewardState", _g_get_rewardState);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "PortraitID", _g_get_PortraitID);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "star", _g_get_star);
            
            
            
@@ -368,6 +370,20 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_dungeonType(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                HazyRegionConfig gen_to_be_invoked = (HazyRegionConfig)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.dungeonType);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_point(RealStatePtr L)
        {
            try {
@@ -437,6 +453,20 @@
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_star(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                HazyRegionConfig gen_to_be_invoked = (HazyRegionConfig)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.star);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        
        
        

 Lua/Gen/InstanceResourcesLoaderWrap.cs

New file
@@ -0,0 +1,722 @@
#if USE_UNI_LUA
using LuaAPI = UniLua.Lua;
using RealStatePtr = UniLua.ILuaState;
using LuaCSFunction = UniLua.CSharpFunctionDelegate;
#else
using LuaAPI = XLua.LuaDLL.Lua;
using RealStatePtr = System.IntPtr;
using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
#endif

using XLua;
using System.Collections.Generic;


namespace XLua.CSObjectWrap
{
    using Utils = XLua.Utils;
    public class InstanceResourcesLoaderWrap 
    {
        public static void __Register(RealStatePtr L)
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(InstanceResourcesLoader);
            Utils.BeginObjectRegister(type, L, translator, 0, 0, 0, 0);
			
			
			
			
			
			
            Utils.EndObjectRegister(type, L, translator, null, null,
                null, null, null);

            Utils.BeginClassRegister(type, L, __CreateInstance, 28, 0, 0);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadEmptyJY", _m_LoadEmptyJY_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadNpc", _m_LoadNpc_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadDefaultFightNPC", _m_LoadDefaultFightNPC_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadDefaultFuncNPC", _m_LoadDefaultFuncNPC_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "AsyncLoadDefaultFuncNpc", _m_AsyncLoadDefaultFuncNpc_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "AsyncLoadDefaultFightNpc", _m_AsyncLoadDefaultFightNpc_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "AsyncLoadDefaultPet", _m_AsyncLoadDefaultPet_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadDefaultHorse", _m_LoadDefaultHorse_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadDefaultPet", _m_LoadDefaultPet_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadNpcPrefab", _m_LoadNpcPrefab_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadModelRes", _m_LoadModelRes_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadCreateRole", _m_LoadCreateRole_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadModelPrefab", _m_LoadModelPrefab_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "AsyncLoadModelRes", _m_AsyncLoadModelRes_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadMob", _m_LoadMob_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "UnloadAsset", _m_UnloadAsset_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadEffect", _m_LoadEffect_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "LoadEffectAsync", _m_LoadEffectAsync_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "AsyncLoadNpc", _m_AsyncLoadNpc_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "PreloadSkillEffect", _m_PreloadSkillEffect_xlua_st_);
            
			
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "raceSuffix", InstanceResourcesLoader.raceSuffix);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "horseSuffix", InstanceResourcesLoader.horseSuffix);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "weaponSuffix", InstanceResourcesLoader.weaponSuffix);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "secondarySuffix", InstanceResourcesLoader.secondarySuffix);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "handSuffix", InstanceResourcesLoader.handSuffix);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "wingSuffix", InstanceResourcesLoader.wingSuffix);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "emptyJyName", InstanceResourcesLoader.emptyJyName);
            
			
			
			
            Utils.EndClassRegister(type, L, translator);
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstance(RealStatePtr L)
        {
            
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                if(LuaAPI.lua_gettop(L) == 1)
                {
					
                    InstanceResourcesLoader gen_ret = new InstanceResourcesLoader();
                    translator.Push(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 InstanceResourcesLoader constructor!");
            
        }
        
		
        
		
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_LoadEmptyJY_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    
                        UnityEngine.GameObject gen_ret = InstanceResourcesLoader.LoadEmptyJY(  );
                        translator.Push(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_LoadNpc_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _id = LuaAPI.xlua_tointeger(L, 1);
                    
                        UnityEngine.GameObject gen_ret = InstanceResourcesLoader.LoadNpc( _id );
                        translator.Push(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_LoadDefaultFightNPC_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    
                        UnityEngine.GameObject gen_ret = InstanceResourcesLoader.LoadDefaultFightNPC(  );
                        translator.Push(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_LoadDefaultFuncNPC_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    
                        UnityEngine.GameObject gen_ret = InstanceResourcesLoader.LoadDefaultFuncNPC(  );
                        translator.Push(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_AsyncLoadDefaultFuncNpc_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    System.Action<bool, UnityEngine.Object> _callBack = translator.GetDelegate<System.Action<bool, UnityEngine.Object>>(L, 1);
                    
                    InstanceResourcesLoader.AsyncLoadDefaultFuncNpc( _callBack );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AsyncLoadDefaultFightNpc_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    System.Action<bool, UnityEngine.Object> _callBack = translator.GetDelegate<System.Action<bool, UnityEngine.Object>>(L, 1);
                    
                    InstanceResourcesLoader.AsyncLoadDefaultFightNpc( _callBack );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AsyncLoadDefaultPet_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    System.Action<bool, UnityEngine.Object> _callBack = translator.GetDelegate<System.Action<bool, UnityEngine.Object>>(L, 1);
                    
                    InstanceResourcesLoader.AsyncLoadDefaultPet( _callBack );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_LoadDefaultHorse_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    
                        UnityEngine.GameObject gen_ret = InstanceResourcesLoader.LoadDefaultHorse(  );
                        translator.Push(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_LoadDefaultPet_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    
                        UnityEngine.GameObject gen_ret = InstanceResourcesLoader.LoadDefaultPet(  );
                        translator.Push(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_LoadNpcPrefab_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _npcID = LuaAPI.xlua_tointeger(L, 1);
                    
                        UnityEngine.GameObject gen_ret = InstanceResourcesLoader.LoadNpcPrefab( _npcID );
                        translator.Push(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_LoadModelRes_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 2)) 
                {
                    int _id = LuaAPI.xlua_tointeger(L, 1);
                    bool __ui = LuaAPI.lua_toboolean(L, 2);
                    
                        UnityEngine.GameObject gen_ret = InstanceResourcesLoader.LoadModelRes( _id, __ui );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) 
                {
                    int _id = LuaAPI.xlua_tointeger(L, 1);
                    
                        UnityEngine.GameObject gen_ret = InstanceResourcesLoader.LoadModelRes( _id );
                        translator.Push(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 InstanceResourcesLoader.LoadModelRes!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_LoadCreateRole_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _job = LuaAPI.xlua_tointeger(L, 1);
                    System.Action<bool, UnityEngine.Object> __callBack = translator.GetDelegate<System.Action<bool, UnityEngine.Object>>(L, 2);
                    
                    InstanceResourcesLoader.LoadCreateRole( _job, __callBack );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_LoadModelPrefab_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    string __suffix = LuaAPI.lua_tostring(L, 1);
                    string _name = LuaAPI.lua_tostring(L, 2);
                    bool __ui = LuaAPI.lua_toboolean(L, 3);
                    
                        UnityEngine.GameObject gen_ret = InstanceResourcesLoader.LoadModelPrefab( __suffix, _name, __ui );
                        translator.Push(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_AsyncLoadModelRes_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable<System.Action<bool, UnityEngine.Object>>(L, 2)) 
                {
                    int _id = LuaAPI.xlua_tointeger(L, 1);
                    System.Action<bool, UnityEngine.Object> _callback = translator.GetDelegate<System.Action<bool, UnityEngine.Object>>(L, 2);
                    
                    InstanceResourcesLoader.AsyncLoadModelRes( _id, _callback );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) 
                {
                    int _id = LuaAPI.xlua_tointeger(L, 1);
                    
                    InstanceResourcesLoader.AsyncLoadModelRes( _id );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to InstanceResourcesLoader.AsyncLoadModelRes!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_LoadMob_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    string _assetBundleName = LuaAPI.lua_tostring(L, 1);
                    string _assetName = LuaAPI.lua_tostring(L, 2);
                    
                        UnityEngine.GameObject gen_ret = InstanceResourcesLoader.LoadMob( _assetBundleName, _assetName );
                        translator.Push(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_UnloadAsset_xlua_st_(RealStatePtr L)
        {
            try {
            
            
            
                
                {
                    string _bundleName = LuaAPI.lua_tostring(L, 1);
                    string _assetName = LuaAPI.lua_tostring(L, 2);
                    
                    InstanceResourcesLoader.UnloadAsset( _bundleName, _assetName );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_LoadEffect_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    int _id = LuaAPI.xlua_tointeger(L, 1);
                    
                        UnityEngine.GameObject gen_ret = InstanceResourcesLoader.LoadEffect( _id );
                        translator.Push(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_LoadEffectAsync_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable<System.Action<bool, UnityEngine.Object>>(L, 2)) 
                {
                    int __id = LuaAPI.xlua_tointeger(L, 1);
                    System.Action<bool, UnityEngine.Object> __callBack = translator.GetDelegate<System.Action<bool, UnityEngine.Object>>(L, 2);
                    
                    InstanceResourcesLoader.LoadEffectAsync( __id, __callBack );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) 
                {
                    int __id = LuaAPI.xlua_tointeger(L, 1);
                    
                    InstanceResourcesLoader.LoadEffectAsync( __id );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to InstanceResourcesLoader.LoadEffectAsync!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AsyncLoadNpc_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)&& translator.Assignable<System.Action<bool, UnityEngine.Object>>(L, 2)) 
                {
                    int _npcID = LuaAPI.xlua_tointeger(L, 1);
                    System.Action<bool, UnityEngine.Object> _callBack = translator.GetDelegate<System.Action<bool, UnityEngine.Object>>(L, 2);
                    
                    InstanceResourcesLoader.AsyncLoadNpc( _npcID, _callBack );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) 
                {
                    int _npcID = LuaAPI.xlua_tointeger(L, 1);
                    
                    InstanceResourcesLoader.AsyncLoadNpc( _npcID );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& translator.Assignable<System.Action<bool, UnityEngine.Object>>(L, 3)) 
                {
                    string _assetBundleName = LuaAPI.lua_tostring(L, 1);
                    string _assetName = LuaAPI.lua_tostring(L, 2);
                    System.Action<bool, UnityEngine.Object> _callBack = translator.GetDelegate<System.Action<bool, UnityEngine.Object>>(L, 3);
                    
                    InstanceResourcesLoader.AsyncLoadNpc( _assetBundleName, _assetName, _callBack );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) 
                {
                    string _assetBundleName = LuaAPI.lua_tostring(L, 1);
                    string _assetName = LuaAPI.lua_tostring(L, 2);
                    
                    InstanceResourcesLoader.AsyncLoadNpc( _assetBundleName, _assetName );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to InstanceResourcesLoader.AsyncLoadNpc!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PreloadSkillEffect_xlua_st_(RealStatePtr L)
        {
            try {
            
            
            
                
                {
                    int _id = LuaAPI.xlua_tointeger(L, 1);
                    
                    InstanceResourcesLoader.PreloadSkillEffect( _id );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        
        
        
        
        
		
		
		
		
    }
}

 Lua/Gen/InstanceResourcesLoaderWrap.cs.meta

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

 Lua/Gen/MapEventPointConfigWrap.cs

@@ -21,12 +21,13 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(MapEventPointConfig);
            Utils.BeginObjectRegister(type, L, translator, 0, 0, 13, 0);
            Utils.BeginObjectRegister(type, L, translator, 0, 0, 14, 0);
            
            
            
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Key", _g_get_Key);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "MapID", _g_get_MapID);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "DataMapID", _g_get_DataMapID);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "LineId", _g_get_LineId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "NPCID", _g_get_NPCID);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsShowInfo", _g_get_IsShowInfo);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "ShowInMipMap", _g_get_ShowInMipMap);
@@ -300,9 +301,27 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_MapID(RealStatePtr L)
        static int _g_get_DataMapID(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MapEventPointConfig gen_to_be_invoked = (MapEventPointConfig)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.DataMapID);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_LineId(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                MapEventPointConfig gen_to_be_invoked = (MapEventPointConfig)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.LineId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }

 Lua/Gen/MapTransferUtilityWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(MapTransferUtility);
            Utils.BeginObjectRegister(type, L, translator, 0, 10, 6, 6);
            Utils.BeginObjectRegister(type, L, translator, 0, 11, 6, 6);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Initialize", _m_Initialize);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "MoveToDazuo", _m_MoveToDazuo);
@@ -33,6 +33,7 @@
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnHeroPathFinding", _m_OnHeroPathFinding);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnHeroStopPathFind", _m_OnHeroStopPathFind);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Clear", _m_Clear);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "StopMovetoNpc", _m_StopMovetoNpc);
            
            
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "MapTransferDoType", _g_get_MapTransferDoType);
@@ -512,6 +513,33 @@
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_StopMovetoNpc(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                MapTransferUtility gen_to_be_invoked = (MapTransferUtility)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.StopMovetoNpc(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        
        
        

 Lua/Gen/OccupationNameConfigWrap.cs

@@ -269,6 +269,12 @@
            
                
                {
                    int _occupa = LuaAPI.xlua_tointeger(L, 1);
                    
                        string gen_ret = OccupationNameConfig.GetOccupationName( _occupa );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }

 Lua/Gen/PersonalBossConfigWrap.cs

@@ -26,6 +26,7 @@
            
            
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "NPCID", _g_get_NPCID);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "lineId", _g_get_lineId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "MustItemID", _g_get_MustItemID);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "RareItemID", _g_get_RareItemID);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "PortraitID", _g_get_PortraitID);
@@ -291,6 +292,20 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_lineId(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                PersonalBossConfig gen_to_be_invoked = (PersonalBossConfig)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.lineId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_MustItemID(RealStatePtr L)
        {
            try {

 Lua/Gen/PrepareHandlerWrap.cs

@@ -21,9 +21,11 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(PrepareHandler);
            Utils.BeginObjectRegister(type, L, translator, 0, 5, 8, 7);
            Utils.BeginObjectRegister(type, L, translator, 0, 7, 8, 7);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "TriggerOnShowCollect", _m_TriggerOnShowCollect);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "HandleCallback", _m_HandleCallback);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Arrive", _m_Arrive);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Leave", _m_Leave);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "ServerPrepareStart", _m_ServerPrepareStart);
@@ -92,6 +94,35 @@
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_TriggerOnShowCollect(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                PrepareHandler gen_to_be_invoked = (PrepareHandler)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    uint _sid = LuaAPI.xlua_touint(L, 2);
                    int _npcId = LuaAPI.xlua_tointeger(L, 3);
                    
                    gen_to_be_invoked.TriggerOnShowCollect( _sid, _npcId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Init(RealStatePtr L)
        {
            try {
@@ -119,6 +150,36 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_HandleCallback(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                PrepareHandler gen_to_be_invoked = (PrepareHandler)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    E_NpcType _type;translator.Get(L, 2, out _type);
                    int _npcID = LuaAPI.xlua_tointeger(L, 3);
                    uint _sid = LuaAPI.xlua_touint(L, 4);
                    
                    gen_to_be_invoked.HandleCallback( _type, _npcID, _sid );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Arrive(RealStatePtr L)
        {
            try {

 Lua/Gen/Resources.meta

New file
@@ -0,0 +1,9 @@
fileFormatVersion: 2
guid: 2a460c5e1b7a1b74cab84494289095f0
folderAsset: yes
timeCreated: 1558410732
licenseType: Pro
DefaultImporter:
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Lua/Gen/SnxxzUIAlchemyModelWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(Snxxz.UI.AlchemyModel);
            Utils.BeginObjectRegister(type, L, translator, 0, 25, 12, 4);
            Utils.BeginObjectRegister(type, L, translator, 0, 27, 14, 6);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeforePlayerDataInitialize", _m_OnBeforePlayerDataInitialize);
@@ -31,6 +31,8 @@
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryGetAlchemyCount", _m_TryGetAlchemyCount);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryGetAlchemyMaterials", _m_TryGetAlchemyMaterials);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryGetAlchemyUseLimit", _m_TryGetAlchemyUseLimit);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryLearn", _m_TryLearn);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryGetAlchemyByStudyMaterial", _m_TryGetAlchemyByStudyMaterial);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAlchemyRedpointId", _m_GetAlchemyRedpointId);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetQualityRedpointId", _m_GetQualityRedpointId);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetAlchemySuccRate", _m_GetAlchemySuccRate);
@@ -57,6 +59,8 @@
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "stoveExp", _g_get_stoveExp);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "alchemySuccRate", _g_get_alchemySuccRate);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "jumpAlchemy", _g_get_jumpAlchemy);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "alchemyNormalNotifySymbol", _g_get_alchemyNormalNotifySymbol);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "alchemyFairyNotifySymbol", _g_get_alchemyFairyNotifySymbol);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isServerPrepare", _g_get_isServerPrepare);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "redpoint", _g_get_redpoint);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "alchemyDrugRedpoint1", _g_get_alchemyDrugRedpoint1);
@@ -67,6 +71,8 @@
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "selectAlchemy", _s_set_selectAlchemy);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "selectAlchemyType", _s_set_selectAlchemyType);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "jumpAlchemy", _s_set_jumpAlchemy);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "alchemyNormalNotifySymbol", _s_set_alchemyNormalNotifySymbol);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "alchemyFairyNotifySymbol", _s_set_alchemyFairyNotifySymbol);
            
            
            Utils.EndObjectRegister(type, L, translator, null, null,
@@ -338,6 +344,70 @@
                        bool gen_ret = gen_to_be_invoked.TryGetAlchemyUseLimit( _id, out _drugUseLimit );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    translator.Push(L, _drugUseLimit);
                        
                    
                    
                    
                    return 2;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_TryLearn(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.AlchemyModel gen_to_be_invoked = (Snxxz.UI.AlchemyModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _alchmeyId = LuaAPI.xlua_tointeger(L, 2);
                    int _error;
                    
                        bool gen_ret = gen_to_be_invoked.TryLearn( _alchmeyId, out _error );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    LuaAPI.xlua_pushinteger(L, _error);
                        
                    
                    
                    
                    return 2;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_TryGetAlchemyByStudyMaterial(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.AlchemyModel gen_to_be_invoked = (Snxxz.UI.AlchemyModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _id = LuaAPI.xlua_tointeger(L, 2);
                    int _alchemyId;
                    
                        bool gen_ret = gen_to_be_invoked.TryGetAlchemyByStudyMaterial( _id, out _alchemyId );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    LuaAPI.xlua_pushinteger(L, _alchemyId);
                        
                    
                    
@@ -865,6 +935,34 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_alchemyNormalNotifySymbol(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.AlchemyModel gen_to_be_invoked = (Snxxz.UI.AlchemyModel)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.alchemyNormalNotifySymbol);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_alchemyFairyNotifySymbol(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.AlchemyModel gen_to_be_invoked = (Snxxz.UI.AlchemyModel)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.alchemyFairyNotifySymbol);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isServerPrepare(RealStatePtr L)
        {
            try {
@@ -1010,6 +1108,36 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_alchemyNormalNotifySymbol(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.AlchemyModel gen_to_be_invoked = (Snxxz.UI.AlchemyModel)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.alchemyNormalNotifySymbol = 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_alchemyFairyNotifySymbol(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.AlchemyModel gen_to_be_invoked = (Snxxz.UI.AlchemyModel)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.alchemyFairyNotifySymbol = 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_redpointIndex(RealStatePtr L)
        {
            try {

 Lua/Gen/SnxxzUIBossShowModelWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(Snxxz.UI.BossShowModel);
            Utils.BeginObjectRegister(type, L, translator, 0, 19, 7, 2);
            Utils.BeginObjectRegister(type, L, translator, 0, 19, 8, 2);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "StartBossShow", _m_StartBossShow);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Start", _m_Start);
@@ -48,6 +48,7 @@
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "showTargetList", _g_get_showTargetList);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "BossShowing", _g_get_BossShowing);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "showCamera", _g_get_showCamera);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "showHero", _g_get_showHero);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "satisfyStep", _g_get_satisfyStep);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "reqDungeonLineId", _g_get_reqDungeonLineId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "showActorDic", _g_get_showActorDic);
@@ -666,6 +667,20 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_showHero(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.BossShowModel gen_to_be_invoked = (Snxxz.UI.BossShowModel)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.showHero);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_satisfyStep(RealStatePtr L)
        {
            try {

 Lua/Gen/SnxxzUIEquipModelWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(Snxxz.UI.EquipModel);
            Utils.BeginObjectRegister(type, L, translator, 0, 34, 16, 1);
            Utils.BeginObjectRegister(type, L, translator, 0, 35, 16, 1);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnInit", _m_UnInit);
@@ -49,6 +49,7 @@
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshGetWays", _m_RefreshGetWays);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearGetWays", _m_ClearGetWays);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "CompareToCurrent", _m_CompareToCurrent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "ExistBetterEquip", _m_ExistBetterEquip);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetEquipSuitEntry", _m_GetEquipSuitEntry);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsSuitPlaceEffectPlayed", _m_IsSuitPlaceEffectPlayed);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "RecordSuitPlaceEffectPlay", _m_RecordSuitPlaceEffectPlay);
@@ -873,6 +874,51 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ExistBetterEquip(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.EquipModel gen_to_be_invoked = (Snxxz.UI.EquipModel)translator.FastGetCSObj(L, 1);
            
            
                int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) 
                {
                    int _level = LuaAPI.xlua_tointeger(L, 2);
                    
                        bool gen_ret = gen_to_be_invoked.ExistBetterEquip( _level );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& translator.Assignable<System.Collections.Generic.List<int>>(L, 3)) 
                {
                    int _level = LuaAPI.xlua_tointeger(L, 2);
                    System.Collections.Generic.List<int> _places = (System.Collections.Generic.List<int>)translator.GetObject(L, 3, typeof(System.Collections.Generic.List<int>));
                    
                        bool gen_ret = gen_to_be_invoked.ExistBetterEquip( _level, _places );
                        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.EquipModel.ExistBetterEquip!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetEquipSuitEntry(RealStatePtr L)
        {
            try {

 Lua/Gen/SnxxzUIEquipStrengthModelWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(Snxxz.UI.EquipStrengthModel);
            Utils.BeginObjectRegister(type, L, translator, 0, 24, 12, 7);
            Utils.BeginObjectRegister(type, L, translator, 0, 25, 11, 8);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeforePlayerDataInitialize", _m_OnBeforePlayerDataInitialize);
@@ -42,6 +42,7 @@
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "HasEnoughMoney", _m_HasEnoughMoney);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryGetRedpoint", _m_TryGetRedpoint);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDayRemind", _m_SetDayRemind);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "ExistAnySatisfyStrengh", _m_ExistAnySatisfyStrengh);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "EquipStrengthUpdate", _e_EquipStrengthUpdate);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "EquipStrengthLvUpdate", _e_EquipStrengthLvUpdate);
@@ -58,6 +59,7 @@
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "EquipStrengthDic", _g_get_EquipStrengthDic);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "EquipLevelMaxDic", _g_get_EquipLevelMaxDic);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "EvolutionTypeMaxDic", _g_get_EvolutionTypeMaxDic);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "redpointLimits", _g_get_redpointLimits);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "redpoint", _g_get_redpoint);
            
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "IsChangeBool", _s_set_IsChangeBool);
@@ -67,6 +69,7 @@
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "EquipStrengthDic", _s_set_EquipStrengthDic);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "EquipLevelMaxDic", _s_set_EquipLevelMaxDic);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "EvolutionTypeMaxDic", _s_set_EvolutionTypeMaxDic);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "redpointLimits", _s_set_redpointLimits);
            
            
            Utils.EndObjectRegister(type, L, translator, null, null,
@@ -739,6 +742,34 @@
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ExistAnySatisfyStrengh(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.EquipStrengthModel gen_to_be_invoked = (Snxxz.UI.EquipStrengthModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        bool gen_ret = gen_to_be_invoked.ExistAnySatisfyStrengh(  );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        
        
        
@@ -862,6 +893,20 @@
            
                Snxxz.UI.EquipStrengthModel gen_to_be_invoked = (Snxxz.UI.EquipStrengthModel)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.EvolutionTypeMaxDic);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_redpointLimits(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.EquipStrengthModel gen_to_be_invoked = (Snxxz.UI.EquipStrengthModel)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.redpointLimits);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
@@ -1003,6 +1048,21 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_redpointLimits(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.EquipStrengthModel gen_to_be_invoked = (Snxxz.UI.EquipStrengthModel)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.redpointLimits = (Int3[])translator.GetObject(L, 2, typeof(Int3[]));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_REDPOINTBASE(RealStatePtr L)
        {
            try {

 Lua/Gen/SnxxzUIFunctionalGuideCenterWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(Snxxz.UI.FunctionalGuideCenter);
            Utils.BeginObjectRegister(type, L, translator, 0, 11, 0, 0);
            Utils.BeginObjectRegister(type, L, translator, 0, 12, 0, 0);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "CheckGuides", _m_CheckGuides);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetUnderwayGuides", _m_GetUnderwayGuides);
@@ -31,6 +31,7 @@
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "FinishGuide", _m_FinishGuide);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveGuide", _m_RemoveGuide);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveAllUnderWayGuide", _m_RemoveAllUnderWayGuide);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsAreaNeedUnflod", _m_IsAreaNeedUnflod);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "beginGuideEvent", _e_beginGuideEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "finishGuideEevent", _e_finishGuideEevent);
@@ -306,6 +307,35 @@
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsAreaNeedUnflod(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.FunctionalGuideCenter gen_to_be_invoked = (Snxxz.UI.FunctionalGuideCenter)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _area = LuaAPI.xlua_tointeger(L, 2);
                    
                        bool gen_ret = gen_to_be_invoked.IsAreaNeedUnflod( _area );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        
        
        

 Lua/Gen/SnxxzUIHazyDemonKingModelWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(Snxxz.UI.HazyDemonKingModel);
            Utils.BeginObjectRegister(type, L, translator, 0, 18, 2, 0);
            Utils.BeginObjectRegister(type, L, translator, 0, 17, 2, 0);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeforePlayerDataInitialize", _m_OnBeforePlayerDataInitialize);
@@ -53,9 +53,9 @@
            Utils.BeginClassRegister(type, L, __CreateInstance, 4, 0, 0);
            
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Client_MapID", Snxxz.UI.HazyDemonKingModel.CLIENTDATAMAP);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DEMONKINGMAPID1", Snxxz.UI.HazyDemonKingModel.DATAMAP);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DEMONKINGMAPID2", Snxxz.UI.HazyDemonKingModel.CROSSSERVERDATAMAP);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CLIENTDATAMAP", Snxxz.UI.HazyDemonKingModel.CLIENTDATAMAP);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DATAMAP", Snxxz.UI.HazyDemonKingModel.DATAMAP);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CROSSSERVERDATAMAP", Snxxz.UI.HazyDemonKingModel.CROSSSERVERDATAMAP);
            
            
            
@@ -516,6 +516,8 @@
        }
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_IsInDungeon(RealStatePtr L)
        {

 Lua/Gen/SnxxzUIHazyGrassModelWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(Snxxz.UI.HazyGrassModel);
            Utils.BeginObjectRegister(type, L, translator, 0, 17, 2, 0);
            Utils.BeginObjectRegister(type, L, translator, 0, 17, 1, 0);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeforePlayerDataInitialize", _m_OnBeforePlayerDataInitialize);
@@ -30,7 +30,10 @@
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsInGrassDungeon", _m_IsInGrassDungeon);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetClientMapId", _m_GetClientMapId);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetGrassMapId", _m_GetGrassMapId);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetGrassNpcInfos", _m_GetGrassNpcInfos);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetMapNpcCount", _m_GetMapNpcCount);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLocalSaveKey", _m_GetLocalSaveKey);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "DeleteLocalSaveKey", _m_DeleteLocalSaveKey);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "CanCollectClientNpc", _m_CanCollectClientNpc);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "DisplayCollectErrorTip", _m_DisplayCollectErrorTip);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "ReceivePackage", _m_ReceivePackage);
@@ -40,6 +43,7 @@
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "onMapNpcCountRefresh", _e_onMapNpcCountRefresh);
            
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsInDungeon", _g_get_IsInDungeon);
            
            
            
            Utils.EndObjectRegister(type, L, translator, null, null,
@@ -48,10 +52,10 @@
            Utils.BeginClassRegister(type, L, __CreateInstance, 5, 0, 0);
            
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReikiGrassMapId", Snxxz.UI.HazyGrassModel.REIKI_DATAMAP);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyGrassMapId", Snxxz.UI.HazyGrassModel.FAIRY_DATAMAP);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Client_ReikiGrassMapID", Snxxz.UI.HazyGrassModel.REIKI_CLIENTDATAMAP);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Client_FairyGrassMapID", Snxxz.UI.HazyGrassModel.FAIRY_CLIENTDATAMAP);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "REIKI_DATAMAP", Snxxz.UI.HazyGrassModel.REIKI_DATAMAP);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FAIRY_DATAMAP", Snxxz.UI.HazyGrassModel.FAIRY_DATAMAP);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "REIKI_CLIENTDATAMAP", Snxxz.UI.HazyGrassModel.REIKI_CLIENTDATAMAP);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FAIRY_CLIENTDATAMAP", Snxxz.UI.HazyGrassModel.FAIRY_CLIENTDATAMAP);
            
            
            
@@ -285,6 +289,35 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetGrassNpcInfos(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.HazyGrassModel gen_to_be_invoked = (Snxxz.UI.HazyGrassModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _mapId = LuaAPI.xlua_tointeger(L, 2);
                    
                        System.Collections.Generic.List<int> gen_ret = gen_to_be_invoked.GetGrassNpcInfos( _mapId );
                        translator.Push(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_GetMapNpcCount(RealStatePtr L)
        {
            try {
@@ -305,6 +338,62 @@
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetLocalSaveKey(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.HazyGrassModel gen_to_be_invoked = (Snxxz.UI.HazyGrassModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _mapId = LuaAPI.xlua_tointeger(L, 2);
                    
                        string gen_ret = gen_to_be_invoked.GetLocalSaveKey( _mapId );
                        LuaAPI.lua_pushstring(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_DeleteLocalSaveKey(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.HazyGrassModel gen_to_be_invoked = (Snxxz.UI.HazyGrassModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.DeleteLocalSaveKey(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
@@ -454,6 +543,8 @@
        }
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_IsInDungeon(RealStatePtr L)
        {
@@ -468,6 +559,10 @@
            return 1;
        }
        
        
        
		
		
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_onMapNpcCountRefresh(RealStatePtr L)
        {
@@ -501,5 +596,8 @@
            LuaAPI.luaL_error(L, "invalid arguments to Snxxz.UI.HazyGrassModel.onMapNpcCountRefresh!");
            return 0;
        }
        
		
		
    }
}

 Lua/Gen/SnxxzUIHazyRegionModelWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(Snxxz.UI.HazyRegionModel);
            Utils.BeginObjectRegister(type, L, translator, 0, 23, 14, 3);
            Utils.BeginObjectRegister(type, L, translator, 0, 23, 16, 3);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeforePlayerDataInitialize", _m_OnBeforePlayerDataInitialize);
@@ -61,6 +61,8 @@
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "incidentDirty", _g_get_incidentDirty);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "selectIncident", _g_get_selectIncident);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "InFakeHazyRegion", _g_get_InFakeHazyRegion);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "incidentTypesSort", _g_get_incidentTypesSort);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "incidentSelectSort", _g_get_incidentSelectSort);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "redpoint", _g_get_redpoint);
            
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "requireIncidentAnimation", _s_set_requireIncidentAnimation);
@@ -71,9 +73,10 @@
            Utils.EndObjectRegister(type, L, translator, null, null,
                null, null, null);

            Utils.BeginClassRegister(type, L, __CreateInstance, 1, 0, 0);
            Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0);
            
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PRECIOUS_CLIENTDATAMAP", Snxxz.UI.HazyRegionModel.PRECIOUS_CLIENTDATAMAP);
            
            
            
@@ -899,6 +902,34 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_incidentTypesSort(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.HazyRegionModel gen_to_be_invoked = (Snxxz.UI.HazyRegionModel)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.incidentTypesSort);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_incidentSelectSort(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.HazyRegionModel gen_to_be_invoked = (Snxxz.UI.HazyRegionModel)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.incidentSelectSort);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_redpoint(RealStatePtr L)
        {
            try {

 Lua/Gen/SnxxzUIMapModelWrap.cs

@@ -547,7 +547,11 @@
            
                
                {
                    int __mapId = LuaAPI.xlua_tointeger(L, 2);
                    int _dataMapId = LuaAPI.xlua_tointeger(L, 2);
                    int _lineId = LuaAPI.xlua_tointeger(L, 3);
                    
                        System.Collections.Generic.List<int> gen_ret = gen_to_be_invoked.GetMapEventPoints( _dataMapId, _lineId );
                        translator.Push(L, gen_ret);
                    
                    
                    
@@ -670,9 +674,14 @@
                    
                    return 1;
                }
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) 
                if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) 
                {
                    int __mapId = LuaAPI.xlua_tointeger(L, 2);
                    int _lineId = LuaAPI.xlua_tointeger(L, 3);
                    
                        int gen_ret = gen_to_be_invoked.GetRecommendHangPoint( __mapId, _lineId );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;

 Lua/Gen/SnxxzUINewBieCenterWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(Snxxz.UI.NewBieCenter);
            Utils.BeginObjectRegister(type, L, translator, 0, 17, 4, 2);
            Utils.BeginObjectRegister(type, L, translator, 0, 18, 4, 2);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnInit", _m_UnInit);
@@ -37,6 +37,7 @@
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "CompleteAllGuides", _m_CompleteAllGuides);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetAllGuides", _m_ResetAllGuides);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetGuide", _m_ResetGuide);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsAreaNeedUnflod", _m_IsAreaNeedUnflod);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "guideStepChangeEvent", _e_guideStepChangeEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "guideBeginEvent", _e_guideBeginEvent);
@@ -483,6 +484,35 @@
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsAreaNeedUnflod(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.NewBieCenter gen_to_be_invoked = (Snxxz.UI.NewBieCenter)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _area = LuaAPI.xlua_tointeger(L, 2);
                    
                        bool gen_ret = gen_to_be_invoked.IsAreaNeedUnflod( _area );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        
        
        

 Lua/Gen/SnxxzUIPackModelWrap.cs

New file
@@ -0,0 +1,2953 @@
#if USE_UNI_LUA
using LuaAPI = UniLua.Lua;
using RealStatePtr = UniLua.ILuaState;
using LuaCSFunction = UniLua.CSharpFunctionDelegate;
#else
using LuaAPI = XLua.LuaDLL.Lua;
using RealStatePtr = System.IntPtr;
using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
#endif

using XLua;
using System.Collections.Generic;


namespace XLua.CSObjectWrap
{
    using Utils = XLua.Utils;
    public class SnxxzUIPackModelWrap 
    {
        public static void __Register(RealStatePtr L)
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(Snxxz.UI.PackModel);
            Utils.BeginObjectRegister(type, L, translator, 0, 77, 24, 4);
			
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeforePlayerDataInitialize", _m_OnBeforePlayerDataInitialize);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnAfterPlayerDataInitialize", _m_OnAfterPlayerDataInitialize);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPlayerLoginOk", _m_OnPlayerLoginOk);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnInit", _m_UnInit);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdatePack", _m_UpdatePack);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateItem", _m_UpdateItem);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateUnlockedGridCount", _m_UpdateUnlockedGridCount);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshItemCount", _m_RefreshItemCount);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "ClearPack", _m_ClearPack);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveItem", _m_RemoveItem);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "PackResetOk", _m_PackResetOk);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "UseItemSuccess", _m_UseItemSuccess);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateItemUseCnt", _m_UpdateItemUseCnt);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateItemSumUseCnt", _m_UpdateItemSumUseCnt);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetRoleEquipPathId", _m_GetRoleEquipPathId);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsShowAddEquipByPlace", _m_IsShowAddEquipByPlace);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSinglePack", _m_GetSinglePack);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnLockPackGrid", _m_UnLockPackGrid);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetItemByGuid", _m_GetItemByGuid);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetItemByIndex", _m_GetItemByIndex);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetItemsById", _m_GetItemsById);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetItems", _m_GetItems);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetItemGUIDByID", _m_GetItemGUIDByID);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetItemCountByID", _m_GetItemCountByID);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetEmptyGridCount", _m_GetEmptyGridCount);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryGetShareNumItem", _m_TryGetShareNumItem);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetItemUsedTimesToday", _m_GetItemUsedTimesToday);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetItemTotalUsedTimes", _m_GetItemTotalUsedTimes);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GotoWashAttributePoint", _m_GotoWashAttributePoint);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "EquipDecomRedCtrl", _m_EquipDecomRedCtrl);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLookIndex", _m_SetLookIndex);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshBagInfo", _m_RefreshBagInfo);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetJumpToOneKeySell", _m_SetJumpToOneKeySell);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSkillConfig", _m_GetSkillConfig);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDungeonIDByDrugID", _m_GetDungeonIDByDrugID);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDrugIDListByDungeonID", _m_GetDrugIDListByDungeonID);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsReachUseLimit", _m_IsReachUseLimit);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBetterEquipCount", _m_GetBetterEquipCount);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetColorSelect", _m_SetColorSelect);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetDevourEquipPlace", _m_SetDevourEquipPlace);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDevourModellist", _m_GetDevourModellist);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "CompareByColor", _m_CompareByColor);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetCanDevourModellist", _m_GetCanDevourModellist);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsCanDevour", _m_IsCanDevour);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsMaxDecomLv", _m_IsMaxDecomLv);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetSelectDevourList", _m_GetSelectDevourList);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshGetNewItem", _m_RefreshGetNewItem);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "AddSelectDevourModellist", _m_AddSelectDevourModellist);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "CheckIsReachDevourCondi", _m_CheckIsReachDevourCondi);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "RemoveSelectDevourModellist", _m_RemoveSelectDevourModellist);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDecomAttrDictByLv", _m_GetDecomAttrDictByLv);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsReachMinDecomposeNum", _m_IsReachMinDecomposeNum);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SendEquipdevourQuest", _m_SendEquipdevourQuest);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SendEquipDevourRecordQuest", _m_SendEquipDevourRecordQuest);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetServerDecomposeSet", _m_GetServerDecomposeSet);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetShowMatInfo", _m_SetShowMatInfo);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetDrugOrderByCnt", _m_GetDrugOrderByCnt);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "CheckIsDrugById", _m_CheckIsDrugById);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "CompareByIsHave", _m_CompareByIsHave);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsHaveDrugUse", _m_IsHaveDrugUse);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsHaveDrugRecycle", _m_IsHaveDrugRecycle);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsReachMaxUseDrug", _m_IsReachMaxUseDrug);
			
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "refrechPackEvent", _e_refrechPackEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "refreshItemCountEvent", _e_refreshItemCountEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "gridRefreshEvent", _e_gridRefreshEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "itemCntAddEvent", _e_itemCntAddEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "itemCntReduceEvent", _e_itemCntReduceEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "useItemSuccessEvent", _e_useItemSuccessEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "refreshItemDayUseCountEvent", _e_refreshItemDayUseCountEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "refreshItemSumUseCountEvent", _e_refreshItemSumUseCountEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "lookEquipEvent", _e_lookEquipEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshBagEvent", _e_RefreshBagEvent);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "itemUseAct", _e_itemUseAct);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshColorSelectAct", _e_RefreshColorSelectAct);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshEquipDecomNumAct", _e_RefreshEquipDecomNumAct);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshDecomAttrAct", _e_RefreshDecomAttrAct);
			
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "makeDruglist", _g_get_makeDruglist);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isPlayBetterEquipEffect", _g_get_isPlayBetterEquipEffect);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "fairyRedPointLvlimt", _g_get_fairyRedPointLvlimt);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "wingsRedpointLvlimt", _g_get_wingsRedpointLvlimt);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "fairyGetPathId", _g_get_fairyGetPathId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "wingsGetPathIdDict", _g_get_wingsGetPathIdDict);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "dungeonUseDict", _g_get_dungeonUseDict);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "lookLineIndex", _g_get_lookLineIndex);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "lookItemGUID", _g_get_lookItemGUID);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "colorType", _g_get_colorType);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "defaultUnSelectlist", _g_get_defaultUnSelectlist);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "devourPlacelist", _g_get_devourPlacelist);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "devourRedpointLevel", _g_get_devourRedpointLevel);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "minDevourEquipNum", _g_get_minDevourEquipNum);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "decomposeLv", _g_get_decomposeLv);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "decomposeExp", _g_get_decomposeExp);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "decomposeProgress", _g_get_decomposeProgress);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "addDecomposeExp", _g_get_addDecomposeExp);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "minDecomposeNum", _g_get_minDecomposeNum);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "isAutoDecompose", _g_get_isAutoDecompose);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "recordAutoDecomNum", _g_get_recordAutoDecomNum);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "getItems", _g_get_getItems);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "redpointEquipDecom", _g_get_redpointEquipDecom);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "selectDevourlist", _g_get_selectDevourlist);
            
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isPlayBetterEquipEffect", _s_set_isPlayBetterEquipEffect);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "isAutoDecompose", _s_set_isAutoDecompose);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "redpointEquipDecom", _s_set_redpointEquipDecom);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "selectDevourlist", _s_set_selectDevourlist);
            
			
            Utils.EndObjectRegister(type, L, translator, null, null,
                null, null, null);

            Utils.BeginClassRegister(type, L, __CreateInstance, 3, 1, 1);
			
			
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RecordKnapsackTitle", Snxxz.UI.PackModel.RecordKnapsackTitle);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipDecompose_RedKey", Snxxz.UI.PackModel.EquipDecompose_RedKey);
            
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "StrengthAttrShift_RecordKey", _g_get_StrengthAttrShift_RecordKey);
            
            Utils.RegisterFunc(L, Utils.CLS_SETTER_IDX, "StrengthAttrShift_RecordKey", _s_set_StrengthAttrShift_RecordKey);
            
			
            Utils.EndClassRegister(type, L, translator);
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstance(RealStatePtr L)
        {
            
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                if(LuaAPI.lua_gettop(L) == 1)
                {
					
                    Snxxz.UI.PackModel gen_ret = new Snxxz.UI.PackModel();
                    translator.Push(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.PackModel constructor!");
            
        }
        
		
        
		
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Init(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.Init(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_OnBeforePlayerDataInitialize(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.OnBeforePlayerDataInitialize(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_OnAfterPlayerDataInitialize(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.OnAfterPlayerDataInitialize(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_OnPlayerLoginOk(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.OnPlayerLoginOk(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UnInit(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.UnInit(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdatePack(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    H0725_tagRolePackRefreshEx _packInfo = (H0725_tagRolePackRefreshEx)translator.GetObject(L, 2, typeof(H0725_tagRolePackRefreshEx));
                    
                    gen_to_be_invoked.UpdatePack( _packInfo );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdateItem(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    H0704_tagRolePackRefresh _serverItem = (H0704_tagRolePackRefresh)translator.GetObject(L, 2, typeof(H0704_tagRolePackRefresh));
                    
                    gen_to_be_invoked.UpdateItem( _serverItem );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdateUnlockedGridCount(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    H0724_tagRolePackCanUseCount _useCount = (H0724_tagRolePackCanUseCount)translator.GetObject(L, 2, typeof(H0724_tagRolePackCanUseCount));
                    
                    gen_to_be_invoked.UpdateUnlockedGridCount( _useCount );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_RefreshItemCount(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    H0707_tagItemCountRefresh _refresh = (H0707_tagItemCountRefresh)translator.GetObject(L, 2, typeof(H0707_tagItemCountRefresh));
                    
                    gen_to_be_invoked.RefreshItemCount( _refresh );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ClearPack(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    H0711_tagClearItemPack _clearPack = (H0711_tagClearItemPack)translator.GetObject(L, 2, typeof(H0711_tagClearItemPack));
                    
                    gen_to_be_invoked.ClearPack( _clearPack );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_RemoveItem(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    H0709_tagClearItem _clearItem = (H0709_tagClearItem)translator.GetObject(L, 2, typeof(H0709_tagClearItem));
                    
                    gen_to_be_invoked.RemoveItem( _clearItem );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_PackResetOk(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    H0316_tagPackResetOK _packreset = (H0316_tagPackResetOK)translator.GetObject(L, 2, typeof(H0316_tagPackResetOK));
                    
                    gen_to_be_invoked.PackResetOk( _packreset );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UseItemSuccess(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    H0706_tagUseItemSuccess _success = (H0706_tagUseItemSuccess)translator.GetObject(L, 2, typeof(H0706_tagUseItemSuccess));
                    
                    gen_to_be_invoked.UseItemSuccess( _success );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdateItemUseCnt(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    HA809_tagMCItemDayUseCntInfo _useCntInfo = (HA809_tagMCItemDayUseCntInfo)translator.GetObject(L, 2, typeof(HA809_tagMCItemDayUseCntInfo));
                    
                    gen_to_be_invoked.UpdateItemUseCnt( _useCntInfo );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UpdateItemSumUseCnt(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    HA339_tagMCAttrFruitEatCntList _useCntInfo = (HA339_tagMCAttrFruitEatCntList)translator.GetObject(L, 2, typeof(HA339_tagMCAttrFruitEatCntList));
                    
                    gen_to_be_invoked.UpdateItemSumUseCnt( _useCntInfo );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetRoleEquipPathId(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _equipPlace = LuaAPI.xlua_tointeger(L, 2);
                    
                        int gen_ret = gen_to_be_invoked.GetRoleEquipPathId( _equipPlace );
                        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_IsShowAddEquipByPlace(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _equipPlace = LuaAPI.xlua_tointeger(L, 2);
                    
                        bool gen_ret = gen_to_be_invoked.IsShowAddEquipByPlace( _equipPlace );
                        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_GetSinglePack(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    PackType _type;translator.Get(L, 2, out _type);
                    
                        Snxxz.UI.SinglePack gen_ret = gen_to_be_invoked.GetSinglePack( _type );
                        translator.Push(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_UnLockPackGrid(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _chooseGridCount = LuaAPI.xlua_tointeger(L, 2);
                    PackType _type;translator.Get(L, 3, out _type);
                    
                    gen_to_be_invoked.UnLockPackGrid( _chooseGridCount, _type );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetItemByGuid(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    string _guid = LuaAPI.lua_tostring(L, 2);
                    
                        Snxxz.UI.ItemModel gen_ret = gen_to_be_invoked.GetItemByGuid( _guid );
                        translator.Push(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_GetItemByIndex(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    PackType _type;translator.Get(L, 2, out _type);
                    int _index = LuaAPI.xlua_tointeger(L, 3);
                    
                        Snxxz.UI.ItemModel gen_ret = gen_to_be_invoked.GetItemByIndex( _type, _index );
                        translator.Push(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_GetItemsById(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 4&& translator.Assignable<PackType>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) 
                {
                    PackType _type;translator.Get(L, 2, out _type);
                    int _id = LuaAPI.xlua_tointeger(L, 3);
                    bool _includeAuction = LuaAPI.lua_toboolean(L, 4);
                    
                        System.Collections.Generic.List<Snxxz.UI.ItemModel> gen_ret = gen_to_be_invoked.GetItemsById( _type, _id, _includeAuction );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 3&& translator.Assignable<PackType>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) 
                {
                    PackType _type;translator.Get(L, 2, out _type);
                    int _id = LuaAPI.xlua_tointeger(L, 3);
                    
                        System.Collections.Generic.List<Snxxz.UI.ItemModel> gen_ret = gen_to_be_invoked.GetItemsById( _type, _id );
                        translator.Push(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.PackModel.GetItemsById!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetItems(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    PackType _packType;translator.Get(L, 2, out _packType);
                    Snxxz.UI.SinglePack.FilterParams _param;translator.Get(L, 3, out _param);
                    
                        System.Collections.Generic.List<Snxxz.UI.ItemModel> gen_ret = gen_to_be_invoked.GetItems( _packType, _param );
                        translator.Push(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_GetItemGUIDByID(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)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 _itemId = LuaAPI.xlua_tointeger(L, 2);
                    bool _includeAuction = LuaAPI.lua_toboolean(L, 3);
                    
                        string gen_ret = gen_to_be_invoked.GetItemGUIDByID( _itemId, _includeAuction );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) 
                {
                    int _itemId = LuaAPI.xlua_tointeger(L, 2);
                    
                        string gen_ret = gen_to_be_invoked.GetItemGUIDByID( _itemId );
                        LuaAPI.lua_pushstring(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.PackModel.GetItemGUIDByID!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetItemCountByID(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 4&& translator.Assignable<PackType>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 4)) 
                {
                    PackType _type;translator.Get(L, 2, out _type);
                    int _id = LuaAPI.xlua_tointeger(L, 3);
                    bool _includeAuction = LuaAPI.lua_toboolean(L, 4);
                    
                        int gen_ret = gen_to_be_invoked.GetItemCountByID( _type, _id, _includeAuction );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 3&& translator.Assignable<PackType>(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) 
                {
                    PackType _type;translator.Get(L, 2, out _type);
                    int _id = LuaAPI.xlua_tointeger(L, 3);
                    
                        int gen_ret = gen_to_be_invoked.GetItemCountByID( _type, _id );
                        LuaAPI.xlua_pushinteger(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.PackModel.GetItemCountByID!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetEmptyGridCount(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    PackType _type;translator.Get(L, 2, out _type);
                    
                        int gen_ret = gen_to_be_invoked.GetEmptyGridCount( _type );
                        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_TryGetShareNumItem(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _itemId = LuaAPI.xlua_tointeger(L, 2);
                    System.Collections.Generic.List<int> _idlist;
                    
                        bool gen_ret = gen_to_be_invoked.TryGetShareNumItem( _itemId, out _idlist );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    translator.Push(L, _idlist);
                        
                    
                    
                    
                    return 2;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetItemUsedTimesToday(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _itemId = LuaAPI.xlua_tointeger(L, 2);
                    
                        int gen_ret = gen_to_be_invoked.GetItemUsedTimesToday( _itemId );
                        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_GetItemTotalUsedTimes(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _itemId = LuaAPI.xlua_tointeger(L, 2);
                    
                        int gen_ret = gen_to_be_invoked.GetItemTotalUsedTimes( _itemId );
                        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_GotoWashAttributePoint(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    string _guid = LuaAPI.lua_tostring(L, 2);
                    
                    gen_to_be_invoked.GotoWashAttributePoint( _guid );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_EquipDecomRedCtrl(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.EquipDecomRedCtrl(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetLookIndex(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 3&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) 
                {
                    string _guid = LuaAPI.lua_tostring(L, 2);
                    int _singleRowCount = LuaAPI.xlua_tointeger(L, 3);
                    
                    gen_to_be_invoked.SetLookIndex( _guid, _singleRowCount );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) 
                {
                    string _guid = LuaAPI.lua_tostring(L, 2);
                    
                    gen_to_be_invoked.SetLookIndex( _guid );
                    
                    
                    
                    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.PackModel.SetLookIndex!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_RefreshBagInfo(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.RefreshBagInfo(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetJumpToOneKeySell(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    UnityEngine.Transform _parent = (UnityEngine.Transform)translator.GetObject(L, 2, typeof(UnityEngine.Transform));
                    
                    gen_to_be_invoked.SetJumpToOneKeySell( _parent );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetSkillConfig(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _itemId = LuaAPI.xlua_tointeger(L, 2);
                    
                        SkillConfig gen_ret = gen_to_be_invoked.GetSkillConfig( _itemId );
                        translator.Push(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_GetDungeonIDByDrugID(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _drugID = LuaAPI.xlua_tointeger(L, 2);
                    
                        int gen_ret = gen_to_be_invoked.GetDungeonIDByDrugID( _drugID );
                        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_GetDrugIDListByDungeonID(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _dungeonID = LuaAPI.xlua_tointeger(L, 2);
                    
                        int[] gen_ret = gen_to_be_invoked.GetDrugIDListByDungeonID( _dungeonID );
                        translator.Push(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_IsReachUseLimit(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    string _guid = LuaAPI.lua_tostring(L, 2);
                    ulong _count;
                    
                        bool gen_ret = gen_to_be_invoked.IsReachUseLimit( _guid, out _count );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    LuaAPI.lua_pushuint64(L, _count);
                        
                    
                    
                    
                    return 2;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetBetterEquipCount(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    System.Collections.Generic.List<Snxxz.UI.ItemModel> _itemModels = (System.Collections.Generic.List<Snxxz.UI.ItemModel>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<Snxxz.UI.ItemModel>));
                    
                        int gen_ret = gen_to_be_invoked.GetBetterEquipCount( _itemModels );
                        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_SetColorSelect(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    Snxxz.UI.PackModel.EquipColorType _type;translator.Get(L, 2, out _type);
                    
                    gen_to_be_invoked.SetColorSelect( _type );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetDevourEquipPlace(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.SetDevourEquipPlace(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetDevourModellist(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        System.Collections.Generic.List<Snxxz.UI.ItemModel> gen_ret = gen_to_be_invoked.GetDevourModellist(  );
                        translator.Push(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_CompareByColor(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    Snxxz.UI.ItemModel _start = (Snxxz.UI.ItemModel)translator.GetObject(L, 2, typeof(Snxxz.UI.ItemModel));
                    Snxxz.UI.ItemModel _next = (Snxxz.UI.ItemModel)translator.GetObject(L, 3, typeof(Snxxz.UI.ItemModel));
                    
                        int gen_ret = gen_to_be_invoked.CompareByColor( _start, _next );
                        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_GetCanDevourModellist(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        System.Collections.Generic.List<Snxxz.UI.ItemModel> gen_ret = gen_to_be_invoked.GetCanDevourModellist(  );
                        translator.Push(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_IsCanDevour(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    Snxxz.UI.ItemModel _model = (Snxxz.UI.ItemModel)translator.GetObject(L, 2, typeof(Snxxz.UI.ItemModel));
                    
                        bool gen_ret = gen_to_be_invoked.IsCanDevour( _model );
                        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_IsMaxDecomLv(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _decomLv = LuaAPI.xlua_tointeger(L, 2);
                    int _realLv;
                    
                        bool gen_ret = gen_to_be_invoked.IsMaxDecomLv( _decomLv, out _realLv );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    LuaAPI.xlua_pushinteger(L, _realLv);
                        
                    
                    
                    
                    return 2;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetSelectDevourList(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.GetSelectDevourList(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_RefreshGetNewItem(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    Snxxz.UI.ItemModel _model = (Snxxz.UI.ItemModel)translator.GetObject(L, 2, typeof(Snxxz.UI.ItemModel));
                    
                    gen_to_be_invoked.RefreshGetNewItem( _model );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_AddSelectDevourModellist(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    Snxxz.UI.ItemModel _model = (Snxxz.UI.ItemModel)translator.GetObject(L, 2, typeof(Snxxz.UI.ItemModel));
                    
                    gen_to_be_invoked.AddSelectDevourModellist( _model );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_CheckIsReachDevourCondi(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    Snxxz.UI.ItemModel _model = (Snxxz.UI.ItemModel)translator.GetObject(L, 2, typeof(Snxxz.UI.ItemModel));
                    
                        bool gen_ret = gen_to_be_invoked.CheckIsReachDevourCondi( _model );
                        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_RemoveSelectDevourModellist(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    Snxxz.UI.ItemModel _model = (Snxxz.UI.ItemModel)translator.GetObject(L, 2, typeof(Snxxz.UI.ItemModel));
                    
                    gen_to_be_invoked.RemoveSelectDevourModellist( _model );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetDecomAttrDictByLv(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _decomLv = LuaAPI.xlua_tointeger(L, 2);
                    
                        System.Collections.Generic.Dictionary<int, int> gen_ret = gen_to_be_invoked.GetDecomAttrDictByLv( _decomLv );
                        translator.Push(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_IsReachMinDecomposeNum(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        bool gen_ret = gen_to_be_invoked.IsReachMinDecomposeNum(  );
                        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_SendEquipdevourQuest(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    bool _auto = LuaAPI.lua_toboolean(L, 2);
                    
                    gen_to_be_invoked.SendEquipdevourQuest( _auto );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SendEquipDevourRecordQuest(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.SendEquipDevourRecordQuest(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetServerDecomposeSet(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    HA31C_tagMCEquipDecomposeInfo _info = (HA31C_tagMCEquipDecomposeInfo)translator.GetObject(L, 2, typeof(HA31C_tagMCEquipDecomposeInfo));
                    
                    gen_to_be_invoked.GetServerDecomposeSet( _info );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetShowMatInfo(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        System.Collections.Generic.List<Snxxz.UI.PackModel.DecomposeGetMatInfo> gen_ret = gen_to_be_invoked.SetShowMatInfo(  );
                        translator.Push(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_GetDrugOrderByCnt(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        System.Collections.Generic.List<AttrFruitConfig> gen_ret = gen_to_be_invoked.GetDrugOrderByCnt(  );
                        translator.Push(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_CheckIsDrugById(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _itemId = LuaAPI.xlua_tointeger(L, 2);
                    
                        bool gen_ret = gen_to_be_invoked.CheckIsDrugById( _itemId );
                        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_CompareByIsHave(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    AttrFruitConfig _start = (AttrFruitConfig)translator.GetObject(L, 2, typeof(AttrFruitConfig));
                    AttrFruitConfig _end = (AttrFruitConfig)translator.GetObject(L, 3, typeof(AttrFruitConfig));
                    
                        int gen_ret = gen_to_be_invoked.CompareByIsHave( _start, _end );
                        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_IsHaveDrugUse(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    AttrFruitConfig _fruitConfig = (AttrFruitConfig)translator.GetObject(L, 2, typeof(AttrFruitConfig));
                    
                        bool gen_ret = gen_to_be_invoked.IsHaveDrugUse( _fruitConfig );
                        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_IsHaveDrugRecycle(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    AttrFruitConfig _fruitConfig = (AttrFruitConfig)translator.GetObject(L, 2, typeof(AttrFruitConfig));
                    
                        bool gen_ret = gen_to_be_invoked.IsHaveDrugRecycle( _fruitConfig );
                        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_IsReachMaxUseDrug(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    AttrFruitConfig _fruitConfig = (AttrFruitConfig)translator.GetObject(L, 2, typeof(AttrFruitConfig));
                    
                        bool gen_ret = gen_to_be_invoked.IsReachMaxUseDrug( _fruitConfig );
                        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 _g_get_makeDruglist(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.makeDruglist);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isPlayBetterEquipEffect(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isPlayBetterEquipEffect);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_fairyRedPointLvlimt(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.fairyRedPointLvlimt);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_wingsRedpointLvlimt(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.wingsRedpointLvlimt);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_fairyGetPathId(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.fairyGetPathId);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_wingsGetPathIdDict(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.wingsGetPathIdDict);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_dungeonUseDict(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.dungeonUseDict);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_lookLineIndex(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.lookLineIndex);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_lookItemGUID(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushstring(L, gen_to_be_invoked.lookItemGUID);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_colorType(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.colorType);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_defaultUnSelectlist(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.defaultUnSelectlist);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_devourPlacelist(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.devourPlacelist);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_devourRedpointLevel(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.devourRedpointLevel);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_minDevourEquipNum(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.minDevourEquipNum);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_decomposeLv(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.decomposeLv);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_decomposeExp(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.decomposeExp);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_decomposeProgress(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.decomposeProgress);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_addDecomposeExp(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.addDecomposeExp);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_minDecomposeNum(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.minDecomposeNum);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_isAutoDecompose(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.isAutoDecompose);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_recordAutoDecomNum(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.recordAutoDecomNum);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_getItems(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.getItems);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_StrengthAttrShift_RecordKey(RealStatePtr L)
        {
            try {
            
                LuaAPI.lua_pushstring(L, Snxxz.UI.PackModel.StrengthAttrShift_RecordKey);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_redpointEquipDecom(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.redpointEquipDecom);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_selectDevourlist(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.selectDevourlist);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_isPlayBetterEquipEffect(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isPlayBetterEquipEffect = 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_isAutoDecompose(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.isAutoDecompose = 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_StrengthAttrShift_RecordKey(RealStatePtr L)
        {
            try {
                
                Snxxz.UI.PackModel.StrengthAttrShift_RecordKey = LuaAPI.lua_tostring(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_redpointEquipDecom(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.redpointEquipDecom = (Snxxz.UI.Redpoint)translator.GetObject(L, 2, typeof(Snxxz.UI.Redpoint));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_selectDevourlist(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.selectDevourlist = (System.Collections.Generic.List<Snxxz.UI.ItemModel>)translator.GetObject(L, 2, typeof(System.Collections.Generic.List<Snxxz.UI.ItemModel>));
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
		
		
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_refrechPackEvent(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
            Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                System.Action<PackType> gen_delegate = translator.GetDelegate<System.Action<PackType>>(L, 3);
                if (gen_delegate == null) {
                    return LuaAPI.luaL_error(L, "#3 need System.Action<PackType>!");
                }
				
                if (gen_param_count == 3)
                {
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "+")) {
                        gen_to_be_invoked.refrechPackEvent += gen_delegate;
                        return 0;
                    } 
					
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.refrechPackEvent -= 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.PackModel.refrechPackEvent!");
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_refreshItemCountEvent(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
            Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                System.Action<PackType, int, int> gen_delegate = translator.GetDelegate<System.Action<PackType, int, int>>(L, 3);
                if (gen_delegate == null) {
                    return LuaAPI.luaL_error(L, "#3 need System.Action<PackType, int, int>!");
                }
				
                if (gen_param_count == 3)
                {
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "+")) {
                        gen_to_be_invoked.refreshItemCountEvent += gen_delegate;
                        return 0;
                    } 
					
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.refreshItemCountEvent -= 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.PackModel.refreshItemCountEvent!");
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_gridRefreshEvent(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
            Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                System.Action<PackType> gen_delegate = translator.GetDelegate<System.Action<PackType>>(L, 3);
                if (gen_delegate == null) {
                    return LuaAPI.luaL_error(L, "#3 need System.Action<PackType>!");
                }
				
                if (gen_param_count == 3)
                {
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "+")) {
                        gen_to_be_invoked.gridRefreshEvent += gen_delegate;
                        return 0;
                    } 
					
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.gridRefreshEvent -= 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.PackModel.gridRefreshEvent!");
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_itemCntAddEvent(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
            Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                System.Action<PackType, int, int> gen_delegate = translator.GetDelegate<System.Action<PackType, int, int>>(L, 3);
                if (gen_delegate == null) {
                    return LuaAPI.luaL_error(L, "#3 need System.Action<PackType, int, int>!");
                }
				
                if (gen_param_count == 3)
                {
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "+")) {
                        gen_to_be_invoked.itemCntAddEvent += gen_delegate;
                        return 0;
                    } 
					
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.itemCntAddEvent -= 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.PackModel.itemCntAddEvent!");
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_itemCntReduceEvent(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
            Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                System.Action<PackType, int, int> gen_delegate = translator.GetDelegate<System.Action<PackType, int, int>>(L, 3);
                if (gen_delegate == null) {
                    return LuaAPI.luaL_error(L, "#3 need System.Action<PackType, int, int>!");
                }
				
                if (gen_param_count == 3)
                {
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "+")) {
                        gen_to_be_invoked.itemCntReduceEvent += gen_delegate;
                        return 0;
                    } 
					
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.itemCntReduceEvent -= 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.PackModel.itemCntReduceEvent!");
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_useItemSuccessEvent(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
            Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)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.useItemSuccessEvent += gen_delegate;
                        return 0;
                    } 
					
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.useItemSuccessEvent -= 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.PackModel.useItemSuccessEvent!");
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_refreshItemDayUseCountEvent(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
            Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)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.refreshItemDayUseCountEvent += gen_delegate;
                        return 0;
                    } 
					
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.refreshItemDayUseCountEvent -= 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.PackModel.refreshItemDayUseCountEvent!");
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_refreshItemSumUseCountEvent(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
            Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)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.refreshItemSumUseCountEvent += gen_delegate;
                        return 0;
                    } 
					
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.refreshItemSumUseCountEvent -= 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.PackModel.refreshItemSumUseCountEvent!");
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_lookEquipEvent(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
            Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)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.lookEquipEvent += gen_delegate;
                        return 0;
                    } 
					
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.lookEquipEvent -= 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.PackModel.lookEquipEvent!");
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_RefreshBagEvent(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
            Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)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.RefreshBagEvent += gen_delegate;
                        return 0;
                    } 
					
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.RefreshBagEvent -= 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.PackModel.RefreshBagEvent!");
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_itemUseAct(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
            Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                System.Action<PackType, string> gen_delegate = translator.GetDelegate<System.Action<PackType, string>>(L, 3);
                if (gen_delegate == null) {
                    return LuaAPI.luaL_error(L, "#3 need System.Action<PackType, string>!");
                }
				
                if (gen_param_count == 3)
                {
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "+")) {
                        gen_to_be_invoked.itemUseAct += gen_delegate;
                        return 0;
                    } 
					
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.itemUseAct -= 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.PackModel.itemUseAct!");
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_RefreshColorSelectAct(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
            Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
                System.Action<Snxxz.UI.PackModel.EquipColorType> gen_delegate = translator.GetDelegate<System.Action<Snxxz.UI.PackModel.EquipColorType>>(L, 3);
                if (gen_delegate == null) {
                    return LuaAPI.luaL_error(L, "#3 need System.Action<Snxxz.UI.PackModel.EquipColorType>!");
                }
				
                if (gen_param_count == 3)
                {
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "+")) {
                        gen_to_be_invoked.RefreshColorSelectAct += gen_delegate;
                        return 0;
                    } 
					
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.RefreshColorSelectAct -= 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.PackModel.RefreshColorSelectAct!");
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_RefreshEquipDecomNumAct(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
            Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)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.RefreshEquipDecomNumAct += gen_delegate;
                        return 0;
                    } 
					
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.RefreshEquipDecomNumAct -= 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.PackModel.RefreshEquipDecomNumAct!");
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_RefreshDecomAttrAct(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
            Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)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.RefreshDecomAttrAct += gen_delegate;
                        return 0;
                    } 
					
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.RefreshDecomAttrAct -= 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.PackModel.RefreshDecomAttrAct!");
            return 0;
        }
        
		
		
    }
}

 Lua/Gen/SnxxzUIPackModelWrap.cs.meta

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

 Lua/Gen/SnxxzUIPersonalBossModelWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(Snxxz.UI.PersonalBossModel);
            Utils.BeginObjectRegister(type, L, translator, 0, 10, 2, 2);
            Utils.BeginObjectRegister(type, L, translator, 0, 11, 2, 2);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnInit", _m_UnInit);
@@ -30,7 +30,9 @@
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetPersonalBosses", _m_GetPersonalBosses);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsBossUnLocked", _m_IsBossUnLocked);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLatestUnLockBoss", _m_GetLatestUnLockBoss);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBossNpcId", _m_GetBossNpcId);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "UpdateRedpoint", _m_UpdateRedpoint);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "RequestGotoDungeon", _m_RequestGotoDungeon);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "bossSelectedEvent", _e_bossSelectedEvent);
            
@@ -285,6 +287,35 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetBossNpcId(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PersonalBossModel gen_to_be_invoked = (Snxxz.UI.PersonalBossModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _lineId = LuaAPI.xlua_tointeger(L, 2);
                    
                        int gen_ret = gen_to_be_invoked.GetBossNpcId( _lineId );
                        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_UpdateRedpoint(RealStatePtr L)
        {
            try {
@@ -312,6 +343,37 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_RequestGotoDungeon(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PersonalBossModel gen_to_be_invoked = (Snxxz.UI.PersonalBossModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int __bossId = LuaAPI.xlua_tointeger(L, 2);
                    
                    gen_to_be_invoked.RequestGotoDungeon( __bossId );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_selectedBoss(RealStatePtr L)
        {
            try {

 Lua/Gen/SnxxzUIReikiRootModelWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(Snxxz.UI.ReikiRootModel);
            Utils.BeginObjectRegister(type, L, translator, 0, 22, 17, 8);
            Utils.BeginObjectRegister(type, L, translator, 0, 23, 19, 10);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeforePlayerDataInitialize", _m_OnBeforePlayerDataInitialize);
@@ -32,6 +32,7 @@
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetReikiRootFreePoint", _m_GetReikiRootFreePoint);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetTotalWashPoint", _m_GetTotalWashPoint);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetReikiRootTotalPoint", _m_GetReikiRootTotalPoint);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetReikiRootTotalPointWithFree", _m_GetReikiRootTotalPointWithFree);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetReikiRootRecommendPoint", _m_GetReikiRootRecommendPoint);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetQualityPoint", _m_GetQualityPoint);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetReikiRootProperty", _m_GetReikiRootProperty);
@@ -59,6 +60,9 @@
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "resetReikiRemind", _g_get_resetReikiRemind);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "resetReikiLimitLevel", _g_get_resetReikiLimitLevel);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "selectReikiRoot", _g_get_selectReikiRoot);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "openFromTreasureSkill", _g_get_openFromTreasureSkill);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "reikiPointPromoteSymbol", _g_get_reikiPointPromoteSymbol);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "reikiPointAutoAddLevel", _g_get_reikiPointAutoAddLevel);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "lastReikiRootPoints", _g_get_lastReikiRootPoints);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "afterReikiRootPoints", _g_get_afterReikiRootPoints);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "reikiRoots", _g_get_reikiRoots);
@@ -69,6 +73,8 @@
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "resetReikiRootRecord", _s_set_resetReikiRootRecord);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "resetReikiRemind", _s_set_resetReikiRemind);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "selectReikiRoot", _s_set_selectReikiRoot);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "openFromTreasureSkill", _s_set_openFromTreasureSkill);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "reikiPointPromoteSymbol", _s_set_reikiPointPromoteSymbol);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "lastReikiRootPoints", _s_set_lastReikiRootPoints);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "afterReikiRootPoints", _s_set_afterReikiRootPoints);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "reikiRoots", _s_set_reikiRoots);
@@ -372,6 +378,34 @@
                {
                    
                        int gen_ret = gen_to_be_invoked.GetReikiRootTotalPoint(  );
                        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_GetReikiRootTotalPointWithFree(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.ReikiRootModel gen_to_be_invoked = (Snxxz.UI.ReikiRootModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        int gen_ret = gen_to_be_invoked.GetReikiRootTotalPointWithFree(  );
                        LuaAPI.xlua_pushinteger(L, gen_ret);
                    
                    
@@ -874,6 +908,48 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_openFromTreasureSkill(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.ReikiRootModel gen_to_be_invoked = (Snxxz.UI.ReikiRootModel)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.openFromTreasureSkill);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_reikiPointPromoteSymbol(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.ReikiRootModel gen_to_be_invoked = (Snxxz.UI.ReikiRootModel)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.reikiPointPromoteSymbol);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_reikiPointAutoAddLevel(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.ReikiRootModel gen_to_be_invoked = (Snxxz.UI.ReikiRootModel)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.reikiPointAutoAddLevel);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_lastReikiRootPoints(RealStatePtr L)
        {
            try {
@@ -1007,6 +1083,36 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_openFromTreasureSkill(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.ReikiRootModel gen_to_be_invoked = (Snxxz.UI.ReikiRootModel)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.openFromTreasureSkill = 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_reikiPointPromoteSymbol(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.ReikiRootModel gen_to_be_invoked = (Snxxz.UI.ReikiRootModel)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.reikiPointPromoteSymbol = 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_lastReikiRootPoints(RealStatePtr L)
        {
            try {

 Lua/Gen/SnxxzUIRewardPreviewGroupWrap.cs

@@ -21,10 +21,11 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(Snxxz.UI.RewardPreviewGroup);
            Utils.BeginObjectRegister(type, L, translator, 0, 3, 0, 0);
            Utils.BeginObjectRegister(type, L, translator, 0, 4, 0, 0);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Display", _m_Display);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "LuaDisplay", _m_LuaDisplay);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "LuaDisplayInt2", _m_LuaDisplayInt2);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Hide", _m_Hide);
            
            
@@ -170,6 +171,34 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_LuaDisplayInt2(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.RewardPreviewGroup gen_to_be_invoked = (Snxxz.UI.RewardPreviewGroup)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    Int2[] _rewards = (Int2[])translator.GetObject(L, 2, typeof(Int2[]));
                    
                    gen_to_be_invoked.LuaDisplayInt2( _rewards );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Hide(RealStatePtr L)
        {
            try {

 Lua/Gen/SnxxzUIRidingPetBossModelWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(Snxxz.UI.RidingPetBossModel);
            Utils.BeginObjectRegister(type, L, translator, 0, 8, 4, 3);
            Utils.BeginObjectRegister(type, L, translator, 0, 10, 3, 3);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeforePlayerDataInitialize", _m_OnBeforePlayerDataInitialize);
@@ -30,10 +30,12 @@
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "ReceivePackage", _m_ReceivePackage);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBossName", _m_GetBossName);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetBossRemianedHP", _m_GetBossRemianedHP);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsBossAlive", _m_IsBossAlive);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetRidingPetBossLineDictAction", _e_GetRidingPetBossLineDictAction);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "onBossStateRefresh", _e_onBossStateRefresh);
            
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "BossIDArray", _g_get_BossIDArray);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "BossIDArray", _g_get_BossIDArray);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Boss1RewardIDArray", _g_get_Boss1RewardIDArray);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "Boss2RewardIDArray", _g_get_Boss2RewardIDArray);
            
@@ -294,6 +296,37 @@
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsBossAlive(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.RidingPetBossModel gen_to_be_invoked = (Snxxz.UI.RidingPetBossModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _index = LuaAPI.xlua_tointeger(L, 2);
                    
                        bool gen_ret = gen_to_be_invoked.IsBossAlive( _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 _g_get_BossIDArray(RealStatePtr L)
@@ -420,6 +453,40 @@
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_onBossStateRefresh(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
            Snxxz.UI.RidingPetBossModel gen_to_be_invoked = (Snxxz.UI.RidingPetBossModel)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.onBossStateRefresh += gen_delegate;
                        return 0;
                    } 
					
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.onBossStateRefresh -= 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.RidingPetBossModel.onBossStateRefresh!");
            return 0;
        }
        
        
        
    }

 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, 43, 19, 12);
            Utils.BeginObjectRegister(type, L, translator, 0, 43, 20, 12);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeforePlayerDataInitialize", _m_OnBeforePlayerDataInitialize);
@@ -86,6 +86,7 @@
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "entranceOpenCondition", _g_get_entranceOpenCondition);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "treasureChapterId", _g_get_treasureChapterId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "displayInductionId", _g_get_displayInductionId);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "treasureAddReikiPoint", _g_get_treasureAddReikiPoint);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "vipKillNPCTreasure", _g_get_vipKillNPCTreasure);
            
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "selectedTreasure", _s_set_selectedTreasure);
@@ -105,9 +106,10 @@
            Utils.EndObjectRegister(type, L, translator, null, null,
                null, null, null);

            Utils.BeginClassRegister(type, L, __CreateInstance, 5, 1, 1);
            Utils.BeginClassRegister(type, L, __CreateInstance, 6, 1, 1);
            
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CLIENTDATAMAP", Snxxz.UI.TreasureModel.CLIENTDATAMAP);
            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);
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TREASURE_GUIDE_ID", Snxxz.UI.TreasureModel.TREASURE_GUIDE_ID);
@@ -1449,6 +1451,20 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_treasureAddReikiPoint(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.treasureAddReikiPoint);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_vipKillNPCTreasure(RealStatePtr L)
        {
            try {

 Lua/Gen/SnxxzUITreasureSkillModelWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(Snxxz.UI.TreasureSkillModel);
            Utils.BeginObjectRegister(type, L, translator, 0, 23, 7, 4);
            Utils.BeginObjectRegister(type, L, translator, 0, 23, 8, 4);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeforePlayerDataInitialize", _m_OnBeforePlayerDataInitialize);
@@ -49,6 +49,7 @@
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "expertActiveRefresh", _e_expertActiveRefresh);
            
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "selectSkill", _g_get_selectSkill);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "serverInited", _g_get_serverInited);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "skillLevelUpLimitLevel", _g_get_skillLevelUpLimitLevel);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "requireRemind", _g_get_requireRemind);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "newSatisfyActiveExpertDirty", _g_get_newSatisfyActiveExpertDirty);
@@ -644,6 +645,20 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_serverInited(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.TreasureSkillModel gen_to_be_invoked = (Snxxz.UI.TreasureSkillModel)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushboolean(L, gen_to_be_invoked.serverInited);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_skillLevelUpLimitLevel(RealStatePtr L)
        {
            try {

 Lua/Gen/SnxxzUIWingsRedDotModelWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(Snxxz.UI.WingsRedDotModel);
            Utils.BeginObjectRegister(type, L, translator, 0, 5, 2, 2);
            Utils.BeginObjectRegister(type, L, translator, 0, 5, 1, 1);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPlayerLoginOk", _m_OnPlayerLoginOk);
@@ -30,11 +30,9 @@
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "WingsDot", _m_WingsDot);
            
            
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "redPointStre", _g_get_redPointStre);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsBoolOpenWingeWin", _g_get_IsBoolOpenWingeWin);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "IsBoolOpenWingeWin", _g_get_IsBoolOpenWingeWin);
            
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "redPointStre", _s_set_redPointStre);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "IsBoolOpenWingeWin", _s_set_IsBoolOpenWingeWin);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "IsBoolOpenWingeWin", _s_set_IsBoolOpenWingeWin);
            
            
            Utils.EndObjectRegister(type, L, translator, null, null,
@@ -219,19 +217,6 @@
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_redPointStre(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.WingsRedDotModel gen_to_be_invoked = (Snxxz.UI.WingsRedDotModel)translator.FastGetCSObj(L, 1);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_IsBoolOpenWingeWin(RealStatePtr L)
        {
            try {
@@ -246,20 +231,6 @@
        }
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_redPointStre(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.WingsRedDotModel gen_to_be_invoked = (Snxxz.UI.WingsRedDotModel)translator.FastGetCSObj(L, 1);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_IsBoolOpenWingeWin(RealStatePtr L)

 Lua/Gen/TaskFeedbackConfigWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(TaskFeedbackConfig);
            Utils.BeginObjectRegister(type, L, translator, 0, 0, 9, 0);
            Utils.BeginObjectRegister(type, L, translator, 0, 0, 11, 0);
            
            
            
@@ -31,7 +31,11 @@
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "equips", _g_get_equips);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "items", _g_get_items);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "sideTasks", _g_get_sideTasks);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "reikiRoot", _g_get_reikiRoot);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "succGuide", _g_get_succGuide);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "jump", _g_get_jump);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "failFuncs", _g_get_failFuncs);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "remind", _g_get_remind);
            
            
            
@@ -364,17 +368,80 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_reikiRoot(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                TaskFeedbackConfig gen_to_be_invoked = (TaskFeedbackConfig)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushstring(L, gen_to_be_invoked.reikiRoot);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_succGuide(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
                TaskFeedbackConfig gen_to_be_invoked = (TaskFeedbackConfig)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.succGuide);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.succGuide);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_jump(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                TaskFeedbackConfig gen_to_be_invoked = (TaskFeedbackConfig)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.jump);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_failFuncs(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                TaskFeedbackConfig gen_to_be_invoked = (TaskFeedbackConfig)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushstring(L, gen_to_be_invoked.failFuncs);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_remind(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                TaskFeedbackConfig gen_to_be_invoked = (TaskFeedbackConfig)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.remind);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        
        
		
		
		
		
    }
}

 Lua/Gen/TaskFeedbackFuncConfigWrap.cs

New file
@@ -0,0 +1,402 @@
#if USE_UNI_LUA
using LuaAPI = UniLua.Lua;
using RealStatePtr = UniLua.ILuaState;
using LuaCSFunction = UniLua.CSharpFunctionDelegate;
#else
using LuaAPI = XLua.LuaDLL.Lua;
using RealStatePtr = System.IntPtr;
using LuaCSFunction = XLua.LuaDLL.lua_CSFunction;
#endif

using XLua;
using System.Collections.Generic;


namespace XLua.CSObjectWrap
{
    using Utils = XLua.Utils;
    public class TaskFeedbackFuncConfigWrap 
    {
        public static void __Register(RealStatePtr L)
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(TaskFeedbackFuncConfig);
            Utils.BeginObjectRegister(type, L, translator, 0, 0, 8, 0);
			
			
			
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "id", _g_get_id);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "name", _g_get_name);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "jump", _g_get_jump);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "guide", _g_get_guide);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "type", _g_get_type);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "condition", _g_get_condition);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "itemCondition", _g_get_itemCondition);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "betterEquips", _g_get_betterEquips);
            
			
			
            Utils.EndObjectRegister(type, L, translator, null, null,
                null, null, null);

            Utils.BeginClassRegister(type, L, __CreateInstance, 6, 1, 0);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "Get", _m_Get_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetKeys", _m_GetKeys_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetValues", _m_GetValues_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "Has", _m_Has_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "Init", _m_Init_xlua_st_);
            
			
            
            Utils.RegisterFunc(L, Utils.CLS_GETTER_IDX, "inited", _g_get_inited);
            
			
			
            Utils.EndClassRegister(type, L, translator);
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int __CreateInstance(RealStatePtr L)
        {
            
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                if(LuaAPI.lua_gettop(L) == 1)
                {
					
                    TaskFeedbackFuncConfig gen_ret = new TaskFeedbackFuncConfig();
                    translator.Push(L, gen_ret);
                    
                    return 1;
                }
                if(LuaAPI.lua_gettop(L) == 2 && (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING))
                {
                    string _input = LuaAPI.lua_tostring(L, 2);
					
                    TaskFeedbackFuncConfig gen_ret = new TaskFeedbackFuncConfig(_input);
                    translator.Push(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 TaskFeedbackFuncConfig constructor!");
            
        }
        
		
        
		
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Get_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) 
                {
                    int _id = LuaAPI.xlua_tointeger(L, 1);
                    
                        TaskFeedbackFuncConfig gen_ret = TaskFeedbackFuncConfig.Get( _id );
                        translator.Push(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) 
                {
                    string _id = LuaAPI.lua_tostring(L, 1);
                    
                        TaskFeedbackFuncConfig gen_ret = TaskFeedbackFuncConfig.Get( _id );
                        translator.Push(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 TaskFeedbackFuncConfig.Get!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetKeys_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    
                        System.Collections.Generic.List<string> gen_ret = TaskFeedbackFuncConfig.GetKeys(  );
                        translator.Push(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_GetValues_xlua_st_(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
            
                
                {
                    
                        System.Collections.Generic.List<TaskFeedbackFuncConfig> gen_ret = TaskFeedbackFuncConfig.GetValues(  );
                        translator.Push(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_Has_xlua_st_(RealStatePtr L)
        {
            try {
            
            
            
                int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 1&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 1)) 
                {
                    int _id = LuaAPI.xlua_tointeger(L, 1);
                    
                        bool gen_ret = TaskFeedbackFuncConfig.Has( _id );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                if(gen_param_count == 1&& (LuaAPI.lua_isnil(L, 1) || LuaAPI.lua_type(L, 1) == LuaTypes.LUA_TSTRING)) 
                {
                    string _id = LuaAPI.lua_tostring(L, 1);
                    
                        bool gen_ret = TaskFeedbackFuncConfig.Has( _id );
                        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 TaskFeedbackFuncConfig.Has!");
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Init_xlua_st_(RealStatePtr L)
        {
            try {
            
            
            
                int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 1&& LuaTypes.LUA_TBOOLEAN == LuaAPI.lua_type(L, 1)) 
                {
                    bool _sync = LuaAPI.lua_toboolean(L, 1);
                    
                    TaskFeedbackFuncConfig.Init( _sync );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 0) 
                {
                    
                    TaskFeedbackFuncConfig.Init(  );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
            return LuaAPI.luaL_error(L, "invalid arguments to TaskFeedbackFuncConfig.Init!");
            
        }
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_inited(RealStatePtr L)
        {
            try {
            
                LuaAPI.lua_pushboolean(L, TaskFeedbackFuncConfig.inited);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_id(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                TaskFeedbackFuncConfig gen_to_be_invoked = (TaskFeedbackFuncConfig)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.id);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_name(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                TaskFeedbackFuncConfig gen_to_be_invoked = (TaskFeedbackFuncConfig)translator.FastGetCSObj(L, 1);
                LuaAPI.lua_pushstring(L, gen_to_be_invoked.name);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_jump(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                TaskFeedbackFuncConfig gen_to_be_invoked = (TaskFeedbackFuncConfig)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.jump);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_guide(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                TaskFeedbackFuncConfig gen_to_be_invoked = (TaskFeedbackFuncConfig)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.guide);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_type(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                TaskFeedbackFuncConfig gen_to_be_invoked = (TaskFeedbackFuncConfig)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.type);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_condition(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                TaskFeedbackFuncConfig gen_to_be_invoked = (TaskFeedbackFuncConfig)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.condition);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_itemCondition(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                TaskFeedbackFuncConfig gen_to_be_invoked = (TaskFeedbackFuncConfig)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.itemCondition);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_betterEquips(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                TaskFeedbackFuncConfig gen_to_be_invoked = (TaskFeedbackFuncConfig)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.betterEquips);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        
        
		
		
		
		
    }
}

 Lua/Gen/TaskFeedbackFuncConfigWrap.cs.meta

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

 Lua/Gen/TreasureDungeonConfigWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(TreasureDungeonConfig);
            Utils.BeginObjectRegister(type, L, translator, 0, 0, 8, 0);
            Utils.BeginObjectRegister(type, L, translator, 0, 0, 9, 0);
            
            
            
@@ -33,6 +33,7 @@
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "fightPower", _g_get_fightPower);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "icon", _g_get_icon);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "bossName", _g_get_bossName);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "defense", _g_get_defense);
            
            
            
@@ -392,6 +393,20 @@
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_defense(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                TreasureDungeonConfig gen_to_be_invoked = (TreasureDungeonConfig)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.defense);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        
        
        

 Lua/Gen/XLuaGenAutoRegister.cs

@@ -631,6 +631,9 @@
            translator.DelayWrapLoader(typeof(TaskFeedbackConfig), TaskFeedbackConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(TaskFeedbackFuncConfig), TaskFeedbackFuncConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(TaskListConfig), TaskListConfigWrap.__Register);
        
        
@@ -642,13 +645,13 @@
        
            translator.DelayWrapLoader(typeof(TreasureChapterConfig), TreasureChapterConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(TreasureConfig), TreasureConfigWrap.__Register);
        
        }
        
        static void wrapInit4(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(TreasureConfig), TreasureConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(TreasureDungeonConfig), TreasureDungeonConfigWrap.__Register);
        
@@ -657,7 +660,6 @@
        
        
            translator.DelayWrapLoader(typeof(TreasurePrivilegeConfig), TreasurePrivilegeConfigWrap.__Register);
        
        
        
            translator.DelayWrapLoader(typeof(TreasureSkillConfig), TreasureSkillConfigWrap.__Register);
@@ -744,10 +746,16 @@
            translator.DelayWrapLoader(typeof(GameNetSystem), GameNetSystemWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(AnimatorControllerLoader), AnimatorControllerLoaderWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(AssetBundleUtility), AssetBundleUtilityWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(GameObjectPoolManager), GameObjectPoolManagerWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(InstanceResourcesLoader), InstanceResourcesLoaderWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UILoader), UILoaderWrap.__Register);
@@ -794,16 +802,16 @@
        
            translator.DelayWrapLoader(typeof(GuideMessageModel), GuideMessageModelWrap.__Register);
        
        }
        
        static void wrapInit5(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(NewGuideModel), NewGuideModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(StoryHintModel), StoryHintModelWrap.__Register);
        
        }
        
        static void wrapInit5(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(LuaBehaviour), LuaBehaviourWrap.__Register);
        
@@ -951,16 +959,16 @@
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.RealmBetterEquipModel), SnxxzUIRealmBetterEquipModelWrap.__Register);
        
        }
        
        static void wrapInit6(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.BossRebornModel), SnxxzUIBossRebornModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.BossShowModel), SnxxzUIBossShowModelWrap.__Register);
        
        }
        
        static void wrapInit6(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.ChatBubbleModel), SnxxzUIChatBubbleModelWrap.__Register);
        
@@ -1108,16 +1116,16 @@
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.PersonalBossModel), SnxxzUIPersonalBossModelWrap.__Register);
        
        }
        
        static void wrapInit7(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.RewardPreviewGroup), SnxxzUIRewardPreviewGroupWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.WorldBossModel), SnxxzUIWorldBossModelWrap.__Register);
        
        }
        
        static void wrapInit7(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(FriendsModel), FriendsModelWrap.__Register);
        
@@ -1191,6 +1199,9 @@
            translator.DelayWrapLoader(typeof(Snxxz.UI.ItemTipsModel), SnxxzUIItemTipsModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.PackModel), SnxxzUIPackModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.TreasureEffectModel), SnxxzUITreasureEffectModelWrap.__Register);
        
        
@@ -1262,16 +1273,16 @@
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.NewYearFairylandCeremonyModel), SnxxzUINewYearFairylandCeremonyModelWrap.__Register);
        
        }
        
        static void wrapInit8(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.OffLineTimeLackModel), SnxxzUIOffLineTimeLackModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.AccumulateRechargeModel), SnxxzUIAccumulateRechargeModelWrap.__Register);
        
        }
        
        static void wrapInit8(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.FestivalRedpackModel), SnxxzUIFestivalRedpackModelWrap.__Register);
        
@@ -1419,16 +1430,16 @@
        
            translator.DelayWrapLoader(typeof(ChatSetting), ChatSettingWrap.__Register);
        
        }
        
        static void wrapInit9(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.FuncSwitchModel), SnxxzUIFuncSwitchModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(HangUpSetModel), HangUpSetModelWrap.__Register);
        
        }
        
        static void wrapInit9(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(PrivateRemind), PrivateRemindWrap.__Register);
        
@@ -1576,16 +1587,16 @@
        
            translator.DelayWrapLoader(typeof(E_ActorState), E_ActorStateWrap.__Register);
        
        }
        
        static void wrapInit10(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(E_BuffType), E_BuffTypeWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(E_ClientNpcType), E_ClientNpcTypeWrap.__Register);
        
        }
        
        static void wrapInit10(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(E_NpcType), E_NpcTypeWrap.__Register);
        
@@ -1733,16 +1744,16 @@
        
            translator.DelayWrapLoader(typeof(ItemUseDataKey), ItemUseDataKeyWrap.__Register);
        
        }
        
        static void wrapInit11(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(ItemOperateType), ItemOperateTypeWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ItemWinType), ItemWinTypeWrap.__Register);
        
        }
        
        static void wrapInit11(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(ItemTipChildType), ItemTipChildTypeWrap.__Register);
        

 Lua/Gen/link.xml

@@ -213,6 +213,7 @@
        <type fullname="TASKINFOConfig" preserve="all"/>
        <type fullname="TalentConfig" preserve="all"/>
        <type fullname="TaskFeedbackConfig" preserve="all"/>
        <type fullname="TaskFeedbackFuncConfig" preserve="all"/>
        <type fullname="TaskListConfig" preserve="all"/>
        <type fullname="TaskPowerConfig" preserve="all"/>
        <type fullname="TeamTargetConfig" preserve="all"/>
@@ -221,7 +222,6 @@
        <type fullname="TreasureDungeonConfig" preserve="all"/>
        <type fullname="TreasureFindHostConfig" preserve="all"/>
        <type fullname="TreasurePrivilegeConfig" preserve="all"/>
        <type fullname="TreasureRefineConfig" preserve="all"/>
        <type fullname="TreasureSkillConfig" preserve="all"/>
        <type fullname="TreasureUpConfig" preserve="all"/>
        <type fullname="TrialRewardsConfig" preserve="all"/>
@@ -250,8 +250,10 @@
        <type fullname="PlayerDatas" preserve="all"/>
        <type fullname="SnxxzGame" preserve="all"/>
        <type fullname="GameNetSystem" preserve="all"/>
        <type fullname="AnimatorControllerLoader" preserve="all"/>
        <type fullname="AssetBundleUtility" preserve="all"/>
        <type fullname="GameObjectPoolManager" preserve="all"/>
        <type fullname="InstanceResourcesLoader" preserve="all"/>
        <type fullname="UILoader" preserve="all"/>
        <type fullname="SDKUtility" preserve="all"/>
        <type fullname="SFXPlayUtility" preserve="all"/>

 System/CrossServerOneVsOne/CrossServerWin.cs

@@ -11,9 +11,8 @@
        protected override void AddListeners()

        {

            base.AddListeners();

            SetFunctionListener(0, OpenHazyRegion);

            SetFunctionListener(1, ClickArenaFunc);

            SetFunctionListener(2, ClickBossFunc);

            SetFunctionListener(0, ClickArenaFunc);

            SetFunctionListener(1, ClickBossFunc);

        }



        private void ClickBossFunc()

@@ -28,13 +27,6 @@
            CloseSubWindows();

            WindowCenter.Instance.Open<CrossServerOneVsOneWin>();

            functionOrder = 2;

        }



        private void OpenHazyRegion()

        {

            CloseSubWindows();

            WindowCenter.Instance.Open<HazyRegionWin>();

            functionOrder = 0;

        }

    }

}


 System/FindPrecious/RewardPreviewGroup.cs

@@ -98,6 +98,22 @@
            Display(items);

        }



        public void LuaDisplayInt2(Int2[] rewards)

        {

            if (rewards == null)

            {

                return;

            }



            var items = new List<Item>();

            foreach (var reward in rewards)

            {

                items.Add(new Item(reward.x, reward.y));

            }



            Display(items);

        }



        public void Hide()

        {

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


 System/HazyRegion/HazyRegionFrameWin.cs

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

//    [Author]:           第二世界

//    [  Date ]:           Saturday, May 25, 2019

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



using System;

using System.Collections;

using System.Collections.Generic;

using UnityEngine;

using UnityEngine.UI;



namespace Snxxz.UI

{



    public class HazyRegionFrameWin : OneLevelWin

    {

        protected override void AddListeners()
        {

            base.AddListeners();



            SetFunctionListener(0, OpenHazyRegion);
        }


        private void OpenHazyRegion()
        {
            CloseSubWindows();
            WindowCenter.Instance.Open<HazyRegionWin>();
            functionOrder = 0;
        }

    }

}










 System/HazyRegion/HazyRegionFrameWin.cs.meta

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

 System/HazyRegion/HazyRegionModel.cs

@@ -78,9 +78,10 @@
            }

        }



        public readonly Redpoint redpoint = new Redpoint(213, 21303);

        readonly Redpoint entranceRedpoint = new Redpoint(21303, 2130301);

        readonly Redpoint incidentRedpoint = new Redpoint(21303, 2130302);

        public readonly Redpoint redpointBase = new Redpoint(39);

        public readonly Redpoint redpoint = new Redpoint(39, 3901);

        readonly Redpoint entranceRedpoint = new Redpoint(3901, 390101);

        readonly Redpoint incidentRedpoint = new Redpoint(3901, 390102);



        int cacheMapId = 0;




 System/MainInterfacePanel/HighSettingTip.cs

@@ -37,6 +37,7 @@
        [SerializeField] Button m_CrossServerBtn;//跨服1V1按钮

        [SerializeField] Button m_OpenServiceBtn;//周狂欢按钮

        [SerializeField] Button m_NewYearBtn;//新年盛典

        [SerializeField] Button m_HazyRegion;



        private bool isNeedTip = true;



@@ -62,6 +63,7 @@
            m_CrossServerBtn.SetListener(OnClickCrossServerBtn);

            m_OpenServiceBtn.SetListener(OnClickOpenServiceBtn);

            m_NewYearBtn.SetListener(OnClickNewYearBtn);

            m_HazyRegion.SetListener(OpenHazyRegion);

        }



        public void Init()

@@ -209,6 +211,12 @@
            }

        }



        private void OpenHazyRegion()

        {

            WindowCenter.Instance.Close<MainInterfaceWin>();

            WindowCenter.Instance.Open<HazyRegionFrameWin>();

        }



        void OnClickOpenServiceBtn()

        {

            WindowCenter.Instance.Open<AchievementActivityWin>();


 System/Treasure/TreasureModel.cs

@@ -39,7 +39,7 @@


        public static int redpointIndex = 1;



        Redpoint treasureRedpoint = new Redpoint(TREASURE_REDPOINTID);

        Redpoint treasureRedpoint = new Redpoint(1, TREASURE_REDPOINTID);

        Redpoint humanRedpoint = new Redpoint(TREASURE_REDPOINTID, CATEGORY_REDPOINTIDS[(int)TreasureCategory.Human - 1]);

        Redpoint demonRedpoint = new Redpoint(TREASURE_REDPOINTID, CATEGORY_REDPOINTIDS[(int)TreasureCategory.Demon - 1]);

        Redpoint fairypoint = new Redpoint(TREASURE_REDPOINTID, CATEGORY_REDPOINTIDS[(int)TreasureCategory.Fairy - 1]);


 System/WindowJump/WindowJumpMgr.cs

@@ -719,7 +719,7 @@
                SetJumpLogic<AuctionHouseWin>(_tagWinSearchModel.TABID);

                break;

            case JumpUIType.HazyRegion:

                SetJumpLogic<CrossServerWin>(_tagWinSearchModel.TABID);

                SetJumpLogic<HazyRegionFrameWin>(_tagWinSearchModel.TABID);

                break;

            case JumpUIType.Alchemy1:

            case JumpUIType.Alchemy2: