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

client_linchunjie

2019-03-18 9f02200a3535b9011d039a90fae339a17b13bd90

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

 Lua/Gen/EquipSuitConfigWrap.cs

@@ -40,13 +40,14 @@
            Utils.EndObjectRegister(type, L, translator, null, null,
                null, null, null);

            Utils.BeginClassRegister(type, L, __CreateInstance, 7, 1, 0);
            Utils.BeginClassRegister(type, L, __CreateInstance, 8, 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_IDX, "GetConfigs", _m_GetConfigs_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetEquipSuitName", _m_GetEquipSuitName_xlua_st_);
            
            
            
@@ -323,6 +324,31 @@
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetEquipSuitName_xlua_st_(RealStatePtr L)
        {
            try {
            
            
            
                
                {
                    int _suitId = LuaAPI.xlua_tointeger(L, 1);
                    
                        string gen_ret = EquipSuitConfig.GetEquipSuitName( _suitId );
                        LuaAPI.lua_pushstring(L, gen_ret);
                    
                    
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        
        
        

 Lua/Gen/SnxxzUIEquipModelWrap.cs

@@ -21,11 +21,12 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(Snxxz.UI.EquipModel);
            Utils.BeginObjectRegister(type, L, translator, 0, 23, 10, 2);
            Utils.BeginObjectRegister(type, L, translator, 0, 24, 8, 1);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnInit", _m_UnInit);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetLastestUnLockEquipSet", _m_GetLastestUnLockEquipSet);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OneKeyPutOn", _m_OneKeyPutOn);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SelectSet", _m_SelectSet);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "ResetOperateParams", _m_ResetOperateParams);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SelectCandidateEquip", _m_SelectCandidateEquip);
@@ -49,9 +50,7 @@
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "appearanceChangeEvent", _e_appearanceChangeEvent);
            
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "showedUnLockLevel", _g_get_showedUnLockLevel);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "showedUnLockSlot", _g_get_showedUnLockSlot);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "selectedLevel", _g_get_selectedLevel);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "selectedPlace", _g_get_selectedPlace);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "selectedEquip", _g_get_selectedEquip);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "selectedStarLevel", _g_get_selectedStarLevel);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "appearance", _g_get_appearance);
@@ -60,18 +59,18 @@
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "getWays", _g_get_getWays);
            
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "showedUnLockLevel", _s_set_showedUnLockLevel);
            Utils.RegisterFunc(L, Utils.SETTER_IDX, "showedUnLockSlot", _s_set_showedUnLockSlot);
            
            
            Utils.EndObjectRegister(type, L, translator, null, null,
                null, null, null);

            Utils.BeginClassRegister(type, L, __CreateInstance, 4, 0, 0);
            Utils.BeginClassRegister(type, L, __CreateInstance, 5, 0, 0);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetItemServerEquipPlace", _m_GetItemServerEquipPlace_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "GetSuitName", _m_GetSuitName_xlua_st_);
            Utils.RegisterFunc(L, Utils.CLS_IDX, "IsRealmEquip", _m_IsRealmEquip_xlua_st_);
            
            
            Utils.RegisterObject(L, translator, Utils.CLS_IDX, "realmEquipTypes", Snxxz.UI.EquipModel.realmEquipTypes);
            
            
            
