From c8e3a97e4e02e7328d70dbc3dc69c3d4230a5a37 Mon Sep 17 00:00:00 2001
From: client_linchunjie <461730578@qq.com>
Date: 星期三, 15 五月 2019 10:36:47 +0800
Subject: [PATCH] Merge branch 'master' of http://192.168.0.87:10010/r/snxxz_scripts
---
Lua/Gen/EnumWrap.cs | 9180 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 9,180 insertions(+), 0 deletions(-)
diff --git a/Lua/Gen/EnumWrap.cs b/Lua/Gen/EnumWrap.cs
index 8dad8cc..a917940 100644
--- a/Lua/Gen/EnumWrap.cs
+++ b/Lua/Gen/EnumWrap.cs
@@ -16,4 +16,9184 @@
{
using Utils = XLua.Utils;
+ public class E_ActorClassTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(E_ActorClassType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(E_ActorClassType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(E_ActorClassType), L, null, 23, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnDefine", E_ActorClassType.UnDefine);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Hero", E_ActorClassType.Hero);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Player", E_ActorClassType.Player);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Guard", E_ActorClassType.Guard);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcFightNorm", E_ActorClassType.NpcFightNorm);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcFightBoss", E_ActorClassType.NpcFightBoss);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcSummonFunc", E_ActorClassType.NpcSummonFunc);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcCollect", E_ActorClassType.NpcCollect);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcSummonFight", E_ActorClassType.NpcSummonFight);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcFunc", E_ActorClassType.NpcFunc);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pet", E_ActorClassType.Pet);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcTouchKilled", E_ActorClassType.NpcTouchKilled);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcClientFightNorm", E_ActorClassType.NpcClientFightNorm);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcClientFightBoss", E_ActorClassType.NpcClientFightBoss);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcClientFunc", E_ActorClassType.NpcClientFunc);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcFightVirtualPlayer", E_ActorClassType.NpcFightVirtualPlayer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlayerXmzz", E_ActorClassType.PlayerXmzz);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ClientPlayer", E_ActorClassType.ClientPlayer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlayerZZ", E_ActorClassType.PlayerZZ);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlayerSgzcRobot", E_ActorClassType.PlayerSgzcRobot);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PVPClientPlayer", E_ActorClassType.PVPClientPlayer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcClientCollect", E_ActorClassType.NpcClientCollect);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(E_ActorClassType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushE_ActorClassType(L, (E_ActorClassType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "UnDefine"))
+ {
+ translator.PushE_ActorClassType(L, E_ActorClassType.UnDefine);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Hero"))
+ {
+ translator.PushE_ActorClassType(L, E_ActorClassType.Hero);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Player"))
+ {
+ translator.PushE_ActorClassType(L, E_ActorClassType.Player);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Guard"))
+ {
+ translator.PushE_ActorClassType(L, E_ActorClassType.Guard);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcFightNorm"))
+ {
+ translator.PushE_ActorClassType(L, E_ActorClassType.NpcFightNorm);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcFightBoss"))
+ {
+ translator.PushE_ActorClassType(L, E_ActorClassType.NpcFightBoss);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcSummonFunc"))
+ {
+ translator.PushE_ActorClassType(L, E_ActorClassType.NpcSummonFunc);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcCollect"))
+ {
+ translator.PushE_ActorClassType(L, E_ActorClassType.NpcCollect);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcSummonFight"))
+ {
+ translator.PushE_ActorClassType(L, E_ActorClassType.NpcSummonFight);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcFunc"))
+ {
+ translator.PushE_ActorClassType(L, E_ActorClassType.NpcFunc);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Pet"))
+ {
+ translator.PushE_ActorClassType(L, E_ActorClassType.Pet);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcTouchKilled"))
+ {
+ translator.PushE_ActorClassType(L, E_ActorClassType.NpcTouchKilled);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcClientFightNorm"))
+ {
+ translator.PushE_ActorClassType(L, E_ActorClassType.NpcClientFightNorm);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcClientFightBoss"))
+ {
+ translator.PushE_ActorClassType(L, E_ActorClassType.NpcClientFightBoss);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcClientFunc"))
+ {
+ translator.PushE_ActorClassType(L, E_ActorClassType.NpcClientFunc);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcFightVirtualPlayer"))
+ {
+ translator.PushE_ActorClassType(L, E_ActorClassType.NpcFightVirtualPlayer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PlayerXmzz"))
+ {
+ translator.PushE_ActorClassType(L, E_ActorClassType.PlayerXmzz);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ClientPlayer"))
+ {
+ translator.PushE_ActorClassType(L, E_ActorClassType.ClientPlayer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PlayerZZ"))
+ {
+ translator.PushE_ActorClassType(L, E_ActorClassType.PlayerZZ);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PlayerSgzcRobot"))
+ {
+ translator.PushE_ActorClassType(L, E_ActorClassType.PlayerSgzcRobot);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PVPClientPlayer"))
+ {
+ translator.PushE_ActorClassType(L, E_ActorClassType.PVPClientPlayer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcClientCollect"))
+ {
+ translator.PushE_ActorClassType(L, E_ActorClassType.NpcClientCollect);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for E_ActorClassType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for E_ActorClassType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class E_ActorStateWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(E_ActorState), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(E_ActorState), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(E_ActorState), L, null, 11, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Idle", E_ActorState.Idle);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CtrlRun", E_ActorState.CtrlRun);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AutoRun", E_ActorState.AutoRun);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Hurt", E_ActorState.Hurt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Die", E_ActorState.Die);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CommonAtk", E_ActorState.CommonAtk);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CastSkill", E_ActorState.CastSkill);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DaZuo", E_ActorState.DaZuo);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Roll", E_ActorState.Roll);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mocked", E_ActorState.Mocked);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(E_ActorState), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushE_ActorState(L, (E_ActorState)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Idle"))
+ {
+ translator.PushE_ActorState(L, E_ActorState.Idle);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CtrlRun"))
+ {
+ translator.PushE_ActorState(L, E_ActorState.CtrlRun);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AutoRun"))
+ {
+ translator.PushE_ActorState(L, E_ActorState.AutoRun);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Hurt"))
+ {
+ translator.PushE_ActorState(L, E_ActorState.Hurt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Die"))
+ {
+ translator.PushE_ActorState(L, E_ActorState.Die);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CommonAtk"))
+ {
+ translator.PushE_ActorState(L, E_ActorState.CommonAtk);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CastSkill"))
+ {
+ translator.PushE_ActorState(L, E_ActorState.CastSkill);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DaZuo"))
+ {
+ translator.PushE_ActorState(L, E_ActorState.DaZuo);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Roll"))
+ {
+ translator.PushE_ActorState(L, E_ActorState.Roll);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Mocked"))
+ {
+ translator.PushE_ActorState(L, E_ActorState.Mocked);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for E_ActorState!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for E_ActorState! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class E_BuffTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(E_BuffType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(E_BuffType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(E_BuffType), L, null, 12, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "bfBuff", E_BuffType.bfBuff);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "bfDeBuff", E_BuffType.bfDeBuff);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "bfAura", E_BuffType.bfAura);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "bfIncBuff", E_BuffType.bfIncBuff);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "btPassiveBuf", E_BuffType.btPassiveBuf);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "bfEquipBuff", E_BuffType.bfEquipBuff);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "bfMapBuff", E_BuffType.bfMapBuff);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "bfActionBuff", E_BuffType.bfActionBuff);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "bfProcessBuff", E_BuffType.bfProcessBuff);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "bfProcessDeBuff", E_BuffType.bfProcessDeBuff);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "btBufMax", E_BuffType.btBufMax);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(E_BuffType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushE_BuffType(L, (E_BuffType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "bfBuff"))
+ {
+ translator.PushE_BuffType(L, E_BuffType.bfBuff);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "bfDeBuff"))
+ {
+ translator.PushE_BuffType(L, E_BuffType.bfDeBuff);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "bfAura"))
+ {
+ translator.PushE_BuffType(L, E_BuffType.bfAura);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "bfIncBuff"))
+ {
+ translator.PushE_BuffType(L, E_BuffType.bfIncBuff);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "btPassiveBuf"))
+ {
+ translator.PushE_BuffType(L, E_BuffType.btPassiveBuf);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "bfEquipBuff"))
+ {
+ translator.PushE_BuffType(L, E_BuffType.bfEquipBuff);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "bfMapBuff"))
+ {
+ translator.PushE_BuffType(L, E_BuffType.bfMapBuff);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "bfActionBuff"))
+ {
+ translator.PushE_BuffType(L, E_BuffType.bfActionBuff);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "bfProcessBuff"))
+ {
+ translator.PushE_BuffType(L, E_BuffType.bfProcessBuff);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "bfProcessDeBuff"))
+ {
+ translator.PushE_BuffType(L, E_BuffType.bfProcessDeBuff);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "btBufMax"))
+ {
+ translator.PushE_BuffType(L, E_BuffType.btBufMax);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for E_BuffType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for E_BuffType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class E_ClientNpcTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(E_ClientNpcType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(E_ClientNpcType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(E_ClientNpcType), L, null, 3, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Func", E_ClientNpcType.Func);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fight", E_ClientNpcType.Fight);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(E_ClientNpcType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushE_ClientNpcType(L, (E_ClientNpcType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Func"))
+ {
+ translator.PushE_ClientNpcType(L, E_ClientNpcType.Func);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Fight"))
+ {
+ translator.PushE_ClientNpcType(L, E_ClientNpcType.Fight);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for E_ClientNpcType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for E_ClientNpcType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class E_NpcTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(E_NpcType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(E_NpcType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(E_NpcType), L, null, 22, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Func", E_NpcType.Func);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Defend", E_NpcType.Defend);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fight", E_NpcType.Fight);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Summon", E_NpcType.Summon);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Ghost", E_NpcType.Ghost);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Trap", E_NpcType.Trap);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Car", E_NpcType.Car);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Sprite", E_NpcType.Sprite);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VirtualPlayer", E_NpcType.VirtualPlayer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Flag", E_NpcType.Flag);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Collect", E_NpcType.Collect);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Catch", E_NpcType.Catch);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pet", E_NpcType.Pet);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TouchKilled", E_NpcType.TouchKilled);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FMBoss", E_NpcType.FMBoss);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BreakableObj", E_NpcType.BreakableObj);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FightAssist", E_NpcType.FightAssist);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SGZC_FightAssist", E_NpcType.SGZC_FightAssist);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MonsterTime", E_NpcType.MonsterTime);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PersonalEnemy", E_NpcType.PersonalEnemy);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenWorldMap", E_NpcType.OpenWorldMap);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(E_NpcType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushE_NpcType(L, (E_NpcType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Func"))
+ {
+ translator.PushE_NpcType(L, E_NpcType.Func);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Defend"))
+ {
+ translator.PushE_NpcType(L, E_NpcType.Defend);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Fight"))
+ {
+ translator.PushE_NpcType(L, E_NpcType.Fight);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Summon"))
+ {
+ translator.PushE_NpcType(L, E_NpcType.Summon);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Ghost"))
+ {
+ translator.PushE_NpcType(L, E_NpcType.Ghost);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Trap"))
+ {
+ translator.PushE_NpcType(L, E_NpcType.Trap);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Car"))
+ {
+ translator.PushE_NpcType(L, E_NpcType.Car);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Sprite"))
+ {
+ translator.PushE_NpcType(L, E_NpcType.Sprite);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "VirtualPlayer"))
+ {
+ translator.PushE_NpcType(L, E_NpcType.VirtualPlayer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Flag"))
+ {
+ translator.PushE_NpcType(L, E_NpcType.Flag);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Collect"))
+ {
+ translator.PushE_NpcType(L, E_NpcType.Collect);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Catch"))
+ {
+ translator.PushE_NpcType(L, E_NpcType.Catch);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Pet"))
+ {
+ translator.PushE_NpcType(L, E_NpcType.Pet);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "TouchKilled"))
+ {
+ translator.PushE_NpcType(L, E_NpcType.TouchKilled);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FMBoss"))
+ {
+ translator.PushE_NpcType(L, E_NpcType.FMBoss);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BreakableObj"))
+ {
+ translator.PushE_NpcType(L, E_NpcType.BreakableObj);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FightAssist"))
+ {
+ translator.PushE_NpcType(L, E_NpcType.FightAssist);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SGZC_FightAssist"))
+ {
+ translator.PushE_NpcType(L, E_NpcType.SGZC_FightAssist);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MonsterTime"))
+ {
+ translator.PushE_NpcType(L, E_NpcType.MonsterTime);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PersonalEnemy"))
+ {
+ translator.PushE_NpcType(L, E_NpcType.PersonalEnemy);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenWorldMap"))
+ {
+ translator.PushE_NpcType(L, E_NpcType.OpenWorldMap);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for E_NpcType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for E_NpcType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class E_MovingStateWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(E_MovingState), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(E_MovingState), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(E_MovingState), L, null, 4, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", E_MovingState.Normal);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fly", E_MovingState.Fly);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Ride", E_MovingState.Ride);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(E_MovingState), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushE_MovingState(L, (E_MovingState)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
+ {
+ translator.PushE_MovingState(L, E_MovingState.Normal);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Fly"))
+ {
+ translator.PushE_MovingState(L, E_MovingState.Fly);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Ride"))
+ {
+ translator.PushE_MovingState(L, E_MovingState.Ride);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for E_MovingState!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for E_MovingState! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class WindowTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(WindowType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(WindowType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(WindowType), L, null, 8, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Base", WindowType.Base);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", WindowType.Normal);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Modal", WindowType.Modal);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Tip", WindowType.Tip);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "System", WindowType.System);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Loading", WindowType.Loading);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Flag", WindowType.Flag);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(WindowType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushWindowType(L, (WindowType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Base"))
+ {
+ translator.PushWindowType(L, WindowType.Base);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
+ {
+ translator.PushWindowType(L, WindowType.Normal);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Modal"))
+ {
+ translator.PushWindowType(L, WindowType.Modal);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Tip"))
+ {
+ translator.PushWindowType(L, WindowType.Tip);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "System"))
+ {
+ translator.PushWindowType(L, WindowType.System);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Loading"))
+ {
+ translator.PushWindowType(L, WindowType.Loading);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Flag"))
+ {
+ translator.PushWindowType(L, WindowType.Flag);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for WindowType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for WindowType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class GestureTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(GestureType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(GestureType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(GestureType), L, null, 5, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Left", GestureType.Left);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Right", GestureType.Right);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Up", GestureType.Up);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Down", GestureType.Down);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(GestureType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushGestureType(L, (GestureType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Left"))
+ {
+ translator.PushGestureType(L, GestureType.Left);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Right"))
+ {
+ translator.PushGestureType(L, GestureType.Right);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Up"))
+ {
+ translator.PushGestureType(L, GestureType.Up);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Down"))
+ {
+ translator.PushGestureType(L, GestureType.Down);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for GestureType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for GestureType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class UnityPlatformWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(UnityPlatform), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(UnityPlatform), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(UnityPlatform), L, null, 5, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Editor", UnityPlatform.Editor);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Android", UnityPlatform.Android);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Iphone", UnityPlatform.Iphone);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Standalone", UnityPlatform.Standalone);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(UnityPlatform), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushUnityPlatform(L, (UnityPlatform)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Editor"))
+ {
+ translator.PushUnityPlatform(L, UnityPlatform.Editor);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Android"))
+ {
+ translator.PushUnityPlatform(L, UnityPlatform.Android);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Iphone"))
+ {
+ translator.PushUnityPlatform(L, UnityPlatform.Iphone);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Standalone"))
+ {
+ translator.PushUnityPlatform(L, UnityPlatform.Standalone);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for UnityPlatform!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for UnityPlatform! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class RoleRenameResultWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(RoleRenameResult), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(RoleRenameResult), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(RoleRenameResult), L, null, 7, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MoneyErr", RoleRenameResult.MoneyErr);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NameRuleErr", RoleRenameResult.NameRuleErr);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NameLengErr", RoleRenameResult.NameLengErr);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NameRepeatErr", RoleRenameResult.NameRepeatErr);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RenameFailErr", RoleRenameResult.RenameFailErr);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RenameSuccess", RoleRenameResult.RenameSuccess);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(RoleRenameResult), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushRoleRenameResult(L, (RoleRenameResult)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "MoneyErr"))
+ {
+ translator.PushRoleRenameResult(L, RoleRenameResult.MoneyErr);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NameRuleErr"))
+ {
+ translator.PushRoleRenameResult(L, RoleRenameResult.NameRuleErr);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NameLengErr"))
+ {
+ translator.PushRoleRenameResult(L, RoleRenameResult.NameLengErr);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NameRepeatErr"))
+ {
+ translator.PushRoleRenameResult(L, RoleRenameResult.NameRepeatErr);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RenameFailErr"))
+ {
+ translator.PushRoleRenameResult(L, RoleRenameResult.RenameFailErr);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RenameSuccess"))
+ {
+ translator.PushRoleRenameResult(L, RoleRenameResult.RenameSuccess);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for RoleRenameResult!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for RoleRenameResult! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class E_SkillCastTargetWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(E_SkillCastTarget), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(E_SkillCastTarget), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(E_SkillCastTarget), L, null, 16, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", E_SkillCastTarget.None);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Self", E_SkillCastTarget.Self);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TeamMate", E_SkillCastTarget.TeamMate);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Friend", E_SkillCastTarget.Friend);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CanAttacked", E_SkillCastTarget.CanAttacked);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SelfAndFriend", E_SkillCastTarget.SelfAndFriend);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlayerDeadBody", E_SkillCastTarget.PlayerDeadBody);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnDeadPlayer", E_SkillCastTarget.UnDeadPlayer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CanAttackedMonster", E_SkillCastTarget.CanAttackedMonster);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CanAttackedPlayer", E_SkillCastTarget.CanAttackedPlayer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "All", E_SkillCastTarget.All);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetToOwner", E_SkillCastTarget.PetToOwner);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SummonToOwner", E_SkillCastTarget.SummonToOwner);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Monster", E_SkillCastTarget.Monster);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FriendNpc", E_SkillCastTarget.FriendNpc);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(E_SkillCastTarget), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushE_SkillCastTarget(L, (E_SkillCastTarget)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
+ {
+ translator.PushE_SkillCastTarget(L, E_SkillCastTarget.None);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Self"))
+ {
+ translator.PushE_SkillCastTarget(L, E_SkillCastTarget.Self);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "TeamMate"))
+ {
+ translator.PushE_SkillCastTarget(L, E_SkillCastTarget.TeamMate);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Friend"))
+ {
+ translator.PushE_SkillCastTarget(L, E_SkillCastTarget.Friend);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CanAttacked"))
+ {
+ translator.PushE_SkillCastTarget(L, E_SkillCastTarget.CanAttacked);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SelfAndFriend"))
+ {
+ translator.PushE_SkillCastTarget(L, E_SkillCastTarget.SelfAndFriend);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PlayerDeadBody"))
+ {
+ translator.PushE_SkillCastTarget(L, E_SkillCastTarget.PlayerDeadBody);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "UnDeadPlayer"))
+ {
+ translator.PushE_SkillCastTarget(L, E_SkillCastTarget.UnDeadPlayer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CanAttackedMonster"))
+ {
+ translator.PushE_SkillCastTarget(L, E_SkillCastTarget.CanAttackedMonster);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CanAttackedPlayer"))
+ {
+ translator.PushE_SkillCastTarget(L, E_SkillCastTarget.CanAttackedPlayer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "All"))
+ {
+ translator.PushE_SkillCastTarget(L, E_SkillCastTarget.All);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PetToOwner"))
+ {
+ translator.PushE_SkillCastTarget(L, E_SkillCastTarget.PetToOwner);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SummonToOwner"))
+ {
+ translator.PushE_SkillCastTarget(L, E_SkillCastTarget.SummonToOwner);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Monster"))
+ {
+ translator.PushE_SkillCastTarget(L, E_SkillCastTarget.Monster);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FriendNpc"))
+ {
+ translator.PushE_SkillCastTarget(L, E_SkillCastTarget.FriendNpc);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for E_SkillCastTarget!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for E_SkillCastTarget! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class E_SkillTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(E_SkillType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(E_SkillType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(E_SkillType), L, null, 24, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Special", E_SkillType.Special);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Attack", E_SkillType.Attack);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Recover", E_SkillType.Recover);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ContinuousGain", E_SkillType.ContinuousGain);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SustainedReduction", E_SkillType.SustainedReduction);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GainBuff", E_SkillType.GainBuff);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReductionBuff", E_SkillType.ReductionBuff);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Passive", E_SkillType.Passive);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Reborn", E_SkillType.Reborn);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ValueAdded", E_SkillType.ValueAdded);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Halo", E_SkillType.Halo);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip", E_SkillType.Equip);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Area", E_SkillType.Area);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Summon", E_SkillType.Summon);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ControlBuff", E_SkillType.ControlBuff);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MutilHurtBuffAtk", E_SkillType.MutilHurtBuffAtk);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PassiveGainBuff", E_SkillType.PassiveGainBuff);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PassiveReductionBuff", E_SkillType.PassiveReductionBuff);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PassiveControlBuff", E_SkillType.PassiveControlBuff);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Property", E_SkillType.Property);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PassiveBuff", E_SkillType.PassiveBuff);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PassiveContinuousGain", E_SkillType.PassiveContinuousGain);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PassiveSustainedReduction", E_SkillType.PassiveSustainedReduction);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(E_SkillType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushE_SkillType(L, (E_SkillType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Special"))
+ {
+ translator.PushE_SkillType(L, E_SkillType.Special);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Attack"))
+ {
+ translator.PushE_SkillType(L, E_SkillType.Attack);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Recover"))
+ {
+ translator.PushE_SkillType(L, E_SkillType.Recover);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ContinuousGain"))
+ {
+ translator.PushE_SkillType(L, E_SkillType.ContinuousGain);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SustainedReduction"))
+ {
+ translator.PushE_SkillType(L, E_SkillType.SustainedReduction);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "GainBuff"))
+ {
+ translator.PushE_SkillType(L, E_SkillType.GainBuff);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ReductionBuff"))
+ {
+ translator.PushE_SkillType(L, E_SkillType.ReductionBuff);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Passive"))
+ {
+ translator.PushE_SkillType(L, E_SkillType.Passive);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Reborn"))
+ {
+ translator.PushE_SkillType(L, E_SkillType.Reborn);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ValueAdded"))
+ {
+ translator.PushE_SkillType(L, E_SkillType.ValueAdded);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Halo"))
+ {
+ translator.PushE_SkillType(L, E_SkillType.Halo);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip"))
+ {
+ translator.PushE_SkillType(L, E_SkillType.Equip);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Area"))
+ {
+ translator.PushE_SkillType(L, E_SkillType.Area);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Summon"))
+ {
+ translator.PushE_SkillType(L, E_SkillType.Summon);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ControlBuff"))
+ {
+ translator.PushE_SkillType(L, E_SkillType.ControlBuff);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MutilHurtBuffAtk"))
+ {
+ translator.PushE_SkillType(L, E_SkillType.MutilHurtBuffAtk);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PassiveGainBuff"))
+ {
+ translator.PushE_SkillType(L, E_SkillType.PassiveGainBuff);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PassiveReductionBuff"))
+ {
+ translator.PushE_SkillType(L, E_SkillType.PassiveReductionBuff);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PassiveControlBuff"))
+ {
+ translator.PushE_SkillType(L, E_SkillType.PassiveControlBuff);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Property"))
+ {
+ translator.PushE_SkillType(L, E_SkillType.Property);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PassiveBuff"))
+ {
+ translator.PushE_SkillType(L, E_SkillType.PassiveBuff);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PassiveContinuousGain"))
+ {
+ translator.PushE_SkillType(L, E_SkillType.PassiveContinuousGain);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PassiveSustainedReduction"))
+ {
+ translator.PushE_SkillType(L, E_SkillType.PassiveSustainedReduction);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for E_SkillType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for E_SkillType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class E_SkillFuncTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(E_SkillFuncType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(E_SkillFuncType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(E_SkillFuncType), L, null, 15, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Common", E_SkillFuncType.Common);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FaBaoActiveSkill", E_SkillFuncType.FaBaoActiveSkill);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FaBaoPassiveSkills", E_SkillFuncType.FaBaoPassiveSkills);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FaBaoSpSkill", E_SkillFuncType.FaBaoSpSkill);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TalentSkills", E_SkillFuncType.TalentSkills);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RiderSkill", E_SkillFuncType.RiderSkill);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetSkill", E_SkillFuncType.PetSkill);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GodWeaponSkill", E_SkillFuncType.GodWeaponSkill);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NormalAttack", E_SkillFuncType.NormalAttack);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SpLv15Skill", E_SkillFuncType.SpLv15Skill);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Roll", E_SkillFuncType.Roll);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RealmSkill", E_SkillFuncType.RealmSkill);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MythicalAnimal", E_SkillFuncType.MythicalAnimal);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ZhuxianSkill", E_SkillFuncType.ZhuxianSkill);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(E_SkillFuncType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushE_SkillFuncType(L, (E_SkillFuncType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Common"))
+ {
+ translator.PushE_SkillFuncType(L, E_SkillFuncType.Common);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FaBaoActiveSkill"))
+ {
+ translator.PushE_SkillFuncType(L, E_SkillFuncType.FaBaoActiveSkill);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FaBaoPassiveSkills"))
+ {
+ translator.PushE_SkillFuncType(L, E_SkillFuncType.FaBaoPassiveSkills);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FaBaoSpSkill"))
+ {
+ translator.PushE_SkillFuncType(L, E_SkillFuncType.FaBaoSpSkill);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "TalentSkills"))
+ {
+ translator.PushE_SkillFuncType(L, E_SkillFuncType.TalentSkills);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RiderSkill"))
+ {
+ translator.PushE_SkillFuncType(L, E_SkillFuncType.RiderSkill);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PetSkill"))
+ {
+ translator.PushE_SkillFuncType(L, E_SkillFuncType.PetSkill);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "GodWeaponSkill"))
+ {
+ translator.PushE_SkillFuncType(L, E_SkillFuncType.GodWeaponSkill);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NormalAttack"))
+ {
+ translator.PushE_SkillFuncType(L, E_SkillFuncType.NormalAttack);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SpLv15Skill"))
+ {
+ translator.PushE_SkillFuncType(L, E_SkillFuncType.SpLv15Skill);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Roll"))
+ {
+ translator.PushE_SkillFuncType(L, E_SkillFuncType.Roll);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RealmSkill"))
+ {
+ translator.PushE_SkillFuncType(L, E_SkillFuncType.RealmSkill);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MythicalAnimal"))
+ {
+ translator.PushE_SkillFuncType(L, E_SkillFuncType.MythicalAnimal);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ZhuxianSkill"))
+ {
+ translator.PushE_SkillFuncType(L, E_SkillFuncType.ZhuxianSkill);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for E_SkillFuncType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for E_SkillFuncType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class E_SkillCastTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(E_SkillCastType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(E_SkillCastType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(E_SkillCastType), L, null, 4, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", E_SkillCastType.None);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NeedTarget", E_SkillCastType.NeedTarget);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Ground", E_SkillCastType.Ground);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(E_SkillCastType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushE_SkillCastType(L, (E_SkillCastType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
+ {
+ translator.PushE_SkillCastType(L, E_SkillCastType.None);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NeedTarget"))
+ {
+ translator.PushE_SkillCastType(L, E_SkillCastType.NeedTarget);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Ground"))
+ {
+ translator.PushE_SkillCastType(L, E_SkillCastType.Ground);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for E_SkillCastType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for E_SkillCastType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class MapTransferTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(MapTransferType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(MapTransferType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(MapTransferType), L, null, 4, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WorldTransport", MapTransferType.WorldTransport);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BigMapTransport", MapTransferType.BigMapTransport);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MissionTransport", MapTransferType.MissionTransport);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(MapTransferType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushMapTransferType(L, (MapTransferType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "WorldTransport"))
+ {
+ translator.PushMapTransferType(L, MapTransferType.WorldTransport);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BigMapTransport"))
+ {
+ translator.PushMapTransferType(L, MapTransferType.BigMapTransport);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MissionTransport"))
+ {
+ translator.PushMapTransferType(L, MapTransferType.MissionTransport);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for MapTransferType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for MapTransferType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class DropItemTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(DropItemType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(DropItemType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(DropItemType), L, null, 5, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pattern0", DropItemType.Pattern0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pattern1", DropItemType.Pattern1);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pattern2", DropItemType.Pattern2);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pattern3", DropItemType.Pattern3);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(DropItemType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushDropItemType(L, (DropItemType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Pattern0"))
+ {
+ translator.PushDropItemType(L, DropItemType.Pattern0);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Pattern1"))
+ {
+ translator.PushDropItemType(L, DropItemType.Pattern1);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Pattern2"))
+ {
+ translator.PushDropItemType(L, DropItemType.Pattern2);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Pattern3"))
+ {
+ translator.PushDropItemType(L, DropItemType.Pattern3);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for DropItemType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for DropItemType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class DailyQuestTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(DailyQuestType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(DailyQuestType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(DailyQuestType), L, null, 34, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BountyMission", DailyQuestType.BountyMission);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IceCrystal", DailyQuestType.IceCrystal);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyFeast", DailyQuestType.FairyFeast);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BlastStove", DailyQuestType.BlastStove);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Kirin", DailyQuestType.Kirin);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyLand", DailyQuestType.FairyLand);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GuardSky", DailyQuestType.GuardSky);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Demon", DailyQuestType.Demon);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Trial", DailyQuestType.Trial);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AncientBattleGround", DailyQuestType.AncientBattleGround);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EmperorRelic", DailyQuestType.EmperorRelic);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WyTaiChi", DailyQuestType.WyTaiChi);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyLeague", DailyQuestType.FairyLeague);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HeavenBattle", DailyQuestType.HeavenBattle);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Prayer", DailyQuestType.Prayer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WorldBoss", DailyQuestType.WorldBoss);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DemonJar", DailyQuestType.DemonJar);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyTask", DailyQuestType.FairyTask);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneTowerSweep", DailyQuestType.RuneTowerSweep);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneTower", DailyQuestType.RuneTower);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureCollectSoul", DailyQuestType.TreasureCollectSoul);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BossHome", DailyQuestType.BossHome);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PersonalBoss", DailyQuestType.PersonalBoss);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ElderGodArea", DailyQuestType.ElderGodArea);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyGrabBoss", DailyQuestType.FairyGrabBoss);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KillMonster", DailyQuestType.KillMonster);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DungeonAssist", DailyQuestType.DungeonAssist);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GatherSoulDungeon", DailyQuestType.GatherSoulDungeon);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CrossServerPk", DailyQuestType.CrossServerPk);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AllianceBoss", DailyQuestType.AllianceBoss);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RidingPetActivity", DailyQuestType.RidingPetActivity);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HazyRegion", DailyQuestType.HazyRegion);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkyTower", DailyQuestType.SkyTower);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(DailyQuestType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushDailyQuestType(L, (DailyQuestType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "BountyMission"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.BountyMission);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "IceCrystal"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.IceCrystal);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyFeast"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.FairyFeast);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BlastStove"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.BlastStove);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Kirin"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.Kirin);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyLand"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.FairyLand);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "GuardSky"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.GuardSky);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Demon"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.Demon);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Trial"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.Trial);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AncientBattleGround"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.AncientBattleGround);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "EmperorRelic"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.EmperorRelic);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "WyTaiChi"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.WyTaiChi);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyLeague"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.FairyLeague);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "HeavenBattle"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.HeavenBattle);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Prayer"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.Prayer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "WorldBoss"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.WorldBoss);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DemonJar"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.DemonJar);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyTask"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.FairyTask);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneTowerSweep"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.RuneTowerSweep);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneTower"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.RuneTower);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureCollectSoul"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.TreasureCollectSoul);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BossHome"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.BossHome);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PersonalBoss"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.PersonalBoss);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ElderGodArea"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.ElderGodArea);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyGrabBoss"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.FairyGrabBoss);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "KillMonster"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.KillMonster);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DungeonAssist"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.DungeonAssist);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "GatherSoulDungeon"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.GatherSoulDungeon);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CrossServerPk"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.CrossServerPk);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AllianceBoss"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.AllianceBoss);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RidingPetActivity"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.RidingPetActivity);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "HazyRegion"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.HazyRegion);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SkyTower"))
+ {
+ translator.PushDailyQuestType(L, DailyQuestType.SkyTower);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for DailyQuestType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for DailyQuestType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class DungeonCoolDownTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(DungeonCoolDownType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(DungeonCoolDownType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(DungeonCoolDownType), L, null, 11, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LeaveMap", DungeonCoolDownType.LeaveMap);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WaitStart", DungeonCoolDownType.WaitStart);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FightStart", DungeonCoolDownType.FightStart);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FlagTake", DungeonCoolDownType.FlagTake);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NextRound", DungeonCoolDownType.NextRound);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FBAddTime", DungeonCoolDownType.FBAddTime);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ElderGodAreaDeadTime", DungeonCoolDownType.ElderGodAreaDeadTime);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PickUpTime", DungeonCoolDownType.PickUpTime);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WaitPlayer", DungeonCoolDownType.WaitPlayer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlayerLeave", DungeonCoolDownType.PlayerLeave);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(DungeonCoolDownType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushDungeonCoolDownType(L, (DungeonCoolDownType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "LeaveMap"))
+ {
+ translator.PushDungeonCoolDownType(L, DungeonCoolDownType.LeaveMap);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "WaitStart"))
+ {
+ translator.PushDungeonCoolDownType(L, DungeonCoolDownType.WaitStart);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FightStart"))
+ {
+ translator.PushDungeonCoolDownType(L, DungeonCoolDownType.FightStart);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FlagTake"))
+ {
+ translator.PushDungeonCoolDownType(L, DungeonCoolDownType.FlagTake);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NextRound"))
+ {
+ translator.PushDungeonCoolDownType(L, DungeonCoolDownType.NextRound);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FBAddTime"))
+ {
+ translator.PushDungeonCoolDownType(L, DungeonCoolDownType.FBAddTime);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ElderGodAreaDeadTime"))
+ {
+ translator.PushDungeonCoolDownType(L, DungeonCoolDownType.ElderGodAreaDeadTime);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PickUpTime"))
+ {
+ translator.PushDungeonCoolDownType(L, DungeonCoolDownType.PickUpTime);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "WaitPlayer"))
+ {
+ translator.PushDungeonCoolDownType(L, DungeonCoolDownType.WaitPlayer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PlayerLeave"))
+ {
+ translator.PushDungeonCoolDownType(L, DungeonCoolDownType.PlayerLeave);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for DungeonCoolDownType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for DungeonCoolDownType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class RoleEquipTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(RoleEquipType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(RoleEquipType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(RoleEquipType), L, null, 22, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Weapon", RoleEquipType.Weapon);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Weapon2", RoleEquipType.Weapon2);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Hat", RoleEquipType.Hat);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Clothes", RoleEquipType.Clothes);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Belt", RoleEquipType.Belt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Trousers", RoleEquipType.Trousers);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Shoes", RoleEquipType.Shoes);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Glove", RoleEquipType.Glove);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Neck", RoleEquipType.Neck);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyCan1", RoleEquipType.FairyCan1);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyCan2", RoleEquipType.FairyCan2);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Jade", RoleEquipType.Jade);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Wing", RoleEquipType.Wing);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Guard", RoleEquipType.Guard);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PeerlessWeapon1", RoleEquipType.PeerlessWeapon1);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PeerlessWeapon2", RoleEquipType.PeerlessWeapon2);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mount", RoleEquipType.Mount);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FashionWeapon", RoleEquipType.FashionWeapon);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FashionClothes", RoleEquipType.FashionClothes);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FashionWeapon2", RoleEquipType.FashionWeapon2);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "retMax", RoleEquipType.retMax);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(RoleEquipType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushRoleEquipType(L, (RoleEquipType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Weapon"))
+ {
+ translator.PushRoleEquipType(L, RoleEquipType.Weapon);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Weapon2"))
+ {
+ translator.PushRoleEquipType(L, RoleEquipType.Weapon2);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Hat"))
+ {
+ translator.PushRoleEquipType(L, RoleEquipType.Hat);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Clothes"))
+ {
+ translator.PushRoleEquipType(L, RoleEquipType.Clothes);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Belt"))
+ {
+ translator.PushRoleEquipType(L, RoleEquipType.Belt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Trousers"))
+ {
+ translator.PushRoleEquipType(L, RoleEquipType.Trousers);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Shoes"))
+ {
+ translator.PushRoleEquipType(L, RoleEquipType.Shoes);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Glove"))
+ {
+ translator.PushRoleEquipType(L, RoleEquipType.Glove);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Neck"))
+ {
+ translator.PushRoleEquipType(L, RoleEquipType.Neck);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyCan1"))
+ {
+ translator.PushRoleEquipType(L, RoleEquipType.FairyCan1);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyCan2"))
+ {
+ translator.PushRoleEquipType(L, RoleEquipType.FairyCan2);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Jade"))
+ {
+ translator.PushRoleEquipType(L, RoleEquipType.Jade);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Wing"))
+ {
+ translator.PushRoleEquipType(L, RoleEquipType.Wing);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Guard"))
+ {
+ translator.PushRoleEquipType(L, RoleEquipType.Guard);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PeerlessWeapon1"))
+ {
+ translator.PushRoleEquipType(L, RoleEquipType.PeerlessWeapon1);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PeerlessWeapon2"))
+ {
+ translator.PushRoleEquipType(L, RoleEquipType.PeerlessWeapon2);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Mount"))
+ {
+ translator.PushRoleEquipType(L, RoleEquipType.Mount);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FashionWeapon"))
+ {
+ translator.PushRoleEquipType(L, RoleEquipType.FashionWeapon);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FashionClothes"))
+ {
+ translator.PushRoleEquipType(L, RoleEquipType.FashionClothes);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FashionWeapon2"))
+ {
+ translator.PushRoleEquipType(L, RoleEquipType.FashionWeapon2);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "retMax"))
+ {
+ translator.PushRoleEquipType(L, RoleEquipType.retMax);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for RoleEquipType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for RoleEquipType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class PlayerDataTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(PlayerDataType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(PlayerDataType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(PlayerDataType), L, null, 213, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AccountID", PlayerDataType.AccountID);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlayerID", PlayerDataType.PlayerID);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlayerName", PlayerDataType.PlayerName);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Sex", PlayerDataType.Sex);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Hair", PlayerDataType.Hair);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HairColor", PlayerDataType.HairColor);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Face", PlayerDataType.Face);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Job", PlayerDataType.Job);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LV", PlayerDataType.LV);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TotalExp", PlayerDataType.TotalExp);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Family", PlayerDataType.Family);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Country", PlayerDataType.Country);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TeamHornor", PlayerDataType.TeamHornor);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PKValue", PlayerDataType.PKValue);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FamilyHornor", PlayerDataType.FamilyHornor);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FamilyActiveValue", PlayerDataType.FamilyActiveValue);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CountryHornor", PlayerDataType.CountryHornor);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mate", PlayerDataType.Mate);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Gold", PlayerDataType.Gold);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GoldPaper", PlayerDataType.GoldPaper);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Silver", PlayerDataType.Silver);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SilverPaper", PlayerDataType.SilverPaper);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FightPoint", PlayerDataType.FightPoint);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HappyPoint", PlayerDataType.HappyPoint);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MapID", PlayerDataType.MapID);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PosX", PlayerDataType.PosX);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PosY", PlayerDataType.PosY);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "State", PlayerDataType.State);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MaxHP", PlayerDataType.MaxHP);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HP", PlayerDataType.HP);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MaxMP", PlayerDataType.MaxMP);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MP", PlayerDataType.MP);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "XP", PlayerDataType.XP);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HPRestoreSetting", PlayerDataType.HPRestoreSetting);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MPRestoreSetting", PlayerDataType.MPRestoreSetting);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExpRate", PlayerDataType.ExpRate);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreePoint", PlayerDataType.FreePoint);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreeSkillPoint", PlayerDataType.FreeSkillPoint);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "STR", PlayerDataType.STR);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PNE", PlayerDataType.PNE);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PHY", PlayerDataType.PHY);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CON", PlayerDataType.CON);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DEF", PlayerDataType.DEF);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MINATK", PlayerDataType.MINATK);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MAXATK", PlayerDataType.MAXATK);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MAtkMin", PlayerDataType.MAtkMin);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MAtkMax", PlayerDataType.MAtkMax);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MDef", PlayerDataType.MDef);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HIT", PlayerDataType.HIT);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "POISIONATK", PlayerDataType.POISIONATK);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FIREATK", PlayerDataType.FIREATK);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "REALATK", PlayerDataType.REALATK);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "THUNDERATK", PlayerDataType.THUNDERATK);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WINDATK", PlayerDataType.WINDATK);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "POISIONDEF", PlayerDataType.POISIONDEF);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FIREDEF", PlayerDataType.FIREDEF);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "REALDEF", PlayerDataType.REALDEF);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "THUNDERDEF", PlayerDataType.THUNDERDEF);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WINDDEF", PlayerDataType.WINDDEF);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Miss", PlayerDataType.Miss);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SuperHit", PlayerDataType.SuperHit);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Buff", PlayerDataType.Buff);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Skill", PlayerDataType.Skill);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mark", PlayerDataType.Mark);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SettingH", PlayerDataType.SettingH);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SettingV", PlayerDataType.SettingV);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FightPK", PlayerDataType.FightPK);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ActiveValue", PlayerDataType.ActiveValue);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlayerType", PlayerDataType.PlayerType);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NameColor", PlayerDataType.NameColor);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AtkInterval", PlayerDataType.AtkInterval);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Speed", PlayerDataType.Speed);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SuperHitRate", PlayerDataType.SuperHitRate);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PickupDist", PlayerDataType.PickupDist);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CountryLastWeekHornor", PlayerDataType.CountryLastWeekHornor);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LastWeekOnlineTime", PlayerDataType.LastWeekOnlineTime);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LastWeekFamilyActiveValue", PlayerDataType.LastWeekFamilyActiveValue);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FBID", PlayerDataType.FBID);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FamilyLV", PlayerDataType.FamilyLV);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RealMapID", PlayerDataType.RealMapID);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GMLevel", PlayerDataType.GMLevel);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TeamID", PlayerDataType.TeamID);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TeamLV", PlayerDataType.TeamLV);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FightPower", PlayerDataType.FightPower);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RebornMapID", PlayerDataType.RebornMapID);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RebornPosX", PlayerDataType.RebornPosX);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RebornPosY", PlayerDataType.RebornPosY);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Coin", PlayerDataType.Coin);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BillboardLV", PlayerDataType.BillboardLV);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Tick", PlayerDataType.Tick);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CurrentPlayerType", PlayerDataType.CurrentPlayerType);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FriendFavor", PlayerDataType.FriendFavor);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BackpackLV", PlayerDataType.BackpackLV);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReincarnationLV", PlayerDataType.ReincarnationLV);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BaseSTR", PlayerDataType.BaseSTR);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BasePNE", PlayerDataType.BasePNE);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BasePHY", PlayerDataType.BasePHY);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BaseCON", PlayerDataType.BaseCON);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReceivedSalary", PlayerDataType.ReceivedSalary);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WarehouseLV", PlayerDataType.WarehouseLV);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipShowSwitch", PlayerDataType.EquipShowSwitch);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LuckValue", PlayerDataType.LuckValue);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr1", PlayerDataType.ExAttr1);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr2", PlayerDataType.ExAttr2);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr3", PlayerDataType.ExAttr3);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr4", PlayerDataType.ExAttr4);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr5", PlayerDataType.ExAttr5);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Faction", PlayerDataType.Faction);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "InfamyValue", PlayerDataType.InfamyValue);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RealmLevel", PlayerDataType.RealmLevel);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IsFindByLabel", PlayerDataType.IsFindByLabel);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IsCloseFriendLabel", PlayerDataType.IsCloseFriendLabel);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ChangeCoinPointTotal", PlayerDataType.ChangeCoinPointTotal);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VIPLv", PlayerDataType.VIPLv);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr6", PlayerDataType.ExAttr6);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr7", PlayerDataType.ExAttr7);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr8", PlayerDataType.ExAttr8);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr9", PlayerDataType.ExAttr9);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr10", PlayerDataType.ExAttr10);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ModelMark", PlayerDataType.ModelMark);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PrizeCoin", PlayerDataType.PrizeCoin);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr11", PlayerDataType.ExAttr11);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr12", PlayerDataType.ExAttr12);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr13", PlayerDataType.ExAttr13);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExAttr14", PlayerDataType.ExAttr14);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillAtkRate", PlayerDataType.SkillAtkRate);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LuckyHitRate", PlayerDataType.LuckyHitRate);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LuckyHitVal", PlayerDataType.LuckyHitVal);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GreatHitRate", PlayerDataType.GreatHitRate);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GreatHitVal", PlayerDataType.GreatHitVal);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KillBackHP", PlayerDataType.KillBackHP);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KillBackMP", PlayerDataType.KillBackMP);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DamageReduceRate", PlayerDataType.DamageReduceRate);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DamageBackRate", PlayerDataType.DamageBackRate);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GoldFoundRate", PlayerDataType.GoldFoundRate);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IgnoreDefRate", PlayerDataType.IgnoreDefRate);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BattleValEx1", PlayerDataType.BattleValEx1);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BattleValEx2", PlayerDataType.BattleValEx2);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BattleValEx3", PlayerDataType.BattleValEx3);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BattleValEx4", PlayerDataType.BattleValEx4);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BattleValEx5", PlayerDataType.BattleValEx5);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HPRestorePer", PlayerDataType.HPRestorePer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LVEx", PlayerDataType.LVEx);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LV2", PlayerDataType.LV2);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExpPoint", PlayerDataType.ExpPoint);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OperateInfo", PlayerDataType.OperateInfo);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SuperHitReduce", PlayerDataType.SuperHitReduce);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LuckyHitRateReduce", PlayerDataType.LuckyHitRateReduce);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillAtkRateReduce", PlayerDataType.SkillAtkRateReduce);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DamagePVP", PlayerDataType.DamagePVP);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SpeedValue", PlayerDataType.SpeedValue);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DamagePVE", PlayerDataType.DamagePVE);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetDamPer", PlayerDataType.PetDamPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IgnoreDefRateReduce", PlayerDataType.IgnoreDefRateReduce);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DamChanceDef", PlayerDataType.DamChanceDef);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BleedDamage", PlayerDataType.BleedDamage);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FaintRate", PlayerDataType.FaintRate);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FaintDefRate", PlayerDataType.FaintDefRate);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FinalHurt", PlayerDataType.FinalHurt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FinalHurtReduce", PlayerDataType.FinalHurtReduce);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DamagePerPVP", PlayerDataType.DamagePerPVP);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DamagePerPVPReduce", PlayerDataType.DamagePerPVPReduce);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ComboDamRate", PlayerDataType.ComboDamRate);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ComboDamPer", PlayerDataType.ComboDamPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MaxProDef", PlayerDataType.MaxProDef);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FamilyContribution", PlayerDataType.FamilyContribution);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FamilyStoreScore", PlayerDataType.FamilyStoreScore);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneSplinters", PlayerDataType.RuneSplinters);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Rune", PlayerDataType.Rune);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RealmPoint", PlayerDataType.RealmPoint);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MagicEssence", PlayerDataType.MagicEssence);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnionLiven", PlayerDataType.UnionLiven);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FBHelpPoint", PlayerDataType.FBHelpPoint);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlayerPKState", PlayerDataType.PlayerPKState);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IsAttackBossState", PlayerDataType.IsAttackBossState);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BasicsMinimum", PlayerDataType.BasicsMinimum);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BasicsMaxAttack", PlayerDataType.BasicsMaxAttack);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BasicsLife", PlayerDataType.BasicsLife);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BasicsDefense", PlayerDataType.BasicsDefense);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BasicsScoreAHit", PlayerDataType.BasicsScoreAHit);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BasicsDodge", PlayerDataType.BasicsDodge);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OnlyFinalHurt", PlayerDataType.OnlyFinalHurt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_ForbidenTalk", PlayerDataType.CDBPlayerRefresh_ForbidenTalk);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_FuncDef", PlayerDataType.CDBPlayerRefresh_FuncDef);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_TreasureScore", PlayerDataType.CDBPlayerRefresh_TreasureScore);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_Danjing", PlayerDataType.CDBPlayerRefresh_Danjing);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_NPCHurtAddPer", PlayerDataType.CDBPlayerRefresh_NPCHurtAddPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FunalHurtPer", PlayerDataType.FunalHurtPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_TalentPoint", PlayerDataType.CDBPlayerRefresh_TalentPoint);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_GodWeaponLV_1", PlayerDataType.CDBPlayerRefresh_GodWeaponLV_1);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_GodWeaponLV_2", PlayerDataType.CDBPlayerRefresh_GodWeaponLV_2);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_GodWeaponLV_3", PlayerDataType.CDBPlayerRefresh_GodWeaponLV_3);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_GodWeaponLV_4", PlayerDataType.CDBPlayerRefresh_GodWeaponLV_4);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_SoulDust", PlayerDataType.CDBPlayerRefresh_SoulDust);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_SoulSplinters", PlayerDataType.CDBPlayerRefresh_SoulSplinters);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_SoulCore", PlayerDataType.CDBPlayerRefresh_SoulCore);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_Honor", PlayerDataType.CDBPlayerRefresh_Honor);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_ZhuxianRate", PlayerDataType.CDBPlayerRefresh_ZhuxianRate);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_Mater", PlayerDataType.CDBPlayerRefresh_Mater);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_Wood", PlayerDataType.CDBPlayerRefresh_Wood);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_Water", PlayerDataType.CDBPlayerRefresh_Water);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_Fire", PlayerDataType.CDBPlayerRefresh_Fire);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_Earth", PlayerDataType.CDBPlayerRefresh_Earth);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_NormalHurt", PlayerDataType.CDBPlayerRefresh_NormalHurt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_NormalHurtPer", PlayerDataType.CDBPlayerRefresh_NormalHurtPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_FabaoHurt", PlayerDataType.CDBPlayerRefresh_FabaoHurt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_FabaoHurtPer", PlayerDataType.CDBPlayerRefresh_FabaoHurtPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_SuperHitRateReduce", PlayerDataType.CDBPlayerRefresh_SuperHitRateReduce);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_LuckyHitReduce", PlayerDataType.CDBPlayerRefresh_LuckyHitReduce);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_FinalHurtReducePer", PlayerDataType.CDBPlayerRefresh_FinalHurtReducePer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_YinjiTime", PlayerDataType.CDBPlayerRefresh_YinjiTime);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CDBPlayerRefresh_YinjiCount", PlayerDataType.CDBPlayerRefresh_YinjiCount);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(PlayerDataType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushPlayerDataType(L, (PlayerDataType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "AccountID"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.AccountID);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PlayerID"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.PlayerID);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PlayerName"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.PlayerName);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Sex"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.Sex);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Hair"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.Hair);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "HairColor"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.HairColor);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Face"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.Face);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Job"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.Job);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "LV"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.LV);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "TotalExp"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.TotalExp);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Family"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.Family);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Country"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.Country);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "TeamHornor"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.TeamHornor);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PKValue"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.PKValue);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FamilyHornor"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.FamilyHornor);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FamilyActiveValue"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.FamilyActiveValue);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CountryHornor"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CountryHornor);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Mate"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.Mate);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Gold"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.Gold);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "GoldPaper"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.GoldPaper);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Silver"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.Silver);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SilverPaper"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.SilverPaper);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FightPoint"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.FightPoint);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "HappyPoint"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.HappyPoint);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MapID"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.MapID);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PosX"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.PosX);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PosY"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.PosY);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "State"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.State);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MaxHP"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.MaxHP);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "HP"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.HP);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MaxMP"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.MaxMP);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MP"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.MP);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "XP"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.XP);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "HPRestoreSetting"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.HPRestoreSetting);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MPRestoreSetting"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.MPRestoreSetting);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ExpRate"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.ExpRate);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FreePoint"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.FreePoint);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FreeSkillPoint"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.FreeSkillPoint);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "STR"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.STR);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PNE"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.PNE);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PHY"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.PHY);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CON"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CON);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DEF"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.DEF);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MINATK"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.MINATK);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MAXATK"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.MAXATK);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MAtkMin"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.MAtkMin);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MAtkMax"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.MAtkMax);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MDef"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.MDef);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "HIT"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.HIT);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "POISIONATK"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.POISIONATK);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FIREATK"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.FIREATK);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "REALATK"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.REALATK);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "THUNDERATK"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.THUNDERATK);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "WINDATK"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.WINDATK);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "POISIONDEF"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.POISIONDEF);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FIREDEF"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.FIREDEF);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "REALDEF"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.REALDEF);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "THUNDERDEF"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.THUNDERDEF);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "WINDDEF"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.WINDDEF);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Miss"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.Miss);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SuperHit"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.SuperHit);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Buff"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.Buff);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Skill"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.Skill);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Mark"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.Mark);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SettingH"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.SettingH);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SettingV"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.SettingV);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FightPK"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.FightPK);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ActiveValue"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.ActiveValue);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PlayerType"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.PlayerType);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NameColor"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.NameColor);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AtkInterval"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.AtkInterval);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Speed"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.Speed);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SuperHitRate"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.SuperHitRate);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PickupDist"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.PickupDist);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CountryLastWeekHornor"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CountryLastWeekHornor);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "LastWeekOnlineTime"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.LastWeekOnlineTime);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "LastWeekFamilyActiveValue"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.LastWeekFamilyActiveValue);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FBID"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.FBID);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FamilyLV"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.FamilyLV);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RealMapID"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.RealMapID);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "GMLevel"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.GMLevel);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "TeamID"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.TeamID);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "TeamLV"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.TeamLV);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FightPower"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.FightPower);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RebornMapID"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.RebornMapID);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RebornPosX"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.RebornPosX);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RebornPosY"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.RebornPosY);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Coin"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.Coin);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BillboardLV"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.BillboardLV);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Tick"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.Tick);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CurrentPlayerType"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CurrentPlayerType);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FriendFavor"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.FriendFavor);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BackpackLV"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.BackpackLV);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ReincarnationLV"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.ReincarnationLV);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BaseSTR"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.BaseSTR);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BasePNE"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.BasePNE);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BasePHY"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.BasePHY);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BaseCON"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.BaseCON);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ReceivedSalary"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.ReceivedSalary);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "WarehouseLV"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.WarehouseLV);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipShowSwitch"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.EquipShowSwitch);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "LuckValue"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.LuckValue);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr1"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.ExAttr1);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr2"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.ExAttr2);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr3"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.ExAttr3);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr4"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.ExAttr4);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr5"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.ExAttr5);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Faction"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.Faction);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "InfamyValue"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.InfamyValue);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RealmLevel"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.RealmLevel);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "IsFindByLabel"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.IsFindByLabel);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "IsCloseFriendLabel"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.IsCloseFriendLabel);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ChangeCoinPointTotal"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.ChangeCoinPointTotal);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "VIPLv"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.VIPLv);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr6"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.ExAttr6);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr7"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.ExAttr7);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr8"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.ExAttr8);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr9"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.ExAttr9);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr10"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.ExAttr10);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ModelMark"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.ModelMark);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PrizeCoin"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.PrizeCoin);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr11"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.ExAttr11);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr12"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.ExAttr12);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr13"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.ExAttr13);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ExAttr14"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.ExAttr14);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillAtkRate"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.SkillAtkRate);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "LuckyHitRate"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.LuckyHitRate);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "LuckyHitVal"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.LuckyHitVal);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "GreatHitRate"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.GreatHitRate);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "GreatHitVal"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.GreatHitVal);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "KillBackHP"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.KillBackHP);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "KillBackMP"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.KillBackMP);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DamageReduceRate"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.DamageReduceRate);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DamageBackRate"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.DamageBackRate);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "GoldFoundRate"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.GoldFoundRate);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "IgnoreDefRate"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.IgnoreDefRate);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BattleValEx1"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.BattleValEx1);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BattleValEx2"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.BattleValEx2);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BattleValEx3"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.BattleValEx3);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BattleValEx4"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.BattleValEx4);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BattleValEx5"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.BattleValEx5);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "HPRestorePer"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.HPRestorePer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "LVEx"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.LVEx);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "LV2"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.LV2);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ExpPoint"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.ExpPoint);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "OperateInfo"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.OperateInfo);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SuperHitReduce"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.SuperHitReduce);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "LuckyHitRateReduce"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.LuckyHitRateReduce);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillAtkRateReduce"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.SkillAtkRateReduce);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DamagePVP"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.DamagePVP);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SpeedValue"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.SpeedValue);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DamagePVE"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.DamagePVE);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PetDamPer"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.PetDamPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "IgnoreDefRateReduce"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.IgnoreDefRateReduce);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DamChanceDef"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.DamChanceDef);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BleedDamage"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.BleedDamage);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FaintRate"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.FaintRate);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FaintDefRate"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.FaintDefRate);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FinalHurt"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.FinalHurt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FinalHurtReduce"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.FinalHurtReduce);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DamagePerPVP"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.DamagePerPVP);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DamagePerPVPReduce"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.DamagePerPVPReduce);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ComboDamRate"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.ComboDamRate);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ComboDamPer"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.ComboDamPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MaxProDef"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.MaxProDef);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FamilyContribution"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.FamilyContribution);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FamilyStoreScore"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.FamilyStoreScore);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneSplinters"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.RuneSplinters);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Rune"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.Rune);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RealmPoint"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.RealmPoint);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MagicEssence"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.MagicEssence);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "UnionLiven"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.UnionLiven);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FBHelpPoint"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.FBHelpPoint);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PlayerPKState"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.PlayerPKState);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "IsAttackBossState"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.IsAttackBossState);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BasicsMinimum"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.BasicsMinimum);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BasicsMaxAttack"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.BasicsMaxAttack);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BasicsLife"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.BasicsLife);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BasicsDefense"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.BasicsDefense);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BasicsScoreAHit"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.BasicsScoreAHit);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BasicsDodge"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.BasicsDodge);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "OnlyFinalHurt"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.OnlyFinalHurt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_ForbidenTalk"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_ForbidenTalk);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_FuncDef"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_FuncDef);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_TreasureScore"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_TreasureScore);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_Danjing"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_Danjing);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_NPCHurtAddPer"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_NPCHurtAddPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FunalHurtPer"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.FunalHurtPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_TalentPoint"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_TalentPoint);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_GodWeaponLV_1"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_GodWeaponLV_1);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_GodWeaponLV_2"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_GodWeaponLV_2);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_GodWeaponLV_3"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_GodWeaponLV_3);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_GodWeaponLV_4"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_GodWeaponLV_4);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_SoulDust"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_SoulDust);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_SoulSplinters"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_SoulSplinters);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_SoulCore"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_SoulCore);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_Honor"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_Honor);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_ZhuxianRate"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_ZhuxianRate);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_Mater"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_Mater);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_Wood"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_Wood);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_Water"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_Water);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_Fire"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_Fire);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_Earth"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_Earth);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_NormalHurt"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_NormalHurt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_NormalHurtPer"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_NormalHurtPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_FabaoHurt"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_FabaoHurt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_FabaoHurtPer"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_FabaoHurtPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_SuperHitRateReduce"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_SuperHitRateReduce);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_LuckyHitReduce"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_LuckyHitReduce);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_FinalHurtReducePer"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_FinalHurtReducePer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_YinjiTime"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_YinjiTime);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CDBPlayerRefresh_YinjiCount"))
+ {
+ translator.PushPlayerDataType(L, PlayerDataType.CDBPlayerRefresh_YinjiCount);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for PlayerDataType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for PlayerDataType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class PackTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(PackType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(PackType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(PackType), L, null, 14, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Deleted", PackType.Deleted);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip", PackType.Equip);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Item", PackType.Item);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Warehouse", PackType.Warehouse);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Horse", PackType.Horse);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AnyWhere", PackType.AnyWhere);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "InterimPack", PackType.InterimPack);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Treasure", PackType.Treasure);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetPack", PackType.PetPack);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DogzItem", PackType.DogzItem);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DogzEquip", PackType.DogzEquip);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GatherSoul", PackType.GatherSoul);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RunePack", PackType.RunePack);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(PackType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushPackType(L, (PackType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Deleted"))
+ {
+ translator.PushPackType(L, PackType.Deleted);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip"))
+ {
+ translator.PushPackType(L, PackType.Equip);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Item"))
+ {
+ translator.PushPackType(L, PackType.Item);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Warehouse"))
+ {
+ translator.PushPackType(L, PackType.Warehouse);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Horse"))
+ {
+ translator.PushPackType(L, PackType.Horse);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AnyWhere"))
+ {
+ translator.PushPackType(L, PackType.AnyWhere);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "InterimPack"))
+ {
+ translator.PushPackType(L, PackType.InterimPack);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Treasure"))
+ {
+ translator.PushPackType(L, PackType.Treasure);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PetPack"))
+ {
+ translator.PushPackType(L, PackType.PetPack);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DogzItem"))
+ {
+ translator.PushPackType(L, PackType.DogzItem);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DogzEquip"))
+ {
+ translator.PushPackType(L, PackType.DogzEquip);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "GatherSoul"))
+ {
+ translator.PushPackType(L, PackType.GatherSoul);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RunePack"))
+ {
+ translator.PushPackType(L, PackType.RunePack);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for PackType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for PackType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class ItemTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(ItemType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(ItemType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(ItemType), L, null, 25, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Copper", ItemType.Copper);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Drugs", ItemType.Drugs);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Buff", ItemType.Buff);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Gemstone", ItemType.Gemstone);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ComposeSuitStone", ItemType.ComposeSuitStone);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WingsMat", ItemType.WingsMat);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DropCopper", ItemType.DropCopper);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VipTools", ItemType.VipTools);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Box", ItemType.Box);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_Weapon", ItemType.Equip_Weapon);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_Weapon2", ItemType.Equip_Weapon2);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_Hat", ItemType.Equip_Hat);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_Clothes", ItemType.Equip_Clothes);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_Belt", ItemType.Equip_Belt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_Trousers", ItemType.Equip_Trousers);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_Shoes", ItemType.Equip_Shoes);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_Glove", ItemType.Equip_Glove);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_Neck", ItemType.Equip_Neck);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_FairyCan1", ItemType.Equip_FairyCan1);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_FairyCan2", ItemType.Equip_FairyCan2);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_Jade", ItemType.Equip_Jade);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip_Wing", ItemType.Equip_Wing);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Guard_1", ItemType.Guard_1);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Guard_2", ItemType.Guard_2);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(ItemType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushItemType(L, (ItemType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Copper"))
+ {
+ translator.PushItemType(L, ItemType.Copper);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Drugs"))
+ {
+ translator.PushItemType(L, ItemType.Drugs);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Buff"))
+ {
+ translator.PushItemType(L, ItemType.Buff);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Gemstone"))
+ {
+ translator.PushItemType(L, ItemType.Gemstone);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ComposeSuitStone"))
+ {
+ translator.PushItemType(L, ItemType.ComposeSuitStone);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "WingsMat"))
+ {
+ translator.PushItemType(L, ItemType.WingsMat);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DropCopper"))
+ {
+ translator.PushItemType(L, ItemType.DropCopper);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "VipTools"))
+ {
+ translator.PushItemType(L, ItemType.VipTools);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Box"))
+ {
+ translator.PushItemType(L, ItemType.Box);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_Weapon"))
+ {
+ translator.PushItemType(L, ItemType.Equip_Weapon);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_Weapon2"))
+ {
+ translator.PushItemType(L, ItemType.Equip_Weapon2);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_Hat"))
+ {
+ translator.PushItemType(L, ItemType.Equip_Hat);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_Clothes"))
+ {
+ translator.PushItemType(L, ItemType.Equip_Clothes);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_Belt"))
+ {
+ translator.PushItemType(L, ItemType.Equip_Belt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_Trousers"))
+ {
+ translator.PushItemType(L, ItemType.Equip_Trousers);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_Shoes"))
+ {
+ translator.PushItemType(L, ItemType.Equip_Shoes);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_Glove"))
+ {
+ translator.PushItemType(L, ItemType.Equip_Glove);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_Neck"))
+ {
+ translator.PushItemType(L, ItemType.Equip_Neck);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_FairyCan1"))
+ {
+ translator.PushItemType(L, ItemType.Equip_FairyCan1);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_FairyCan2"))
+ {
+ translator.PushItemType(L, ItemType.Equip_FairyCan2);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_Jade"))
+ {
+ translator.PushItemType(L, ItemType.Equip_Jade);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip_Wing"))
+ {
+ translator.PushItemType(L, ItemType.Equip_Wing);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Guard_1"))
+ {
+ translator.PushItemType(L, ItemType.Guard_1);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Guard_2"))
+ {
+ translator.PushItemType(L, ItemType.Guard_2);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for ItemType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for ItemType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class MakeTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(MakeType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(MakeType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(MakeType), L, null, 10, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OneKeySell", MakeType.OneKeySell);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipStarUpgrade", MakeType.EquipStarUpgrade);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ItemCompound", MakeType.ItemCompound);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DrugRefine", MakeType.DrugRefine);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DrugRecycle", MakeType.DrugRecycle);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DogzEquipPlus", MakeType.DogzEquipPlus);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneCompound", MakeType.RuneCompound);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GatherSoulCompound", MakeType.GatherSoulCompound);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GatherSoulDecompose", MakeType.GatherSoulDecompose);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(MakeType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushMakeType(L, (MakeType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "OneKeySell"))
+ {
+ translator.PushMakeType(L, MakeType.OneKeySell);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipStarUpgrade"))
+ {
+ translator.PushMakeType(L, MakeType.EquipStarUpgrade);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ItemCompound"))
+ {
+ translator.PushMakeType(L, MakeType.ItemCompound);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DrugRefine"))
+ {
+ translator.PushMakeType(L, MakeType.DrugRefine);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DrugRecycle"))
+ {
+ translator.PushMakeType(L, MakeType.DrugRecycle);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DogzEquipPlus"))
+ {
+ translator.PushMakeType(L, MakeType.DogzEquipPlus);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneCompound"))
+ {
+ translator.PushMakeType(L, MakeType.RuneCompound);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "GatherSoulCompound"))
+ {
+ translator.PushMakeType(L, MakeType.GatherSoulCompound);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "GatherSoulDecompose"))
+ {
+ translator.PushMakeType(L, MakeType.GatherSoulDecompose);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for MakeType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for MakeType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class TitleTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(TitleType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(TitleType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(TitleType), L, null, 6, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", TitleType.None);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Get", TitleType.Get);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Activity", TitleType.Activity);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Vip", TitleType.Vip);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Achivement", TitleType.Achivement);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(TitleType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushTitleType(L, (TitleType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
+ {
+ translator.PushTitleType(L, TitleType.None);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Get"))
+ {
+ translator.PushTitleType(L, TitleType.Get);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Activity"))
+ {
+ translator.PushTitleType(L, TitleType.Activity);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Vip"))
+ {
+ translator.PushTitleType(L, TitleType.Vip);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Achivement"))
+ {
+ translator.PushTitleType(L, TitleType.Achivement);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for TitleType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for TitleType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class FuncOpenEnumWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(FuncOpenEnum), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(FuncOpenEnum), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(FuncOpenEnum), L, null, 59, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Strength", FuncOpenEnum.Strength);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Gem", FuncOpenEnum.Gem);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Wing", FuncOpenEnum.Wing);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pet", FuncOpenEnum.Pet);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Treasure", FuncOpenEnum.Treasure);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mounts", FuncOpenEnum.Mounts);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Rune", FuncOpenEnum.Rune);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Realm", FuncOpenEnum.Realm);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fairy", FuncOpenEnum.Fairy);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyTask", FuncOpenEnum.FairyTask);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GodWeapon", FuncOpenEnum.GodWeapon);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SelfBoss", FuncOpenEnum.SelfBoss);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Title", FuncOpenEnum.Title);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Talent", FuncOpenEnum.Talent);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Suit", FuncOpenEnum.Suit);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExpPray", FuncOpenEnum.ExpPray);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CoinPray", FuncOpenEnum.CoinPray);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WorldLv", FuncOpenEnum.WorldLv);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Rank", FuncOpenEnum.Rank);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Friend", FuncOpenEnum.Friend);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TouchSky", FuncOpenEnum.TouchSky);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Compose", FuncOpenEnum.Compose);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HuntTreasure", FuncOpenEnum.HuntTreasure);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Market", FuncOpenEnum.Market);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DayDaily", FuncOpenEnum.DayDaily);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Store", FuncOpenEnum.Store);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneTower", FuncOpenEnum.RuneTower);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SignIn", FuncOpenEnum.SignIn);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Potential", FuncOpenEnum.Potential);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IceCrystal", FuncOpenEnum.IceCrystal);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyFest", FuncOpenEnum.FairyFest);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Kylin", FuncOpenEnum.Kylin);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyLand", FuncOpenEnum.FairyLand);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BlastFurnace", FuncOpenEnum.BlastFurnace);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Munekado", FuncOpenEnum.Munekado);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GuardSky", FuncOpenEnum.GuardSky);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WingRefine", FuncOpenEnum.WingRefine);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipRefine", FuncOpenEnum.EquipRefine);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ElderGods", FuncOpenEnum.ElderGods);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipCompose", FuncOpenEnum.EquipCompose);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Guard", FuncOpenEnum.Guard);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillTreasure", FuncOpenEnum.SkillTreasure);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WingCompose", FuncOpenEnum.WingCompose);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Demon", FuncOpenEnum.Demon);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HappyFindTreasure", FuncOpenEnum.HappyFindTreasure);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FightPromote", FuncOpenEnum.FightPromote);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AncientBattleGround", FuncOpenEnum.AncientBattleGround);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Chat", FuncOpenEnum.Chat);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyLeague", FuncOpenEnum.FairyLeague);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Recharge", FuncOpenEnum.Recharge);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerRedEnvelope", FuncOpenEnum.OpenServerRedEnvelope);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipDecompose", FuncOpenEnum.EquipDecompose);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureFindHost", FuncOpenEnum.TreasureFindHost);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Dogz", FuncOpenEnum.Dogz);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReikiRoot", FuncOpenEnum.ReikiRoot);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CrossServer", FuncOpenEnum.CrossServer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CrossServerBoss", FuncOpenEnum.CrossServerBoss);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HazyRegion", FuncOpenEnum.HazyRegion);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(FuncOpenEnum), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushFuncOpenEnum(L, (FuncOpenEnum)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Strength"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Strength);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Gem"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Gem);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Wing"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Wing);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Pet"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Pet);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Treasure"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Treasure);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Mounts"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Mounts);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Rune"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Rune);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Realm"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Realm);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Fairy"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Fairy);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyTask"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.FairyTask);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "GodWeapon"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.GodWeapon);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SelfBoss"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.SelfBoss);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Title"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Title);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Talent"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Talent);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Suit"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Suit);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ExpPray"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.ExpPray);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CoinPray"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.CoinPray);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "WorldLv"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.WorldLv);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Rank"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Rank);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Friend"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Friend);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "TouchSky"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.TouchSky);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Compose"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Compose);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "HuntTreasure"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.HuntTreasure);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Market"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Market);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DayDaily"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.DayDaily);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Store"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Store);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneTower"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.RuneTower);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SignIn"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.SignIn);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Potential"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Potential);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "IceCrystal"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.IceCrystal);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyFest"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.FairyFest);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Kylin"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Kylin);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyLand"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.FairyLand);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BlastFurnace"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.BlastFurnace);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Munekado"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Munekado);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "GuardSky"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.GuardSky);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "WingRefine"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.WingRefine);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipRefine"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.EquipRefine);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ElderGods"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.ElderGods);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipCompose"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.EquipCompose);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Guard"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Guard);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillTreasure"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.SkillTreasure);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "WingCompose"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.WingCompose);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Demon"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Demon);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "HappyFindTreasure"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.HappyFindTreasure);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FightPromote"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.FightPromote);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AncientBattleGround"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.AncientBattleGround);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Chat"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Chat);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyLeague"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.FairyLeague);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Recharge"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Recharge);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerRedEnvelope"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.OpenServerRedEnvelope);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipDecompose"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.EquipDecompose);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureFindHost"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.TreasureFindHost);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Dogz"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.Dogz);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ReikiRoot"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.ReikiRoot);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CrossServer"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.CrossServer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CrossServerBoss"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.CrossServerBoss);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "HazyRegion"))
+ {
+ translator.PushFuncOpenEnum(L, FuncOpenEnum.HazyRegion);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for FuncOpenEnum!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for FuncOpenEnum! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class PropertyTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(PropertyType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(PropertyType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(PropertyType), L, null, 126, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LV", PropertyType.LV);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "POWER", PropertyType.POWER);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AGILITY", PropertyType.AGILITY);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PHYSIQUE", PropertyType.PHYSIQUE);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MENTALITY", PropertyType.MENTALITY);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HP", PropertyType.HP);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ATK", PropertyType.ATK);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DEF", PropertyType.DEF);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HIT", PropertyType.HIT);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MISS", PropertyType.MISS);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ATKSPEED", PropertyType.ATKSPEED);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CritChance", PropertyType.CritChance);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CritHurt", PropertyType.CritHurt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CritResis", PropertyType.CritResis);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HeartHit", PropertyType.HeartHit);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HeartHurt", PropertyType.HeartHurt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HeartResis", PropertyType.HeartResis);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillHurt", PropertyType.SkillHurt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PVPAddHurt", PropertyType.PVPAddHurt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PVPReduceHurt", PropertyType.PVPReduceHurt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LifeReply", PropertyType.LifeReply);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HurtReflect", PropertyType.HurtReflect);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MoveSpeed", PropertyType.MoveSpeed);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetHurt", PropertyType.PetHurt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetAddHurt", PropertyType.PetAddHurt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RealHurt", PropertyType.RealHurt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RealResis", PropertyType.RealResis);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DefyDef", PropertyType.DefyDef);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DefyDefResis", PropertyType.DefyDefResis);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DefChance", PropertyType.DefChance);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BloodHurt", PropertyType.BloodHurt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AktReplyBlood", PropertyType.AktReplyBlood);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Stun", PropertyType.Stun);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CtrlResis", PropertyType.CtrlResis);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AddFinalHurt", PropertyType.AddFinalHurt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReduceFinalHurt", PropertyType.ReduceFinalHurt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PVPAddHurtPer", PropertyType.PVPAddHurtPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PVPReduceHurtPer", PropertyType.PVPReduceHurtPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DleHitChance", PropertyType.DleHitChance);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DleHurt", PropertyType.DleHurt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BasicAtkPercent", PropertyType.BasicAtkPercent);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BasicHpPercent", PropertyType.BasicHpPercent);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BasicDefPercent", PropertyType.BasicDefPercent);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HitPercent", PropertyType.HitPercent);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DodgePercent", PropertyType.DodgePercent);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KillMonsExpPercent", PropertyType.KillMonsExpPercent);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HorcruxBasicAttrPercent", PropertyType.HorcruxBasicAttrPercent);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReduceSkillHurtPercent", PropertyType.ReduceSkillHurtPercent);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HpPercent", PropertyType.HpPercent);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AtkPercent", PropertyType.AtkPercent);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EveryLvAddAtk", PropertyType.EveryLvAddAtk);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EveryLvAddHp", PropertyType.EveryLvAddHp);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AddEquipDropPrecent", PropertyType.AddEquipDropPrecent);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AddCoinsPrecent", PropertyType.AddCoinsPrecent);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AddRealHurtPer", PropertyType.AddRealHurtPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReduceRealHurtPer", PropertyType.ReduceRealHurtPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ArmorMaxHPPer", PropertyType.ArmorMaxHPPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WeaponAtkPer", PropertyType.WeaponAtkPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ArmorDefPer", PropertyType.ArmorDefPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MinAtk", PropertyType.MinAtk);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MaxAtk", PropertyType.MaxAtk);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DefencePercent", PropertyType.DefencePercent);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CritHurtPercent", PropertyType.CritHurtPercent);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MoveSpeedPercent", PropertyType.MoveSpeedPercent);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MaxProDef", PropertyType.MaxProDef);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ProDefHPPer", PropertyType.ProDefHPPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ProDefAbsorb", PropertyType.ProDefAbsorb);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BaseHitPer", PropertyType.BaseHitPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BaseMissPer", PropertyType.BaseMissPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetMinAtk", PropertyType.PetMinAtk);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetMaxAtk", PropertyType.PetMaxAtk);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OnlyFinalHurt", PropertyType.OnlyFinalHurt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PVPAtkBackHP", PropertyType.PVPAtkBackHP);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ChanceExpRate", PropertyType.ChanceExpRate);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HorseAtkPer", PropertyType.HorseAtkPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StoneBasePer", PropertyType.StoneBasePer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RealmBasePer", PropertyType.RealmBasePer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetSkillAtkRate", PropertyType.PetSkillAtkRate);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WingHPPer", PropertyType.WingHPPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SuiteBasePer", PropertyType.SuiteBasePer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PlusBaseAtkPer", PropertyType.PlusBaseAtkPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcHurtAddPer", PropertyType.NpcHurtAddPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JobAHurtAddPer", PropertyType.JobAHurtAddPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JobBHurtAddPer", PropertyType.JobBHurtAddPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JobCHurtAddPer", PropertyType.JobCHurtAddPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JobAAtkReducePer", PropertyType.JobAAtkReducePer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JobBAtkReducePer", PropertyType.JobBAtkReducePer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JobCAtkReducePer", PropertyType.JobCAtkReducePer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ZXCloakAttrPer", PropertyType.ZXCloakAttrPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ZXMaskAttrPer", PropertyType.ZXMaskAttrPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ZXGloveAttrPer", PropertyType.ZXGloveAttrPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ZXRuyiAttrPer", PropertyType.ZXRuyiAttrPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ZXPendantAttrPer", PropertyType.ZXPendantAttrPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ZXRingAttrPer", PropertyType.ZXRingAttrPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillAddPerA", PropertyType.SkillAddPerA);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillAddPerB", PropertyType.SkillAddPerB);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillAddPerC", PropertyType.SkillAddPerC);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillAddPerD", PropertyType.SkillAddPerD);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillAddPerE", PropertyType.SkillAddPerE);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillAddPerF", PropertyType.SkillAddPerF);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillAddPerG", PropertyType.SkillAddPerG);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillReducePerA", PropertyType.SkillReducePerA);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillReducePerB", PropertyType.SkillReducePerB);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillReducePerC", PropertyType.SkillReducePerC);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillReducePerD", PropertyType.SkillReducePerD);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillReducePerE", PropertyType.SkillReducePerE);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillReducePerF", PropertyType.SkillReducePerF);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillReducePerG", PropertyType.SkillReducePerG);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Luck", PropertyType.Luck);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LuckPer", PropertyType.LuckPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AddNormalHurt", PropertyType.AddNormalHurt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AddNormalHurtPer", PropertyType.AddNormalHurtPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AddSkillHurt", PropertyType.AddSkillHurt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AddSkillHurtPer", PropertyType.AddSkillHurtPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReduceCrit", PropertyType.ReduceCrit);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AddHeartHurtPer", PropertyType.AddHeartHurtPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReduceHeartHurtPer", PropertyType.ReduceHeartHurtPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AddPVEHurt", PropertyType.AddPVEHurt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AddFinalHurtPer", PropertyType.AddFinalHurtPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ReduceFinalHurtPer", PropertyType.ReduceFinalHurtPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mater", PropertyType.Mater);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Wood", PropertyType.Wood);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Water", PropertyType.Water);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fire", PropertyType.Fire);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Earth", PropertyType.Earth);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(PropertyType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushPropertyType(L, (PropertyType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "LV"))
+ {
+ translator.PushPropertyType(L, PropertyType.LV);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "POWER"))
+ {
+ translator.PushPropertyType(L, PropertyType.POWER);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AGILITY"))
+ {
+ translator.PushPropertyType(L, PropertyType.AGILITY);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PHYSIQUE"))
+ {
+ translator.PushPropertyType(L, PropertyType.PHYSIQUE);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MENTALITY"))
+ {
+ translator.PushPropertyType(L, PropertyType.MENTALITY);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "HP"))
+ {
+ translator.PushPropertyType(L, PropertyType.HP);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ATK"))
+ {
+ translator.PushPropertyType(L, PropertyType.ATK);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DEF"))
+ {
+ translator.PushPropertyType(L, PropertyType.DEF);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "HIT"))
+ {
+ translator.PushPropertyType(L, PropertyType.HIT);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MISS"))
+ {
+ translator.PushPropertyType(L, PropertyType.MISS);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ATKSPEED"))
+ {
+ translator.PushPropertyType(L, PropertyType.ATKSPEED);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CritChance"))
+ {
+ translator.PushPropertyType(L, PropertyType.CritChance);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CritHurt"))
+ {
+ translator.PushPropertyType(L, PropertyType.CritHurt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CritResis"))
+ {
+ translator.PushPropertyType(L, PropertyType.CritResis);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "HeartHit"))
+ {
+ translator.PushPropertyType(L, PropertyType.HeartHit);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "HeartHurt"))
+ {
+ translator.PushPropertyType(L, PropertyType.HeartHurt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "HeartResis"))
+ {
+ translator.PushPropertyType(L, PropertyType.HeartResis);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillHurt"))
+ {
+ translator.PushPropertyType(L, PropertyType.SkillHurt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PVPAddHurt"))
+ {
+ translator.PushPropertyType(L, PropertyType.PVPAddHurt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PVPReduceHurt"))
+ {
+ translator.PushPropertyType(L, PropertyType.PVPReduceHurt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "LifeReply"))
+ {
+ translator.PushPropertyType(L, PropertyType.LifeReply);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "HurtReflect"))
+ {
+ translator.PushPropertyType(L, PropertyType.HurtReflect);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MoveSpeed"))
+ {
+ translator.PushPropertyType(L, PropertyType.MoveSpeed);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PetHurt"))
+ {
+ translator.PushPropertyType(L, PropertyType.PetHurt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PetAddHurt"))
+ {
+ translator.PushPropertyType(L, PropertyType.PetAddHurt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RealHurt"))
+ {
+ translator.PushPropertyType(L, PropertyType.RealHurt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RealResis"))
+ {
+ translator.PushPropertyType(L, PropertyType.RealResis);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DefyDef"))
+ {
+ translator.PushPropertyType(L, PropertyType.DefyDef);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DefyDefResis"))
+ {
+ translator.PushPropertyType(L, PropertyType.DefyDefResis);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DefChance"))
+ {
+ translator.PushPropertyType(L, PropertyType.DefChance);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BloodHurt"))
+ {
+ translator.PushPropertyType(L, PropertyType.BloodHurt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AktReplyBlood"))
+ {
+ translator.PushPropertyType(L, PropertyType.AktReplyBlood);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Stun"))
+ {
+ translator.PushPropertyType(L, PropertyType.Stun);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CtrlResis"))
+ {
+ translator.PushPropertyType(L, PropertyType.CtrlResis);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AddFinalHurt"))
+ {
+ translator.PushPropertyType(L, PropertyType.AddFinalHurt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ReduceFinalHurt"))
+ {
+ translator.PushPropertyType(L, PropertyType.ReduceFinalHurt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PVPAddHurtPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.PVPAddHurtPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PVPReduceHurtPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.PVPReduceHurtPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DleHitChance"))
+ {
+ translator.PushPropertyType(L, PropertyType.DleHitChance);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DleHurt"))
+ {
+ translator.PushPropertyType(L, PropertyType.DleHurt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BasicAtkPercent"))
+ {
+ translator.PushPropertyType(L, PropertyType.BasicAtkPercent);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BasicHpPercent"))
+ {
+ translator.PushPropertyType(L, PropertyType.BasicHpPercent);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BasicDefPercent"))
+ {
+ translator.PushPropertyType(L, PropertyType.BasicDefPercent);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "HitPercent"))
+ {
+ translator.PushPropertyType(L, PropertyType.HitPercent);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DodgePercent"))
+ {
+ translator.PushPropertyType(L, PropertyType.DodgePercent);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "KillMonsExpPercent"))
+ {
+ translator.PushPropertyType(L, PropertyType.KillMonsExpPercent);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "HorcruxBasicAttrPercent"))
+ {
+ translator.PushPropertyType(L, PropertyType.HorcruxBasicAttrPercent);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ReduceSkillHurtPercent"))
+ {
+ translator.PushPropertyType(L, PropertyType.ReduceSkillHurtPercent);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "HpPercent"))
+ {
+ translator.PushPropertyType(L, PropertyType.HpPercent);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AtkPercent"))
+ {
+ translator.PushPropertyType(L, PropertyType.AtkPercent);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "EveryLvAddAtk"))
+ {
+ translator.PushPropertyType(L, PropertyType.EveryLvAddAtk);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "EveryLvAddHp"))
+ {
+ translator.PushPropertyType(L, PropertyType.EveryLvAddHp);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AddEquipDropPrecent"))
+ {
+ translator.PushPropertyType(L, PropertyType.AddEquipDropPrecent);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AddCoinsPrecent"))
+ {
+ translator.PushPropertyType(L, PropertyType.AddCoinsPrecent);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AddRealHurtPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.AddRealHurtPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ReduceRealHurtPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.ReduceRealHurtPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ArmorMaxHPPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.ArmorMaxHPPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "WeaponAtkPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.WeaponAtkPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ArmorDefPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.ArmorDefPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MinAtk"))
+ {
+ translator.PushPropertyType(L, PropertyType.MinAtk);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MaxAtk"))
+ {
+ translator.PushPropertyType(L, PropertyType.MaxAtk);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DefencePercent"))
+ {
+ translator.PushPropertyType(L, PropertyType.DefencePercent);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CritHurtPercent"))
+ {
+ translator.PushPropertyType(L, PropertyType.CritHurtPercent);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MoveSpeedPercent"))
+ {
+ translator.PushPropertyType(L, PropertyType.MoveSpeedPercent);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MaxProDef"))
+ {
+ translator.PushPropertyType(L, PropertyType.MaxProDef);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ProDefHPPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.ProDefHPPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ProDefAbsorb"))
+ {
+ translator.PushPropertyType(L, PropertyType.ProDefAbsorb);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BaseHitPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.BaseHitPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BaseMissPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.BaseMissPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PetMinAtk"))
+ {
+ translator.PushPropertyType(L, PropertyType.PetMinAtk);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PetMaxAtk"))
+ {
+ translator.PushPropertyType(L, PropertyType.PetMaxAtk);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "OnlyFinalHurt"))
+ {
+ translator.PushPropertyType(L, PropertyType.OnlyFinalHurt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PVPAtkBackHP"))
+ {
+ translator.PushPropertyType(L, PropertyType.PVPAtkBackHP);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ChanceExpRate"))
+ {
+ translator.PushPropertyType(L, PropertyType.ChanceExpRate);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "HorseAtkPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.HorseAtkPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "StoneBasePer"))
+ {
+ translator.PushPropertyType(L, PropertyType.StoneBasePer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RealmBasePer"))
+ {
+ translator.PushPropertyType(L, PropertyType.RealmBasePer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PetSkillAtkRate"))
+ {
+ translator.PushPropertyType(L, PropertyType.PetSkillAtkRate);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "WingHPPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.WingHPPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SuiteBasePer"))
+ {
+ translator.PushPropertyType(L, PropertyType.SuiteBasePer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PlusBaseAtkPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.PlusBaseAtkPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcHurtAddPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.NpcHurtAddPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "JobAHurtAddPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.JobAHurtAddPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "JobBHurtAddPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.JobBHurtAddPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "JobCHurtAddPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.JobCHurtAddPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "JobAAtkReducePer"))
+ {
+ translator.PushPropertyType(L, PropertyType.JobAAtkReducePer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "JobBAtkReducePer"))
+ {
+ translator.PushPropertyType(L, PropertyType.JobBAtkReducePer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "JobCAtkReducePer"))
+ {
+ translator.PushPropertyType(L, PropertyType.JobCAtkReducePer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ZXCloakAttrPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.ZXCloakAttrPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ZXMaskAttrPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.ZXMaskAttrPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ZXGloveAttrPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.ZXGloveAttrPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ZXRuyiAttrPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.ZXRuyiAttrPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ZXPendantAttrPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.ZXPendantAttrPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ZXRingAttrPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.ZXRingAttrPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillAddPerA"))
+ {
+ translator.PushPropertyType(L, PropertyType.SkillAddPerA);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillAddPerB"))
+ {
+ translator.PushPropertyType(L, PropertyType.SkillAddPerB);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillAddPerC"))
+ {
+ translator.PushPropertyType(L, PropertyType.SkillAddPerC);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillAddPerD"))
+ {
+ translator.PushPropertyType(L, PropertyType.SkillAddPerD);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillAddPerE"))
+ {
+ translator.PushPropertyType(L, PropertyType.SkillAddPerE);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillAddPerF"))
+ {
+ translator.PushPropertyType(L, PropertyType.SkillAddPerF);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillAddPerG"))
+ {
+ translator.PushPropertyType(L, PropertyType.SkillAddPerG);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillReducePerA"))
+ {
+ translator.PushPropertyType(L, PropertyType.SkillReducePerA);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillReducePerB"))
+ {
+ translator.PushPropertyType(L, PropertyType.SkillReducePerB);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillReducePerC"))
+ {
+ translator.PushPropertyType(L, PropertyType.SkillReducePerC);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillReducePerD"))
+ {
+ translator.PushPropertyType(L, PropertyType.SkillReducePerD);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillReducePerE"))
+ {
+ translator.PushPropertyType(L, PropertyType.SkillReducePerE);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillReducePerF"))
+ {
+ translator.PushPropertyType(L, PropertyType.SkillReducePerF);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillReducePerG"))
+ {
+ translator.PushPropertyType(L, PropertyType.SkillReducePerG);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Luck"))
+ {
+ translator.PushPropertyType(L, PropertyType.Luck);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "LuckPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.LuckPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AddNormalHurt"))
+ {
+ translator.PushPropertyType(L, PropertyType.AddNormalHurt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AddNormalHurtPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.AddNormalHurtPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AddSkillHurt"))
+ {
+ translator.PushPropertyType(L, PropertyType.AddSkillHurt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AddSkillHurtPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.AddSkillHurtPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ReduceCrit"))
+ {
+ translator.PushPropertyType(L, PropertyType.ReduceCrit);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AddHeartHurtPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.AddHeartHurtPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ReduceHeartHurtPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.ReduceHeartHurtPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AddPVEHurt"))
+ {
+ translator.PushPropertyType(L, PropertyType.AddPVEHurt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AddFinalHurtPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.AddFinalHurtPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ReduceFinalHurtPer"))
+ {
+ translator.PushPropertyType(L, PropertyType.ReduceFinalHurtPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Mater"))
+ {
+ translator.PushPropertyType(L, PropertyType.Mater);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Wood"))
+ {
+ translator.PushPropertyType(L, PropertyType.Wood);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Water"))
+ {
+ translator.PushPropertyType(L, PropertyType.Water);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Fire"))
+ {
+ translator.PushPropertyType(L, PropertyType.Fire);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Earth"))
+ {
+ translator.PushPropertyType(L, PropertyType.Earth);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for PropertyType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for PropertyType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class TextColTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(TextColType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(TextColType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(TextColType), L, null, 16, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", TextColType.None);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "White", TextColType.White);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Blue", TextColType.Blue);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Purple", TextColType.Purple);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Orange", TextColType.Orange);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Red", TextColType.Red);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pink", TextColType.Pink);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NavyBrown", TextColType.NavyBrown);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Green", TextColType.Green);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Black", TextColType.Black);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DarkGreen", TextColType.DarkGreen);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NavyYellow", TextColType.NavyYellow);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LightGreen", TextColType.LightGreen);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LightYellow", TextColType.LightYellow);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Gray", TextColType.Gray);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(TextColType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushTextColType(L, (TextColType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
+ {
+ translator.PushTextColType(L, TextColType.None);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "White"))
+ {
+ translator.PushTextColType(L, TextColType.White);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Blue"))
+ {
+ translator.PushTextColType(L, TextColType.Blue);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Purple"))
+ {
+ translator.PushTextColType(L, TextColType.Purple);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Orange"))
+ {
+ translator.PushTextColType(L, TextColType.Orange);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Red"))
+ {
+ translator.PushTextColType(L, TextColType.Red);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Pink"))
+ {
+ translator.PushTextColType(L, TextColType.Pink);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NavyBrown"))
+ {
+ translator.PushTextColType(L, TextColType.NavyBrown);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Green"))
+ {
+ translator.PushTextColType(L, TextColType.Green);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Black"))
+ {
+ translator.PushTextColType(L, TextColType.Black);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DarkGreen"))
+ {
+ translator.PushTextColType(L, TextColType.DarkGreen);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NavyYellow"))
+ {
+ translator.PushTextColType(L, TextColType.NavyYellow);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "LightGreen"))
+ {
+ translator.PushTextColType(L, TextColType.LightGreen);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "LightYellow"))
+ {
+ translator.PushTextColType(L, TextColType.LightYellow);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Gray"))
+ {
+ translator.PushTextColType(L, TextColType.Gray);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for TextColType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for TextColType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class E_ModelResTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(E_ModelResType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(E_ModelResType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(E_ModelResType), L, null, 8, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Weapon", E_ModelResType.Weapon);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Wing", E_ModelResType.Wing);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Horse", E_ModelResType.Horse);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Suit", E_ModelResType.Suit);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pet", E_ModelResType.Pet);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Secondary", E_ModelResType.Secondary);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Hand", E_ModelResType.Hand);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(E_ModelResType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushE_ModelResType(L, (E_ModelResType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Weapon"))
+ {
+ translator.PushE_ModelResType(L, E_ModelResType.Weapon);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Wing"))
+ {
+ translator.PushE_ModelResType(L, E_ModelResType.Wing);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Horse"))
+ {
+ translator.PushE_ModelResType(L, E_ModelResType.Horse);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Suit"))
+ {
+ translator.PushE_ModelResType(L, E_ModelResType.Suit);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Pet"))
+ {
+ translator.PushE_ModelResType(L, E_ModelResType.Pet);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Secondary"))
+ {
+ translator.PushE_ModelResType(L, E_ModelResType.Secondary);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Hand"))
+ {
+ translator.PushE_ModelResType(L, E_ModelResType.Hand);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for E_ModelResType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for E_ModelResType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class TreasureCategoryWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(TreasureCategory), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(TreasureCategory), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(TreasureCategory), L, null, 6, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Human", TreasureCategory.Human);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Demon", TreasureCategory.Demon);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fairy", TreasureCategory.Fairy);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "King", TreasureCategory.King);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Zerg", TreasureCategory.Zerg);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(TreasureCategory), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushTreasureCategory(L, (TreasureCategory)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Human"))
+ {
+ translator.PushTreasureCategory(L, TreasureCategory.Human);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Demon"))
+ {
+ translator.PushTreasureCategory(L, TreasureCategory.Demon);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Fairy"))
+ {
+ translator.PushTreasureCategory(L, TreasureCategory.Fairy);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "King"))
+ {
+ translator.PushTreasureCategory(L, TreasureCategory.King);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Zerg"))
+ {
+ translator.PushTreasureCategory(L, TreasureCategory.Zerg);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for TreasureCategory!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for TreasureCategory! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class TreasureStateWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(TreasureState), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(TreasureState), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(TreasureState), L, null, 4, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Collected", TreasureState.Collected);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Collecting", TreasureState.Collecting);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Locked", TreasureState.Locked);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(TreasureState), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushTreasureState(L, (TreasureState)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Collected"))
+ {
+ translator.PushTreasureState(L, TreasureState.Collected);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Collecting"))
+ {
+ translator.PushTreasureState(L, TreasureState.Collecting);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Locked"))
+ {
+ translator.PushTreasureState(L, TreasureState.Locked);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for TreasureState!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for TreasureState! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class FunctionUnlockTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(FunctionUnlockType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(FunctionUnlockType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(FunctionUnlockType), L, null, 7, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Treasure", FunctionUnlockType.Treasure);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", FunctionUnlockType.Normal);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureSkill", FunctionUnlockType.TreasureSkill);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Skill", FunctionUnlockType.Skill);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureFunc", FunctionUnlockType.TreasureFunc);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureChapter", FunctionUnlockType.TreasureChapter);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(FunctionUnlockType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushFunctionUnlockType(L, (FunctionUnlockType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Treasure"))
+ {
+ translator.PushFunctionUnlockType(L, FunctionUnlockType.Treasure);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
+ {
+ translator.PushFunctionUnlockType(L, FunctionUnlockType.Normal);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureSkill"))
+ {
+ translator.PushFunctionUnlockType(L, FunctionUnlockType.TreasureSkill);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Skill"))
+ {
+ translator.PushFunctionUnlockType(L, FunctionUnlockType.Skill);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureFunc"))
+ {
+ translator.PushFunctionUnlockType(L, FunctionUnlockType.TreasureFunc);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureChapter"))
+ {
+ translator.PushFunctionUnlockType(L, FunctionUnlockType.TreasureChapter);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for FunctionUnlockType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for FunctionUnlockType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class RedPointStateWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(RedPointState), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(RedPointState), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(RedPointState), L, null, 6, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", RedPointState.None);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Simple", RedPointState.Simple);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Quantity", RedPointState.Quantity);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Full", RedPointState.Full);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GetReward", RedPointState.GetReward);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(RedPointState), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushRedPointState(L, (RedPointState)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
+ {
+ translator.PushRedPointState(L, RedPointState.None);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Simple"))
+ {
+ translator.PushRedPointState(L, RedPointState.Simple);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Quantity"))
+ {
+ translator.PushRedPointState(L, RedPointState.Quantity);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Full"))
+ {
+ translator.PushRedPointState(L, RedPointState.Full);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "GetReward"))
+ {
+ translator.PushRedPointState(L, RedPointState.GetReward);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for RedPointState!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for RedPointState! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class TeamInviteTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(TeamInviteType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(TeamInviteType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(TeamInviteType), L, null, 4, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Friend", TeamInviteType.Friend);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fairy", TeamInviteType.Fairy);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NearBy", TeamInviteType.NearBy);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(TeamInviteType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushTeamInviteType(L, (TeamInviteType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Friend"))
+ {
+ translator.PushTeamInviteType(L, TeamInviteType.Friend);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Fairy"))
+ {
+ translator.PushTeamInviteType(L, TeamInviteType.Fairy);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NearBy"))
+ {
+ translator.PushTeamInviteType(L, TeamInviteType.NearBy);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for TeamInviteType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for TeamInviteType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class TeammatePrepareStateWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(TeammatePrepareState), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(TeammatePrepareState), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(TeammatePrepareState), L, null, 4, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnPrepared", TeammatePrepareState.UnPrepared);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Prepared", TeammatePrepareState.Prepared);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Rejected", TeammatePrepareState.Rejected);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(TeammatePrepareState), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushTeammatePrepareState(L, (TeammatePrepareState)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "UnPrepared"))
+ {
+ translator.PushTeammatePrepareState(L, TeammatePrepareState.UnPrepared);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Prepared"))
+ {
+ translator.PushTeammatePrepareState(L, TeammatePrepareState.Prepared);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Rejected"))
+ {
+ translator.PushTeammatePrepareState(L, TeammatePrepareState.Rejected);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for TeammatePrepareState!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for TeammatePrepareState! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class VipPrivilegeTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(VipPrivilegeType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(VipPrivilegeType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(VipPrivilegeType), L, null, 33, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureAtk", VipPrivilegeType.TreasureAtk);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GemHole", VipPrivilegeType.GemHole);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VipBuff", VipPrivilegeType.VipBuff);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TradeTax", VipPrivilegeType.TradeTax);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PrivateClerk", VipPrivilegeType.PrivateClerk);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FreeTransfer", VipPrivilegeType.FreeTransfer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AutoFairyMisstion", VipPrivilegeType.AutoFairyMisstion);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Gather", VipPrivilegeType.Gather);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Undead", VipPrivilegeType.Undead);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KillMonsterExpUp", VipPrivilegeType.KillMonsterExpUp);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Minion", VipPrivilegeType.Minion);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KillMonsterSp", VipPrivilegeType.KillMonsterSp);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GoldWish", VipPrivilegeType.GoldWish);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExpWish", VipPrivilegeType.ExpWish);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SelfBoss", VipPrivilegeType.SelfBoss);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BossHome", VipPrivilegeType.BossHome);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetDungeon", VipPrivilegeType.PetDungeon);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BaptizeDungeon", VipPrivilegeType.BaptizeDungeon);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ForbiddenArea", VipPrivilegeType.ForbiddenArea);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fane", VipPrivilegeType.Fane);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Chasm", VipPrivilegeType.Chasm);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DarkDorr", VipPrivilegeType.DarkDorr);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyDaimondGift", VipPrivilegeType.FairyDaimondGift);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MarketPutawayPwd", VipPrivilegeType.MarketPutawayPwd);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DemonJar", VipPrivilegeType.DemonJar);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DemonJarDouble", VipPrivilegeType.DemonJarDouble);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BindJadeWheel", VipPrivilegeType.BindJadeWheel);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PrayForDrug", VipPrivilegeType.PrayForDrug);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DemonJarAuto", VipPrivilegeType.DemonJarAuto);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AssistXianYuanCoinsAdd", VipPrivilegeType.AssistXianYuanCoinsAdd);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AssistXianYuanCoinsRatioAdd", VipPrivilegeType.AssistXianYuanCoinsRatioAdd);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JadeDynastyBoss", VipPrivilegeType.JadeDynastyBoss);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(VipPrivilegeType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushVipPrivilegeType(L, (VipPrivilegeType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureAtk"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.TreasureAtk);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "GemHole"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.GemHole);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "VipBuff"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.VipBuff);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "TradeTax"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.TradeTax);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PrivateClerk"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.PrivateClerk);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FreeTransfer"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.FreeTransfer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AutoFairyMisstion"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.AutoFairyMisstion);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Gather"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.Gather);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Undead"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.Undead);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "KillMonsterExpUp"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.KillMonsterExpUp);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Minion"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.Minion);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "KillMonsterSp"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.KillMonsterSp);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "GoldWish"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.GoldWish);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ExpWish"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.ExpWish);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SelfBoss"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.SelfBoss);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BossHome"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.BossHome);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PetDungeon"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.PetDungeon);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BaptizeDungeon"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.BaptizeDungeon);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ForbiddenArea"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.ForbiddenArea);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Fane"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.Fane);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Chasm"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.Chasm);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DarkDorr"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.DarkDorr);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyDaimondGift"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.FairyDaimondGift);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MarketPutawayPwd"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.MarketPutawayPwd);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DemonJar"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.DemonJar);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DemonJarDouble"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.DemonJarDouble);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BindJadeWheel"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.BindJadeWheel);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PrayForDrug"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.PrayForDrug);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DemonJarAuto"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.DemonJarAuto);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AssistXianYuanCoinsAdd"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.AssistXianYuanCoinsAdd);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AssistXianYuanCoinsRatioAdd"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.AssistXianYuanCoinsRatioAdd);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "JadeDynastyBoss"))
+ {
+ translator.PushVipPrivilegeType(L, VipPrivilegeType.JadeDynastyBoss);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for VipPrivilegeType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for VipPrivilegeType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class E_AttackModeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(E_AttackMode), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(E_AttackMode), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(E_AttackMode), L, null, 9, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Peace", E_AttackMode.Peace);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "All", E_AttackMode.All);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Country", E_AttackMode.Country);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Group", E_AttackMode.Group);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Team", E_AttackMode.Team);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Family", E_AttackMode.Family);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GoodEval", E_AttackMode.GoodEval);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Contest", E_AttackMode.Contest);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(E_AttackMode), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushE_AttackMode(L, (E_AttackMode)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Peace"))
+ {
+ translator.PushE_AttackMode(L, E_AttackMode.Peace);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "All"))
+ {
+ translator.PushE_AttackMode(L, E_AttackMode.All);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Country"))
+ {
+ translator.PushE_AttackMode(L, E_AttackMode.Country);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Group"))
+ {
+ translator.PushE_AttackMode(L, E_AttackMode.Group);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Team"))
+ {
+ translator.PushE_AttackMode(L, E_AttackMode.Team);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Family"))
+ {
+ translator.PushE_AttackMode(L, E_AttackMode.Family);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "GoodEval"))
+ {
+ translator.PushE_AttackMode(L, E_AttackMode.GoodEval);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Contest"))
+ {
+ translator.PushE_AttackMode(L, E_AttackMode.Contest);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for E_AttackMode!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for E_AttackMode! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class E_ItemColorWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(E_ItemColor), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(E_ItemColor), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(E_ItemColor), L, null, 7, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "White", E_ItemColor.White);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Blue", E_ItemColor.Blue);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Purple", E_ItemColor.Purple);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Orange", E_ItemColor.Orange);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Red", E_ItemColor.Red);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pink", E_ItemColor.Pink);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(E_ItemColor), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushE_ItemColor(L, (E_ItemColor)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "White"))
+ {
+ translator.PushE_ItemColor(L, E_ItemColor.White);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Blue"))
+ {
+ translator.PushE_ItemColor(L, E_ItemColor.Blue);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Purple"))
+ {
+ translator.PushE_ItemColor(L, E_ItemColor.Purple);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Orange"))
+ {
+ translator.PushE_ItemColor(L, E_ItemColor.Orange);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Red"))
+ {
+ translator.PushE_ItemColor(L, E_ItemColor.Red);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Pink"))
+ {
+ translator.PushE_ItemColor(L, E_ItemColor.Pink);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for E_ItemColor!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for E_ItemColor! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class FindPreciousTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(FindPreciousType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(FindPreciousType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(FindPreciousType), L, null, 10, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WorldBoss", FindPreciousType.WorldBoss);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BossHome", FindPreciousType.BossHome);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PersonalBoss", FindPreciousType.PersonalBoss);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ElderGodArea", FindPreciousType.ElderGodArea);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DemonJar", FindPreciousType.DemonJar);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DogzDungeon", FindPreciousType.DogzDungeon);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CrossServerBoss", FindPreciousType.CrossServerBoss);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JadeDynastyBoss", FindPreciousType.JadeDynastyBoss);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", FindPreciousType.None);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(FindPreciousType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushFindPreciousType(L, (FindPreciousType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "WorldBoss"))
+ {
+ translator.PushFindPreciousType(L, FindPreciousType.WorldBoss);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BossHome"))
+ {
+ translator.PushFindPreciousType(L, FindPreciousType.BossHome);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PersonalBoss"))
+ {
+ translator.PushFindPreciousType(L, FindPreciousType.PersonalBoss);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ElderGodArea"))
+ {
+ translator.PushFindPreciousType(L, FindPreciousType.ElderGodArea);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DemonJar"))
+ {
+ translator.PushFindPreciousType(L, FindPreciousType.DemonJar);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DogzDungeon"))
+ {
+ translator.PushFindPreciousType(L, FindPreciousType.DogzDungeon);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CrossServerBoss"))
+ {
+ translator.PushFindPreciousType(L, FindPreciousType.CrossServerBoss);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "JadeDynastyBoss"))
+ {
+ translator.PushFindPreciousType(L, FindPreciousType.JadeDynastyBoss);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
+ {
+ translator.PushFindPreciousType(L, FindPreciousType.None);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for FindPreciousType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for FindPreciousType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class GotServerRewardTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(GotServerRewardType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(GotServerRewardType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(GotServerRewardType), L, null, 26, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_Activity", GotServerRewardType.Def_RewardType_Activity);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_FamilyActivity", GotServerRewardType.Def_RewardType_FamilyActivity);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_ChampionFamilyDailyReward", GotServerRewardType.Def_RewardType_ChampionFamilyDailyReward);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_XMZZWinCnt", GotServerRewardType.Def_RewardType_XMZZWinCnt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_FairyDayAward", GotServerRewardType.Def_RewardType_FairyDayAward);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_XBXZ", GotServerRewardType.Def_RewardType_XBXZ);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_DayRealmPoint", GotServerRewardType.Def_RewardType_DayRealmPoint);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_GoldGiftFirst", GotServerRewardType.Def_RewardType_GoldGiftFirst);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_TreasureSoul", GotServerRewardType.Def_RewardType_TreasureSoul);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_ConsumeRebate", GotServerRewardType.Def_RewardType_ConsumeRebate);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_BossReborn", GotServerRewardType.Def_RewardType_BossReborn);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_FCRecharge", GotServerRewardType.Def_RewardType_FCRecharge);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_FCParty", GotServerRewardType.Def_RewardType_FCParty);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_WishingWell", GotServerRewardType.Def_RewardType_WishingWell);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_OpenFunc", GotServerRewardType.Def_RewardType_OpenFunc);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_TotalRecharge", GotServerRewardType.Def_RewardType_TotalRecharge);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_IceLodeStar", GotServerRewardType.Def_RewardType_IceLodeStar);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_WeekPartyAct", GotServerRewardType.Def_RewardType_WeekPartyAct);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_WeekPartyPoint", GotServerRewardType.Def_RewardType_WeekPartyPoint);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_ActLoginAwardAct", GotServerRewardType.Def_RewardType_ActLoginAwardAct);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_NewFairyCRecharge", GotServerRewardType.Def_RewardType_NewFairyCRecharge);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_NewFairyCParty", GotServerRewardType.Def_RewardType_NewFairyCParty);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_FeastWeekPartyAct", GotServerRewardType.Def_RewardType_FeastWeekPartyAct);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_FeastWeekPartyPoint", GotServerRewardType.Def_RewardType_FeastWeekPartyPoint);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_RewardType_FairyAdventuresAward", GotServerRewardType.Def_RewardType_FairyAdventuresAward);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(GotServerRewardType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushGotServerRewardType(L, (GotServerRewardType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_Activity"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_Activity);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_FamilyActivity"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_FamilyActivity);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_ChampionFamilyDailyReward"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_ChampionFamilyDailyReward);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_XMZZWinCnt"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_XMZZWinCnt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_FairyDayAward"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_FairyDayAward);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_XBXZ"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_XBXZ);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_DayRealmPoint"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_DayRealmPoint);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_GoldGiftFirst"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_GoldGiftFirst);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_TreasureSoul"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_TreasureSoul);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_ConsumeRebate"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_ConsumeRebate);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_BossReborn"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_BossReborn);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_FCRecharge"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_FCRecharge);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_FCParty"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_FCParty);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_WishingWell"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_WishingWell);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_OpenFunc"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_OpenFunc);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_TotalRecharge"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_TotalRecharge);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_IceLodeStar"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_IceLodeStar);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_WeekPartyAct"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_WeekPartyAct);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_WeekPartyPoint"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_WeekPartyPoint);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_ActLoginAwardAct"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_ActLoginAwardAct);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_NewFairyCRecharge"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_NewFairyCRecharge);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_NewFairyCParty"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_NewFairyCParty);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_FeastWeekPartyAct"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_FeastWeekPartyAct);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_FeastWeekPartyPoint"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_FeastWeekPartyPoint);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_RewardType_FairyAdventuresAward"))
+ {
+ translator.PushGotServerRewardType(L, GotServerRewardType.Def_RewardType_FairyAdventuresAward);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for GotServerRewardType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for GotServerRewardType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class MapTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(MapType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(MapType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(MapType), L, null, 12, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenCountry", MapType.OpenCountry);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SingleFB", MapType.SingleFB);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MultipleFB", MapType.MultipleFB);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FamilyFB", MapType.FamilyFB);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FamilyWarFB", MapType.FamilyWarFB);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CountryExam", MapType.CountryExam);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CountryFB", MapType.CountryFB);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AllByCountry", MapType.AllByCountry);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "All", MapType.All);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VSRoom", MapType.VSRoom);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CrossAll", MapType.CrossAll);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(MapType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushMapType(L, (MapType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "OpenCountry"))
+ {
+ translator.PushMapType(L, MapType.OpenCountry);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SingleFB"))
+ {
+ translator.PushMapType(L, MapType.SingleFB);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MultipleFB"))
+ {
+ translator.PushMapType(L, MapType.MultipleFB);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FamilyFB"))
+ {
+ translator.PushMapType(L, MapType.FamilyFB);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FamilyWarFB"))
+ {
+ translator.PushMapType(L, MapType.FamilyWarFB);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CountryExam"))
+ {
+ translator.PushMapType(L, MapType.CountryExam);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CountryFB"))
+ {
+ translator.PushMapType(L, MapType.CountryFB);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AllByCountry"))
+ {
+ translator.PushMapType(L, MapType.AllByCountry);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "All"))
+ {
+ translator.PushMapType(L, MapType.All);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "VSRoom"))
+ {
+ translator.PushMapType(L, MapType.VSRoom);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CrossAll"))
+ {
+ translator.PushMapType(L, MapType.CrossAll);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for MapType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for MapType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class GuideTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(GuideType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(GuideType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(GuideType), L, null, 3, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NewBie", GuideType.NewBie);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Functional", GuideType.Functional);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(GuideType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushGuideType(L, (GuideType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "NewBie"))
+ {
+ translator.PushGuideType(L, GuideType.NewBie);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Functional"))
+ {
+ translator.PushGuideType(L, GuideType.Functional);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for GuideType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for GuideType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class GuideTriggerTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(GuideTriggerType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(GuideTriggerType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(GuideTriggerType), L, null, 28, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", GuideTriggerType.None);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FunctionOpen", GuideTriggerType.FunctionOpen);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ManualFunctionOpen", GuideTriggerType.ManualFunctionOpen);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Level", GuideTriggerType.Level);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Treasure", GuideTriggerType.Treasure);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipQuality", GuideTriggerType.EquipQuality);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Item", GuideTriggerType.Item);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureDungeon", GuideTriggerType.TreasureDungeon);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Map", GuideTriggerType.Map);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneInlay", GuideTriggerType.RuneInlay);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RealmSitDown", GuideTriggerType.RealmSitDown);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ItemCompound", GuideTriggerType.ItemCompound);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HangUpResult", GuideTriggerType.HangUpResult);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureCollectSoul", GuideTriggerType.TreasureCollectSoul);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureAwaken", GuideTriggerType.TreasureAwaken);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pray", GuideTriggerType.Pray);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VIPExperience", GuideTriggerType.VIPExperience);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyLandBuyTimes", GuideTriggerType.FairyLandBuyTimes);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TeamAutoAccept", GuideTriggerType.TeamAutoAccept);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TrialExchange", GuideTriggerType.TrialExchange);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "QuestCanAccept", GuideTriggerType.QuestCanAccept);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "QuestCanDo", GuideTriggerType.QuestCanDo);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "QuestCanAward", GuideTriggerType.QuestCanAward);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "QuestLimit", GuideTriggerType.QuestLimit);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "QuestContinue", GuideTriggerType.QuestContinue);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BranchQuestCando", GuideTriggerType.BranchQuestCando);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BranchQuestCanAward", GuideTriggerType.BranchQuestCanAward);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(GuideTriggerType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushGuideTriggerType(L, (GuideTriggerType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.None);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FunctionOpen"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.FunctionOpen);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ManualFunctionOpen"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.ManualFunctionOpen);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Level"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.Level);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Treasure"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.Treasure);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipQuality"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.EquipQuality);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Item"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.Item);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureDungeon"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.TreasureDungeon);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Map"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.Map);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneInlay"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.RuneInlay);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RealmSitDown"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.RealmSitDown);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ItemCompound"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.ItemCompound);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "HangUpResult"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.HangUpResult);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureCollectSoul"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.TreasureCollectSoul);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureAwaken"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.TreasureAwaken);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Pray"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.Pray);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "VIPExperience"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.VIPExperience);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyLandBuyTimes"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.FairyLandBuyTimes);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "TeamAutoAccept"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.TeamAutoAccept);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "TrialExchange"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.TrialExchange);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "QuestCanAccept"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.QuestCanAccept);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "QuestCanDo"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.QuestCanDo);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "QuestCanAward"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.QuestCanAward);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "QuestLimit"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.QuestLimit);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "QuestContinue"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.QuestContinue);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BranchQuestCando"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.BranchQuestCando);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BranchQuestCanAward"))
+ {
+ translator.PushGuideTriggerType(L, GuideTriggerType.BranchQuestCanAward);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for GuideTriggerType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for GuideTriggerType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class FuncPowerTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(FuncPowerType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(FuncPowerType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(FuncPowerType), L, null, 26, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Role", FuncPowerType.Role);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Equip", FuncPowerType.Equip);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Plus", FuncPowerType.Plus);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Stone", FuncPowerType.Stone);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Reiki", FuncPowerType.Reiki);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Wing", FuncPowerType.Wing);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Wash", FuncPowerType.Wash);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pet", FuncPowerType.Pet);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Horse", FuncPowerType.Horse);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Realm", FuncPowerType.Realm);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GodWeapon", FuncPowerType.GodWeapon);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Title", FuncPowerType.Title);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Rune", FuncPowerType.Rune);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Star", FuncPowerType.Star);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Human", FuncPowerType.Human);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Alchemy", FuncPowerType.Alchemy);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Demon", FuncPowerType.Demon);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fairy", FuncPowerType.Fairy);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetSoul", FuncPowerType.PetSoul);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HorseSoul", FuncPowerType.HorseSoul);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Dogz", FuncPowerType.Dogz);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GatherSoul", FuncPowerType.GatherSoul);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "King", FuncPowerType.King);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FashionDress", FuncPowerType.FashionDress);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JadeDynastyEquip", FuncPowerType.JadeDynastyEquip);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(FuncPowerType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushFuncPowerType(L, (FuncPowerType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Role"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.Role);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Equip"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.Equip);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Plus"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.Plus);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Stone"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.Stone);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Reiki"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.Reiki);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Wing"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.Wing);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Wash"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.Wash);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Pet"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.Pet);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Horse"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.Horse);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Realm"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.Realm);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "GodWeapon"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.GodWeapon);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Title"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.Title);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Rune"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.Rune);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Star"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.Star);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Human"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.Human);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Alchemy"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.Alchemy);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Demon"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.Demon);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Fairy"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.Fairy);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PetSoul"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.PetSoul);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "HorseSoul"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.HorseSoul);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Dogz"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.Dogz);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "GatherSoul"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.GatherSoul);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "King"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.King);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FashionDress"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.FashionDress);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "JadeDynastyEquip"))
+ {
+ translator.PushFuncPowerType(L, FuncPowerType.JadeDynastyEquip);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for FuncPowerType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for FuncPowerType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class E_AtkTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(E_AtkType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(E_AtkType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(E_AtkType), L, null, 13, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Special", E_AtkType.Special);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Single", E_AtkType.Single);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Multiple", E_AtkType.Multiple);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Transmit", E_AtkType.Transmit);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ClearHatred", E_AtkType.ClearHatred);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SingleHatred", E_AtkType.SingleHatred);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MultipleBuff", E_AtkType.MultipleBuff);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Summon", E_AtkType.Summon);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SingleRecoverAtkPer", E_AtkType.SingleRecoverAtkPer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FastMove", E_AtkType.FastMove);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FlashMove", E_AtkType.FlashMove);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RushAttack", E_AtkType.RushAttack);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(E_AtkType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushE_AtkType(L, (E_AtkType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Special"))
+ {
+ translator.PushE_AtkType(L, E_AtkType.Special);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Single"))
+ {
+ translator.PushE_AtkType(L, E_AtkType.Single);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Multiple"))
+ {
+ translator.PushE_AtkType(L, E_AtkType.Multiple);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Transmit"))
+ {
+ translator.PushE_AtkType(L, E_AtkType.Transmit);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ClearHatred"))
+ {
+ translator.PushE_AtkType(L, E_AtkType.ClearHatred);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SingleHatred"))
+ {
+ translator.PushE_AtkType(L, E_AtkType.SingleHatred);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MultipleBuff"))
+ {
+ translator.PushE_AtkType(L, E_AtkType.MultipleBuff);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Summon"))
+ {
+ translator.PushE_AtkType(L, E_AtkType.Summon);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SingleRecoverAtkPer"))
+ {
+ translator.PushE_AtkType(L, E_AtkType.SingleRecoverAtkPer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FastMove"))
+ {
+ translator.PushE_AtkType(L, E_AtkType.FastMove);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FlashMove"))
+ {
+ translator.PushE_AtkType(L, E_AtkType.FlashMove);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RushAttack"))
+ {
+ translator.PushE_AtkType(L, E_AtkType.RushAttack);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for E_AtkType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for E_AtkType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class GameObjTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(GameObjType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(GameObjType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(GameObjType), L, null, 7, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "gotNone", GameObjType.gotNone);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "gotPlayer", GameObjType.gotPlayer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "gotNPC", GameObjType.gotNPC);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "gotItem", GameObjType.gotItem);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "gotFlyObj", GameObjType.gotFlyObj);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "gotMax", GameObjType.gotMax);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(GameObjType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushGameObjType(L, (GameObjType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "gotNone"))
+ {
+ translator.PushGameObjType(L, GameObjType.gotNone);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "gotPlayer"))
+ {
+ translator.PushGameObjType(L, GameObjType.gotPlayer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "gotNPC"))
+ {
+ translator.PushGameObjType(L, GameObjType.gotNPC);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "gotItem"))
+ {
+ translator.PushGameObjType(L, GameObjType.gotItem);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "gotFlyObj"))
+ {
+ translator.PushGameObjType(L, GameObjType.gotFlyObj);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "gotMax"))
+ {
+ translator.PushGameObjType(L, GameObjType.gotMax);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for GameObjType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for GameObjType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class HurtAttackTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(HurtAttackType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(HurtAttackType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(HurtAttackType), L, null, 17, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", HurtAttackType.Normal);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Recovery", HurtAttackType.Recovery);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BounceHurt", HurtAttackType.BounceHurt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Bleed", HurtAttackType.Bleed);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Parry", HurtAttackType.Parry);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DoubleHit", HurtAttackType.DoubleHit);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SuperHit", HurtAttackType.SuperHit);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LuckyHit", HurtAttackType.LuckyHit);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Miss", HurtAttackType.Miss);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Immune", HurtAttackType.Immune);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Suppress", HurtAttackType.Suppress);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ZhanSha", HurtAttackType.ZhanSha);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ZhuXianAtk", HurtAttackType.ZhuXianAtk);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FinalKill", HurtAttackType.FinalKill);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DeadlyHit", HurtAttackType.DeadlyHit);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ThumpHit", HurtAttackType.ThumpHit);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(HurtAttackType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushHurtAttackType(L, (HurtAttackType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
+ {
+ translator.PushHurtAttackType(L, HurtAttackType.Normal);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Recovery"))
+ {
+ translator.PushHurtAttackType(L, HurtAttackType.Recovery);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BounceHurt"))
+ {
+ translator.PushHurtAttackType(L, HurtAttackType.BounceHurt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Bleed"))
+ {
+ translator.PushHurtAttackType(L, HurtAttackType.Bleed);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Parry"))
+ {
+ translator.PushHurtAttackType(L, HurtAttackType.Parry);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DoubleHit"))
+ {
+ translator.PushHurtAttackType(L, HurtAttackType.DoubleHit);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SuperHit"))
+ {
+ translator.PushHurtAttackType(L, HurtAttackType.SuperHit);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "LuckyHit"))
+ {
+ translator.PushHurtAttackType(L, HurtAttackType.LuckyHit);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Miss"))
+ {
+ translator.PushHurtAttackType(L, HurtAttackType.Miss);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Immune"))
+ {
+ translator.PushHurtAttackType(L, HurtAttackType.Immune);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Suppress"))
+ {
+ translator.PushHurtAttackType(L, HurtAttackType.Suppress);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ZhanSha"))
+ {
+ translator.PushHurtAttackType(L, HurtAttackType.ZhanSha);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ZhuXianAtk"))
+ {
+ translator.PushHurtAttackType(L, HurtAttackType.ZhuXianAtk);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FinalKill"))
+ {
+ translator.PushHurtAttackType(L, HurtAttackType.FinalKill);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DeadlyHit"))
+ {
+ translator.PushHurtAttackType(L, HurtAttackType.DeadlyHit);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ThumpHit"))
+ {
+ translator.PushHurtAttackType(L, HurtAttackType.ThumpHit);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for HurtAttackType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for HurtAttackType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class DungeonTargetTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(DungeonTargetType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(DungeonTargetType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(DungeonTargetType), L, null, 13, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NPC", DungeonTargetType.NPC);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Exp", DungeonTargetType.Exp);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Score", DungeonTargetType.Score);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Money", DungeonTargetType.Money);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Wave", DungeonTargetType.Wave);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NpcTotal", DungeonTargetType.NpcTotal);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Stage", DungeonTargetType.Stage);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NPCDialogue", DungeonTargetType.NPCDialogue);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "VictorySumCnt", DungeonTargetType.VictorySumCnt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StageVictoryCnt", DungeonTargetType.StageVictoryCnt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Collect", DungeonTargetType.Collect);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AttackCount", DungeonTargetType.AttackCount);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(DungeonTargetType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushDungeonTargetType(L, (DungeonTargetType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "NPC"))
+ {
+ translator.PushDungeonTargetType(L, DungeonTargetType.NPC);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Exp"))
+ {
+ translator.PushDungeonTargetType(L, DungeonTargetType.Exp);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Score"))
+ {
+ translator.PushDungeonTargetType(L, DungeonTargetType.Score);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Money"))
+ {
+ translator.PushDungeonTargetType(L, DungeonTargetType.Money);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Wave"))
+ {
+ translator.PushDungeonTargetType(L, DungeonTargetType.Wave);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NpcTotal"))
+ {
+ translator.PushDungeonTargetType(L, DungeonTargetType.NpcTotal);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Stage"))
+ {
+ translator.PushDungeonTargetType(L, DungeonTargetType.Stage);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NPCDialogue"))
+ {
+ translator.PushDungeonTargetType(L, DungeonTargetType.NPCDialogue);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "VictorySumCnt"))
+ {
+ translator.PushDungeonTargetType(L, DungeonTargetType.VictorySumCnt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "StageVictoryCnt"))
+ {
+ translator.PushDungeonTargetType(L, DungeonTargetType.StageVictoryCnt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Collect"))
+ {
+ translator.PushDungeonTargetType(L, DungeonTargetType.Collect);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AttackCount"))
+ {
+ translator.PushDungeonTargetType(L, DungeonTargetType.AttackCount);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for DungeonTargetType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for DungeonTargetType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class AchievementTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(AchievementType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(AchievementType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(AchievementType), L, null, 65, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Level", AchievementType.Level);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FightPower", AchievementType.FightPower);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MainLine", AchievementType.MainLine);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KillMonster", AchievementType.KillMonster);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DailyQuest", AchievementType.DailyQuest);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyQuest", AchievementType.FairyQuest);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JobRank", AchievementType.JobRank);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MagicWeaponLevel", AchievementType.MagicWeaponLevel);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MountCount", AchievementType.MountCount);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MountLevel", AchievementType.MountLevel);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetCount", AchievementType.PetCount);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetLevel", AchievementType.PetLevel);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CollectGold", AchievementType.CollectGold);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CollectBindDiamond", AchievementType.CollectBindDiamond);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CollectDiamond", AchievementType.CollectDiamond);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AccumulativeSignIn", AchievementType.AccumulativeSignIn);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ContinuousSignIn", AchievementType.ContinuousSignIn);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PackbackGrid", AchievementType.PackbackGrid);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FriendCount", AchievementType.FriendCount);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WorldChat", AchievementType.WorldChat);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SaleItem", AchievementType.SaleItem);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BuyItem", AchievementType.BuyItem);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Dead", AchievementType.Dead);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ClearRedName", AchievementType.ClearRedName);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KillPlayer", AchievementType.KillPlayer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "StrengthenCount", AchievementType.StrengthenCount);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipStrengthenLevel", AchievementType.EquipStrengthenLevel);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "WorldBoss", AchievementType.WorldBoss);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CircleQuest", AchievementType.CircleQuest);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureDungeon", AchievementType.TreasureDungeon);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JoinGuild", AchievementType.JoinGuild);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JoinTeam", AchievementType.JoinTeam);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "CollectTreasure", AchievementType.CollectTreasure);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "BeKilledCount", AchievementType.BeKilledCount);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PrayCount", AchievementType.PrayCount);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "KillNPC", AchievementType.KillNPC);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FindWorldMap", AchievementType.FindWorldMap);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PutonEquipPlace", AchievementType.PutonEquipPlace);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PutonEquipQuality", AchievementType.PutonEquipQuality);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "MissionTranfer", AchievementType.MissionTranfer);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PropertyAdd", AchievementType.PropertyAdd);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneTower", AchievementType.RuneTower);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mount", AchievementType.Mount);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GetRune", AchievementType.GetRune);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneLevel", AchievementType.RuneLevel);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairyArea", AchievementType.FairyArea);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ComposeItem", AchievementType.ComposeItem);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "InlayGem", AchievementType.InlayGem);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Kylin", AchievementType.Kylin);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Realm", AchievementType.Realm);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RefiningDan", AchievementType.RefiningDan);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ActivevalueAward", AchievementType.ActivevalueAward);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "TreasureLevel", AchievementType.TreasureLevel);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AncientBattleGroundKillCnt", AchievementType.AncientBattleGroundKillCnt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AncientBattleGroundMultiKill", AchievementType.AncientBattleGroundMultiKill);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnLockPet", AchievementType.UnLockPet);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetRank", AchievementType.PetRank);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PetRanks", AchievementType.PetRanks);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LifeGemInlay", AchievementType.LifeGemInlay);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AttackGemInlay", AchievementType.AttackGemInlay);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FairylandExp", AchievementType.FairylandExp);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NuwaGradeS", AchievementType.NuwaGradeS);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "AnyMountLevel", AchievementType.AnyMountLevel);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "DvsFWinningStreak", AchievementType.DvsFWinningStreak);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(AchievementType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushAchievementType(L, (AchievementType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Level"))
+ {
+ translator.PushAchievementType(L, AchievementType.Level);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FightPower"))
+ {
+ translator.PushAchievementType(L, AchievementType.FightPower);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MainLine"))
+ {
+ translator.PushAchievementType(L, AchievementType.MainLine);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "KillMonster"))
+ {
+ translator.PushAchievementType(L, AchievementType.KillMonster);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DailyQuest"))
+ {
+ translator.PushAchievementType(L, AchievementType.DailyQuest);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyQuest"))
+ {
+ translator.PushAchievementType(L, AchievementType.FairyQuest);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "JobRank"))
+ {
+ translator.PushAchievementType(L, AchievementType.JobRank);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MagicWeaponLevel"))
+ {
+ translator.PushAchievementType(L, AchievementType.MagicWeaponLevel);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MountCount"))
+ {
+ translator.PushAchievementType(L, AchievementType.MountCount);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MountLevel"))
+ {
+ translator.PushAchievementType(L, AchievementType.MountLevel);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PetCount"))
+ {
+ translator.PushAchievementType(L, AchievementType.PetCount);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PetLevel"))
+ {
+ translator.PushAchievementType(L, AchievementType.PetLevel);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CollectGold"))
+ {
+ translator.PushAchievementType(L, AchievementType.CollectGold);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CollectBindDiamond"))
+ {
+ translator.PushAchievementType(L, AchievementType.CollectBindDiamond);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CollectDiamond"))
+ {
+ translator.PushAchievementType(L, AchievementType.CollectDiamond);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AccumulativeSignIn"))
+ {
+ translator.PushAchievementType(L, AchievementType.AccumulativeSignIn);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ContinuousSignIn"))
+ {
+ translator.PushAchievementType(L, AchievementType.ContinuousSignIn);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PackbackGrid"))
+ {
+ translator.PushAchievementType(L, AchievementType.PackbackGrid);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FriendCount"))
+ {
+ translator.PushAchievementType(L, AchievementType.FriendCount);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "WorldChat"))
+ {
+ translator.PushAchievementType(L, AchievementType.WorldChat);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SaleItem"))
+ {
+ translator.PushAchievementType(L, AchievementType.SaleItem);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BuyItem"))
+ {
+ translator.PushAchievementType(L, AchievementType.BuyItem);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Dead"))
+ {
+ translator.PushAchievementType(L, AchievementType.Dead);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ClearRedName"))
+ {
+ translator.PushAchievementType(L, AchievementType.ClearRedName);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "KillPlayer"))
+ {
+ translator.PushAchievementType(L, AchievementType.KillPlayer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "StrengthenCount"))
+ {
+ translator.PushAchievementType(L, AchievementType.StrengthenCount);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "EquipStrengthenLevel"))
+ {
+ translator.PushAchievementType(L, AchievementType.EquipStrengthenLevel);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "WorldBoss"))
+ {
+ translator.PushAchievementType(L, AchievementType.WorldBoss);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CircleQuest"))
+ {
+ translator.PushAchievementType(L, AchievementType.CircleQuest);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureDungeon"))
+ {
+ translator.PushAchievementType(L, AchievementType.TreasureDungeon);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "JoinGuild"))
+ {
+ translator.PushAchievementType(L, AchievementType.JoinGuild);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "JoinTeam"))
+ {
+ translator.PushAchievementType(L, AchievementType.JoinTeam);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "CollectTreasure"))
+ {
+ translator.PushAchievementType(L, AchievementType.CollectTreasure);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "BeKilledCount"))
+ {
+ translator.PushAchievementType(L, AchievementType.BeKilledCount);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PrayCount"))
+ {
+ translator.PushAchievementType(L, AchievementType.PrayCount);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "KillNPC"))
+ {
+ translator.PushAchievementType(L, AchievementType.KillNPC);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FindWorldMap"))
+ {
+ translator.PushAchievementType(L, AchievementType.FindWorldMap);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PutonEquipPlace"))
+ {
+ translator.PushAchievementType(L, AchievementType.PutonEquipPlace);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PutonEquipQuality"))
+ {
+ translator.PushAchievementType(L, AchievementType.PutonEquipQuality);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "MissionTranfer"))
+ {
+ translator.PushAchievementType(L, AchievementType.MissionTranfer);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PropertyAdd"))
+ {
+ translator.PushAchievementType(L, AchievementType.PropertyAdd);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneTower"))
+ {
+ translator.PushAchievementType(L, AchievementType.RuneTower);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Mount"))
+ {
+ translator.PushAchievementType(L, AchievementType.Mount);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "GetRune"))
+ {
+ translator.PushAchievementType(L, AchievementType.GetRune);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneLevel"))
+ {
+ translator.PushAchievementType(L, AchievementType.RuneLevel);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FairyArea"))
+ {
+ translator.PushAchievementType(L, AchievementType.FairyArea);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ComposeItem"))
+ {
+ translator.PushAchievementType(L, AchievementType.ComposeItem);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "InlayGem"))
+ {
+ translator.PushAchievementType(L, AchievementType.InlayGem);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Kylin"))
+ {
+ translator.PushAchievementType(L, AchievementType.Kylin);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Realm"))
+ {
+ translator.PushAchievementType(L, AchievementType.Realm);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RefiningDan"))
+ {
+ translator.PushAchievementType(L, AchievementType.RefiningDan);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ActivevalueAward"))
+ {
+ translator.PushAchievementType(L, AchievementType.ActivevalueAward);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "TreasureLevel"))
+ {
+ translator.PushAchievementType(L, AchievementType.TreasureLevel);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AncientBattleGroundKillCnt"))
+ {
+ translator.PushAchievementType(L, AchievementType.AncientBattleGroundKillCnt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AncientBattleGroundMultiKill"))
+ {
+ translator.PushAchievementType(L, AchievementType.AncientBattleGroundMultiKill);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "UnLockPet"))
+ {
+ translator.PushAchievementType(L, AchievementType.UnLockPet);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PetRank"))
+ {
+ translator.PushAchievementType(L, AchievementType.PetRank);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PetRanks"))
+ {
+ translator.PushAchievementType(L, AchievementType.PetRanks);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "LifeGemInlay"))
+ {
+ translator.PushAchievementType(L, AchievementType.LifeGemInlay);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AttackGemInlay"))
+ {
+ translator.PushAchievementType(L, AchievementType.AttackGemInlay);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FairylandExp"))
+ {
+ translator.PushAchievementType(L, AchievementType.FairylandExp);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "NuwaGradeS"))
+ {
+ translator.PushAchievementType(L, AchievementType.NuwaGradeS);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "AnyMountLevel"))
+ {
+ translator.PushAchievementType(L, AchievementType.AnyMountLevel);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "DvsFWinningStreak"))
+ {
+ translator.PushAchievementType(L, AchievementType.DvsFWinningStreak);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for AchievementType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for AchievementType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class ItemTimeTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(ItemTimeType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(ItemTimeType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(ItemTimeType), L, null, 3, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "EquipedTime", ItemTimeType.EquipedTime);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RealityTime", ItemTimeType.RealityTime);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(ItemTimeType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushItemTimeType(L, (ItemTimeType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "EquipedTime"))
+ {
+ translator.PushItemTimeType(L, ItemTimeType.EquipedTime);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RealityTime"))
+ {
+ translator.PushItemTimeType(L, ItemTimeType.RealityTime);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for ItemTimeType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for ItemTimeType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class TitleBtnStateWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(TitleBtnState), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(TitleBtnState), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(TitleBtnState), L, null, 4, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", TitleBtnState.Normal);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Click", TitleBtnState.Click);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Locked", TitleBtnState.Locked);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(TitleBtnState), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushTitleBtnState(L, (TitleBtnState)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
+ {
+ translator.PushTitleBtnState(L, TitleBtnState.Normal);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Click"))
+ {
+ translator.PushTitleBtnState(L, TitleBtnState.Click);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Locked"))
+ {
+ translator.PushTitleBtnState(L, TitleBtnState.Locked);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for TitleBtnState!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for TitleBtnState! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class LegendAttrTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(LegendAttrType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(LegendAttrType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(LegendAttrType), L, null, 4, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", LegendAttrType.Normal);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pursuit", LegendAttrType.Pursuit);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fixed", LegendAttrType.Fixed);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(LegendAttrType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushLegendAttrType(L, (LegendAttrType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
+ {
+ translator.PushLegendAttrType(L, LegendAttrType.Normal);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Pursuit"))
+ {
+ translator.PushLegendAttrType(L, LegendAttrType.Pursuit);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Fixed"))
+ {
+ translator.PushLegendAttrType(L, LegendAttrType.Fixed);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for LegendAttrType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for LegendAttrType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class ServerStateWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(ServerState), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(ServerState), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(ServerState), L, null, 6, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Maintain", ServerState.Maintain);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", ServerState.Normal);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Busy", ServerState.Busy);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Hot", ServerState.Hot);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Predicted", ServerState.Predicted);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(ServerState), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushServerState(L, (ServerState)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Maintain"))
+ {
+ translator.PushServerState(L, ServerState.Maintain);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
+ {
+ translator.PushServerState(L, ServerState.Normal);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Busy"))
+ {
+ translator.PushServerState(L, ServerState.Busy);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Hot"))
+ {
+ translator.PushServerState(L, ServerState.Hot);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Predicted"))
+ {
+ translator.PushServerState(L, ServerState.Predicted);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for ServerState!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for ServerState! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class ItemUseDataKeyWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(ItemUseDataKey), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(ItemUseDataKey), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(ItemUseDataKey), L, null, 29, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "mapLoaction", ItemUseDataKey.mapLoaction);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "legendAttrID", ItemUseDataKey.legendAttrID);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "itemCount", ItemUseDataKey.itemCount);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "legendAttrValue", ItemUseDataKey.legendAttrValue);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "outOfPrintAttrID", ItemUseDataKey.outOfPrintAttrID);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "outOfPrintAttrValue", ItemUseDataKey.outOfPrintAttrValue);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "itemColor", ItemUseDataKey.itemColor);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "cancelUseLimit", ItemUseDataKey.cancelUseLimit);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "source", ItemUseDataKey.source);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "wingMaterialItemID", ItemUseDataKey.wingMaterialItemID);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "wingMaterialItemCount", ItemUseDataKey.wingMaterialItemCount);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "suiteLV", ItemUseDataKey.suiteLV);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "dogzEquipPlus", ItemUseDataKey.dogzEquipPlus);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "hasOpenCnt", ItemUseDataKey.hasOpenCnt);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "itemDecompound", ItemUseDataKey.itemDecompound);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "createItemLoginDay", ItemUseDataKey.createItemLoginDay);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "lastOpenItemLoginDay", ItemUseDataKey.lastOpenItemLoginDay);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "runeLV", ItemUseDataKey.runeLV);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "birthChartLV", ItemUseDataKey.birthChartLV);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "wingProgressValue", ItemUseDataKey.wingProgressValue);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "createTime", ItemUseDataKey.createTime);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "totalTime", ItemUseDataKey.totalTime);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "auctionItemCreateTime", ItemUseDataKey.auctionItemCreateTime);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "pet_NPCID", ItemUseDataKey.pet_NPCID);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "pet_ClassLV", ItemUseDataKey.pet_ClassLV);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "pet_State", ItemUseDataKey.pet_State);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "pet_QualityLV", ItemUseDataKey.pet_QualityLV);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "pet_Skill", ItemUseDataKey.pet_Skill);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(ItemUseDataKey), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushItemUseDataKey(L, (ItemUseDataKey)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "mapLoaction"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.mapLoaction);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "legendAttrID"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.legendAttrID);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "itemCount"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.itemCount);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "legendAttrValue"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.legendAttrValue);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "outOfPrintAttrID"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.outOfPrintAttrID);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "outOfPrintAttrValue"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.outOfPrintAttrValue);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "itemColor"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.itemColor);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "cancelUseLimit"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.cancelUseLimit);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "source"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.source);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "wingMaterialItemID"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.wingMaterialItemID);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "wingMaterialItemCount"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.wingMaterialItemCount);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "suiteLV"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.suiteLV);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "dogzEquipPlus"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.dogzEquipPlus);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "hasOpenCnt"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.hasOpenCnt);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "itemDecompound"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.itemDecompound);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "createItemLoginDay"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.createItemLoginDay);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "lastOpenItemLoginDay"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.lastOpenItemLoginDay);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "runeLV"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.runeLV);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "birthChartLV"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.birthChartLV);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "wingProgressValue"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.wingProgressValue);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "createTime"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.createTime);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "totalTime"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.totalTime);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "auctionItemCreateTime"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.auctionItemCreateTime);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "pet_NPCID"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.pet_NPCID);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "pet_ClassLV"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.pet_ClassLV);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "pet_State"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.pet_State);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "pet_QualityLV"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.pet_QualityLV);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "pet_Skill"))
+ {
+ translator.PushItemUseDataKey(L, ItemUseDataKey.pet_Skill);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for ItemUseDataKey!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for ItemUseDataKey! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class ItemOperateTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(ItemOperateType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(ItemOperateType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(ItemOperateType), L, null, 24, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "makeUse", ItemOperateType.makeUse);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "putOn", ItemOperateType.putOn);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "dismantle", ItemOperateType.dismantle);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "split", ItemOperateType.split);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "putAway", ItemOperateType.putAway);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "compose", ItemOperateType.compose);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "sell", ItemOperateType.sell);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "putOff", ItemOperateType.putOff);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "putIn", ItemOperateType.putIn);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "putOut", ItemOperateType.putOut);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "exchange", ItemOperateType.exchange);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "buy", ItemOperateType.buy);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "putItemout", ItemOperateType.putItemout);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "renewal", ItemOperateType.renewal);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "refine", ItemOperateType.refine);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "LevelUp", ItemOperateType.LevelUp);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Resolve", ItemOperateType.Resolve);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Wear", ItemOperateType.Wear);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Replace", ItemOperateType.Replace);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "strength", ItemOperateType.strength);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "inlay", ItemOperateType.inlay);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "train", ItemOperateType.train);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "star", ItemOperateType.star);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(ItemOperateType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushItemOperateType(L, (ItemOperateType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "makeUse"))
+ {
+ translator.PushItemOperateType(L, ItemOperateType.makeUse);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "putOn"))
+ {
+ translator.PushItemOperateType(L, ItemOperateType.putOn);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "dismantle"))
+ {
+ translator.PushItemOperateType(L, ItemOperateType.dismantle);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "split"))
+ {
+ translator.PushItemOperateType(L, ItemOperateType.split);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "putAway"))
+ {
+ translator.PushItemOperateType(L, ItemOperateType.putAway);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "compose"))
+ {
+ translator.PushItemOperateType(L, ItemOperateType.compose);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "sell"))
+ {
+ translator.PushItemOperateType(L, ItemOperateType.sell);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "putOff"))
+ {
+ translator.PushItemOperateType(L, ItemOperateType.putOff);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "putIn"))
+ {
+ translator.PushItemOperateType(L, ItemOperateType.putIn);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "putOut"))
+ {
+ translator.PushItemOperateType(L, ItemOperateType.putOut);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "exchange"))
+ {
+ translator.PushItemOperateType(L, ItemOperateType.exchange);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "buy"))
+ {
+ translator.PushItemOperateType(L, ItemOperateType.buy);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "putItemout"))
+ {
+ translator.PushItemOperateType(L, ItemOperateType.putItemout);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "renewal"))
+ {
+ translator.PushItemOperateType(L, ItemOperateType.renewal);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "refine"))
+ {
+ translator.PushItemOperateType(L, ItemOperateType.refine);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "LevelUp"))
+ {
+ translator.PushItemOperateType(L, ItemOperateType.LevelUp);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Resolve"))
+ {
+ translator.PushItemOperateType(L, ItemOperateType.Resolve);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Wear"))
+ {
+ translator.PushItemOperateType(L, ItemOperateType.Wear);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Replace"))
+ {
+ translator.PushItemOperateType(L, ItemOperateType.Replace);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "strength"))
+ {
+ translator.PushItemOperateType(L, ItemOperateType.strength);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "inlay"))
+ {
+ translator.PushItemOperateType(L, ItemOperateType.inlay);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "train"))
+ {
+ translator.PushItemOperateType(L, ItemOperateType.train);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "star"))
+ {
+ translator.PushItemOperateType(L, ItemOperateType.star);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for ItemOperateType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for ItemOperateType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class ItemWinTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(ItemWinType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(ItemWinType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(ItemWinType), L, null, 12, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "itemWin", ItemWinType.itemWin);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "boxWin", ItemWinType.boxWin);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "equipWin", ItemWinType.equipWin);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "wingsWin", ItemWinType.wingsWin);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "guardWin", ItemWinType.guardWin);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "buyItemWin", ItemWinType.buyItemWin);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "buyBoxWin", ItemWinType.buyBoxWin);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "petMatWin", ItemWinType.petMatWin);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "buyPetMatWin", ItemWinType.buyPetMatWin);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "gatherSoul", ItemWinType.gatherSoul);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "kingTreasure", ItemWinType.kingTreasure);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(ItemWinType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushItemWinType(L, (ItemWinType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "itemWin"))
+ {
+ translator.PushItemWinType(L, ItemWinType.itemWin);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "boxWin"))
+ {
+ translator.PushItemWinType(L, ItemWinType.boxWin);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "equipWin"))
+ {
+ translator.PushItemWinType(L, ItemWinType.equipWin);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "wingsWin"))
+ {
+ translator.PushItemWinType(L, ItemWinType.wingsWin);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "guardWin"))
+ {
+ translator.PushItemWinType(L, ItemWinType.guardWin);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "buyItemWin"))
+ {
+ translator.PushItemWinType(L, ItemWinType.buyItemWin);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "buyBoxWin"))
+ {
+ translator.PushItemWinType(L, ItemWinType.buyBoxWin);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "petMatWin"))
+ {
+ translator.PushItemWinType(L, ItemWinType.petMatWin);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "buyPetMatWin"))
+ {
+ translator.PushItemWinType(L, ItemWinType.buyPetMatWin);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "gatherSoul"))
+ {
+ translator.PushItemWinType(L, ItemWinType.gatherSoul);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "kingTreasure"))
+ {
+ translator.PushItemWinType(L, ItemWinType.kingTreasure);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for ItemWinType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for ItemWinType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class ItemTipChildTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(ItemTipChildType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(ItemTipChildType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(ItemTipChildType), L, null, 7, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", ItemTipChildType.Normal);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Buy", ItemTipChildType.Buy);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnionWarehouseDonation", ItemTipChildType.UnionWarehouseDonation);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "UnionWarehouseExchange", ItemTipChildType.UnionWarehouseExchange);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GetEquipPath", ItemTipChildType.GetEquipPath);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "GetWingsPath", ItemTipChildType.GetWingsPath);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(ItemTipChildType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushItemTipChildType(L, (ItemTipChildType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
+ {
+ translator.PushItemTipChildType(L, ItemTipChildType.Normal);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Buy"))
+ {
+ translator.PushItemTipChildType(L, ItemTipChildType.Buy);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "UnionWarehouseDonation"))
+ {
+ translator.PushItemTipChildType(L, ItemTipChildType.UnionWarehouseDonation);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "UnionWarehouseExchange"))
+ {
+ translator.PushItemTipChildType(L, ItemTipChildType.UnionWarehouseExchange);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "GetEquipPath"))
+ {
+ translator.PushItemTipChildType(L, ItemTipChildType.GetEquipPath);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "GetWingsPath"))
+ {
+ translator.PushItemTipChildType(L, ItemTipChildType.GetWingsPath);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for ItemTipChildType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for ItemTipChildType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class InstalledAssetWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(InstalledAsset), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(InstalledAsset), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(InstalledAsset), L, null, 5, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "NullAsset", InstalledAsset.NullAsset);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "HalfAsset", InstalledAsset.HalfAsset);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FullAsset", InstalledAsset.FullAsset);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "IngoreDownLoad", InstalledAsset.IngoreDownLoad);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(InstalledAsset), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushInstalledAsset(L, (InstalledAsset)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "NullAsset"))
+ {
+ translator.PushInstalledAsset(L, InstalledAsset.NullAsset);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "HalfAsset"))
+ {
+ translator.PushInstalledAsset(L, InstalledAsset.HalfAsset);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "FullAsset"))
+ {
+ translator.PushInstalledAsset(L, InstalledAsset.FullAsset);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "IngoreDownLoad"))
+ {
+ translator.PushInstalledAsset(L, InstalledAsset.IngoreDownLoad);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for InstalledAsset!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for InstalledAsset! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class VersionAuthorityWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(VersionAuthority), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(VersionAuthority), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(VersionAuthority), L, null, 3, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "InterTest", VersionAuthority.InterTest);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Release", VersionAuthority.Release);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(VersionAuthority), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushVersionAuthority(L, (VersionAuthority)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "InterTest"))
+ {
+ translator.PushVersionAuthority(L, VersionAuthority.InterTest);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Release"))
+ {
+ translator.PushVersionAuthority(L, VersionAuthority.Release);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for VersionAuthority!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for VersionAuthority! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class FootAudioTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(FootAudioType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(FootAudioType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(FootAudioType), L, null, 4, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Walk", FootAudioType.Walk);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Ride", FootAudioType.Ride);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Fly", FootAudioType.Fly);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(FootAudioType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushFootAudioType(L, (FootAudioType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "Walk"))
+ {
+ translator.PushFootAudioType(L, FootAudioType.Walk);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Ride"))
+ {
+ translator.PushFootAudioType(L, FootAudioType.Ride);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Fly"))
+ {
+ translator.PushFootAudioType(L, FootAudioType.Fly);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for FootAudioType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for FootAudioType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class AttackFailTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(AttackFailType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(AttackFailType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(AttackFailType), L, null, 4, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillFail_Other", AttackFailType.SkillFail_Other);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillFail_CD", AttackFailType.SkillFail_CD);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "SkillFail_AtkInterval", AttackFailType.SkillFail_AtkInterval);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(AttackFailType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushAttackFailType(L, (AttackFailType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "SkillFail_Other"))
+ {
+ translator.PushAttackFailType(L, AttackFailType.SkillFail_Other);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillFail_CD"))
+ {
+ translator.PushAttackFailType(L, AttackFailType.SkillFail_CD);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "SkillFail_AtkInterval"))
+ {
+ translator.PushAttackFailType(L, AttackFailType.SkillFail_AtkInterval);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for AttackFailType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for AttackFailType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class DungeonFightStageWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(DungeonFightStage), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(DungeonFightStage), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(DungeonFightStage), L, null, 7, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", DungeonFightStage.None);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Prepare", DungeonFightStage.Prepare);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Normal", DungeonFightStage.Normal);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "PickUp", DungeonFightStage.PickUp);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ExitPrepare", DungeonFightStage.ExitPrepare);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "ElderGodAreaNearDead", DungeonFightStage.ElderGodAreaNearDead);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(DungeonFightStage), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushDungeonFightStage(L, (DungeonFightStage)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
+ {
+ translator.PushDungeonFightStage(L, DungeonFightStage.None);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Prepare"))
+ {
+ translator.PushDungeonFightStage(L, DungeonFightStage.Prepare);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Normal"))
+ {
+ translator.PushDungeonFightStage(L, DungeonFightStage.Normal);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "PickUp"))
+ {
+ translator.PushDungeonFightStage(L, DungeonFightStage.PickUp);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ExitPrepare"))
+ {
+ translator.PushDungeonFightStage(L, DungeonFightStage.ExitPrepare);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "ElderGodAreaNearDead"))
+ {
+ translator.PushDungeonFightStage(L, DungeonFightStage.ElderGodAreaNearDead);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for DungeonFightStage!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for DungeonFightStage! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class RankTypeWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(RankType), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(RankType), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(RankType), L, null, 24, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "FightPower", RankType.FightPower);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Job1FightPower", RankType.Job1FightPower);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Job2FightPower", RankType.Job2FightPower);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Job3FightPower", RankType.Job3FightPower);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Level", RankType.Level);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mount", RankType.Mount);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pet", RankType.Pet);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "RuneTower", RankType.RuneTower);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OfflineExp", RankType.OfflineExp);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Realm", RankType.Realm);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerStrengthen", RankType.OpenServerStrengthen);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerMount", RankType.OpenServerMount);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerGem", RankType.OpenServerGem);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerLv", RankType.OpenServerLv);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerRealm", RankType.OpenServerRealm);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerFightPower", RankType.OpenServerFightPower);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_BT_FCCostGold", RankType.Def_BT_FCCostGold);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerRune", RankType.OpenServerRune);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerGodWeapon", RankType.OpenServerGodWeapon);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerRecharge", RankType.OpenServerRecharge);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "OpenServerPet", RankType.OpenServerPet);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "JadeDynastyTower", RankType.JadeDynastyTower);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Def_BT_NewFCCostGold", RankType.Def_BT_NewFCCostGold);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(RankType), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushRankType(L, (RankType)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "FightPower"))
+ {
+ translator.PushRankType(L, RankType.FightPower);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Job1FightPower"))
+ {
+ translator.PushRankType(L, RankType.Job1FightPower);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Job2FightPower"))
+ {
+ translator.PushRankType(L, RankType.Job2FightPower);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Job3FightPower"))
+ {
+ translator.PushRankType(L, RankType.Job3FightPower);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Level"))
+ {
+ translator.PushRankType(L, RankType.Level);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Mount"))
+ {
+ translator.PushRankType(L, RankType.Mount);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Pet"))
+ {
+ translator.PushRankType(L, RankType.Pet);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "RuneTower"))
+ {
+ translator.PushRankType(L, RankType.RuneTower);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "OfflineExp"))
+ {
+ translator.PushRankType(L, RankType.OfflineExp);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Realm"))
+ {
+ translator.PushRankType(L, RankType.Realm);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerStrengthen"))
+ {
+ translator.PushRankType(L, RankType.OpenServerStrengthen);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerMount"))
+ {
+ translator.PushRankType(L, RankType.OpenServerMount);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerGem"))
+ {
+ translator.PushRankType(L, RankType.OpenServerGem);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerLv"))
+ {
+ translator.PushRankType(L, RankType.OpenServerLv);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerRealm"))
+ {
+ translator.PushRankType(L, RankType.OpenServerRealm);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerFightPower"))
+ {
+ translator.PushRankType(L, RankType.OpenServerFightPower);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_BT_FCCostGold"))
+ {
+ translator.PushRankType(L, RankType.Def_BT_FCCostGold);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerRune"))
+ {
+ translator.PushRankType(L, RankType.OpenServerRune);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerGodWeapon"))
+ {
+ translator.PushRankType(L, RankType.OpenServerGodWeapon);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerRecharge"))
+ {
+ translator.PushRankType(L, RankType.OpenServerRecharge);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "OpenServerPet"))
+ {
+ translator.PushRankType(L, RankType.OpenServerPet);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "JadeDynastyTower"))
+ {
+ translator.PushRankType(L, RankType.JadeDynastyTower);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Def_BT_NewFCCostGold"))
+ {
+ translator.PushRankType(L, RankType.Def_BT_NewFCCostGold);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for RankType!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for RankType! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
+ public class PetOrMountWrap
+ {
+ public static void __Register(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ Utils.BeginObjectRegister(typeof(PetOrMount), L, translator, 0, 0, 0, 0);
+ Utils.EndObjectRegister(typeof(PetOrMount), L, translator, null, null, null, null, null);
+
+ Utils.BeginClassRegister(typeof(PetOrMount), L, null, 4, 0, 0);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "None", PetOrMount.None);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Pet", PetOrMount.Pet);
+
+ Utils.RegisterObject(L, translator, Utils.CLS_IDX, "Mount", PetOrMount.Mount);
+
+ Utils.RegisterFunc(L, Utils.CLS_IDX, "__CastFrom", __CastFrom);
+
+ Utils.EndClassRegister(typeof(PetOrMount), L, translator);
+ }
+
+ [MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
+ static int __CastFrom(RealStatePtr L)
+ {
+ ObjectTranslator translator = ObjectTranslatorPool.Instance.Find(L);
+ LuaTypes lua_type = LuaAPI.lua_type(L, 1);
+ if (lua_type == LuaTypes.LUA_TNUMBER)
+ {
+ translator.PushPetOrMount(L, (PetOrMount)LuaAPI.xlua_tointeger(L, 1));
+ }
+
+ else if(lua_type == LuaTypes.LUA_TSTRING)
+ {
+ if (LuaAPI.xlua_is_eq_str(L, 1, "None"))
+ {
+ translator.PushPetOrMount(L, PetOrMount.None);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Pet"))
+ {
+ translator.PushPetOrMount(L, PetOrMount.Pet);
+ }
+ else if (LuaAPI.xlua_is_eq_str(L, 1, "Mount"))
+ {
+ translator.PushPetOrMount(L, PetOrMount.Mount);
+ }
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid string for PetOrMount!");
+ }
+ }
+
+ else
+ {
+ return LuaAPI.luaL_error(L, "invalid lua type for PetOrMount! Expect number or string, got + " + lua_type);
+ }
+
+ return 1;
+ }
+ }
+
}
\ No newline at end of file
--
Gitblit v1.8.0