snxxz_scripts.git

			@@ -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;
			}
			}