@@ -192,6 +191,34 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_OneKeyPutOn(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.EquipModel gen_to_be_invoked = (Snxxz.UI.EquipModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _level = LuaAPI.xlua_tointeger(L, 2);
                    
                    gen_to_be_invoked.OneKeyPutOn( _level );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SelectSet(RealStatePtr L)
        {
            try {
@@ -204,6 +231,12 @@
            
                
                {
                    int _level = LuaAPI.xlua_tointeger(L, 2);
                    
                    gen_to_be_invoked.SelectSet( _level );
                    
                    
                    
                    return 0;
                }
                
@@ -834,20 +867,6 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_showedUnLockSlot(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.EquipModel gen_to_be_invoked = (Snxxz.UI.EquipModel)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.showedUnLockSlot);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_selectedLevel(RealStatePtr L)
        {
            try {
@@ -862,19 +881,13 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_selectedPlace(RealStatePtr L)
        {
            try {
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_selectedEquip(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.EquipModel gen_to_be_invoked = (Snxxz.UI.EquipModel)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.selectedEquip);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
@@ -961,21 +974,6 @@
            
                Snxxz.UI.EquipModel gen_to_be_invoked = (Snxxz.UI.EquipModel)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.showedUnLockLevel = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _s_set_showedUnLockSlot(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.EquipModel gen_to_be_invoked = (Snxxz.UI.EquipModel)translator.FastGetCSObj(L, 1);
                gen_to_be_invoked.showedUnLockSlot = LuaAPI.xlua_tointeger(L, 2);
            
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);

 Lua/Gen/SnxxzUIItemLogicUtilityWrap.cs

@@ -21,10 +21,11 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(Snxxz.UI.ItemLogicUtility);
            Utils.BeginObjectRegister(type, L, translator, 0, 30, 3, 1);
            Utils.BeginObjectRegister(type, L, translator, 0, 31, 3, 1);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetEquipScore", _m_GetEquipScore);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsCustomItem", _m_IsCustomItem);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "RecommendItem", _m_RecommendItem);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnGetEquip", _m_OnGetEquip);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshPickItem", _m_RefreshPickItem);
@@ -194,6 +195,35 @@
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsCustomItem(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.ItemLogicUtility gen_to_be_invoked = (Snxxz.UI.ItemLogicUtility)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _itemId = LuaAPI.xlua_tointeger(L, 2);
                    
                        bool gen_ret = gen_to_be_invoked.IsCustomItem( _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_RecommendItem(RealStatePtr L)
        {
            try {

 Lua/Gen/SnxxzUIItemOperateUtilityWrap.cs

@@ -21,7 +21,7 @@
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(Snxxz.UI.ItemOperateUtility);
            Utils.BeginObjectRegister(type, L, translator, 0, 21, 2, 1);
            Utils.BeginObjectRegister(type, L, translator, 0, 20, 2, 1);
            
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "PutOnItem", _m_PutOnItem);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "PutOffEquip", _m_PutOffEquip);
@@ -34,7 +34,6 @@
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "CheckIsMaxOfflineTime", _m_CheckIsMaxOfflineTime);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "UseItem", _m_UseItem);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "CanUseItem", _m_CanUseItem);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "UseItemMainServer", _m_UseItemMainServer);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "UseItemCrossServer", _m_UseItemCrossServer);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnClickSplitBtn", _m_OnClickSplitBtn);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SplitItem", _m_SplitItem);
@@ -364,34 +363,34 @@
            
                int gen_param_count = LuaAPI.lua_gettop(L);
            
                if(gen_param_count == 4&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) 
                if(gen_param_count == 4&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 4)) 
                {
                    int _index = LuaAPI.xlua_tointeger(L, 2);
                    string _guid = LuaAPI.lua_tostring(L, 2);
                    int _useCnt = LuaAPI.xlua_tointeger(L, 3);
                    int _extra = LuaAPI.xlua_tointeger(L, 4);
                    
                    gen_to_be_invoked.UseItem( _index, _useCnt, _extra );
                    gen_to_be_invoked.UseItem( _guid, _useCnt, _extra );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 3&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 3)) 
                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)) 
                {
                    int _index = LuaAPI.xlua_tointeger(L, 2);
                    string _guid = LuaAPI.lua_tostring(L, 2);
                    int _useCnt = LuaAPI.xlua_tointeger(L, 3);
                    
                    gen_to_be_invoked.UseItem( _index, _useCnt );
                    gen_to_be_invoked.UseItem( _guid, _useCnt );
                    
                    
                    
                    return 0;
                }
                if(gen_param_count == 2&& LuaTypes.LUA_TNUMBER == LuaAPI.lua_type(L, 2)) 
                if(gen_param_count == 2&& (LuaAPI.lua_isnil(L, 2) || LuaAPI.lua_type(L, 2) == LuaTypes.LUA_TSTRING)) 
                {
                    int _index = LuaAPI.xlua_tointeger(L, 2);
                    string _guid = LuaAPI.lua_tostring(L, 2);
                    
                    gen_to_be_invoked.UseItem( _index );
                    gen_to_be_invoked.UseItem( _guid );
                    
                    
                    
@@ -419,11 +418,11 @@
            
                
                {
                    int _index = LuaAPI.xlua_tointeger(L, 2);
                    string _guid = LuaAPI.lua_tostring(L, 2);
                    int _useCnt = LuaAPI.xlua_tointeger(L, 3);
                    int _error;
                    
                        bool gen_ret = gen_to_be_invoked.CanUseItem( _index, _useCnt, out _error );
                        bool gen_ret = gen_to_be_invoked.CanUseItem( _guid, _useCnt, out _error );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    LuaAPI.xlua_pushinteger(L, _error);
                        
@@ -431,36 +430,6 @@
                    
                    
                    return 2;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_UseItemMainServer(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.ItemOperateUtility gen_to_be_invoked = (Snxxz.UI.ItemOperateUtility)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _index = LuaAPI.xlua_tointeger(L, 2);
                    int _useCnt = LuaAPI.xlua_tointeger(L, 3);
                    int _extra = LuaAPI.xlua_tointeger(L, 4);
                    
                    gen_to_be_invoked.UseItemMainServer( _index, _useCnt, _extra );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
@@ -482,9 +451,9 @@
            
                
                {
                    int _index = LuaAPI.xlua_tointeger(L, 2);
                    string _guid = LuaAPI.lua_tostring(L, 2);
                    
                    gen_to_be_invoked.UseItemCrossServer( _index );
                    gen_to_be_invoked.UseItemCrossServer( _guid );
                    
                    
                    

 Lua/Gen/SnxxzUIItemOperateUtilityWrap.cs.meta

@@ -1,6 +1,6 @@
fileFormatVersion: 2
guid: fa7ac9851eb489945859b99575782577
timeCreated: 1552276115
timeCreated: 1552902277
licenseType: Pro
MonoImporter:
  serializedVersion: 2

 Lua/Gen/SnxxzUIItemOverdueModelWrap.cs

New file
@@ -0,0 +1,546 @@
#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 SnxxzUIItemOverdueModelWrap 
    {
        public static void __Register(RealStatePtr L)
        {
            ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            System.Type type = typeof(Snxxz.UI.ItemOverdueModel);
            Utils.BeginObjectRegister(type, L, translator, 0, 13, 3, 0);
			
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "Init", _m_Init);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnBeforePlayerDataInitialize", _m_OnBeforePlayerDataInitialize);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnSwitchAccount", _m_OnSwitchAccount);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "OnPlayerLoginOk", _m_OnPlayerLoginOk);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "TryGetItem", _m_TryGetItem);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "ReportConfirmUseItem", _m_ReportConfirmUseItem);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "ShowUseItemAble", _m_ShowUseItemAble);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "UnInit", _m_UnInit);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SendRenewalQuest", _m_SendRenewalQuest);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "IsMoneyEnough", _m_IsMoneyEnough);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetRenewallist", _m_GetRenewallist);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "GetGuardOverdueIcon", _m_GetGuardOverdueIcon);
			
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "showItemRefreshEvent", _e_showItemRefreshEvent);
			
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "currentShowItem", _g_get_currentShowItem);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "VipExperirnceID", _g_get_VipExperirnceID);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "VipCardID", _g_get_VipCardID);
            
			
			
            Utils.EndObjectRegister(type, L, translator, null, null,
                null, null, null);

            Utils.BeginClassRegister(type, L, __CreateInstance, 2, 0, 0);
			
            Utils.RegisterFunc(L, Utils.CLS_IDX, "FirstGoldWPOver", _e_FirstGoldWPOver);
			
            
			
			
			
            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.ItemOverdueModel gen_ret = new Snxxz.UI.ItemOverdueModel();
                    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.ItemOverdueModel constructor!");
            
        }
        
		
        
		
        
        
        
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_Init(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.ItemOverdueModel gen_to_be_invoked = (Snxxz.UI.ItemOverdueModel)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.ItemOverdueModel gen_to_be_invoked = (Snxxz.UI.ItemOverdueModel)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_OnSwitchAccount(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.ItemOverdueModel gen_to_be_invoked = (Snxxz.UI.ItemOverdueModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    gen_to_be_invoked.OnSwitchAccount(  );
                    
                    
                    
                    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.ItemOverdueModel gen_to_be_invoked = (Snxxz.UI.ItemOverdueModel)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_TryGetItem(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.ItemOverdueModel gen_to_be_invoked = (Snxxz.UI.ItemOverdueModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    string __guid = LuaAPI.lua_tostring(L, 2);
                    Snxxz.UI.ItemOverdueModel.OverdueItem __itemModel;
                    
                        bool gen_ret = gen_to_be_invoked.TryGetItem( __guid, out __itemModel );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    translator.Push(L, __itemModel);
                        
                    
                    
                    
                    return 2;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ReportConfirmUseItem(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.ItemOverdueModel gen_to_be_invoked = (Snxxz.UI.ItemOverdueModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    string _guid = LuaAPI.lua_tostring(L, 2);
                    
                    gen_to_be_invoked.ReportConfirmUseItem( _guid );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ShowUseItemAble(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.ItemOverdueModel gen_to_be_invoked = (Snxxz.UI.ItemOverdueModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                        bool gen_ret = gen_to_be_invoked.ShowUseItemAble(  );
                        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_UnInit(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.ItemOverdueModel gen_to_be_invoked = (Snxxz.UI.ItemOverdueModel)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_SendRenewalQuest(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.ItemOverdueModel gen_to_be_invoked = (Snxxz.UI.ItemOverdueModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _index = LuaAPI.xlua_tointeger(L, 2);
                    int _moneyType = LuaAPI.xlua_tointeger(L, 3);
                    
                    gen_to_be_invoked.SendRenewalQuest( _index, _moneyType );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_IsMoneyEnough(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.ItemOverdueModel gen_to_be_invoked = (Snxxz.UI.ItemOverdueModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _moneyType = LuaAPI.xlua_tointeger(L, 2);
                    int _needMoney = LuaAPI.xlua_tointeger(L, 3);
                    
                        bool gen_ret = gen_to_be_invoked.IsMoneyEnough( _moneyType, _needMoney );
                        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_GetRenewallist(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.ItemOverdueModel gen_to_be_invoked = (Snxxz.UI.ItemOverdueModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _itemID = LuaAPI.xlua_tointeger(L, 2);
                    
                        System.Collections.Generic.List<int> gen_ret = gen_to_be_invoked.GetRenewallist( _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_GetGuardOverdueIcon(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.ItemOverdueModel gen_to_be_invoked = (Snxxz.UI.ItemOverdueModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    int _itemId = LuaAPI.xlua_tointeger(L, 2);
                    
                        string gen_ret = gen_to_be_invoked.GetGuardOverdueIcon( _itemId );
                        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 _g_get_currentShowItem(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.ItemOverdueModel gen_to_be_invoked = (Snxxz.UI.ItemOverdueModel)translator.FastGetCSObj(L, 1);
                translator.Push(L, gen_to_be_invoked.currentShowItem);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_VipExperirnceID(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.ItemOverdueModel gen_to_be_invoked = (Snxxz.UI.ItemOverdueModel)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.VipExperirnceID);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_VipCardID(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
			
                Snxxz.UI.ItemOverdueModel gen_to_be_invoked = (Snxxz.UI.ItemOverdueModel)translator.FastGetCSObj(L, 1);
                LuaAPI.xlua_pushinteger(L, gen_to_be_invoked.VipCardID);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        
        
		
		
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_showItemRefreshEvent(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
            Snxxz.UI.ItemOverdueModel gen_to_be_invoked = (Snxxz.UI.ItemOverdueModel)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.showItemRefreshEvent += gen_delegate;
                        return 0;
                    } 
					
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.showItemRefreshEvent -= 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.ItemOverdueModel.showItemRefreshEvent!");
            return 0;
        }
        
		
		
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_FirstGoldWPOver(RealStatePtr L)
        {
            try {
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
                int gen_param_count = LuaAPI.lua_gettop(L);
                System.Action gen_delegate = translator.GetDelegate<System.Action>(L, 2);
                if (gen_delegate == null) {
                    return LuaAPI.luaL_error(L, "#2 need System.Action!");
                }
                
				
                if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "+")) {
                    Snxxz.UI.ItemOverdueModel.FirstGoldWPOver += gen_delegate;
                    return 0;
                } 
				
				
                if (gen_param_count == 2 && LuaAPI.xlua_is_eq_str(L, 1, "-")) {
                    Snxxz.UI.ItemOverdueModel.FirstGoldWPOver -= gen_delegate;
                    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.ItemOverdueModel.FirstGoldWPOver!");
        }
        
    }
}

 Lua/Gen/SnxxzUIItemOverdueModelWrap.cs.meta

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

 Lua/Gen/SnxxzUIPackModelWrap.cs

New file
@@ -0,0 +1,3153 @@
#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, 84, 26, 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, "GetItemsByType", _m_GetItemsByType);
            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, "ContainPreciousItem", _m_ContainPreciousItem);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "ContainTwoStarEquip", _m_ContainTwoStarEquip);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetColorSelect", _m_SetColorSelect);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetLvSelect", _m_SetLvSelect);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "SetStarSelect", _m_SetStarSelect);
            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, "GetAlchemyProgress", _m_GetAlchemyProgress);
			
            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, "RefreshLvSelectAct", _e_RefreshLvSelectAct);
            Utils.RegisterFunc(L, Utils.METHOD_IDX, "RefreshStarSelectAct", _e_RefreshStarSelectAct);
            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, "lvType", _g_get_lvType);
            Utils.RegisterFunc(L, Utils.GETTER_IDX, "starType", _g_get_starType);
            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, "MaxDevourEquipNum", _g_get_MaxDevourEquipNum);
            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);
            
            
                
                {
                    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);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_GetItemsByType(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    
                    return 1;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [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 _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);
            }
            
        }
        
        [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);
            
            
                
                {
                    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);
            }
            
        }
        
        [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_ContainPreciousItem(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 _betterEquipCnt;
                    int _preciousCnt;
                    
                        bool gen_ret = gen_to_be_invoked.ContainPreciousItem( _itemModels, out _betterEquipCnt, out _preciousCnt );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    LuaAPI.xlua_pushinteger(L, _betterEquipCnt);
                        
                    LuaAPI.xlua_pushinteger(L, _preciousCnt);
                        
                    
                    
                    
                    return 3;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_ContainTwoStarEquip(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 _twoStarEquipCnt;
                    
                        bool gen_ret = gen_to_be_invoked.ContainTwoStarEquip( _itemModels, out _twoStarEquipCnt );
                        LuaAPI.lua_pushboolean(L, gen_ret);
                    LuaAPI.xlua_pushinteger(L, _twoStarEquipCnt);
                        
                    
                    
                    
                    return 2;
                }
                
            } 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_SetLvSelect(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.EquipLvType _type;translator.Get(L, 2, out _type);
                    
                    gen_to_be_invoked.SetLvSelect( _type );
                    
                    
                    
                    return 0;
                }
                
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _m_SetStarSelect(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.EquipStarType _type;translator.Get(L, 2, out _type);
                    
                    gen_to_be_invoked.SetStarSelect( _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);
            
            
                
                {
                    
                    gen_to_be_invoked.SendEquipdevourQuest(  );
                    
                    
                    
                    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 _m_GetAlchemyProgress(RealStatePtr L)
        {
            try {
            
                ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
            
            
                Snxxz.UI.PackModel gen_to_be_invoked = (Snxxz.UI.PackModel)translator.FastGetCSObj(L, 1);
            
            
                
                {
                    AlchemyConfig _alchemy = (AlchemyConfig)translator.GetObject(L, 2, typeof(AlchemyConfig));
                    
                        float gen_ret = gen_to_be_invoked.GetAlchemyProgress( _alchemy );
                        LuaAPI.lua_pushnumber(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_lvType(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.lvType);
            } catch(System.Exception gen_e) {
                return LuaAPI.luaL_error(L, "c# exception:" + gen_e);
            }
            return 1;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _g_get_starType(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.starType);
            } 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_MaxDevourEquipNum(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.MaxDevourEquipNum);
            } 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_RefreshLvSelectAct(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.EquipLvType> gen_delegate = translator.GetDelegate<System.Action<Snxxz.UI.PackModel.EquipLvType>>(L, 3);
                if (gen_delegate == null) {
                    return LuaAPI.luaL_error(L, "#3 need System.Action<Snxxz.UI.PackModel.EquipLvType>!");
                }
				
                if (gen_param_count == 3)
                {
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "+")) {
                        gen_to_be_invoked.RefreshLvSelectAct += gen_delegate;
                        return 0;
                    } 
					
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.RefreshLvSelectAct -= 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.RefreshLvSelectAct!");
            return 0;
        }
        
        [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
        static int _e_RefreshStarSelectAct(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.EquipStarType> gen_delegate = translator.GetDelegate<System.Action<Snxxz.UI.PackModel.EquipStarType>>(L, 3);
                if (gen_delegate == null) {
                    return LuaAPI.luaL_error(L, "#3 need System.Action<Snxxz.UI.PackModel.EquipStarType>!");
                }
				
                if (gen_param_count == 3)
                {
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "+")) {
                        gen_to_be_invoked.RefreshStarSelectAct += gen_delegate;
                        return 0;
                    } 
					
					
                    if (LuaAPI.xlua_is_eq_str(L, 2, "-")) {
                        gen_to_be_invoked.RefreshStarSelectAct -= 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.RefreshStarSelectAct!");
            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: 7bec1f946c76f4e4e870be11f2094478
timeCreated: 1552902276
licenseType: Pro
MonoImporter:
  serializedVersion: 2
  defaultReferences: []
  executionOrder: 0
  icon: {instanceID: 0}
  userData: 
  assetBundleName: 
  assetBundleVariant: 

 Lua/Gen/XLuaGenAutoRegister.cs

New file
@@ -0,0 +1,1614 @@
#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 System;
using System.Collections.Generic;
using System.Reflection;


namespace XLua.CSObjectWrap
{
    public class XLua_Gen_Initer_Register__
    {
        
        
        static void wrapInit0(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(UnityEngine.UI.Image), UnityEngineUIImageWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.UI.Text), UnityEngineUITextWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.UI.Button), UnityEngineUIButtonWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DebugEx), DebugExWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ResourcesPath), ResourcesPathWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(AssetSource), AssetSourceWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Equation), EquationWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(LaunchPostProcess), LaunchPostProcessWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ActorShowConfig), ActorShowConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(AlchemyConfig), AlchemyConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(AlchemySpecConfig), AlchemySpecConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(AllPeoplePartyAwardConfig), AllPeoplePartyAwardConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(AllPeoplePartyConfig), AllPeoplePartyConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(AncientRobotNameConfig), AncientRobotNameConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ApkUpdateUrlConfig), ApkUpdateUrlConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(AppointItemConfig), AppointItemConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(AreaCameraConfig), AreaCameraConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(AttrFruitConfig), AttrFruitConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(AuctionConfig), AuctionConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(AuctionIndexConfig), AuctionIndexConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(AuctionItemConfig), AuctionItemConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(AudioConfig), AudioConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(BossHomeConfig), BossHomeConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(BossInfoConfig), BossInfoConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(BossRebornConfig), BossRebornConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(CTGConfig), CTGConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ChatBubbleBoxConfig), ChatBubbleBoxConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ChestsAwardConfig), ChestsAwardConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ChestsConfig), ChestsConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ContactConfig), ContactConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ContinueSignInConfig), ContinueSignInConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(CreateRoleConfig), CreateRoleConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(CrossRealmPKDanAwardConfig), CrossRealmPKDanAwardConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(CrossRealmPKOrderAwardConfig), CrossRealmPKOrderAwardConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(CrossServerArenaConfig), CrossServerArenaConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(CrossServerBossConfig), CrossServerBossConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(CrossServerOneVsOneRobotConfig), CrossServerOneVsOneRobotConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DailyLivenessRewardConfig), DailyLivenessRewardConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DailyQuestConfig), DailyQuestConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DailyQuestMixServerStateTimeConfig), DailyQuestMixServerStateTimeConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DailyQuestOpenTimeConfig), DailyQuestOpenTimeConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DailyQuestSpecialOpenTimeConfig), DailyQuestSpecialOpenTimeConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DamageNumConfig), DamageNumConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DemonJarConfig), DemonJarConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DemonRecommondPropertyConfig), DemonRecommondPropertyConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DialogConfig), DialogConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DienstgradConfig), DienstgradConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DirtyNameConfig), DirtyNameConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DirtyWordConfig), DirtyWordConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DogzConfig), DogzConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DogzDungeonConfig), DogzDungeonConfigWrap.__Register);
        
        }
        
        static void wrapInit1(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(DogzEquipPlusConfig), DogzEquipPlusConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DungeonConfig), DungeonConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DungeonHelpBattleConfig), DungeonHelpBattleConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DungeonHintConfig), DungeonHintConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DungeonInspireConfig), DungeonInspireConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DungeonMixServerStateTimeConfig), DungeonMixServerStateTimeConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DungeonOpenTimeConfig), DungeonOpenTimeConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DungeonSpecialStateTimeConfig), DungeonSpecialStateTimeConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DungeonStateTimeConfig), DungeonStateTimeConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(EffectConfig), EffectConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ElderGodAreaConfig), ElderGodAreaConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(EquipControlConfig), EquipControlConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(EquipDeComposeConfig), EquipDeComposeConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(EquipGSParamConfig), EquipGSParamConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(EquipPlaceMapConfig), EquipPlaceMapConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(EquipPlusEvolveConfig), EquipPlusEvolveConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(EquipStarConfig), EquipStarConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(EquipSuitAttrConfig), EquipSuitAttrConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(EquipSuitCompoundConfig), EquipSuitCompoundConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(EquipSuitConfig), EquipSuitConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(EquipSuitNameConfig), EquipSuitNameConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(EquipWashConfig), EquipWashConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(EquipWashSpecConfig), EquipWashSpecConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(FaceConfig), FaceConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(FairyGrabBossConfig), FairyGrabBossConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(FamilyConfig), FamilyConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(FamilyTechConfig), FamilyTechConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(FashionDressCabinetConfig), FashionDressCabinetConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(FashionDressConfig), FashionDressConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(FestivalRedpackTaskConfig), FestivalRedpackTaskConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(FightPowerParamConfig), FightPowerParamConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(FreeGoodsConfig), FreeGoodsConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(FuncConfigConfig), FuncConfigConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(FuncOpenLVConfig), FuncOpenLVConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(FuncSwitchConfig), FuncSwitchConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(FunctionForecastConfig), FunctionForecastConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(GatherSoulComposeConfig), GatherSoulComposeConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(GatherSoulConfig), GatherSoulConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(GatherSoulPropertyConfig), GatherSoulPropertyConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(GemItemConfig), GemItemConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(GetItemWaysConfig), GetItemWaysConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(GmCmdConfig), GmCmdConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(GodWeaponConfig), GodWeaponConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(GodWeaponEffectConfig), GodWeaponEffectConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(GuardConfig), GuardConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(GuideConfig), GuideConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(HelpInfoConfig), HelpInfoConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(HolidayHomingConfig), HolidayHomingConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(HolidayHomingPointConfig), HolidayHomingPointConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(HorseConfig), HorseConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(HorseUpConfig), HorseUpConfigWrap.__Register);
        
        }
        
        static void wrapInit2(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(IceLodeStarAwardConfig), IceLodeStarAwardConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(IconConfig), IconConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(InSevenDaysConfig), InSevenDaysConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(InvestConfig), InvestConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ItemCompoundConfig), ItemCompoundConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ItemConfig), ItemConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ItemPlusConfig), ItemPlusConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ItemPlusMaxConfig), ItemPlusMaxConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ItemPlusSumAttrConfig), ItemPlusSumAttrConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(JadeDynastyBossConfig), JadeDynastyBossConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(JadeDynastyStoneAttrConfig), JadeDynastyStoneAttrConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(JadeDynastySuitAttrConfig), JadeDynastySuitAttrConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(JadeDynastyTowerConfig), JadeDynastyTowerConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(JobNameConfig), JobNameConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(JobSetupConfig), JobSetupConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(KickOutReasonConfig), KickOutReasonConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(KingTreasureConfig), KingTreasureConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(KingTreasureItemConfig), KingTreasureItemConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(LVAawrdConfig), LVAawrdConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(LanguageConfig), LanguageConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(LegendPropertyConfig), LegendPropertyConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(LegendPropertyValueConfig), LegendPropertyValueConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(LoadingBackGroundConfig), LoadingBackGroundConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(LoadingFunctionConfig), LoadingFunctionConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(LoadingTipConfig), LoadingTipConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(LoginAdConfig), LoginAdConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(LoginRewardConfig), LoginRewardConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(LoginSeverListConfig), LoginSeverListConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(MailConfig), MailConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(MapConfig), MapConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(MapEventPointConfig), MapEventPointConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(MapResourcesConfig), MapResourcesConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(MapUiControlConfig), MapUiControlConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ModelResConfig), ModelResConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(MonsterNameColorConfig), MonsterNameColorConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(MonsterRefreshPointConfig), MonsterRefreshPointConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(NPCConfig), NPCConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(NPCDialogueConfig), NPCDialogueConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(NPCDropItemConfig), NPCDropItemConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(NewAllPeoplePartyAwardConfig), NewAllPeoplePartyAwardConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(NewAllPeoplePartyConfig), NewAllPeoplePartyConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(NewUniquenessArriveConfig), NewUniquenessArriveConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(OSCBillRankAwardConfig), OSCBillRankAwardConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(OSCBillTagAwardConfig), OSCBillTagAwardConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(OSRedAchieveConfig), OSRedAchieveConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(OccupationNameConfig), OccupationNameConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(OnlineAwardConfig), OnlineAwardConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(OrderInfoConfig), OrderInfoConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(PersonalBossConfig), PersonalBossConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(PetClassCostConfig), PetClassCostConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(PetEatEquipConfig), PetEatEquipConfigWrap.__Register);
        
        }
        
        static void wrapInit3(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(PetInfoConfig), PetInfoConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(PlayerLVConfig), PlayerLVConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(PlayerPropertyConfig), PlayerPropertyConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(PriorBundleConfig), PriorBundleConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(PriorLanguageConfig), PriorLanguageConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(PyTaskConfig), PyTaskConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(QuestionBankConfig), QuestionBankConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(RandomNameConfig), RandomNameConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(RankListConfig), RankListConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(RealmConfig), RealmConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(RealmPracticeConfig), RealmPracticeConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(RedPackConfig), RedPackConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(RefineStoveConfig), RefineStoveConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ResourcesBackConfig), ResourcesBackConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(RichTextMsgReplaceConfig), RichTextMsgReplaceConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(RoleEquipStarsConfig), RoleEquipStarsConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(RoleResourceConfig), RoleResourceConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(RoleStrongerConfig), RoleStrongerConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(RuleConfig), RuleConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(RuneComposeConfig), RuneComposeConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(RuneConfig), RuneConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(RuneTowerConfig), RuneTowerConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(RuneTowerFloorConfig), RuneTowerFloorConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(SceneReplaceConfig), SceneReplaceConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(SceneShadowConfig), SceneShadowConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(SignInConfig), SignInConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(SkillClassifingConfig), SkillClassifingConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(SkillConfig), SkillConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(SkillFrameAnimationConfig), SkillFrameAnimationConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(StoreConfig), StoreConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(StoryMissionsConfig), StoryMissionsConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(SuccessConfig), SuccessConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(SuitEffectConfig), SuitEffectConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(SysInfoConfig), SysInfoConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(TASKINFOConfig), TASKINFOConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(TalentConfig), TalentConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(TaskListConfig), TaskListConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(TaskPowerConfig), TaskPowerConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(TeamTargetConfig), TeamTargetConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(TreasureConfig), TreasureConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(TreasureDungeonConfig), TreasureDungeonConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(TreasureFindHostConfig), TreasureFindHostConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(TreasurePrivilegeConfig), TreasurePrivilegeConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(TreasureRefineConfig), TreasureRefineConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(TreasureSkillConfig), TreasureSkillConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(TreasureUpConfig), TreasureUpConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(TrialExchangeConfig), TrialExchangeConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(TrialRewardsConfig), TrialRewardsConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnionLivenConfig), UnionLivenConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UniquenessArriveConfig), UniquenessArriveConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(VIPAwardConfig), VIPAwardConfigWrap.__Register);
        
        }
        
        static void wrapInit4(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(VIPKillNPCConfig), VIPKillNPCConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ViewRoleFuncConfig), ViewRoleFuncConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(VipPrivilegeConfig), VipPrivilegeConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(WHYJRewardConfig), WHYJRewardConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(WashLevelMaxConfig), WashLevelMaxConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(WeatherConfig), WeatherConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(WeekPartyConfig), WeekPartyConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(WeekPartyPointConfig), WeekPartyPointConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(WindowSearchConfig), WindowSearchConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(WingRefineAttrConfig), WingRefineAttrConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(WingRefineExpConfig), WingRefineExpConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(WorldBossConfig), WorldBossConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(XBGetItemConfig), XBGetItemConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(XMZZAchievementConfig), XMZZAchievementConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(bossSkillTipsConfig), bossSkillTipsConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(mapAreaConfig), mapAreaConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(mapbornConfig), mapbornConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(mapnpcConfig), mapnpcConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(maptransportConfig), maptransportConfigWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(PlayerDatas), PlayerDatasWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(SnxxzGame), SnxxzGameWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(GameNetSystem), GameNetSystemWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(AssetBundleUtility), AssetBundleUtilityWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(GameObjectPoolManager), GameObjectPoolManagerWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UILoader), UILoaderWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(SDKUtility), SDKUtilityWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(SFXPlayUtility), SFXPlayUtilityWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(AnyCountDownUtility), AnyCountDownUtilityWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(FlyObjectManager), FlyObjectManagerWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(SkillHelper), SkillHelperWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(StatusMgr), StatusMgrWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(BossFakeLineUtility), BossFakeLineUtilityWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(BattleEffectPlayRule), BattleEffectPlayRuleWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(GAMgr), GAMgrWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(MapTransferUtility), MapTransferUtilityWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(PreFightMission), PreFightMissionWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(PrepareHandler), PrepareHandlerWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(GuideDialogueModel), GuideDialogueModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(GuideMessageModel), GuideMessageModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(NewGuideModel), NewGuideModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(StoryHintModel), StoryHintModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(LuaBehaviour), LuaBehaviourWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(LuaGameNetPackBase), LuaGameNetPackBaseWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(LuaGameNetSystem), LuaGameNetSystemWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(object), SystemObjectWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.Object), UnityEngineObjectWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.Vector2), UnityEngineVector2Wrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.Vector3), UnityEngineVector3Wrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.Vector4), UnityEngineVector4Wrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.Quaternion), UnityEngineQuaternionWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.Color), UnityEngineColorWrap.__Register);
        
        }
        
        static void wrapInit5(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(UnityEngine.Ray), UnityEngineRayWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.Bounds), UnityEngineBoundsWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.Ray2D), UnityEngineRay2DWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.Time), UnityEngineTimeWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.GameObject), UnityEngineGameObjectWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.Component), UnityEngineComponentWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.Behaviour), UnityEngineBehaviourWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.Transform), UnityEngineTransformWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.Resources), UnityEngineResourcesWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.TextAsset), UnityEngineTextAssetWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.Keyframe), UnityEngineKeyframeWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.AnimationCurve), UnityEngineAnimationCurveWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.AnimationClip), UnityEngineAnimationClipWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.MonoBehaviour), UnityEngineMonoBehaviourWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.ParticleSystem), UnityEngineParticleSystemWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.SkinnedMeshRenderer), UnityEngineSkinnedMeshRendererWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.Renderer), UnityEngineRendererWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.WWW), UnityEngineWWWWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.Light), UnityEngineLightWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.Mathf), UnityEngineMathfWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(System.Collections.Generic.List<int>), SystemCollectionsGenericList_1_SystemInt32_Wrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnityEngine.Debug), UnityEngineDebugWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ModelUtility), ModelUtilityWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(LuaWindow), LuaWindowWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(LuaWindowUtility), LuaWindowUtilityWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.AchievementModel), SnxxzUIAchievementModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.ActivityModel), SnxxzUIActivityModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(AssetVersionUtility), AssetVersionUtilityWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DownLoadAndDiscompressTask), DownLoadAndDiscompressTaskWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(InGameDownLoad), InGameDownLoadWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.AuctionConfigClass), SnxxzUIAuctionConfigClassWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.AuctionItemClass), SnxxzUIAuctionItemClassWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.BetterEquipGetModel), SnxxzUIBetterEquipGetModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.ItemUseModel), SnxxzUIItemUseModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.PreciousItemGetModel), SnxxzUIPreciousItemGetModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.RealmBetterEquipModel), SnxxzUIRealmBetterEquipModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(BlastFurnaceModel), BlastFurnaceModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(GetItemPathModel), GetItemPathModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.PrayForDurgModel), SnxxzUIPrayForDurgModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.BossRebornModel), SnxxzUIBossRebornModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.BossShowModel), SnxxzUIBossShowModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.ChatBubbleModel), SnxxzUIChatBubbleModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.ChatCenter), SnxxzUIChatCenterWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(VoiceHttpRequest), VoiceHttpRequestWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(VersionUtility), VersionUtilityWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ComposeWinModel), ComposeWinModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(SelectEquipModel), SelectEquipModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(CrossServerUtility), CrossServerUtilityWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.CrossServerBossModel), SnxxzUICrossServerBossModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.CrossServerOneVsOneModel), SnxxzUICrossServerOneVsOneModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Item_Class), Item_ClassWrap.__Register);
        
        }
        
        static void wrapInit6(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.OpponentInformation), SnxxzUIOpponentInformationWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.DailyQuestActionTimer), SnxxzUIDailyQuestActionTimerWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.DailyQuestModel), SnxxzUIDailyQuestModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.ResourcesBackModel), SnxxzUIResourcesBackModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DebugUtility), DebugUtilityWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.DogzModel), SnxxzUIDogzModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.DogzPackModel), SnxxzUIDogzPackModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.DogzDungeonModel), SnxxzUIDogzDungeonModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.DungeonAssistModel), SnxxzUIDungeonAssistModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.Dungeon), SnxxzUIDungeonWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.DungeonLiquidModel), SnxxzUIDungeonLiquidModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.DungeonModel), SnxxzUIDungeonModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(IceLodeStarAwardClass), IceLodeStarAwardClassWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.TrialDungeonModel), SnxxzUITrialDungeonModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.EquipModel), SnxxzUIEquipModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.EquipGemModel), SnxxzUIEquipGemModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.EquipStarModel), SnxxzUIEquipStarModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.EquipTrainModel), SnxxzUIEquipTrainModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.AllianceBossModel), SnxxzUIAllianceBossModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.FairyBossModel), SnxxzUIFairyBossModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.FairyFeastModel), SnxxzUIFairyFeastModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.FairyGrabBossModel), SnxxzUIFairyGrabBossModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.FairyLeagueModel), SnxxzUIFairyLeagueModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.FairyModel), SnxxzUIFairyModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.KingFairyModel), SnxxzUIKingFairyModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UnionTaskModel), UnionTaskModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.FairylandCeremonyModel), SnxxzUIFairylandCeremonyModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(FakeDungeonUtility), FakeDungeonUtilityWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.FashionDecomposeModel), SnxxzUIFashionDecomposeModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.FashionDressModel), SnxxzUIFashionDressModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.BossHomeModel), SnxxzUIBossHomeModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.DemonJarModel), SnxxzUIDemonJarModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.ElderGodAreaModel), SnxxzUIElderGodAreaModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.FindPreciousModel), SnxxzUIFindPreciousModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.FindPreciousTimer), SnxxzUIFindPreciousTimerWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.PersonalBossModel), SnxxzUIPersonalBossModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.RewardPreviewGroup), SnxxzUIRewardPreviewGroupWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.WorldBossModel), SnxxzUIWorldBossModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(FriendsModel), FriendsModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(GMCmdModel), GMCmdModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.GatherSoulComposeModel), SnxxzUIGatherSoulComposeModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.GatherSoulDungeonModel), SnxxzUIGatherSoulDungeonModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.GatheringSoulModel), SnxxzUIGatheringSoulModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.VirtualPackModel), SnxxzUIVirtualPackModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.GuardModel), SnxxzUIGuardModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.HappyXBModel), SnxxzUIHappyXBModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.HeavenBattleInfo), SnxxzUIHeavenBattleInfoWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(HeavenBattleModel), HeavenBattleModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(HttpRequest), HttpRequestWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.JadeDynastyBossModel), SnxxzUIJadeDynastyBossModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.JadeDynastySkillModel), SnxxzUIJadeDynastySkillModelWrap.__Register);
        
        }
        
        static void wrapInit7(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.JadeDynastyTowerModel), SnxxzUIJadeDynastyTowerModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.FBHelpPointExchageModel), SnxxzUIFBHelpPointExchageModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.KnapsackTimeCDMgr), SnxxzUIKnapsackTimeCDMgrWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.BoxGetItemModel), SnxxzUIBoxGetItemModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.ItemLogicUtility), SnxxzUIItemLogicUtilityWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.ItemOperateUtility), SnxxzUIItemOperateUtilityWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.ItemOverdueModel), SnxxzUIItemOverdueModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.ItemTipsModel), SnxxzUIItemTipsModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.PackModel), SnxxzUIPackModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.TreasureEffectModel), SnxxzUITreasureEffectModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.BatchUseModel), SnxxzUIBatchUseModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.KingTreasureShowModel), SnxxzUIKingTreasureShowModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(KnapSackEventMgr), KnapSackEventMgrWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.CrossServerLogin), SnxxzUICrossServerLoginWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.LoginModel), SnxxzUILoginModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ServerListCenter), ServerListCenterWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.LoginAdModel), SnxxzUILoginAdModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(CapacityDelayModel), CapacityDelayModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(CoinTaskTipModel), CoinTaskTipModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(FeatureNoticeModel), FeatureNoticeModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.MainRedDot), SnxxzUIMainRedDotWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.OffLineOnHookModel), SnxxzUIOffLineOnHookModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.PKModel), SnxxzUIPKModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.StoryMissionsModel), SnxxzUIStoryMissionsModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.TaskAllocation), SnxxzUITaskAllocationWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.TipPanel), SnxxzUITipPanelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.BattleHint), SnxxzUIBattleHintWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.GMNotify), SnxxzUIGMNotifyWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(SysNotifyMgr), SysNotifyMgrWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(HorseClass), HorseClassWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.FunctionalGuideCenter), SnxxzUIFunctionalGuideCenterWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.NewBieCenter), SnxxzUINewBieCenterWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.NewYearFairylandCeremonyModel), SnxxzUINewYearFairylandCeremonyModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.OffLineTimeLackModel), SnxxzUIOffLineTimeLackModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.AccumulateRechargeModel), SnxxzUIAccumulateRechargeModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.FestivalRedpackModel), SnxxzUIFestivalRedpackModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.FlashRushToBuyModel), SnxxzUIFlashRushToBuyModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.FlashSaleModel), SnxxzUIFlashSaleModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.ImpactRankModel), SnxxzUIImpactRankModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.OpenServerActivityCenter), SnxxzUIOpenServerActivityCenterWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(InSevenDayModel), InSevenDayModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(LoginRewardModel), LoginRewardModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.LuckyTreasureModel), SnxxzUILuckyTreasureModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.MonthlyInvestmentModel), SnxxzUIMonthlyInvestmentModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.MysticalPurchaseModel), SnxxzUIMysticalPurchaseModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.OSGiftModel), SnxxzUIOSGiftModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.OSRedEnvelopeModel), SnxxzUIOSRedEnvelopeModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.OpenServerActivityNotifyModel), SnxxzUIOpenServerActivityNotifyModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ActionTypeClass), ActionTypeClassWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.RedEnvelopeModel), SnxxzUIRedEnvelopeModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(SpringFestivalModel), SpringFestivalModelWrap.__Register);
        
        }
        
        static void wrapInit8(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.WishingPoolModel), SnxxzUIWishingPoolModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(PetBackpack), PetBackpackWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(PetReinforceModel), PetReinforceModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.RidingAndPetActivationModel), SnxxzUIRidingAndPetActivationModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(PlayerDeadModel), PlayerDeadModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.RankModel), SnxxzUIRankModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.Redpoint), SnxxzUIRedpointWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.RedpointCenter), SnxxzUIRedpointCenterWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.MagicianModel), SnxxzUIMagicianModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.RoleModel), SnxxzUIRoleModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.RolePointModel), SnxxzUIRolePointModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.TitleModel), SnxxzUITitleModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.RoleParticularModel), SnxxzUIRoleParticularModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.RolePromoteModel), SnxxzUIRolePromoteModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.RuneComposeModel), SnxxzUIRuneComposeModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.RuneModel), SnxxzUIRuneModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.RuneTowerModel), SnxxzUIRuneTowerModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(QuickSetting), QuickSettingWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.SkillModel), SnxxzUISkillModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.TalentModel), SnxxzUITalentModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.TreasureSkillModel), SnxxzUITreasureSkillModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(CoroutineMgr), CoroutineMgrWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(BuyItemPopModel), BuyItemPopModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.BuySuccessModel), SnxxzUIBuySuccessModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(StoreModel), StoreModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(GodBeastModel), GodBeastModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(HowToPlayModel), HowToPlayModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.WingsRedDotModel), SnxxzUIWingsRedDotModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.ActivitiesPushModel), SnxxzUIActivitiesPushModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ChatSetting), ChatSettingWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.FuncSwitchModel), SnxxzUIFuncSwitchModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(HangUpSetModel), HangUpSetModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(PrivateRemind), PrivateRemindWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.SetPrivateModel), SnxxzUISetPrivateModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(SettingEffectMgr), SettingEffectMgrWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(SettingMgr), SettingMgrWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(SystemSetting), SystemSettingWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(TaiChiModel), TaiChiModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.GroupDungeonChallengeProcessor), SnxxzUIGroupDungeonChallengeProcessorWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.TeamModel), SnxxzUITeamModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(PwdKeyboard), PwdKeyboardWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.TreasureModel), SnxxzUITreasureModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.TreasureSoulModel), SnxxzUITreasureSoulModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.TreasureFindHostModel), SnxxzUITreasureFindHostModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(FairyJadeInvestmentModel), FairyJadeInvestmentModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.FirstTimeRechargeModel), SnxxzUIFirstTimeRechargeModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(LimitedTimePackageItemClassModel), LimitedTimePackageItemClassModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(NeedForWhiteModel), NeedForWhiteModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.OSTimeLimitGiftModel), SnxxzUIOSTimeLimitGiftModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.VipInvestModel), SnxxzUIVipInvestModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.WheelOfFortuneModel), SnxxzUIWheelOfFortuneModelWrap.__Register);
        
        }
        
        static void wrapInit9(LuaEnv luaenv, ObjectTranslator translator)
        {
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.VipModel), SnxxzUIVipModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(SpeechTranslate), SpeechTranslateWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.AwardExchangeModel), SnxxzUIAwardExchangeModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.ConsumeRebateModel), SnxxzUIConsumeRebateModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.LevelGiftModel), SnxxzUILevelGiftModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.MultipleExpModel), SnxxzUIMultipleExpModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.MultipleRealmPointModel), SnxxzUIMultipleRealmPointModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.OperationTimeHepler), SnxxzUIOperationTimeHeplerWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.PrayerModel), SnxxzUIPrayerModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.SignInModel), SnxxzUISignInModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.WelfareCenter), SnxxzUIWelfareCenterWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.ModelCenter), SnxxzUIModelCenterWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.WindowCenter), SnxxzUIWindowCenterWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(WindowJumpMgr), WindowJumpMgrWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.MapModel), SnxxzUIMapModelWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(WorldMapSkip), WorldMapSkipWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.FunctionButton), SnxxzUIFunctionButtonWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.ItemBehaviour), SnxxzUIItemBehaviourWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(TimeDownMgr), TimeDownMgrWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(Snxxz.UI.UI3DModelExhibition), SnxxzUIUI3DModelExhibitionWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ButtonEx), ButtonExWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(EffectMgr), EffectMgrWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(TimeMgr), TimeMgrWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UIEffect), UIEffectWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(ComponentExtersion), ComponentExtersionWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(DeviceUtility), DeviceUtilityWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(FileExtersion), FileExtersionWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(GMCommand), GMCommandWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(GlobalTimeEvent), GlobalTimeEventWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(LanguageVerify), LanguageVerifyWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(LayerUtility), LayerUtilityWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(MaterialUtility), MaterialUtilityWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(OperationLogCollect), OperationLogCollectWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(RunTimeExceptionUtility), RunTimeExceptionUtilityWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(TimeUtility), TimeUtilityWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(TransformExtension), TransformExtensionWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UIHelper), UIHelperWrap.__Register);
        
        
            translator.DelayWrapLoader(typeof(UIUtility), UIUtilityWrap.__Register);
        
        
        
        }
        
        static void Init(LuaEnv luaenv, ObjectTranslator translator)
        {
            
            wrapInit0(luaenv, translator);
            
            wrapInit1(luaenv, translator);
            
            wrapInit2(luaenv, translator);
            
            wrapInit3(luaenv, translator);
            
            wrapInit4(luaenv, translator);
            
            wrapInit5(luaenv, translator);
            
            wrapInit6(luaenv, translator);
            
            wrapInit7(luaenv, translator);
            
            wrapInit8(luaenv, translator);
            
            wrapInit9(luaenv, translator);
            
            
            translator.AddInterfaceBridgeCreator(typeof(System.Collections.IEnumerator), SystemCollectionsIEnumeratorBridge.__Create);
            
        }
        
        static XLua_Gen_Initer_Register__()
        {
            XLua.LuaEnv.AddIniter(Init);
        }
		
		
    }
	
}
namespace XLua
{
    public partial class ObjectTranslator
    {
        static XLua.CSObjectWrap.XLua_Gen_Initer_Register__ s_gen_reg_dumb_obj = new XLua.CSObjectWrap.XLua_Gen_Initer_Register__();
        static XLua.CSObjectWrap.XLua_Gen_Initer_Register__ gen_reg_dumb_obj {get{return s_gen_reg_dumb_obj;}}
    }
	
