From c8e3a97e4e02e7328d70dbc3dc69c3d4230a5a37 Mon Sep 17 00:00:00 2001
From: client_linchunjie <461730578@qq.com>
Date: 星期三, 15 五月 2019 10:36:47 +0800
Subject: [PATCH] Merge branch 'master' of http://192.168.0.87:10010/r/snxxz_scripts
---
Lua/Gen/WrapPusher.cs | 6111 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 6,111 insertions(+), 0 deletions(-)
diff --git a/Lua/Gen/WrapPusher.cs b/Lua/Gen/WrapPusher.cs
index 8052711..fe1ae45 100644
--- a/Lua/Gen/WrapPusher.cs
+++ b/Lua/Gen/WrapPusher.cs
@@ -34,6 +34,69 @@
translator.RegisterPushAndGetAndUpdate<UnityEngine.Ray>(translator.PushUnityEngineRay, translator.Get, translator.UpdateUnityEngineRay);
translator.RegisterPushAndGetAndUpdate<UnityEngine.Bounds>(translator.PushUnityEngineBounds, translator.Get, translator.UpdateUnityEngineBounds);
translator.RegisterPushAndGetAndUpdate<UnityEngine.Ray2D>(translator.PushUnityEngineRay2D, translator.Get, translator.UpdateUnityEngineRay2D);
+ translator.RegisterPushAndGetAndUpdate<E_ActorClassType>(translator.PushE_ActorClassType, translator.Get, translator.UpdateE_ActorClassType);
+ translator.RegisterPushAndGetAndUpdate<E_ActorState>(translator.PushE_ActorState, translator.Get, translator.UpdateE_ActorState);
+ translator.RegisterPushAndGetAndUpdate<E_BuffType>(translator.PushE_BuffType, translator.Get, translator.UpdateE_BuffType);
+ translator.RegisterPushAndGetAndUpdate<E_ClientNpcType>(translator.PushE_ClientNpcType, translator.Get, translator.UpdateE_ClientNpcType);
+ translator.RegisterPushAndGetAndUpdate<E_NpcType>(translator.PushE_NpcType, translator.Get, translator.UpdateE_NpcType);
+ translator.RegisterPushAndGetAndUpdate<E_MovingState>(translator.PushE_MovingState, translator.Get, translator.UpdateE_MovingState);
+ translator.RegisterPushAndGetAndUpdate<WindowType>(translator.PushWindowType, translator.Get, translator.UpdateWindowType);
+ translator.RegisterPushAndGetAndUpdate<GestureType>(translator.PushGestureType, translator.Get, translator.UpdateGestureType);
+ translator.RegisterPushAndGetAndUpdate<UnityPlatform>(translator.PushUnityPlatform, translator.Get, translator.UpdateUnityPlatform);
+ translator.RegisterPushAndGetAndUpdate<RoleRenameResult>(translator.PushRoleRenameResult, translator.Get, translator.UpdateRoleRenameResult);
+ translator.RegisterPushAndGetAndUpdate<E_SkillCastTarget>(translator.PushE_SkillCastTarget, translator.Get, translator.UpdateE_SkillCastTarget);
+ translator.RegisterPushAndGetAndUpdate<E_SkillType>(translator.PushE_SkillType, translator.Get, translator.UpdateE_SkillType);
+ translator.RegisterPushAndGetAndUpdate<E_SkillFuncType>(translator.PushE_SkillFuncType, translator.Get, translator.UpdateE_SkillFuncType);
+ translator.RegisterPushAndGetAndUpdate<E_SkillCastType>(translator.PushE_SkillCastType, translator.Get, translator.UpdateE_SkillCastType);
+ translator.RegisterPushAndGetAndUpdate<MapTransferType>(translator.PushMapTransferType, translator.Get, translator.UpdateMapTransferType);
+ translator.RegisterPushAndGetAndUpdate<DropItemType>(translator.PushDropItemType, translator.Get, translator.UpdateDropItemType);
+ translator.RegisterPushAndGetAndUpdate<DailyQuestType>(translator.PushDailyQuestType, translator.Get, translator.UpdateDailyQuestType);
+ translator.RegisterPushAndGetAndUpdate<DungeonCoolDownType>(translator.PushDungeonCoolDownType, translator.Get, translator.UpdateDungeonCoolDownType);
+ translator.RegisterPushAndGetAndUpdate<RoleEquipType>(translator.PushRoleEquipType, translator.Get, translator.UpdateRoleEquipType);
+ translator.RegisterPushAndGetAndUpdate<PlayerDataType>(translator.PushPlayerDataType, translator.Get, translator.UpdatePlayerDataType);
+ translator.RegisterPushAndGetAndUpdate<PackType>(translator.PushPackType, translator.Get, translator.UpdatePackType);
+ translator.RegisterPushAndGetAndUpdate<ItemType>(translator.PushItemType, translator.Get, translator.UpdateItemType);
+ translator.RegisterPushAndGetAndUpdate<MakeType>(translator.PushMakeType, translator.Get, translator.UpdateMakeType);
+ translator.RegisterPushAndGetAndUpdate<TitleType>(translator.PushTitleType, translator.Get, translator.UpdateTitleType);
+ translator.RegisterPushAndGetAndUpdate<FuncOpenEnum>(translator.PushFuncOpenEnum, translator.Get, translator.UpdateFuncOpenEnum);
+ translator.RegisterPushAndGetAndUpdate<PropertyType>(translator.PushPropertyType, translator.Get, translator.UpdatePropertyType);
+ translator.RegisterPushAndGetAndUpdate<TextColType>(translator.PushTextColType, translator.Get, translator.UpdateTextColType);
+ translator.RegisterPushAndGetAndUpdate<E_ModelResType>(translator.PushE_ModelResType, translator.Get, translator.UpdateE_ModelResType);
+ translator.RegisterPushAndGetAndUpdate<TreasureCategory>(translator.PushTreasureCategory, translator.Get, translator.UpdateTreasureCategory);
+ translator.RegisterPushAndGetAndUpdate<TreasureState>(translator.PushTreasureState, translator.Get, translator.UpdateTreasureState);
+ translator.RegisterPushAndGetAndUpdate<FunctionUnlockType>(translator.PushFunctionUnlockType, translator.Get, translator.UpdateFunctionUnlockType);
+ translator.RegisterPushAndGetAndUpdate<RedPointState>(translator.PushRedPointState, translator.Get, translator.UpdateRedPointState);
+ translator.RegisterPushAndGetAndUpdate<TeamInviteType>(translator.PushTeamInviteType, translator.Get, translator.UpdateTeamInviteType);
+ translator.RegisterPushAndGetAndUpdate<TeammatePrepareState>(translator.PushTeammatePrepareState, translator.Get, translator.UpdateTeammatePrepareState);
+ translator.RegisterPushAndGetAndUpdate<VipPrivilegeType>(translator.PushVipPrivilegeType, translator.Get, translator.UpdateVipPrivilegeType);
+ translator.RegisterPushAndGetAndUpdate<E_AttackMode>(translator.PushE_AttackMode, translator.Get, translator.UpdateE_AttackMode);
+ translator.RegisterPushAndGetAndUpdate<E_ItemColor>(translator.PushE_ItemColor, translator.Get, translator.UpdateE_ItemColor);
+ translator.RegisterPushAndGetAndUpdate<FindPreciousType>(translator.PushFindPreciousType, translator.Get, translator.UpdateFindPreciousType);
+ translator.RegisterPushAndGetAndUpdate<GotServerRewardType>(translator.PushGotServerRewardType, translator.Get, translator.UpdateGotServerRewardType);
+ translator.RegisterPushAndGetAndUpdate<MapType>(translator.PushMapType, translator.Get, translator.UpdateMapType);
+ translator.RegisterPushAndGetAndUpdate<GuideType>(translator.PushGuideType, translator.Get, translator.UpdateGuideType);
+ translator.RegisterPushAndGetAndUpdate<GuideTriggerType>(translator.PushGuideTriggerType, translator.Get, translator.UpdateGuideTriggerType);
+ translator.RegisterPushAndGetAndUpdate<FuncPowerType>(translator.PushFuncPowerType, translator.Get, translator.UpdateFuncPowerType);
+ translator.RegisterPushAndGetAndUpdate<E_AtkType>(translator.PushE_AtkType, translator.Get, translator.UpdateE_AtkType);
+ translator.RegisterPushAndGetAndUpdate<GameObjType>(translator.PushGameObjType, translator.Get, translator.UpdateGameObjType);
+ translator.RegisterPushAndGetAndUpdate<HurtAttackType>(translator.PushHurtAttackType, translator.Get, translator.UpdateHurtAttackType);
+ translator.RegisterPushAndGetAndUpdate<DungeonTargetType>(translator.PushDungeonTargetType, translator.Get, translator.UpdateDungeonTargetType);
+ translator.RegisterPushAndGetAndUpdate<AchievementType>(translator.PushAchievementType, translator.Get, translator.UpdateAchievementType);
+ translator.RegisterPushAndGetAndUpdate<ItemTimeType>(translator.PushItemTimeType, translator.Get, translator.UpdateItemTimeType);
+ translator.RegisterPushAndGetAndUpdate<TitleBtnState>(translator.PushTitleBtnState, translator.Get, translator.UpdateTitleBtnState);
+ translator.RegisterPushAndGetAndUpdate<LegendAttrType>(translator.PushLegendAttrType, translator.Get, translator.UpdateLegendAttrType);
+ translator.RegisterPushAndGetAndUpdate<ServerState>(translator.PushServerState, translator.Get, translator.UpdateServerState);
+ translator.RegisterPushAndGetAndUpdate<ItemUseDataKey>(translator.PushItemUseDataKey, translator.Get, translator.UpdateItemUseDataKey);
+ translator.RegisterPushAndGetAndUpdate<ItemOperateType>(translator.PushItemOperateType, translator.Get, translator.UpdateItemOperateType);
+ translator.RegisterPushAndGetAndUpdate<ItemWinType>(translator.PushItemWinType, translator.Get, translator.UpdateItemWinType);
+ translator.RegisterPushAndGetAndUpdate<ItemTipChildType>(translator.PushItemTipChildType, translator.Get, translator.UpdateItemTipChildType);
+ translator.RegisterPushAndGetAndUpdate<InstalledAsset>(translator.PushInstalledAsset, translator.Get, translator.UpdateInstalledAsset);
+ translator.RegisterPushAndGetAndUpdate<VersionAuthority>(translator.PushVersionAuthority, translator.Get, translator.UpdateVersionAuthority);
+ translator.RegisterPushAndGetAndUpdate<FootAudioType>(translator.PushFootAudioType, translator.Get, translator.UpdateFootAudioType);
+ translator.RegisterPushAndGetAndUpdate<AttackFailType>(translator.PushAttackFailType, translator.Get, translator.UpdateAttackFailType);
+ translator.RegisterPushAndGetAndUpdate<DungeonFightStage>(translator.PushDungeonFightStage, translator.Get, translator.UpdateDungeonFightStage);
+ translator.RegisterPushAndGetAndUpdate<RankType>(translator.PushRankType, translator.Get, translator.UpdateRankType);
+ translator.RegisterPushAndGetAndUpdate<PetOrMount>(translator.PushPetOrMount, translator.Get, translator.UpdatePetOrMount);
}
}
@@ -570,6 +633,5298 @@
}
}
+ int E_ActorClassType_TypeID = -1;
+ int E_ActorClassType_EnumRef = -1;
+
+ public void PushE_ActorClassType(RealStatePtr L, E_ActorClassType val)
+ {
+ if (E_ActorClassType_TypeID == -1)
+ {
+ bool is_first;
+ E_ActorClassType_TypeID = getTypeId(L, typeof(E_ActorClassType), out is_first);
+
+ if (E_ActorClassType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(E_ActorClassType));
+ E_ActorClassType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, E_ActorClassType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, E_ActorClassType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for E_ActorClassType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, E_ActorClassType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out E_ActorClassType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_ActorClassType_TypeID)
+ {
+ throw new Exception("invalid userdata for E_ActorClassType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for E_ActorClassType");
+ }
+ val = (E_ActorClassType)e;
+
+ }
+ else
+ {
+ val = (E_ActorClassType)objectCasters.GetCaster(typeof(E_ActorClassType))(L, index, null);
+ }
+ }
+
+ public void UpdateE_ActorClassType(RealStatePtr L, int index, E_ActorClassType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_ActorClassType_TypeID)
+ {
+ throw new Exception("invalid userdata for E_ActorClassType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for E_ActorClassType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int E_ActorState_TypeID = -1;
+ int E_ActorState_EnumRef = -1;
+
+ public void PushE_ActorState(RealStatePtr L, E_ActorState val)
+ {
+ if (E_ActorState_TypeID == -1)
+ {
+ bool is_first;
+ E_ActorState_TypeID = getTypeId(L, typeof(E_ActorState), out is_first);
+
+ if (E_ActorState_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(E_ActorState));
+ E_ActorState_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, E_ActorState_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, E_ActorState_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for E_ActorState ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, E_ActorState_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out E_ActorState val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_ActorState_TypeID)
+ {
+ throw new Exception("invalid userdata for E_ActorState");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for E_ActorState");
+ }
+ val = (E_ActorState)e;
+
+ }
+ else
+ {
+ val = (E_ActorState)objectCasters.GetCaster(typeof(E_ActorState))(L, index, null);
+ }
+ }
+
+ public void UpdateE_ActorState(RealStatePtr L, int index, E_ActorState val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_ActorState_TypeID)
+ {
+ throw new Exception("invalid userdata for E_ActorState");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for E_ActorState ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int E_BuffType_TypeID = -1;
+ int E_BuffType_EnumRef = -1;
+
+ public void PushE_BuffType(RealStatePtr L, E_BuffType val)
+ {
+ if (E_BuffType_TypeID == -1)
+ {
+ bool is_first;
+ E_BuffType_TypeID = getTypeId(L, typeof(E_BuffType), out is_first);
+
+ if (E_BuffType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(E_BuffType));
+ E_BuffType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, E_BuffType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, E_BuffType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for E_BuffType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, E_BuffType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out E_BuffType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_BuffType_TypeID)
+ {
+ throw new Exception("invalid userdata for E_BuffType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for E_BuffType");
+ }
+ val = (E_BuffType)e;
+
+ }
+ else
+ {
+ val = (E_BuffType)objectCasters.GetCaster(typeof(E_BuffType))(L, index, null);
+ }
+ }
+
+ public void UpdateE_BuffType(RealStatePtr L, int index, E_BuffType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_BuffType_TypeID)
+ {
+ throw new Exception("invalid userdata for E_BuffType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for E_BuffType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int E_ClientNpcType_TypeID = -1;
+ int E_ClientNpcType_EnumRef = -1;
+
+ public void PushE_ClientNpcType(RealStatePtr L, E_ClientNpcType val)
+ {
+ if (E_ClientNpcType_TypeID == -1)
+ {
+ bool is_first;
+ E_ClientNpcType_TypeID = getTypeId(L, typeof(E_ClientNpcType), out is_first);
+
+ if (E_ClientNpcType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(E_ClientNpcType));
+ E_ClientNpcType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, E_ClientNpcType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, E_ClientNpcType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for E_ClientNpcType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, E_ClientNpcType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out E_ClientNpcType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_ClientNpcType_TypeID)
+ {
+ throw new Exception("invalid userdata for E_ClientNpcType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for E_ClientNpcType");
+ }
+ val = (E_ClientNpcType)e;
+
+ }
+ else
+ {
+ val = (E_ClientNpcType)objectCasters.GetCaster(typeof(E_ClientNpcType))(L, index, null);
+ }
+ }
+
+ public void UpdateE_ClientNpcType(RealStatePtr L, int index, E_ClientNpcType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_ClientNpcType_TypeID)
+ {
+ throw new Exception("invalid userdata for E_ClientNpcType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for E_ClientNpcType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int E_NpcType_TypeID = -1;
+ int E_NpcType_EnumRef = -1;
+
+ public void PushE_NpcType(RealStatePtr L, E_NpcType val)
+ {
+ if (E_NpcType_TypeID == -1)
+ {
+ bool is_first;
+ E_NpcType_TypeID = getTypeId(L, typeof(E_NpcType), out is_first);
+
+ if (E_NpcType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(E_NpcType));
+ E_NpcType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, E_NpcType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, E_NpcType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for E_NpcType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, E_NpcType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out E_NpcType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_NpcType_TypeID)
+ {
+ throw new Exception("invalid userdata for E_NpcType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for E_NpcType");
+ }
+ val = (E_NpcType)e;
+
+ }
+ else
+ {
+ val = (E_NpcType)objectCasters.GetCaster(typeof(E_NpcType))(L, index, null);
+ }
+ }
+
+ public void UpdateE_NpcType(RealStatePtr L, int index, E_NpcType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_NpcType_TypeID)
+ {
+ throw new Exception("invalid userdata for E_NpcType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for E_NpcType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int E_MovingState_TypeID = -1;
+ int E_MovingState_EnumRef = -1;
+
+ public void PushE_MovingState(RealStatePtr L, E_MovingState val)
+ {
+ if (E_MovingState_TypeID == -1)
+ {
+ bool is_first;
+ E_MovingState_TypeID = getTypeId(L, typeof(E_MovingState), out is_first);
+
+ if (E_MovingState_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(E_MovingState));
+ E_MovingState_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, E_MovingState_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, E_MovingState_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for E_MovingState ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, E_MovingState_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out E_MovingState val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_MovingState_TypeID)
+ {
+ throw new Exception("invalid userdata for E_MovingState");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for E_MovingState");
+ }
+ val = (E_MovingState)e;
+
+ }
+ else
+ {
+ val = (E_MovingState)objectCasters.GetCaster(typeof(E_MovingState))(L, index, null);
+ }
+ }
+
+ public void UpdateE_MovingState(RealStatePtr L, int index, E_MovingState val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_MovingState_TypeID)
+ {
+ throw new Exception("invalid userdata for E_MovingState");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for E_MovingState ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int WindowType_TypeID = -1;
+ int WindowType_EnumRef = -1;
+
+ public void PushWindowType(RealStatePtr L, WindowType val)
+ {
+ if (WindowType_TypeID == -1)
+ {
+ bool is_first;
+ WindowType_TypeID = getTypeId(L, typeof(WindowType), out is_first);
+
+ if (WindowType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(WindowType));
+ WindowType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, WindowType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, WindowType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for WindowType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, WindowType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out WindowType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != WindowType_TypeID)
+ {
+ throw new Exception("invalid userdata for WindowType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for WindowType");
+ }
+ val = (WindowType)e;
+
+ }
+ else
+ {
+ val = (WindowType)objectCasters.GetCaster(typeof(WindowType))(L, index, null);
+ }
+ }
+
+ public void UpdateWindowType(RealStatePtr L, int index, WindowType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != WindowType_TypeID)
+ {
+ throw new Exception("invalid userdata for WindowType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for WindowType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int GestureType_TypeID = -1;
+ int GestureType_EnumRef = -1;
+
+ public void PushGestureType(RealStatePtr L, GestureType val)
+ {
+ if (GestureType_TypeID == -1)
+ {
+ bool is_first;
+ GestureType_TypeID = getTypeId(L, typeof(GestureType), out is_first);
+
+ if (GestureType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(GestureType));
+ GestureType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, GestureType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, GestureType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for GestureType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, GestureType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out GestureType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != GestureType_TypeID)
+ {
+ throw new Exception("invalid userdata for GestureType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for GestureType");
+ }
+ val = (GestureType)e;
+
+ }
+ else
+ {
+ val = (GestureType)objectCasters.GetCaster(typeof(GestureType))(L, index, null);
+ }
+ }
+
+ public void UpdateGestureType(RealStatePtr L, int index, GestureType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != GestureType_TypeID)
+ {
+ throw new Exception("invalid userdata for GestureType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for GestureType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int UnityPlatform_TypeID = -1;
+ int UnityPlatform_EnumRef = -1;
+
+ public void PushUnityPlatform(RealStatePtr L, UnityPlatform val)
+ {
+ if (UnityPlatform_TypeID == -1)
+ {
+ bool is_first;
+ UnityPlatform_TypeID = getTypeId(L, typeof(UnityPlatform), out is_first);
+
+ if (UnityPlatform_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(UnityPlatform));
+ UnityPlatform_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, UnityPlatform_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, UnityPlatform_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for UnityPlatform ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, UnityPlatform_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out UnityPlatform val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != UnityPlatform_TypeID)
+ {
+ throw new Exception("invalid userdata for UnityPlatform");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for UnityPlatform");
+ }
+ val = (UnityPlatform)e;
+
+ }
+ else
+ {
+ val = (UnityPlatform)objectCasters.GetCaster(typeof(UnityPlatform))(L, index, null);
+ }
+ }
+
+ public void UpdateUnityPlatform(RealStatePtr L, int index, UnityPlatform val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != UnityPlatform_TypeID)
+ {
+ throw new Exception("invalid userdata for UnityPlatform");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for UnityPlatform ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int RoleRenameResult_TypeID = -1;
+ int RoleRenameResult_EnumRef = -1;
+
+ public void PushRoleRenameResult(RealStatePtr L, RoleRenameResult val)
+ {
+ if (RoleRenameResult_TypeID == -1)
+ {
+ bool is_first;
+ RoleRenameResult_TypeID = getTypeId(L, typeof(RoleRenameResult), out is_first);
+
+ if (RoleRenameResult_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(RoleRenameResult));
+ RoleRenameResult_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, RoleRenameResult_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, RoleRenameResult_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for RoleRenameResult ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, RoleRenameResult_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out RoleRenameResult val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != RoleRenameResult_TypeID)
+ {
+ throw new Exception("invalid userdata for RoleRenameResult");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for RoleRenameResult");
+ }
+ val = (RoleRenameResult)e;
+
+ }
+ else
+ {
+ val = (RoleRenameResult)objectCasters.GetCaster(typeof(RoleRenameResult))(L, index, null);
+ }
+ }
+
+ public void UpdateRoleRenameResult(RealStatePtr L, int index, RoleRenameResult val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != RoleRenameResult_TypeID)
+ {
+ throw new Exception("invalid userdata for RoleRenameResult");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for RoleRenameResult ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int E_SkillCastTarget_TypeID = -1;
+ int E_SkillCastTarget_EnumRef = -1;
+
+ public void PushE_SkillCastTarget(RealStatePtr L, E_SkillCastTarget val)
+ {
+ if (E_SkillCastTarget_TypeID == -1)
+ {
+ bool is_first;
+ E_SkillCastTarget_TypeID = getTypeId(L, typeof(E_SkillCastTarget), out is_first);
+
+ if (E_SkillCastTarget_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(E_SkillCastTarget));
+ E_SkillCastTarget_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, E_SkillCastTarget_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, E_SkillCastTarget_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for E_SkillCastTarget ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, E_SkillCastTarget_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out E_SkillCastTarget val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_SkillCastTarget_TypeID)
+ {
+ throw new Exception("invalid userdata for E_SkillCastTarget");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for E_SkillCastTarget");
+ }
+ val = (E_SkillCastTarget)e;
+
+ }
+ else
+ {
+ val = (E_SkillCastTarget)objectCasters.GetCaster(typeof(E_SkillCastTarget))(L, index, null);
+ }
+ }
+
+ public void UpdateE_SkillCastTarget(RealStatePtr L, int index, E_SkillCastTarget val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_SkillCastTarget_TypeID)
+ {
+ throw new Exception("invalid userdata for E_SkillCastTarget");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for E_SkillCastTarget ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int E_SkillType_TypeID = -1;
+ int E_SkillType_EnumRef = -1;
+
+ public void PushE_SkillType(RealStatePtr L, E_SkillType val)
+ {
+ if (E_SkillType_TypeID == -1)
+ {
+ bool is_first;
+ E_SkillType_TypeID = getTypeId(L, typeof(E_SkillType), out is_first);
+
+ if (E_SkillType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(E_SkillType));
+ E_SkillType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, E_SkillType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, E_SkillType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for E_SkillType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, E_SkillType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out E_SkillType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_SkillType_TypeID)
+ {
+ throw new Exception("invalid userdata for E_SkillType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for E_SkillType");
+ }
+ val = (E_SkillType)e;
+
+ }
+ else
+ {
+ val = (E_SkillType)objectCasters.GetCaster(typeof(E_SkillType))(L, index, null);
+ }
+ }
+
+ public void UpdateE_SkillType(RealStatePtr L, int index, E_SkillType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_SkillType_TypeID)
+ {
+ throw new Exception("invalid userdata for E_SkillType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for E_SkillType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int E_SkillFuncType_TypeID = -1;
+ int E_SkillFuncType_EnumRef = -1;
+
+ public void PushE_SkillFuncType(RealStatePtr L, E_SkillFuncType val)
+ {
+ if (E_SkillFuncType_TypeID == -1)
+ {
+ bool is_first;
+ E_SkillFuncType_TypeID = getTypeId(L, typeof(E_SkillFuncType), out is_first);
+
+ if (E_SkillFuncType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(E_SkillFuncType));
+ E_SkillFuncType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, E_SkillFuncType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, E_SkillFuncType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for E_SkillFuncType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, E_SkillFuncType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out E_SkillFuncType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_SkillFuncType_TypeID)
+ {
+ throw new Exception("invalid userdata for E_SkillFuncType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for E_SkillFuncType");
+ }
+ val = (E_SkillFuncType)e;
+
+ }
+ else
+ {
+ val = (E_SkillFuncType)objectCasters.GetCaster(typeof(E_SkillFuncType))(L, index, null);
+ }
+ }
+
+ public void UpdateE_SkillFuncType(RealStatePtr L, int index, E_SkillFuncType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_SkillFuncType_TypeID)
+ {
+ throw new Exception("invalid userdata for E_SkillFuncType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for E_SkillFuncType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int E_SkillCastType_TypeID = -1;
+ int E_SkillCastType_EnumRef = -1;
+
+ public void PushE_SkillCastType(RealStatePtr L, E_SkillCastType val)
+ {
+ if (E_SkillCastType_TypeID == -1)
+ {
+ bool is_first;
+ E_SkillCastType_TypeID = getTypeId(L, typeof(E_SkillCastType), out is_first);
+
+ if (E_SkillCastType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(E_SkillCastType));
+ E_SkillCastType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, E_SkillCastType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, E_SkillCastType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for E_SkillCastType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, E_SkillCastType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out E_SkillCastType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_SkillCastType_TypeID)
+ {
+ throw new Exception("invalid userdata for E_SkillCastType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for E_SkillCastType");
+ }
+ val = (E_SkillCastType)e;
+
+ }
+ else
+ {
+ val = (E_SkillCastType)objectCasters.GetCaster(typeof(E_SkillCastType))(L, index, null);
+ }
+ }
+
+ public void UpdateE_SkillCastType(RealStatePtr L, int index, E_SkillCastType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_SkillCastType_TypeID)
+ {
+ throw new Exception("invalid userdata for E_SkillCastType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for E_SkillCastType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int MapTransferType_TypeID = -1;
+ int MapTransferType_EnumRef = -1;
+
+ public void PushMapTransferType(RealStatePtr L, MapTransferType val)
+ {
+ if (MapTransferType_TypeID == -1)
+ {
+ bool is_first;
+ MapTransferType_TypeID = getTypeId(L, typeof(MapTransferType), out is_first);
+
+ if (MapTransferType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(MapTransferType));
+ MapTransferType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, MapTransferType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, MapTransferType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for MapTransferType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, MapTransferType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out MapTransferType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != MapTransferType_TypeID)
+ {
+ throw new Exception("invalid userdata for MapTransferType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for MapTransferType");
+ }
+ val = (MapTransferType)e;
+
+ }
+ else
+ {
+ val = (MapTransferType)objectCasters.GetCaster(typeof(MapTransferType))(L, index, null);
+ }
+ }
+
+ public void UpdateMapTransferType(RealStatePtr L, int index, MapTransferType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != MapTransferType_TypeID)
+ {
+ throw new Exception("invalid userdata for MapTransferType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for MapTransferType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int DropItemType_TypeID = -1;
+ int DropItemType_EnumRef = -1;
+
+ public void PushDropItemType(RealStatePtr L, DropItemType val)
+ {
+ if (DropItemType_TypeID == -1)
+ {
+ bool is_first;
+ DropItemType_TypeID = getTypeId(L, typeof(DropItemType), out is_first);
+
+ if (DropItemType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(DropItemType));
+ DropItemType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, DropItemType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, DropItemType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for DropItemType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, DropItemType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out DropItemType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != DropItemType_TypeID)
+ {
+ throw new Exception("invalid userdata for DropItemType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for DropItemType");
+ }
+ val = (DropItemType)e;
+
+ }
+ else
+ {
+ val = (DropItemType)objectCasters.GetCaster(typeof(DropItemType))(L, index, null);
+ }
+ }
+
+ public void UpdateDropItemType(RealStatePtr L, int index, DropItemType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != DropItemType_TypeID)
+ {
+ throw new Exception("invalid userdata for DropItemType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for DropItemType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int DailyQuestType_TypeID = -1;
+ int DailyQuestType_EnumRef = -1;
+
+ public void PushDailyQuestType(RealStatePtr L, DailyQuestType val)
+ {
+ if (DailyQuestType_TypeID == -1)
+ {
+ bool is_first;
+ DailyQuestType_TypeID = getTypeId(L, typeof(DailyQuestType), out is_first);
+
+ if (DailyQuestType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(DailyQuestType));
+ DailyQuestType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, DailyQuestType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, DailyQuestType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for DailyQuestType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, DailyQuestType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out DailyQuestType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != DailyQuestType_TypeID)
+ {
+ throw new Exception("invalid userdata for DailyQuestType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for DailyQuestType");
+ }
+ val = (DailyQuestType)e;
+
+ }
+ else
+ {
+ val = (DailyQuestType)objectCasters.GetCaster(typeof(DailyQuestType))(L, index, null);
+ }
+ }
+
+ public void UpdateDailyQuestType(RealStatePtr L, int index, DailyQuestType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != DailyQuestType_TypeID)
+ {
+ throw new Exception("invalid userdata for DailyQuestType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for DailyQuestType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int DungeonCoolDownType_TypeID = -1;
+ int DungeonCoolDownType_EnumRef = -1;
+
+ public void PushDungeonCoolDownType(RealStatePtr L, DungeonCoolDownType val)
+ {
+ if (DungeonCoolDownType_TypeID == -1)
+ {
+ bool is_first;
+ DungeonCoolDownType_TypeID = getTypeId(L, typeof(DungeonCoolDownType), out is_first);
+
+ if (DungeonCoolDownType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(DungeonCoolDownType));
+ DungeonCoolDownType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, DungeonCoolDownType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, DungeonCoolDownType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for DungeonCoolDownType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, DungeonCoolDownType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out DungeonCoolDownType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != DungeonCoolDownType_TypeID)
+ {
+ throw new Exception("invalid userdata for DungeonCoolDownType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for DungeonCoolDownType");
+ }
+ val = (DungeonCoolDownType)e;
+
+ }
+ else
+ {
+ val = (DungeonCoolDownType)objectCasters.GetCaster(typeof(DungeonCoolDownType))(L, index, null);
+ }
+ }
+
+ public void UpdateDungeonCoolDownType(RealStatePtr L, int index, DungeonCoolDownType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != DungeonCoolDownType_TypeID)
+ {
+ throw new Exception("invalid userdata for DungeonCoolDownType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for DungeonCoolDownType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int RoleEquipType_TypeID = -1;
+ int RoleEquipType_EnumRef = -1;
+
+ public void PushRoleEquipType(RealStatePtr L, RoleEquipType val)
+ {
+ if (RoleEquipType_TypeID == -1)
+ {
+ bool is_first;
+ RoleEquipType_TypeID = getTypeId(L, typeof(RoleEquipType), out is_first);
+
+ if (RoleEquipType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(RoleEquipType));
+ RoleEquipType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, RoleEquipType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, RoleEquipType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for RoleEquipType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, RoleEquipType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out RoleEquipType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != RoleEquipType_TypeID)
+ {
+ throw new Exception("invalid userdata for RoleEquipType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for RoleEquipType");
+ }
+ val = (RoleEquipType)e;
+
+ }
+ else
+ {
+ val = (RoleEquipType)objectCasters.GetCaster(typeof(RoleEquipType))(L, index, null);
+ }
+ }
+
+ public void UpdateRoleEquipType(RealStatePtr L, int index, RoleEquipType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != RoleEquipType_TypeID)
+ {
+ throw new Exception("invalid userdata for RoleEquipType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for RoleEquipType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int PlayerDataType_TypeID = -1;
+ int PlayerDataType_EnumRef = -1;
+
+ public void PushPlayerDataType(RealStatePtr L, PlayerDataType val)
+ {
+ if (PlayerDataType_TypeID == -1)
+ {
+ bool is_first;
+ PlayerDataType_TypeID = getTypeId(L, typeof(PlayerDataType), out is_first);
+
+ if (PlayerDataType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(PlayerDataType));
+ PlayerDataType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, PlayerDataType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, PlayerDataType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for PlayerDataType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, PlayerDataType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out PlayerDataType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != PlayerDataType_TypeID)
+ {
+ throw new Exception("invalid userdata for PlayerDataType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for PlayerDataType");
+ }
+ val = (PlayerDataType)e;
+
+ }
+ else
+ {
+ val = (PlayerDataType)objectCasters.GetCaster(typeof(PlayerDataType))(L, index, null);
+ }
+ }
+
+ public void UpdatePlayerDataType(RealStatePtr L, int index, PlayerDataType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != PlayerDataType_TypeID)
+ {
+ throw new Exception("invalid userdata for PlayerDataType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for PlayerDataType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int PackType_TypeID = -1;
+ int PackType_EnumRef = -1;
+
+ public void PushPackType(RealStatePtr L, PackType val)
+ {
+ if (PackType_TypeID == -1)
+ {
+ bool is_first;
+ PackType_TypeID = getTypeId(L, typeof(PackType), out is_first);
+
+ if (PackType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(PackType));
+ PackType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, PackType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, PackType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for PackType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, PackType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out PackType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != PackType_TypeID)
+ {
+ throw new Exception("invalid userdata for PackType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for PackType");
+ }
+ val = (PackType)e;
+
+ }
+ else
+ {
+ val = (PackType)objectCasters.GetCaster(typeof(PackType))(L, index, null);
+ }
+ }
+
+ public void UpdatePackType(RealStatePtr L, int index, PackType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != PackType_TypeID)
+ {
+ throw new Exception("invalid userdata for PackType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for PackType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int ItemType_TypeID = -1;
+ int ItemType_EnumRef = -1;
+
+ public void PushItemType(RealStatePtr L, ItemType val)
+ {
+ if (ItemType_TypeID == -1)
+ {
+ bool is_first;
+ ItemType_TypeID = getTypeId(L, typeof(ItemType), out is_first);
+
+ if (ItemType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(ItemType));
+ ItemType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, ItemType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, ItemType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for ItemType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, ItemType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out ItemType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != ItemType_TypeID)
+ {
+ throw new Exception("invalid userdata for ItemType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for ItemType");
+ }
+ val = (ItemType)e;
+
+ }
+ else
+ {
+ val = (ItemType)objectCasters.GetCaster(typeof(ItemType))(L, index, null);
+ }
+ }
+
+ public void UpdateItemType(RealStatePtr L, int index, ItemType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != ItemType_TypeID)
+ {
+ throw new Exception("invalid userdata for ItemType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for ItemType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int MakeType_TypeID = -1;
+ int MakeType_EnumRef = -1;
+
+ public void PushMakeType(RealStatePtr L, MakeType val)
+ {
+ if (MakeType_TypeID == -1)
+ {
+ bool is_first;
+ MakeType_TypeID = getTypeId(L, typeof(MakeType), out is_first);
+
+ if (MakeType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(MakeType));
+ MakeType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, MakeType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, MakeType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for MakeType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, MakeType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out MakeType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != MakeType_TypeID)
+ {
+ throw new Exception("invalid userdata for MakeType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for MakeType");
+ }
+ val = (MakeType)e;
+
+ }
+ else
+ {
+ val = (MakeType)objectCasters.GetCaster(typeof(MakeType))(L, index, null);
+ }
+ }
+
+ public void UpdateMakeType(RealStatePtr L, int index, MakeType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != MakeType_TypeID)
+ {
+ throw new Exception("invalid userdata for MakeType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for MakeType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int TitleType_TypeID = -1;
+ int TitleType_EnumRef = -1;
+
+ public void PushTitleType(RealStatePtr L, TitleType val)
+ {
+ if (TitleType_TypeID == -1)
+ {
+ bool is_first;
+ TitleType_TypeID = getTypeId(L, typeof(TitleType), out is_first);
+
+ if (TitleType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(TitleType));
+ TitleType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, TitleType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, TitleType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for TitleType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, TitleType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out TitleType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != TitleType_TypeID)
+ {
+ throw new Exception("invalid userdata for TitleType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for TitleType");
+ }
+ val = (TitleType)e;
+
+ }
+ else
+ {
+ val = (TitleType)objectCasters.GetCaster(typeof(TitleType))(L, index, null);
+ }
+ }
+
+ public void UpdateTitleType(RealStatePtr L, int index, TitleType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != TitleType_TypeID)
+ {
+ throw new Exception("invalid userdata for TitleType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for TitleType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int FuncOpenEnum_TypeID = -1;
+ int FuncOpenEnum_EnumRef = -1;
+
+ public void PushFuncOpenEnum(RealStatePtr L, FuncOpenEnum val)
+ {
+ if (FuncOpenEnum_TypeID == -1)
+ {
+ bool is_first;
+ FuncOpenEnum_TypeID = getTypeId(L, typeof(FuncOpenEnum), out is_first);
+
+ if (FuncOpenEnum_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(FuncOpenEnum));
+ FuncOpenEnum_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, FuncOpenEnum_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, FuncOpenEnum_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for FuncOpenEnum ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, FuncOpenEnum_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out FuncOpenEnum val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != FuncOpenEnum_TypeID)
+ {
+ throw new Exception("invalid userdata for FuncOpenEnum");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for FuncOpenEnum");
+ }
+ val = (FuncOpenEnum)e;
+
+ }
+ else
+ {
+ val = (FuncOpenEnum)objectCasters.GetCaster(typeof(FuncOpenEnum))(L, index, null);
+ }
+ }
+
+ public void UpdateFuncOpenEnum(RealStatePtr L, int index, FuncOpenEnum val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != FuncOpenEnum_TypeID)
+ {
+ throw new Exception("invalid userdata for FuncOpenEnum");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for FuncOpenEnum ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int PropertyType_TypeID = -1;
+ int PropertyType_EnumRef = -1;
+
+ public void PushPropertyType(RealStatePtr L, PropertyType val)
+ {
+ if (PropertyType_TypeID == -1)
+ {
+ bool is_first;
+ PropertyType_TypeID = getTypeId(L, typeof(PropertyType), out is_first);
+
+ if (PropertyType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(PropertyType));
+ PropertyType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, PropertyType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, PropertyType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for PropertyType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, PropertyType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out PropertyType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != PropertyType_TypeID)
+ {
+ throw new Exception("invalid userdata for PropertyType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for PropertyType");
+ }
+ val = (PropertyType)e;
+
+ }
+ else
+ {
+ val = (PropertyType)objectCasters.GetCaster(typeof(PropertyType))(L, index, null);
+ }
+ }
+
+ public void UpdatePropertyType(RealStatePtr L, int index, PropertyType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != PropertyType_TypeID)
+ {
+ throw new Exception("invalid userdata for PropertyType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for PropertyType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int TextColType_TypeID = -1;
+ int TextColType_EnumRef = -1;
+
+ public void PushTextColType(RealStatePtr L, TextColType val)
+ {
+ if (TextColType_TypeID == -1)
+ {
+ bool is_first;
+ TextColType_TypeID = getTypeId(L, typeof(TextColType), out is_first);
+
+ if (TextColType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(TextColType));
+ TextColType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, TextColType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, TextColType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for TextColType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, TextColType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out TextColType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != TextColType_TypeID)
+ {
+ throw new Exception("invalid userdata for TextColType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for TextColType");
+ }
+ val = (TextColType)e;
+
+ }
+ else
+ {
+ val = (TextColType)objectCasters.GetCaster(typeof(TextColType))(L, index, null);
+ }
+ }
+
+ public void UpdateTextColType(RealStatePtr L, int index, TextColType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != TextColType_TypeID)
+ {
+ throw new Exception("invalid userdata for TextColType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for TextColType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int E_ModelResType_TypeID = -1;
+ int E_ModelResType_EnumRef = -1;
+
+ public void PushE_ModelResType(RealStatePtr L, E_ModelResType val)
+ {
+ if (E_ModelResType_TypeID == -1)
+ {
+ bool is_first;
+ E_ModelResType_TypeID = getTypeId(L, typeof(E_ModelResType), out is_first);
+
+ if (E_ModelResType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(E_ModelResType));
+ E_ModelResType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, E_ModelResType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, E_ModelResType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for E_ModelResType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, E_ModelResType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out E_ModelResType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_ModelResType_TypeID)
+ {
+ throw new Exception("invalid userdata for E_ModelResType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for E_ModelResType");
+ }
+ val = (E_ModelResType)e;
+
+ }
+ else
+ {
+ val = (E_ModelResType)objectCasters.GetCaster(typeof(E_ModelResType))(L, index, null);
+ }
+ }
+
+ public void UpdateE_ModelResType(RealStatePtr L, int index, E_ModelResType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_ModelResType_TypeID)
+ {
+ throw new Exception("invalid userdata for E_ModelResType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for E_ModelResType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int TreasureCategory_TypeID = -1;
+ int TreasureCategory_EnumRef = -1;
+
+ public void PushTreasureCategory(RealStatePtr L, TreasureCategory val)
+ {
+ if (TreasureCategory_TypeID == -1)
+ {
+ bool is_first;
+ TreasureCategory_TypeID = getTypeId(L, typeof(TreasureCategory), out is_first);
+
+ if (TreasureCategory_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(TreasureCategory));
+ TreasureCategory_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, TreasureCategory_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, TreasureCategory_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for TreasureCategory ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, TreasureCategory_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out TreasureCategory val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != TreasureCategory_TypeID)
+ {
+ throw new Exception("invalid userdata for TreasureCategory");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for TreasureCategory");
+ }
+ val = (TreasureCategory)e;
+
+ }
+ else
+ {
+ val = (TreasureCategory)objectCasters.GetCaster(typeof(TreasureCategory))(L, index, null);
+ }
+ }
+
+ public void UpdateTreasureCategory(RealStatePtr L, int index, TreasureCategory val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != TreasureCategory_TypeID)
+ {
+ throw new Exception("invalid userdata for TreasureCategory");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for TreasureCategory ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int TreasureState_TypeID = -1;
+ int TreasureState_EnumRef = -1;
+
+ public void PushTreasureState(RealStatePtr L, TreasureState val)
+ {
+ if (TreasureState_TypeID == -1)
+ {
+ bool is_first;
+ TreasureState_TypeID = getTypeId(L, typeof(TreasureState), out is_first);
+
+ if (TreasureState_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(TreasureState));
+ TreasureState_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, TreasureState_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, TreasureState_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for TreasureState ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, TreasureState_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out TreasureState val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != TreasureState_TypeID)
+ {
+ throw new Exception("invalid userdata for TreasureState");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for TreasureState");
+ }
+ val = (TreasureState)e;
+
+ }
+ else
+ {
+ val = (TreasureState)objectCasters.GetCaster(typeof(TreasureState))(L, index, null);
+ }
+ }
+
+ public void UpdateTreasureState(RealStatePtr L, int index, TreasureState val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != TreasureState_TypeID)
+ {
+ throw new Exception("invalid userdata for TreasureState");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for TreasureState ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int FunctionUnlockType_TypeID = -1;
+ int FunctionUnlockType_EnumRef = -1;
+
+ public void PushFunctionUnlockType(RealStatePtr L, FunctionUnlockType val)
+ {
+ if (FunctionUnlockType_TypeID == -1)
+ {
+ bool is_first;
+ FunctionUnlockType_TypeID = getTypeId(L, typeof(FunctionUnlockType), out is_first);
+
+ if (FunctionUnlockType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(FunctionUnlockType));
+ FunctionUnlockType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, FunctionUnlockType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, FunctionUnlockType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for FunctionUnlockType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, FunctionUnlockType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out FunctionUnlockType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != FunctionUnlockType_TypeID)
+ {
+ throw new Exception("invalid userdata for FunctionUnlockType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for FunctionUnlockType");
+ }
+ val = (FunctionUnlockType)e;
+
+ }
+ else
+ {
+ val = (FunctionUnlockType)objectCasters.GetCaster(typeof(FunctionUnlockType))(L, index, null);
+ }
+ }
+
+ public void UpdateFunctionUnlockType(RealStatePtr L, int index, FunctionUnlockType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != FunctionUnlockType_TypeID)
+ {
+ throw new Exception("invalid userdata for FunctionUnlockType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for FunctionUnlockType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int RedPointState_TypeID = -1;
+ int RedPointState_EnumRef = -1;
+
+ public void PushRedPointState(RealStatePtr L, RedPointState val)
+ {
+ if (RedPointState_TypeID == -1)
+ {
+ bool is_first;
+ RedPointState_TypeID = getTypeId(L, typeof(RedPointState), out is_first);
+
+ if (RedPointState_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(RedPointState));
+ RedPointState_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, RedPointState_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, RedPointState_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for RedPointState ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, RedPointState_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out RedPointState val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != RedPointState_TypeID)
+ {
+ throw new Exception("invalid userdata for RedPointState");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for RedPointState");
+ }
+ val = (RedPointState)e;
+
+ }
+ else
+ {
+ val = (RedPointState)objectCasters.GetCaster(typeof(RedPointState))(L, index, null);
+ }
+ }
+
+ public void UpdateRedPointState(RealStatePtr L, int index, RedPointState val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != RedPointState_TypeID)
+ {
+ throw new Exception("invalid userdata for RedPointState");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for RedPointState ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int TeamInviteType_TypeID = -1;
+ int TeamInviteType_EnumRef = -1;
+
+ public void PushTeamInviteType(RealStatePtr L, TeamInviteType val)
+ {
+ if (TeamInviteType_TypeID == -1)
+ {
+ bool is_first;
+ TeamInviteType_TypeID = getTypeId(L, typeof(TeamInviteType), out is_first);
+
+ if (TeamInviteType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(TeamInviteType));
+ TeamInviteType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, TeamInviteType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, TeamInviteType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for TeamInviteType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, TeamInviteType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out TeamInviteType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != TeamInviteType_TypeID)
+ {
+ throw new Exception("invalid userdata for TeamInviteType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for TeamInviteType");
+ }
+ val = (TeamInviteType)e;
+
+ }
+ else
+ {
+ val = (TeamInviteType)objectCasters.GetCaster(typeof(TeamInviteType))(L, index, null);
+ }
+ }
+
+ public void UpdateTeamInviteType(RealStatePtr L, int index, TeamInviteType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != TeamInviteType_TypeID)
+ {
+ throw new Exception("invalid userdata for TeamInviteType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for TeamInviteType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int TeammatePrepareState_TypeID = -1;
+ int TeammatePrepareState_EnumRef = -1;
+
+ public void PushTeammatePrepareState(RealStatePtr L, TeammatePrepareState val)
+ {
+ if (TeammatePrepareState_TypeID == -1)
+ {
+ bool is_first;
+ TeammatePrepareState_TypeID = getTypeId(L, typeof(TeammatePrepareState), out is_first);
+
+ if (TeammatePrepareState_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(TeammatePrepareState));
+ TeammatePrepareState_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, TeammatePrepareState_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, TeammatePrepareState_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for TeammatePrepareState ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, TeammatePrepareState_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out TeammatePrepareState val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != TeammatePrepareState_TypeID)
+ {
+ throw new Exception("invalid userdata for TeammatePrepareState");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for TeammatePrepareState");
+ }
+ val = (TeammatePrepareState)e;
+
+ }
+ else
+ {
+ val = (TeammatePrepareState)objectCasters.GetCaster(typeof(TeammatePrepareState))(L, index, null);
+ }
+ }
+
+ public void UpdateTeammatePrepareState(RealStatePtr L, int index, TeammatePrepareState val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != TeammatePrepareState_TypeID)
+ {
+ throw new Exception("invalid userdata for TeammatePrepareState");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for TeammatePrepareState ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int VipPrivilegeType_TypeID = -1;
+ int VipPrivilegeType_EnumRef = -1;
+
+ public void PushVipPrivilegeType(RealStatePtr L, VipPrivilegeType val)
+ {
+ if (VipPrivilegeType_TypeID == -1)
+ {
+ bool is_first;
+ VipPrivilegeType_TypeID = getTypeId(L, typeof(VipPrivilegeType), out is_first);
+
+ if (VipPrivilegeType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(VipPrivilegeType));
+ VipPrivilegeType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, VipPrivilegeType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, VipPrivilegeType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for VipPrivilegeType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, VipPrivilegeType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out VipPrivilegeType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != VipPrivilegeType_TypeID)
+ {
+ throw new Exception("invalid userdata for VipPrivilegeType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for VipPrivilegeType");
+ }
+ val = (VipPrivilegeType)e;
+
+ }
+ else
+ {
+ val = (VipPrivilegeType)objectCasters.GetCaster(typeof(VipPrivilegeType))(L, index, null);
+ }
+ }
+
+ public void UpdateVipPrivilegeType(RealStatePtr L, int index, VipPrivilegeType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != VipPrivilegeType_TypeID)
+ {
+ throw new Exception("invalid userdata for VipPrivilegeType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for VipPrivilegeType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int E_AttackMode_TypeID = -1;
+ int E_AttackMode_EnumRef = -1;
+
+ public void PushE_AttackMode(RealStatePtr L, E_AttackMode val)
+ {
+ if (E_AttackMode_TypeID == -1)
+ {
+ bool is_first;
+ E_AttackMode_TypeID = getTypeId(L, typeof(E_AttackMode), out is_first);
+
+ if (E_AttackMode_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(E_AttackMode));
+ E_AttackMode_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, E_AttackMode_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, E_AttackMode_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for E_AttackMode ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, E_AttackMode_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out E_AttackMode val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_AttackMode_TypeID)
+ {
+ throw new Exception("invalid userdata for E_AttackMode");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for E_AttackMode");
+ }
+ val = (E_AttackMode)e;
+
+ }
+ else
+ {
+ val = (E_AttackMode)objectCasters.GetCaster(typeof(E_AttackMode))(L, index, null);
+ }
+ }
+
+ public void UpdateE_AttackMode(RealStatePtr L, int index, E_AttackMode val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_AttackMode_TypeID)
+ {
+ throw new Exception("invalid userdata for E_AttackMode");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for E_AttackMode ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int E_ItemColor_TypeID = -1;
+ int E_ItemColor_EnumRef = -1;
+
+ public void PushE_ItemColor(RealStatePtr L, E_ItemColor val)
+ {
+ if (E_ItemColor_TypeID == -1)
+ {
+ bool is_first;
+ E_ItemColor_TypeID = getTypeId(L, typeof(E_ItemColor), out is_first);
+
+ if (E_ItemColor_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(E_ItemColor));
+ E_ItemColor_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, E_ItemColor_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, E_ItemColor_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for E_ItemColor ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, E_ItemColor_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out E_ItemColor val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_ItemColor_TypeID)
+ {
+ throw new Exception("invalid userdata for E_ItemColor");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for E_ItemColor");
+ }
+ val = (E_ItemColor)e;
+
+ }
+ else
+ {
+ val = (E_ItemColor)objectCasters.GetCaster(typeof(E_ItemColor))(L, index, null);
+ }
+ }
+
+ public void UpdateE_ItemColor(RealStatePtr L, int index, E_ItemColor val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_ItemColor_TypeID)
+ {
+ throw new Exception("invalid userdata for E_ItemColor");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for E_ItemColor ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int FindPreciousType_TypeID = -1;
+ int FindPreciousType_EnumRef = -1;
+
+ public void PushFindPreciousType(RealStatePtr L, FindPreciousType val)
+ {
+ if (FindPreciousType_TypeID == -1)
+ {
+ bool is_first;
+ FindPreciousType_TypeID = getTypeId(L, typeof(FindPreciousType), out is_first);
+
+ if (FindPreciousType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(FindPreciousType));
+ FindPreciousType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, FindPreciousType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, FindPreciousType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for FindPreciousType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, FindPreciousType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out FindPreciousType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != FindPreciousType_TypeID)
+ {
+ throw new Exception("invalid userdata for FindPreciousType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for FindPreciousType");
+ }
+ val = (FindPreciousType)e;
+
+ }
+ else
+ {
+ val = (FindPreciousType)objectCasters.GetCaster(typeof(FindPreciousType))(L, index, null);
+ }
+ }
+
+ public void UpdateFindPreciousType(RealStatePtr L, int index, FindPreciousType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != FindPreciousType_TypeID)
+ {
+ throw new Exception("invalid userdata for FindPreciousType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for FindPreciousType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int GotServerRewardType_TypeID = -1;
+ int GotServerRewardType_EnumRef = -1;
+
+ public void PushGotServerRewardType(RealStatePtr L, GotServerRewardType val)
+ {
+ if (GotServerRewardType_TypeID == -1)
+ {
+ bool is_first;
+ GotServerRewardType_TypeID = getTypeId(L, typeof(GotServerRewardType), out is_first);
+
+ if (GotServerRewardType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(GotServerRewardType));
+ GotServerRewardType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, GotServerRewardType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, GotServerRewardType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for GotServerRewardType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, GotServerRewardType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out GotServerRewardType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != GotServerRewardType_TypeID)
+ {
+ throw new Exception("invalid userdata for GotServerRewardType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for GotServerRewardType");
+ }
+ val = (GotServerRewardType)e;
+
+ }
+ else
+ {
+ val = (GotServerRewardType)objectCasters.GetCaster(typeof(GotServerRewardType))(L, index, null);
+ }
+ }
+
+ public void UpdateGotServerRewardType(RealStatePtr L, int index, GotServerRewardType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != GotServerRewardType_TypeID)
+ {
+ throw new Exception("invalid userdata for GotServerRewardType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for GotServerRewardType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int MapType_TypeID = -1;
+ int MapType_EnumRef = -1;
+
+ public void PushMapType(RealStatePtr L, MapType val)
+ {
+ if (MapType_TypeID == -1)
+ {
+ bool is_first;
+ MapType_TypeID = getTypeId(L, typeof(MapType), out is_first);
+
+ if (MapType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(MapType));
+ MapType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, MapType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, MapType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for MapType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, MapType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out MapType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != MapType_TypeID)
+ {
+ throw new Exception("invalid userdata for MapType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for MapType");
+ }
+ val = (MapType)e;
+
+ }
+ else
+ {
+ val = (MapType)objectCasters.GetCaster(typeof(MapType))(L, index, null);
+ }
+ }
+
+ public void UpdateMapType(RealStatePtr L, int index, MapType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != MapType_TypeID)
+ {
+ throw new Exception("invalid userdata for MapType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for MapType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int GuideType_TypeID = -1;
+ int GuideType_EnumRef = -1;
+
+ public void PushGuideType(RealStatePtr L, GuideType val)
+ {
+ if (GuideType_TypeID == -1)
+ {
+ bool is_first;
+ GuideType_TypeID = getTypeId(L, typeof(GuideType), out is_first);
+
+ if (GuideType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(GuideType));
+ GuideType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, GuideType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, GuideType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for GuideType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, GuideType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out GuideType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != GuideType_TypeID)
+ {
+ throw new Exception("invalid userdata for GuideType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for GuideType");
+ }
+ val = (GuideType)e;
+
+ }
+ else
+ {
+ val = (GuideType)objectCasters.GetCaster(typeof(GuideType))(L, index, null);
+ }
+ }
+
+ public void UpdateGuideType(RealStatePtr L, int index, GuideType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != GuideType_TypeID)
+ {
+ throw new Exception("invalid userdata for GuideType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for GuideType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int GuideTriggerType_TypeID = -1;
+ int GuideTriggerType_EnumRef = -1;
+
+ public void PushGuideTriggerType(RealStatePtr L, GuideTriggerType val)
+ {
+ if (GuideTriggerType_TypeID == -1)
+ {
+ bool is_first;
+ GuideTriggerType_TypeID = getTypeId(L, typeof(GuideTriggerType), out is_first);
+
+ if (GuideTriggerType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(GuideTriggerType));
+ GuideTriggerType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, GuideTriggerType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, GuideTriggerType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for GuideTriggerType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, GuideTriggerType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out GuideTriggerType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != GuideTriggerType_TypeID)
+ {
+ throw new Exception("invalid userdata for GuideTriggerType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for GuideTriggerType");
+ }
+ val = (GuideTriggerType)e;
+
+ }
+ else
+ {
+ val = (GuideTriggerType)objectCasters.GetCaster(typeof(GuideTriggerType))(L, index, null);
+ }
+ }
+
+ public void UpdateGuideTriggerType(RealStatePtr L, int index, GuideTriggerType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != GuideTriggerType_TypeID)
+ {
+ throw new Exception("invalid userdata for GuideTriggerType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for GuideTriggerType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int FuncPowerType_TypeID = -1;
+ int FuncPowerType_EnumRef = -1;
+
+ public void PushFuncPowerType(RealStatePtr L, FuncPowerType val)
+ {
+ if (FuncPowerType_TypeID == -1)
+ {
+ bool is_first;
+ FuncPowerType_TypeID = getTypeId(L, typeof(FuncPowerType), out is_first);
+
+ if (FuncPowerType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(FuncPowerType));
+ FuncPowerType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, FuncPowerType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, FuncPowerType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for FuncPowerType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, FuncPowerType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out FuncPowerType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != FuncPowerType_TypeID)
+ {
+ throw new Exception("invalid userdata for FuncPowerType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for FuncPowerType");
+ }
+ val = (FuncPowerType)e;
+
+ }
+ else
+ {
+ val = (FuncPowerType)objectCasters.GetCaster(typeof(FuncPowerType))(L, index, null);
+ }
+ }
+
+ public void UpdateFuncPowerType(RealStatePtr L, int index, FuncPowerType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != FuncPowerType_TypeID)
+ {
+ throw new Exception("invalid userdata for FuncPowerType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for FuncPowerType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int E_AtkType_TypeID = -1;
+ int E_AtkType_EnumRef = -1;
+
+ public void PushE_AtkType(RealStatePtr L, E_AtkType val)
+ {
+ if (E_AtkType_TypeID == -1)
+ {
+ bool is_first;
+ E_AtkType_TypeID = getTypeId(L, typeof(E_AtkType), out is_first);
+
+ if (E_AtkType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(E_AtkType));
+ E_AtkType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, E_AtkType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, E_AtkType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for E_AtkType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, E_AtkType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out E_AtkType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_AtkType_TypeID)
+ {
+ throw new Exception("invalid userdata for E_AtkType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for E_AtkType");
+ }
+ val = (E_AtkType)e;
+
+ }
+ else
+ {
+ val = (E_AtkType)objectCasters.GetCaster(typeof(E_AtkType))(L, index, null);
+ }
+ }
+
+ public void UpdateE_AtkType(RealStatePtr L, int index, E_AtkType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != E_AtkType_TypeID)
+ {
+ throw new Exception("invalid userdata for E_AtkType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for E_AtkType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int GameObjType_TypeID = -1;
+ int GameObjType_EnumRef = -1;
+
+ public void PushGameObjType(RealStatePtr L, GameObjType val)
+ {
+ if (GameObjType_TypeID == -1)
+ {
+ bool is_first;
+ GameObjType_TypeID = getTypeId(L, typeof(GameObjType), out is_first);
+
+ if (GameObjType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(GameObjType));
+ GameObjType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, GameObjType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, GameObjType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for GameObjType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, GameObjType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out GameObjType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != GameObjType_TypeID)
+ {
+ throw new Exception("invalid userdata for GameObjType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for GameObjType");
+ }
+ val = (GameObjType)e;
+
+ }
+ else
+ {
+ val = (GameObjType)objectCasters.GetCaster(typeof(GameObjType))(L, index, null);
+ }
+ }
+
+ public void UpdateGameObjType(RealStatePtr L, int index, GameObjType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != GameObjType_TypeID)
+ {
+ throw new Exception("invalid userdata for GameObjType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for GameObjType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int HurtAttackType_TypeID = -1;
+ int HurtAttackType_EnumRef = -1;
+
+ public void PushHurtAttackType(RealStatePtr L, HurtAttackType val)
+ {
+ if (HurtAttackType_TypeID == -1)
+ {
+ bool is_first;
+ HurtAttackType_TypeID = getTypeId(L, typeof(HurtAttackType), out is_first);
+
+ if (HurtAttackType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(HurtAttackType));
+ HurtAttackType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, HurtAttackType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, HurtAttackType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for HurtAttackType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, HurtAttackType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out HurtAttackType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != HurtAttackType_TypeID)
+ {
+ throw new Exception("invalid userdata for HurtAttackType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for HurtAttackType");
+ }
+ val = (HurtAttackType)e;
+
+ }
+ else
+ {
+ val = (HurtAttackType)objectCasters.GetCaster(typeof(HurtAttackType))(L, index, null);
+ }
+ }
+
+ public void UpdateHurtAttackType(RealStatePtr L, int index, HurtAttackType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != HurtAttackType_TypeID)
+ {
+ throw new Exception("invalid userdata for HurtAttackType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for HurtAttackType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int DungeonTargetType_TypeID = -1;
+ int DungeonTargetType_EnumRef = -1;
+
+ public void PushDungeonTargetType(RealStatePtr L, DungeonTargetType val)
+ {
+ if (DungeonTargetType_TypeID == -1)
+ {
+ bool is_first;
+ DungeonTargetType_TypeID = getTypeId(L, typeof(DungeonTargetType), out is_first);
+
+ if (DungeonTargetType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(DungeonTargetType));
+ DungeonTargetType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, DungeonTargetType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, DungeonTargetType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for DungeonTargetType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, DungeonTargetType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out DungeonTargetType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != DungeonTargetType_TypeID)
+ {
+ throw new Exception("invalid userdata for DungeonTargetType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for DungeonTargetType");
+ }
+ val = (DungeonTargetType)e;
+
+ }
+ else
+ {
+ val = (DungeonTargetType)objectCasters.GetCaster(typeof(DungeonTargetType))(L, index, null);
+ }
+ }
+
+ public void UpdateDungeonTargetType(RealStatePtr L, int index, DungeonTargetType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != DungeonTargetType_TypeID)
+ {
+ throw new Exception("invalid userdata for DungeonTargetType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for DungeonTargetType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int AchievementType_TypeID = -1;
+ int AchievementType_EnumRef = -1;
+
+ public void PushAchievementType(RealStatePtr L, AchievementType val)
+ {
+ if (AchievementType_TypeID == -1)
+ {
+ bool is_first;
+ AchievementType_TypeID = getTypeId(L, typeof(AchievementType), out is_first);
+
+ if (AchievementType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(AchievementType));
+ AchievementType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, AchievementType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, AchievementType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for AchievementType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, AchievementType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out AchievementType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != AchievementType_TypeID)
+ {
+ throw new Exception("invalid userdata for AchievementType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for AchievementType");
+ }
+ val = (AchievementType)e;
+
+ }
+ else
+ {
+ val = (AchievementType)objectCasters.GetCaster(typeof(AchievementType))(L, index, null);
+ }
+ }
+
+ public void UpdateAchievementType(RealStatePtr L, int index, AchievementType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != AchievementType_TypeID)
+ {
+ throw new Exception("invalid userdata for AchievementType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for AchievementType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int ItemTimeType_TypeID = -1;
+ int ItemTimeType_EnumRef = -1;
+
+ public void PushItemTimeType(RealStatePtr L, ItemTimeType val)
+ {
+ if (ItemTimeType_TypeID == -1)
+ {
+ bool is_first;
+ ItemTimeType_TypeID = getTypeId(L, typeof(ItemTimeType), out is_first);
+
+ if (ItemTimeType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(ItemTimeType));
+ ItemTimeType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, ItemTimeType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, ItemTimeType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for ItemTimeType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, ItemTimeType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out ItemTimeType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != ItemTimeType_TypeID)
+ {
+ throw new Exception("invalid userdata for ItemTimeType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for ItemTimeType");
+ }
+ val = (ItemTimeType)e;
+
+ }
+ else
+ {
+ val = (ItemTimeType)objectCasters.GetCaster(typeof(ItemTimeType))(L, index, null);
+ }
+ }
+
+ public void UpdateItemTimeType(RealStatePtr L, int index, ItemTimeType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != ItemTimeType_TypeID)
+ {
+ throw new Exception("invalid userdata for ItemTimeType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for ItemTimeType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int TitleBtnState_TypeID = -1;
+ int TitleBtnState_EnumRef = -1;
+
+ public void PushTitleBtnState(RealStatePtr L, TitleBtnState val)
+ {
+ if (TitleBtnState_TypeID == -1)
+ {
+ bool is_first;
+ TitleBtnState_TypeID = getTypeId(L, typeof(TitleBtnState), out is_first);
+
+ if (TitleBtnState_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(TitleBtnState));
+ TitleBtnState_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, TitleBtnState_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, TitleBtnState_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for TitleBtnState ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, TitleBtnState_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out TitleBtnState val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != TitleBtnState_TypeID)
+ {
+ throw new Exception("invalid userdata for TitleBtnState");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for TitleBtnState");
+ }
+ val = (TitleBtnState)e;
+
+ }
+ else
+ {
+ val = (TitleBtnState)objectCasters.GetCaster(typeof(TitleBtnState))(L, index, null);
+ }
+ }
+
+ public void UpdateTitleBtnState(RealStatePtr L, int index, TitleBtnState val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != TitleBtnState_TypeID)
+ {
+ throw new Exception("invalid userdata for TitleBtnState");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for TitleBtnState ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int LegendAttrType_TypeID = -1;
+ int LegendAttrType_EnumRef = -1;
+
+ public void PushLegendAttrType(RealStatePtr L, LegendAttrType val)
+ {
+ if (LegendAttrType_TypeID == -1)
+ {
+ bool is_first;
+ LegendAttrType_TypeID = getTypeId(L, typeof(LegendAttrType), out is_first);
+
+ if (LegendAttrType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(LegendAttrType));
+ LegendAttrType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, LegendAttrType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, LegendAttrType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for LegendAttrType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, LegendAttrType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out LegendAttrType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != LegendAttrType_TypeID)
+ {
+ throw new Exception("invalid userdata for LegendAttrType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for LegendAttrType");
+ }
+ val = (LegendAttrType)e;
+
+ }
+ else
+ {
+ val = (LegendAttrType)objectCasters.GetCaster(typeof(LegendAttrType))(L, index, null);
+ }
+ }
+
+ public void UpdateLegendAttrType(RealStatePtr L, int index, LegendAttrType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != LegendAttrType_TypeID)
+ {
+ throw new Exception("invalid userdata for LegendAttrType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for LegendAttrType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int ServerState_TypeID = -1;
+ int ServerState_EnumRef = -1;
+
+ public void PushServerState(RealStatePtr L, ServerState val)
+ {
+ if (ServerState_TypeID == -1)
+ {
+ bool is_first;
+ ServerState_TypeID = getTypeId(L, typeof(ServerState), out is_first);
+
+ if (ServerState_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(ServerState));
+ ServerState_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, ServerState_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, ServerState_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for ServerState ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, ServerState_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out ServerState val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != ServerState_TypeID)
+ {
+ throw new Exception("invalid userdata for ServerState");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for ServerState");
+ }
+ val = (ServerState)e;
+
+ }
+ else
+ {
+ val = (ServerState)objectCasters.GetCaster(typeof(ServerState))(L, index, null);
+ }
+ }
+
+ public void UpdateServerState(RealStatePtr L, int index, ServerState val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != ServerState_TypeID)
+ {
+ throw new Exception("invalid userdata for ServerState");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for ServerState ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int ItemUseDataKey_TypeID = -1;
+ int ItemUseDataKey_EnumRef = -1;
+
+ public void PushItemUseDataKey(RealStatePtr L, ItemUseDataKey val)
+ {
+ if (ItemUseDataKey_TypeID == -1)
+ {
+ bool is_first;
+ ItemUseDataKey_TypeID = getTypeId(L, typeof(ItemUseDataKey), out is_first);
+
+ if (ItemUseDataKey_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(ItemUseDataKey));
+ ItemUseDataKey_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, ItemUseDataKey_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, ItemUseDataKey_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for ItemUseDataKey ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, ItemUseDataKey_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out ItemUseDataKey val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != ItemUseDataKey_TypeID)
+ {
+ throw new Exception("invalid userdata for ItemUseDataKey");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for ItemUseDataKey");
+ }
+ val = (ItemUseDataKey)e;
+
+ }
+ else
+ {
+ val = (ItemUseDataKey)objectCasters.GetCaster(typeof(ItemUseDataKey))(L, index, null);
+ }
+ }
+
+ public void UpdateItemUseDataKey(RealStatePtr L, int index, ItemUseDataKey val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != ItemUseDataKey_TypeID)
+ {
+ throw new Exception("invalid userdata for ItemUseDataKey");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for ItemUseDataKey ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int ItemOperateType_TypeID = -1;
+ int ItemOperateType_EnumRef = -1;
+
+ public void PushItemOperateType(RealStatePtr L, ItemOperateType val)
+ {
+ if (ItemOperateType_TypeID == -1)
+ {
+ bool is_first;
+ ItemOperateType_TypeID = getTypeId(L, typeof(ItemOperateType), out is_first);
+
+ if (ItemOperateType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(ItemOperateType));
+ ItemOperateType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, ItemOperateType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, ItemOperateType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for ItemOperateType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, ItemOperateType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out ItemOperateType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != ItemOperateType_TypeID)
+ {
+ throw new Exception("invalid userdata for ItemOperateType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for ItemOperateType");
+ }
+ val = (ItemOperateType)e;
+
+ }
+ else
+ {
+ val = (ItemOperateType)objectCasters.GetCaster(typeof(ItemOperateType))(L, index, null);
+ }
+ }
+
+ public void UpdateItemOperateType(RealStatePtr L, int index, ItemOperateType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != ItemOperateType_TypeID)
+ {
+ throw new Exception("invalid userdata for ItemOperateType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for ItemOperateType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int ItemWinType_TypeID = -1;
+ int ItemWinType_EnumRef = -1;
+
+ public void PushItemWinType(RealStatePtr L, ItemWinType val)
+ {
+ if (ItemWinType_TypeID == -1)
+ {
+ bool is_first;
+ ItemWinType_TypeID = getTypeId(L, typeof(ItemWinType), out is_first);
+
+ if (ItemWinType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(ItemWinType));
+ ItemWinType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, ItemWinType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, ItemWinType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for ItemWinType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, ItemWinType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out ItemWinType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != ItemWinType_TypeID)
+ {
+ throw new Exception("invalid userdata for ItemWinType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for ItemWinType");
+ }
+ val = (ItemWinType)e;
+
+ }
+ else
+ {
+ val = (ItemWinType)objectCasters.GetCaster(typeof(ItemWinType))(L, index, null);
+ }
+ }
+
+ public void UpdateItemWinType(RealStatePtr L, int index, ItemWinType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != ItemWinType_TypeID)
+ {
+ throw new Exception("invalid userdata for ItemWinType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for ItemWinType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int ItemTipChildType_TypeID = -1;
+ int ItemTipChildType_EnumRef = -1;
+
+ public void PushItemTipChildType(RealStatePtr L, ItemTipChildType val)
+ {
+ if (ItemTipChildType_TypeID == -1)
+ {
+ bool is_first;
+ ItemTipChildType_TypeID = getTypeId(L, typeof(ItemTipChildType), out is_first);
+
+ if (ItemTipChildType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(ItemTipChildType));
+ ItemTipChildType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, ItemTipChildType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, ItemTipChildType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for ItemTipChildType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, ItemTipChildType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out ItemTipChildType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != ItemTipChildType_TypeID)
+ {
+ throw new Exception("invalid userdata for ItemTipChildType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for ItemTipChildType");
+ }
+ val = (ItemTipChildType)e;
+
+ }
+ else
+ {
+ val = (ItemTipChildType)objectCasters.GetCaster(typeof(ItemTipChildType))(L, index, null);
+ }
+ }
+
+ public void UpdateItemTipChildType(RealStatePtr L, int index, ItemTipChildType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != ItemTipChildType_TypeID)
+ {
+ throw new Exception("invalid userdata for ItemTipChildType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for ItemTipChildType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int InstalledAsset_TypeID = -1;
+ int InstalledAsset_EnumRef = -1;
+
+ public void PushInstalledAsset(RealStatePtr L, InstalledAsset val)
+ {
+ if (InstalledAsset_TypeID == -1)
+ {
+ bool is_first;
+ InstalledAsset_TypeID = getTypeId(L, typeof(InstalledAsset), out is_first);
+
+ if (InstalledAsset_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(InstalledAsset));
+ InstalledAsset_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, InstalledAsset_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, InstalledAsset_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for InstalledAsset ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, InstalledAsset_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out InstalledAsset val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != InstalledAsset_TypeID)
+ {
+ throw new Exception("invalid userdata for InstalledAsset");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for InstalledAsset");
+ }
+ val = (InstalledAsset)e;
+
+ }
+ else
+ {
+ val = (InstalledAsset)objectCasters.GetCaster(typeof(InstalledAsset))(L, index, null);
+ }
+ }
+
+ public void UpdateInstalledAsset(RealStatePtr L, int index, InstalledAsset val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != InstalledAsset_TypeID)
+ {
+ throw new Exception("invalid userdata for InstalledAsset");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for InstalledAsset ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int VersionAuthority_TypeID = -1;
+ int VersionAuthority_EnumRef = -1;
+
+ public void PushVersionAuthority(RealStatePtr L, VersionAuthority val)
+ {
+ if (VersionAuthority_TypeID == -1)
+ {
+ bool is_first;
+ VersionAuthority_TypeID = getTypeId(L, typeof(VersionAuthority), out is_first);
+
+ if (VersionAuthority_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(VersionAuthority));
+ VersionAuthority_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, VersionAuthority_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, VersionAuthority_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for VersionAuthority ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, VersionAuthority_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out VersionAuthority val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != VersionAuthority_TypeID)
+ {
+ throw new Exception("invalid userdata for VersionAuthority");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for VersionAuthority");
+ }
+ val = (VersionAuthority)e;
+
+ }
+ else
+ {
+ val = (VersionAuthority)objectCasters.GetCaster(typeof(VersionAuthority))(L, index, null);
+ }
+ }
+
+ public void UpdateVersionAuthority(RealStatePtr L, int index, VersionAuthority val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != VersionAuthority_TypeID)
+ {
+ throw new Exception("invalid userdata for VersionAuthority");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for VersionAuthority ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int FootAudioType_TypeID = -1;
+ int FootAudioType_EnumRef = -1;
+
+ public void PushFootAudioType(RealStatePtr L, FootAudioType val)
+ {
+ if (FootAudioType_TypeID == -1)
+ {
+ bool is_first;
+ FootAudioType_TypeID = getTypeId(L, typeof(FootAudioType), out is_first);
+
+ if (FootAudioType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(FootAudioType));
+ FootAudioType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, FootAudioType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, FootAudioType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for FootAudioType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, FootAudioType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out FootAudioType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != FootAudioType_TypeID)
+ {
+ throw new Exception("invalid userdata for FootAudioType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for FootAudioType");
+ }
+ val = (FootAudioType)e;
+
+ }
+ else
+ {
+ val = (FootAudioType)objectCasters.GetCaster(typeof(FootAudioType))(L, index, null);
+ }
+ }
+
+ public void UpdateFootAudioType(RealStatePtr L, int index, FootAudioType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != FootAudioType_TypeID)
+ {
+ throw new Exception("invalid userdata for FootAudioType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for FootAudioType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int AttackFailType_TypeID = -1;
+ int AttackFailType_EnumRef = -1;
+
+ public void PushAttackFailType(RealStatePtr L, AttackFailType val)
+ {
+ if (AttackFailType_TypeID == -1)
+ {
+ bool is_first;
+ AttackFailType_TypeID = getTypeId(L, typeof(AttackFailType), out is_first);
+
+ if (AttackFailType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(AttackFailType));
+ AttackFailType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, AttackFailType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, AttackFailType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for AttackFailType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, AttackFailType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out AttackFailType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != AttackFailType_TypeID)
+ {
+ throw new Exception("invalid userdata for AttackFailType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for AttackFailType");
+ }
+ val = (AttackFailType)e;
+
+ }
+ else
+ {
+ val = (AttackFailType)objectCasters.GetCaster(typeof(AttackFailType))(L, index, null);
+ }
+ }
+
+ public void UpdateAttackFailType(RealStatePtr L, int index, AttackFailType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != AttackFailType_TypeID)
+ {
+ throw new Exception("invalid userdata for AttackFailType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for AttackFailType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int DungeonFightStage_TypeID = -1;
+ int DungeonFightStage_EnumRef = -1;
+
+ public void PushDungeonFightStage(RealStatePtr L, DungeonFightStage val)
+ {
+ if (DungeonFightStage_TypeID == -1)
+ {
+ bool is_first;
+ DungeonFightStage_TypeID = getTypeId(L, typeof(DungeonFightStage), out is_first);
+
+ if (DungeonFightStage_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(DungeonFightStage));
+ DungeonFightStage_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, DungeonFightStage_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, DungeonFightStage_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for DungeonFightStage ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, DungeonFightStage_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out DungeonFightStage val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != DungeonFightStage_TypeID)
+ {
+ throw new Exception("invalid userdata for DungeonFightStage");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for DungeonFightStage");
+ }
+ val = (DungeonFightStage)e;
+
+ }
+ else
+ {
+ val = (DungeonFightStage)objectCasters.GetCaster(typeof(DungeonFightStage))(L, index, null);
+ }
+ }
+
+ public void UpdateDungeonFightStage(RealStatePtr L, int index, DungeonFightStage val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != DungeonFightStage_TypeID)
+ {
+ throw new Exception("invalid userdata for DungeonFightStage");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for DungeonFightStage ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int RankType_TypeID = -1;
+ int RankType_EnumRef = -1;
+
+ public void PushRankType(RealStatePtr L, RankType val)
+ {
+ if (RankType_TypeID == -1)
+ {
+ bool is_first;
+ RankType_TypeID = getTypeId(L, typeof(RankType), out is_first);
+
+ if (RankType_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(RankType));
+ RankType_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, RankType_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, RankType_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for RankType ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, RankType_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out RankType val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != RankType_TypeID)
+ {
+ throw new Exception("invalid userdata for RankType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for RankType");
+ }
+ val = (RankType)e;
+
+ }
+ else
+ {
+ val = (RankType)objectCasters.GetCaster(typeof(RankType))(L, index, null);
+ }
+ }
+
+ public void UpdateRankType(RealStatePtr L, int index, RankType val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != RankType_TypeID)
+ {
+ throw new Exception("invalid userdata for RankType");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for RankType ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
+ int PetOrMount_TypeID = -1;
+ int PetOrMount_EnumRef = -1;
+
+ public void PushPetOrMount(RealStatePtr L, PetOrMount val)
+ {
+ if (PetOrMount_TypeID == -1)
+ {
+ bool is_first;
+ PetOrMount_TypeID = getTypeId(L, typeof(PetOrMount), out is_first);
+
+ if (PetOrMount_EnumRef == -1)
+ {
+ Utils.LoadCSTable(L, typeof(PetOrMount));
+ PetOrMount_EnumRef = LuaAPI.luaL_ref(L, LuaIndexes.LUA_REGISTRYINDEX);
+ }
+
+ }
+
+ if (LuaAPI.xlua_tryget_cachedud(L, (int)val, PetOrMount_EnumRef) == 1)
+ {
+ return;
+ }
+
+ IntPtr buff = LuaAPI.xlua_pushstruct(L, 4, PetOrMount_TypeID);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail fail for PetOrMount ,value="+val);
+ }
+
+ LuaAPI.lua_getref(L, PetOrMount_EnumRef);
+ LuaAPI.lua_pushvalue(L, -2);
+ LuaAPI.xlua_rawseti(L, -2, (int)val);
+ LuaAPI.lua_pop(L, 1);
+
+ }
+
+ public void Get(RealStatePtr L, int index, out PetOrMount val)
+ {
+ LuaTypes type = LuaAPI.lua_type(L, index);
+ if (type == LuaTypes.LUA_TUSERDATA )
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != PetOrMount_TypeID)
+ {
+ throw new Exception("invalid userdata for PetOrMount");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ int e;
+ if (!CopyByValue.UnPack(buff, 0, out e))
+ {
+ throw new Exception("unpack fail for PetOrMount");
+ }
+ val = (PetOrMount)e;
+
+ }
+ else
+ {
+ val = (PetOrMount)objectCasters.GetCaster(typeof(PetOrMount))(L, index, null);
+ }
+ }
+
+ public void UpdatePetOrMount(RealStatePtr L, int index, PetOrMount val)
+ {
+
+ if (LuaAPI.lua_type(L, index) == LuaTypes.LUA_TUSERDATA)
+ {
+ if (LuaAPI.xlua_gettypeid(L, index) != PetOrMount_TypeID)
+ {
+ throw new Exception("invalid userdata for PetOrMount");
+ }
+
+ IntPtr buff = LuaAPI.lua_touserdata(L, index);
+ if (!CopyByValue.Pack(buff, 0, (int)val))
+ {
+ throw new Exception("pack fail for PetOrMount ,value="+val);
+ }
+ }
+
+ else
+ {
+ throw new Exception("try to update a data with lua type:" + LuaAPI.lua_type(L, index));
+ }
+ }
+
// table cast optimze
@@ -629,6 +5984,384 @@
translator.PushUnityEngineRay2D(L, array[index]);
return true;
}
+ else if (type == typeof(E_ActorClassType[]))
+ {
+ E_ActorClassType[] array = obj as E_ActorClassType[];
+ translator.PushE_ActorClassType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(E_ActorState[]))
+ {
+ E_ActorState[] array = obj as E_ActorState[];
+ translator.PushE_ActorState(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(E_BuffType[]))
+ {
+ E_BuffType[] array = obj as E_BuffType[];
+ translator.PushE_BuffType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(E_ClientNpcType[]))
+ {
+ E_ClientNpcType[] array = obj as E_ClientNpcType[];
+ translator.PushE_ClientNpcType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(E_NpcType[]))
+ {
+ E_NpcType[] array = obj as E_NpcType[];
+ translator.PushE_NpcType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(E_MovingState[]))
+ {
+ E_MovingState[] array = obj as E_MovingState[];
+ translator.PushE_MovingState(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(WindowType[]))
+ {
+ WindowType[] array = obj as WindowType[];
+ translator.PushWindowType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(GestureType[]))
+ {
+ GestureType[] array = obj as GestureType[];
+ translator.PushGestureType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(UnityPlatform[]))
+ {
+ UnityPlatform[] array = obj as UnityPlatform[];
+ translator.PushUnityPlatform(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(RoleRenameResult[]))
+ {
+ RoleRenameResult[] array = obj as RoleRenameResult[];
+ translator.PushRoleRenameResult(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(E_SkillCastTarget[]))
+ {
+ E_SkillCastTarget[] array = obj as E_SkillCastTarget[];
+ translator.PushE_SkillCastTarget(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(E_SkillType[]))
+ {
+ E_SkillType[] array = obj as E_SkillType[];
+ translator.PushE_SkillType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(E_SkillFuncType[]))
+ {
+ E_SkillFuncType[] array = obj as E_SkillFuncType[];
+ translator.PushE_SkillFuncType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(E_SkillCastType[]))
+ {
+ E_SkillCastType[] array = obj as E_SkillCastType[];
+ translator.PushE_SkillCastType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(MapTransferType[]))
+ {
+ MapTransferType[] array = obj as MapTransferType[];
+ translator.PushMapTransferType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(DropItemType[]))
+ {
+ DropItemType[] array = obj as DropItemType[];
+ translator.PushDropItemType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(DailyQuestType[]))
+ {
+ DailyQuestType[] array = obj as DailyQuestType[];
+ translator.PushDailyQuestType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(DungeonCoolDownType[]))
+ {
+ DungeonCoolDownType[] array = obj as DungeonCoolDownType[];
+ translator.PushDungeonCoolDownType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(RoleEquipType[]))
+ {
+ RoleEquipType[] array = obj as RoleEquipType[];
+ translator.PushRoleEquipType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(PlayerDataType[]))
+ {
+ PlayerDataType[] array = obj as PlayerDataType[];
+ translator.PushPlayerDataType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(PackType[]))
+ {
+ PackType[] array = obj as PackType[];
+ translator.PushPackType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(ItemType[]))
+ {
+ ItemType[] array = obj as ItemType[];
+ translator.PushItemType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(MakeType[]))
+ {
+ MakeType[] array = obj as MakeType[];
+ translator.PushMakeType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(TitleType[]))
+ {
+ TitleType[] array = obj as TitleType[];
+ translator.PushTitleType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(FuncOpenEnum[]))
+ {
+ FuncOpenEnum[] array = obj as FuncOpenEnum[];
+ translator.PushFuncOpenEnum(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(PropertyType[]))
+ {
+ PropertyType[] array = obj as PropertyType[];
+ translator.PushPropertyType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(TextColType[]))
+ {
+ TextColType[] array = obj as TextColType[];
+ translator.PushTextColType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(E_ModelResType[]))
+ {
+ E_ModelResType[] array = obj as E_ModelResType[];
+ translator.PushE_ModelResType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(TreasureCategory[]))
+ {
+ TreasureCategory[] array = obj as TreasureCategory[];
+ translator.PushTreasureCategory(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(TreasureState[]))
+ {
+ TreasureState[] array = obj as TreasureState[];
+ translator.PushTreasureState(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(FunctionUnlockType[]))
+ {
+ FunctionUnlockType[] array = obj as FunctionUnlockType[];
+ translator.PushFunctionUnlockType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(RedPointState[]))
+ {
+ RedPointState[] array = obj as RedPointState[];
+ translator.PushRedPointState(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(TeamInviteType[]))
+ {
+ TeamInviteType[] array = obj as TeamInviteType[];
+ translator.PushTeamInviteType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(TeammatePrepareState[]))
+ {
+ TeammatePrepareState[] array = obj as TeammatePrepareState[];
+ translator.PushTeammatePrepareState(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(VipPrivilegeType[]))
+ {
+ VipPrivilegeType[] array = obj as VipPrivilegeType[];
+ translator.PushVipPrivilegeType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(E_AttackMode[]))
+ {
+ E_AttackMode[] array = obj as E_AttackMode[];
+ translator.PushE_AttackMode(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(E_ItemColor[]))
+ {
+ E_ItemColor[] array = obj as E_ItemColor[];
+ translator.PushE_ItemColor(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(FindPreciousType[]))
+ {
+ FindPreciousType[] array = obj as FindPreciousType[];
+ translator.PushFindPreciousType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(GotServerRewardType[]))
+ {
+ GotServerRewardType[] array = obj as GotServerRewardType[];
+ translator.PushGotServerRewardType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(MapType[]))
+ {
+ MapType[] array = obj as MapType[];
+ translator.PushMapType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(GuideType[]))
+ {
+ GuideType[] array = obj as GuideType[];
+ translator.PushGuideType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(GuideTriggerType[]))
+ {
+ GuideTriggerType[] array = obj as GuideTriggerType[];
+ translator.PushGuideTriggerType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(FuncPowerType[]))
+ {
+ FuncPowerType[] array = obj as FuncPowerType[];
+ translator.PushFuncPowerType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(E_AtkType[]))
+ {
+ E_AtkType[] array = obj as E_AtkType[];
+ translator.PushE_AtkType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(GameObjType[]))
+ {
+ GameObjType[] array = obj as GameObjType[];
+ translator.PushGameObjType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(HurtAttackType[]))
+ {
+ HurtAttackType[] array = obj as HurtAttackType[];
+ translator.PushHurtAttackType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(DungeonTargetType[]))
+ {
+ DungeonTargetType[] array = obj as DungeonTargetType[];
+ translator.PushDungeonTargetType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(AchievementType[]))
+ {
+ AchievementType[] array = obj as AchievementType[];
+ translator.PushAchievementType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(ItemTimeType[]))
+ {
+ ItemTimeType[] array = obj as ItemTimeType[];
+ translator.PushItemTimeType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(TitleBtnState[]))
+ {
+ TitleBtnState[] array = obj as TitleBtnState[];
+ translator.PushTitleBtnState(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(LegendAttrType[]))
+ {
+ LegendAttrType[] array = obj as LegendAttrType[];
+ translator.PushLegendAttrType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(ServerState[]))
+ {
+ ServerState[] array = obj as ServerState[];
+ translator.PushServerState(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(ItemUseDataKey[]))
+ {
+ ItemUseDataKey[] array = obj as ItemUseDataKey[];
+ translator.PushItemUseDataKey(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(ItemOperateType[]))
+ {
+ ItemOperateType[] array = obj as ItemOperateType[];
+ translator.PushItemOperateType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(ItemWinType[]))
+ {
+ ItemWinType[] array = obj as ItemWinType[];
+ translator.PushItemWinType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(ItemTipChildType[]))
+ {
+ ItemTipChildType[] array = obj as ItemTipChildType[];
+ translator.PushItemTipChildType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(InstalledAsset[]))
+ {
+ InstalledAsset[] array = obj as InstalledAsset[];
+ translator.PushInstalledAsset(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(VersionAuthority[]))
+ {
+ VersionAuthority[] array = obj as VersionAuthority[];
+ translator.PushVersionAuthority(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(FootAudioType[]))
+ {
+ FootAudioType[] array = obj as FootAudioType[];
+ translator.PushFootAudioType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(AttackFailType[]))
+ {
+ AttackFailType[] array = obj as AttackFailType[];
+ translator.PushAttackFailType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(DungeonFightStage[]))
+ {
+ DungeonFightStage[] array = obj as DungeonFightStage[];
+ translator.PushDungeonFightStage(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(RankType[]))
+ {
+ RankType[] array = obj as RankType[];
+ translator.PushRankType(L, array[index]);
+ return true;
+ }
+ else if (type == typeof(PetOrMount[]))
+ {
+ PetOrMount[] array = obj as PetOrMount[];
+ translator.PushPetOrMount(L, array[index]);
+ return true;
+ }
return false;
}
@@ -683,6 +6416,384 @@
translator.Get(L, obj_idx, out array[array_idx]);
return true;
}
+ else if (type == typeof(E_ActorClassType[]))
+ {
+ E_ActorClassType[] array = obj as E_ActorClassType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(E_ActorState[]))
+ {
+ E_ActorState[] array = obj as E_ActorState[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(E_BuffType[]))
+ {
+ E_BuffType[] array = obj as E_BuffType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(E_ClientNpcType[]))
+ {
+ E_ClientNpcType[] array = obj as E_ClientNpcType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(E_NpcType[]))
+ {
+ E_NpcType[] array = obj as E_NpcType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(E_MovingState[]))
+ {
+ E_MovingState[] array = obj as E_MovingState[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(WindowType[]))
+ {
+ WindowType[] array = obj as WindowType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(GestureType[]))
+ {
+ GestureType[] array = obj as GestureType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(UnityPlatform[]))
+ {
+ UnityPlatform[] array = obj as UnityPlatform[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(RoleRenameResult[]))
+ {
+ RoleRenameResult[] array = obj as RoleRenameResult[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(E_SkillCastTarget[]))
+ {
+ E_SkillCastTarget[] array = obj as E_SkillCastTarget[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(E_SkillType[]))
+ {
+ E_SkillType[] array = obj as E_SkillType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(E_SkillFuncType[]))
+ {
+ E_SkillFuncType[] array = obj as E_SkillFuncType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(E_SkillCastType[]))
+ {
+ E_SkillCastType[] array = obj as E_SkillCastType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(MapTransferType[]))
+ {
+ MapTransferType[] array = obj as MapTransferType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(DropItemType[]))
+ {
+ DropItemType[] array = obj as DropItemType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(DailyQuestType[]))
+ {
+ DailyQuestType[] array = obj as DailyQuestType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(DungeonCoolDownType[]))
+ {
+ DungeonCoolDownType[] array = obj as DungeonCoolDownType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(RoleEquipType[]))
+ {
+ RoleEquipType[] array = obj as RoleEquipType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(PlayerDataType[]))
+ {
+ PlayerDataType[] array = obj as PlayerDataType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(PackType[]))
+ {
+ PackType[] array = obj as PackType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(ItemType[]))
+ {
+ ItemType[] array = obj as ItemType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(MakeType[]))
+ {
+ MakeType[] array = obj as MakeType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(TitleType[]))
+ {
+ TitleType[] array = obj as TitleType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(FuncOpenEnum[]))
+ {
+ FuncOpenEnum[] array = obj as FuncOpenEnum[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(PropertyType[]))
+ {
+ PropertyType[] array = obj as PropertyType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(TextColType[]))
+ {
+ TextColType[] array = obj as TextColType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(E_ModelResType[]))
+ {
+ E_ModelResType[] array = obj as E_ModelResType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(TreasureCategory[]))
+ {
+ TreasureCategory[] array = obj as TreasureCategory[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(TreasureState[]))
+ {
+ TreasureState[] array = obj as TreasureState[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(FunctionUnlockType[]))
+ {
+ FunctionUnlockType[] array = obj as FunctionUnlockType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(RedPointState[]))
+ {
+ RedPointState[] array = obj as RedPointState[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(TeamInviteType[]))
+ {
+ TeamInviteType[] array = obj as TeamInviteType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(TeammatePrepareState[]))
+ {
+ TeammatePrepareState[] array = obj as TeammatePrepareState[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(VipPrivilegeType[]))
+ {
+ VipPrivilegeType[] array = obj as VipPrivilegeType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(E_AttackMode[]))
+ {
+ E_AttackMode[] array = obj as E_AttackMode[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(E_ItemColor[]))
+ {
+ E_ItemColor[] array = obj as E_ItemColor[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(FindPreciousType[]))
+ {
+ FindPreciousType[] array = obj as FindPreciousType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(GotServerRewardType[]))
+ {
+ GotServerRewardType[] array = obj as GotServerRewardType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(MapType[]))
+ {
+ MapType[] array = obj as MapType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(GuideType[]))
+ {
+ GuideType[] array = obj as GuideType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(GuideTriggerType[]))
+ {
+ GuideTriggerType[] array = obj as GuideTriggerType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(FuncPowerType[]))
+ {
+ FuncPowerType[] array = obj as FuncPowerType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(E_AtkType[]))
+ {
+ E_AtkType[] array = obj as E_AtkType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(GameObjType[]))
+ {
+ GameObjType[] array = obj as GameObjType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(HurtAttackType[]))
+ {
+ HurtAttackType[] array = obj as HurtAttackType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(DungeonTargetType[]))
+ {
+ DungeonTargetType[] array = obj as DungeonTargetType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(AchievementType[]))
+ {
+ AchievementType[] array = obj as AchievementType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(ItemTimeType[]))
+ {
+ ItemTimeType[] array = obj as ItemTimeType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(TitleBtnState[]))
+ {
+ TitleBtnState[] array = obj as TitleBtnState[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(LegendAttrType[]))
+ {
+ LegendAttrType[] array = obj as LegendAttrType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(ServerState[]))
+ {
+ ServerState[] array = obj as ServerState[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(ItemUseDataKey[]))
+ {
+ ItemUseDataKey[] array = obj as ItemUseDataKey[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(ItemOperateType[]))
+ {
+ ItemOperateType[] array = obj as ItemOperateType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(ItemWinType[]))
+ {
+ ItemWinType[] array = obj as ItemWinType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(ItemTipChildType[]))
+ {
+ ItemTipChildType[] array = obj as ItemTipChildType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(InstalledAsset[]))
+ {
+ InstalledAsset[] array = obj as InstalledAsset[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(VersionAuthority[]))
+ {
+ VersionAuthority[] array = obj as VersionAuthority[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(FootAudioType[]))
+ {
+ FootAudioType[] array = obj as FootAudioType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(AttackFailType[]))
+ {
+ AttackFailType[] array = obj as AttackFailType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(DungeonFightStage[]))
+ {
+ DungeonFightStage[] array = obj as DungeonFightStage[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(RankType[]))
+ {
+ RankType[] array = obj as RankType[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
+ else if (type == typeof(PetOrMount[]))
+ {
+ PetOrMount[] array = obj as PetOrMount[];
+ translator.Get(L, obj_idx, out array[array_idx]);
+ return true;
+ }
return false;
}
}
--
Gitblit v1.8.0