    internal partial class InternalGlobals
    {
	    
        static InternalGlobals()
        {
            extensionMethodMap = new Dictionary<Type, IEnumerable<MethodInfo>>()
            {
			    
            };
			
            genTryArrayGetPtr = StaticLuaCallbacks.__tryArrayGet;
            genTryArraySetPtr = StaticLuaCallbacks.__tryArraySet;
        }
    }
}

 Lua/Gen/XLuaGenAutoRegister.cs.meta

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

 Lua/Gen/link.xml

@@ -415,7 +415,6 @@
        <type fullname="BuyItemPopModel" preserve="all"/>
        <type fullname="Snxxz.UI.BuySuccessModel" preserve="all"/>
        <type fullname="StoreModel" preserve="all"/>
        <type fullname="EquipReinforceModel" preserve="all"/>
        <type fullname="GodBeastModel" preserve="all"/>
        <type fullname="HowToPlayModel" preserve="all"/>
        <type fullname="Snxxz.UI.WingsRedDotModel" preserve="all"/>

 System/BetterItemGet/PreciousItemGetModel.cs

@@ -98,7 +98,7 @@
            {

                var itemModel = itemModels[0];

                var error = 0; 

                var isHaveMakeNum = ItemOperateUtility.Instance.CanUseItem(itemModel.gridIndex ,1,out error);

                var isHaveMakeNum = ItemOperateUtility.Instance.CanUseItem(itemModel.guid ,1,out error);

                if(isHaveMakeNum)

                {

                    OnGetPreciousItem(PackType.Item, itemModel.guid);


 System/Dungeon/DungeonLiquidCell.cs

@@ -193,14 +193,14 @@
                if (isOk)

                {

                    WindowCenter.Instance.Close<DungeonUseLiquidWin>();

                    ItemOperateUtility.Instance.UseItem(itemModel.gridIndex);

                    ItemOperateUtility.Instance.UseItem(itemModel.guid);

                }

            }));

        }

        else

        {

            WindowCenter.Instance.Close<DungeonUseLiquidWin>();

            ItemOperateUtility.Instance.UseItem(itemModel.gridIndex);

            ItemOperateUtility.Instance.UseItem(itemModel.guid);

        }

    }




 System/Equip/EquipModel.cs

@@ -9,14 +9,11 @@
    [XLua.LuaCallCSharp]
    public class EquipModel : Model
    {
        public static readonly List<int> realmEquipTypes = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 };

        public int showedUnLockLevel {
            get { return LocalSave.GetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "EquipSetUnLockHasShowed"), 1); }
            set { LocalSave.SetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "EquipSetUnLockHasShowed"), value); }
        }

        public int showedUnLockSlot {
            get { return LocalSave.GetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "EquipSlotUnLockHasShowed"), 1); }
            set { LocalSave.SetInt(StringUtility.Contact(PlayerDatas.Instance.baseData.PlayerID, "EquipSlotUnLockHasShowed"), value); }
        }

        public readonly LogicInt selectedLevel = new LogicInt();
@@ -71,7 +68,7 @@
            var items = packModel.GetItems(PackType.Item, new SinglePack.FilterParams()
            {
                levels = level == 0 ? null : new List<int>() { level },
                equipTypes = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 },
                equipTypes = realmEquipTypes,
                job = PlayerDatas.Instance.baseData.Job,
            });

@@ -142,7 +139,7 @@
            var items = packModel.GetItems(PackType.Item, new SinglePack.FilterParams()
            {
                levels = level == 0 ? null : new List<int>() { level },
                equipTypes = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 },
                equipTypes = realmEquipTypes,
                job = PlayerDatas.Instance.baseData.Job,
            });

@@ -548,7 +545,7 @@
            var items = packModel.GetItems(PackType.Item, new SinglePack.FilterParams()
            {
                levels = unLockedLevels,
                equipTypes = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 },
                equipTypes = realmEquipTypes,
                job = PlayerDatas.Instance.baseData.Job,
            });

@@ -575,7 +572,7 @@
            var items = packModel.GetItems(PackType.Item, new SinglePack.FilterParams()
            {
                levels = new List<int>() { level },
                equipTypes = new List<int>() { 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 },
                equipTypes = realmEquipTypes,
                job = PlayerDatas.Instance.baseData.Job,
            });

@@ -670,7 +667,7 @@

        public static bool IsRealmEquip(int equipPlace)
        {
            return equipPlace > 1 && equipPlace <= 12;
            return realmEquipTypes.Contains(equipPlace);
        }

    }

 System/KnapSack/ItemTimeUtility.cs

New file
@@ -0,0 +1,68 @@
using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System;
using Snxxz.UI;

public class ItemTimeUtility : Singleton<ItemTimeUtility>
{

    LogicUpdate logicUpdate;

    Dictionary<string, DateTime> auctionEndTimes = new Dictionary<string, DateTime>();
    Dictionary<string, DateTime> useEndTimes = new Dictionary<string, DateTime>();

    public ItemTimeUtility()
    {
        logicUpdate = new LogicUpdate(1f);
        logicUpdate.Start(OnUpdate);
    }

    public void AddUseEndTime(string guid, DateTime endTime)
    {
        useEndTimes[guid] = endTime;
    }

    public void RemoveUseEndTime(string guid)
    {
        if (useEndTimes.ContainsKey(guid))
        {
            useEndTimes.Remove(guid);
        }
    }

    public void AddAuctionEndTime(string guid, DateTime endTime)
    {
        auctionEndTimes[guid] = endTime;
    }

    public void RemoveAuctionEndTime(string guid)
    {
        if (auctionEndTimes.ContainsKey(guid))
        {
            auctionEndTimes.Remove(guid);
        }
    }

    private void OnUpdate()
    {
        foreach (var item in auctionEndTimes)
        {
            if (TimeUtility.ServerNow > item.Value)
            {
                ProcessAuctionOverdue(item.Key);
            }
        }
    }

    private void ProcessItemUseOverdue(string guid)
    {
        ItemOperateUtility.Instance.UseItem(guid);
    }

    private void ProcessAuctionOverdue(string guid)
    {
        ItemOperateUtility.Instance.UseItem(guid);
    }

}

 System/KnapSack/ItemTimeUtility.cs.meta

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

 System/KnapSack/Logic/BoxGetItemModel.cs

@@ -171,11 +171,7 @@
                return;

            }



            ItemModel itemModel = playerPack.GetItemByGuid(guid);

            if (itemModel != null)

            {

                ItemOperateUtility.Instance.UseItem(itemModel.gridIndex, useCnt);

            }

            ItemOperateUtility.Instance.UseItem(guid, useCnt);

        }



        public bool CheckOpenBoxCondition(int itemId, out bool isBox)


 System/KnapSack/Logic/BoxGetItemWin.cs

@@ -246,7 +246,7 @@
            if (itemModel == null) return;



            int useCnt = BoxModel.GetUseCntByID(itemModel.itemId);

            ItemOperateUtility.Instance.UseItem(itemModel.gridIndex, 1);

            ItemOperateUtility.Instance.UseItem(itemModel.guid, 1);

        }



        private void ClickBackBtn()


 System/KnapSack/Logic/ItemLogicUtility.cs

@@ -571,7 +571,7 @@
                    break;
                case 127:
                    var error = 0;
                    bool isHaveMakeNum = ItemOperateUtility.Instance.CanUseItem(item.gridIndex, 1, out error);
                    bool isHaveMakeNum = ItemOperateUtility.Instance.CanUseItem(item.guid, 1, out error);
                    int remainNum = CrossServerOneVsOnePlayerInfo.Instance.GetDayRemainNum();
                    if (!CrossServerOneVsOnePKSeason.Instance.isSatisfyMatch
                        || remainNum > 0
@@ -1383,9 +1383,9 @@
            if (itemConfig.ExpireTime > 0)
            {
                ItemCDCool cool = KnapsackTimeCDMgr.Instance.GetItemCoolById(guid);
                switch ((EquipReduceType)itemConfig.EndureReduceType)
                switch ((ItemTimeType)itemConfig.EndureReduceType)
                {
                    case EquipReduceType.Def_EquipReduceType_Time:
                    case ItemTimeType.EquipedTime:
                        if (guid != "")
                        {
                            List<int> itemEffectTime = null;
@@ -1407,7 +1407,7 @@
                        }
                        break;

                    case EquipReduceType.Def_EquipReduceType_RTimeItem:
                    case ItemTimeType.RealityTime:
                        if (guid != "")
                        {
                            if (cool == null || cool.GetRemainTime() <= 0)

 System/KnapSack/Logic/ItemModel.cs

@@ -76,10 +76,10 @@
                var createTime = GetUseDataFirstValue((int)ItemUseDataKey.createTime);

                if (createTime > 0)

                {

                    switch ((EquipReduceType)config.EndureReduceType)

                    switch ((ItemTimeType)config.EndureReduceType)

                    {

                        case EquipReduceType.Def_EquipReduceType_Time:

                        case EquipReduceType.Def_EquipReduceType_RTimeItem:

                        case ItemTimeType.EquipedTime:

                        case ItemTimeType.RealityTime:

                            var serverSurplusTime = GetUseDataFirstValue(48);

                            ItemLogicUtility.Instance.SetItemEffectCDTime(info.guid, info.itemId, createTime, serverSurplusTime);

                            break;

@@ -89,6 +89,17 @@
                }

            }



            ItemTimeUtility.Instance.RemoveAuctionEndTime(guid);

            if (isAuction)

            {

                var createTime = GetUseDataFirstValue(50);

                if (createTime > 0)

                {

                    var overdueTime = TimeUtility.GetTime((uint)createTime) + new TimeSpan(GeneralDefine.acutionItemHour * TimeSpan.TicksPerHour);

                    ItemTimeUtility.Instance.AddAuctionEndTime(guid, overdueTime);

                }

            }



            this.score = ItemLogicUtility.Instance.GetEquipScore(packType, itemId, useDataDict);

        }




 System/KnapSack/Logic/ItemOperateUtility.cs

@@ -338,7 +338,7 @@
                    if (CheckUseCondition(useItemModel))
                    {
                        var error = 0;
                        if (CanUseItem(useItemModel.gridIndex, 1, out error))
                        if (CanUseItem(useItemModel.guid, 1, out error))
                        {
                            if (useItemModel.config.Jump != 0)
                            {
@@ -449,7 +449,7 @@
                {
                    if (!CheckIsMaxOfflineTime(maxUseCnt, itemModel))
                    {
                        UseItem(itemModel.gridIndex);
                        UseItem(itemModel.guid);
                    }
                    else
                    {
@@ -500,7 +500,7 @@
                    {
                        if (isOk)
                        {
                            UseItem(itemModel.gridIndex);
                            UseItem(itemModel.guid);
                        }
                    }
                    );
@@ -516,7 +516,7 @@
                            ItemCDCool cool = KnapsackTimeCDMgr.Instance.GetItemCoolById(itemModel.guid);
                            if (cool == null || cool.GetRemainTime() <= 0)
                            {
                                UseItem(itemModel.gridIndex);
                                UseItem(itemModel.guid);
                            }
                            else
                            {
@@ -563,7 +563,7 @@
                    {
                        if (isOk)
                        {
                            UseItem(itemModel.gridIndex, useNum);
                            UseItem(itemModel.guid, useNum);
                        }
                    });
                    return true;
@@ -572,18 +572,18 @@
            return false;
        }

        public void UseItem(int index, int useCnt = 1, int extra = 0)
        public void UseItem(string guid, int useCnt = 1, int extra = 0)
        {
            var itemModel = packModel.GetItemByIndex(PackType.Item, index);
            if (itemModel == null)
            var item = packModel.GetItemByGuid(guid);
            if (item == null)
            {
                return;
            }

            var error = 0;
            if (CanUseItem(index, useCnt, out error))
            if (CanUseItem(guid, useCnt, out error))
            {
                UseItemMainServer(index, useCnt, extra);
                UseItemMainServer(guid, useCnt, extra);
            }
            else
            {
@@ -601,24 +601,24 @@
            }
        }

        public bool CanUseItem(int index, int useCnt, out int error)
        public bool CanUseItem(string guid, int useCnt, out int error)
        {
            var itemModel = packModel.GetItemByIndex(PackType.Item, index);
            if (itemModel == null)
            var item = packModel.GetItemByGuid(guid);
            if (item == null)
            {
                error = 999;
                return false;
            }

            var usedCountToday = packModel.GetItemUsedTimesToday(itemModel.itemId);
            if (itemModel.config.MaxSkillCnt > 0 && itemModel.config.MaxSkillCnt <= usedCountToday)
            var usedCountToday = packModel.GetItemUsedTimesToday(item.itemId);
            if (item.config.MaxSkillCnt > 0 && item.config.MaxSkillCnt <= usedCountToday)
            {
                error = 1;
                return false;
            }

            var usedCountTotal = packModel.GetItemTotalUsedTimes(itemModel.itemId);
            var fruitConfig = AttrFruitConfig.Get(itemModel.itemId);
            var usedCountTotal = packModel.GetItemTotalUsedTimes(item.itemId);
            var fruitConfig = AttrFruitConfig.Get(item.itemId);
            if (fruitConfig != null && (usedCountTotal >= fruitConfig.MaxUseCnt || useCnt > fruitConfig.MaxUseCnt))
            {
                error = 1;
@@ -629,24 +629,24 @@
            return true;
        }

        public void UseItemMainServer(int index, int useCnt, int extra)
        void UseItemMainServer(string guid, int useCnt, int extra)
        {
            var itemModel = packModel.GetItemByIndex(PackType.Item, index);
            var itemModel = packModel.GetItemByGuid(guid);
            if (itemModel == null)
            {
                return;
            }

            var useItem = new CA323_tagCMUseItems();
            useItem.ItemIndex = (byte)index;
            useItem.ItemIndex = (byte)itemModel.gridIndex;
            useItem.UseCnt = (ushort)useCnt;
            useItem.ExData = (uint)extra;
            GameNetSystem.Instance.SendInfo(useItem); //使用物品
        }

        public void UseItemCrossServer(int index)
        public void UseItemCrossServer(string guid)
        {
            var itemModel = packModel.GetItemByIndex(PackType.Item, index);
            var itemModel = packModel.GetItemByGuid(guid);
            if (itemModel == null)
            {
                return;

 System/KnapSack/Logic/MakeDrugCell.cs

@@ -183,7 +183,7 @@
            {

                if (ItemOperateUtility.Instance.CheckItemUselimit(itemId))

                {

                    ItemOperateUtility.Instance.UseItem(list[0].gridIndex);

                    ItemOperateUtility.Instance.UseItem(list[0].guid);

                }

            }

        }


 System/KnapSack/Logic/PackModel.cs

@@ -561,9 +561,9 @@
                if (itemModel.config.ExpireTime > 0)
                {
                    ItemCDCool cool = KnapsackTimeCDMgr.Instance.GetItemCoolById(itemModel.guid);
                    switch ((EquipReduceType)itemModel.config.EndureReduceType)
                    switch ((ItemTimeType)itemModel.config.EndureReduceType)
                    {
                        case EquipReduceType.Def_EquipReduceType_Time:
                        case ItemTimeType.EquipedTime:
                            List<int> itemEffectTime = itemModel.GetUseData((int)ItemUseDataKey.createTime);
                            if (itemEffectTime != null && itemEffectTime[0] != 0)
                            {
@@ -574,7 +574,7 @@
                            }
                            break;

                        case EquipReduceType.Def_EquipReduceType_RTimeItem:
                        case ItemTimeType.RealityTime:
                            if (cool == null || cool.GetRemainTime() <= 0)
                            {
                                isOverdue = true;

 System/KnapSack/Logic/WashAttrPointWin.cs

@@ -169,7 +169,7 @@
                }

                else

                {

                    ItemOperateUtility.Instance.UseItem(itemModel.gridIndex,1,(int)selectAttr);

                    ItemOperateUtility.Instance.UseItem(itemModel.guid,1,(int)selectAttr);

                }

                

            }


 System/KnapSack/Logic/WashPointBatchUseWin.cs

@@ -155,7 +155,7 @@
            if (itemModel == null)
                return;

            ItemOperateUtility.Instance.UseItem(itemModel.gridIndex, (ushort)Mathf.Ceil(_splitSlider.value), BatchUseModel.Instance.extraPrams);
            ItemOperateUtility.Instance.UseItem(itemModel.guid, (ushort)Mathf.Ceil(_splitSlider.value), BatchUseModel.Instance.extraPrams);
            OnClickCloseBtn();
        }


 System/KnapSack/New/BatchWin.cs

@@ -146,7 +146,7 @@
                {

                    if (isOk)

                    {

                        ItemOperateUtility.Instance.UseItem(itemModel.gridIndex, (ushort)Mathf.Ceil(m_SplitSlider.value), BatchUseModel.Instance.extraPrams);

                        ItemOperateUtility.Instance.UseItem(itemModel.guid, (ushort)Mathf.Ceil(m_SplitSlider.value), BatchUseModel.Instance.extraPrams);

                    }

                }

                );

@@ -158,7 +158,7 @@
            }

            else

            {

                ItemOperateUtility.Instance.UseItem(itemModel.gridIndex, (ushort)Mathf.Ceil(m_SplitSlider.value), BatchUseModel.Instance.extraPrams);

                ItemOperateUtility.Instance.UseItem(itemModel.guid, (ushort)Mathf.Ceil(m_SplitSlider.value), BatchUseModel.Instance.extraPrams);

            }



            OnClickCloseBtn();


 System/KnapSack/New/ChooseItemWin.cs

@@ -208,7 +208,7 @@
            ItemModel itemModel = playerPack.GetItemByGuid(BoxModel.guid);

            if(itemModel != null)

            {

                ItemOperateUtility.Instance.UseItem(itemModel.gridIndex,useNum,chooseId);

                ItemOperateUtility.Instance.UseItem(itemModel.guid,useNum,chooseId);

            }

            CloseImmediately();

        }


 System/KnapSack/New/OfflineHangUpUseWin.cs

@@ -104,7 +104,7 @@
            bool isMax = ItemOperateUtility.Instance.CheckIsMaxOfflineTime((int)Mathf.Ceil(_batchUseSlider.value), itemModel);

            if(!isMax)

            {

                ItemOperateUtility.Instance.UseItem(itemModel.gridIndex, (int)Mathf.Ceil(_batchUseSlider.value));

                ItemOperateUtility.Instance.UseItem(itemModel.guid, (int)Mathf.Ceil(_batchUseSlider.value));

            }

            CloseClick();

        }


 Utility/EnumHelper.cs

@@ -1518,27 +1518,15 @@
    NuwaGradeS = 63,

    AnyMountLevel = 64,

    DvsFWinningStreak = 65,





}



/// <summary>

/// 物品使用耐久度限制类型

/// </summary>

public enum EquipReduceType

public enum ItemTimeType

{

    Def_EquipReduceType_None = 0,              //无耐久

    Def_EquipReduceType_DEF = 1,               //被攻击次数

    Def_EquipReduceType_ATK = 2,              //攻击次数

    Def_EquipReduceType_Time = 3,              //时间（装备的时候-1，此后每分钟-1）

    Def_EquipReduceType_AttackValue = 4,       //攻击伤害值

    Def_EquipReduceType_HurtValue = 5,         //受到的伤害值

    Def_EquipReduceType_Spcl = 6,              //物品特殊说明

    Def_EquipReduceType_HPMPValue = 7,         //按恢复的HP或是MP量扣除

    Def_EquipReduceType_Horse = 8,             //马匹

    Def_EquipReduceType_RTimeItem = 9,         //现实时间扣耐久

    Def_EquipReduceType_Day = 10,               //根据天数决定 如1标示当天过期 类推

    Def_EquipReduceType_ServerDay = 11,         //根据开服天数决定 如10表示有效期到开服第10天, 第11天消失

    EquipedTime = 3,              //时间（装备的时候-1，此后每分钟-1）

    RealityTime = 9,                //现实时间扣耐久

}



public enum ImageSelect