RoApp/Assets/ToLua/Source/Generate/ActorDataWrap.cs

//this source code was auto-generated by tolua#, do not modify it
using System;
using LuaInterface;

public class ActorDataWrap
{
	public static void Register(LuaState L)
	{
		L.BeginClass(typeof(ActorData), typeof(System.Object), "ActorData");
		L.RegFunction("GetuId", GetuId);
		L.RegFunction("GetBaseId", GetBaseId);
		L.RegFunction("RefreshSkills", RefreshSkills);
		L.RegFunction("Initialize", Initialize);
		L.RegFunction("GetNverageSkillsLv", GetNverageSkillsLv);
		L.RegFunction("GetScale", GetScale);
		L.RegFunction("SetEquipTotalAttr", SetEquipTotalAttr);
		L.RegFunction("GetEquipTotalAttr", GetEquipTotalAttr);
		L.RegFunction("GetSeverSecondAttr", GetSeverSecondAttr);
		L.RegFunction("SetServerSecondAttr", SetServerSecondAttr);
		L.RegFunction("ResetServerSecondAttr", ResetServerSecondAttr);
		L.RegFunction("GetAdditionalAttr", GetAdditionalAttr);
		L.RegFunction("SetAdditionalAttr", SetAdditionalAttr);
		L.RegFunction("ResetAdditionalAttr", ResetAdditionalAttr);
		L.RegFunction("ResetAdditionalAttrPercent", ResetAdditionalAttrPercent);
		L.RegFunction("GetAdditionalAttrPercent", GetAdditionalAttrPercent);
		L.RegFunction("SetAdditionalAttrPercent", SetAdditionalAttrPercent);
		L.RegFunction("GetFinalAttr", GetFinalAttr);
		L.RegFunction("CloneAllAttributes", CloneAllAttributes);
		L.RegFunction("CloneData", CloneData);
		L.RegFunction("GetBaseSecondAttr", GetBaseSecondAttr);
		L.RegFunction("GetLocalSecondAttr", GetLocalSecondAttr);
		L.RegFunction("GetSecondAttr", GetSecondAttr);
		L.RegFunction("GetFirstAttr", GetFirstAttr);
		L.RegFunction("GetBaseFirstAttr", GetBaseFirstAttr);
		L.RegFunction("SetBaseFirstAttr", SetBaseFirstAttr);
		L.RegFunction("ResetBaseFirstAttr", ResetBaseFirstAttr);
		L.RegFunction("GetAttr", GetAttr);
		L.RegFunction("GetPreviewAttr", GetPreviewAttr);
		L.RegFunction("GetPreviewLvUpLocalAttr", GetPreviewLvUpLocalAttr);
		L.RegFunction("GetPreviewLvUpAttr", GetPreviewLvUpAttr);
		L.RegFunction("SetBuffs", SetBuffs);
		L.RegFunction("SetDropBuffs", SetDropBuffs);
		L.RegFunction("SetPveMark", SetPveMark);
		L.RegFunction("ResetFirstSkill", ResetFirstSkill);
		L.RegFunction("SetAllAttributes", SetAllAttributes);
		L.RegFunction("SetPet", SetPet);
		L.RegFunction("SetLevel", SetLevel);
		L.RegFunction("Dispose", Dispose);
		L.RegFunction("CloneActorData", CloneActorData);
		L.RegFunction("CreateActorFromJson", CreateActorFromJson);
		L.RegFunction("CreateNpcPlayerActor", CreateNpcPlayerActor);
		L.RegFunction("CreateFellowActor", CreateFellowActor);
		L.RegFunction("CreatePetActor", CreatePetActor);
		L.RegFunction("CreatePetBossActor", CreatePetBossActor);
		L.RegFunction("CreatePlayerActor", CreatePlayerActor);
		L.RegFunction("ParseSkillParam", ParseSkillParam);
		L.RegFunction("ParseBuffParam", ParseBuffParam);
		L.RegFunction("ToJson", ToJson);
		L.RegFunction("__tostring", ToLua.op_ToString);
		L.RegConstant("Attr_STR", 1);
		L.RegConstant("Attr_AGI", 2);
		L.RegConstant("Attr_INT", 3);
		L.RegConstant("Attr_VIT", 4);
		L.RegConstant("Attr_DEX", 5);
		L.RegConstant("Attr_LUK", 6);
		L.RegConstant("Attr_Life", 7);
		L.RegConstant("Attr_Sp", 8);
		L.RegConstant("Attr_Attack", 9);
		L.RegConstant("Attr_MagicAttack", 10);
		L.RegConstant("Attr_Defense", 11);
		L.RegConstant("Attr_MagicDefense", 12);
		L.RegConstant("Attr_Hit", 13);
		L.RegConstant("Attr_Dodge", 14);
		L.RegConstant("Attr_Crit", 15);
		L.RegConstant("Attr_Ten", 16);
		L.RegConstant("Attr_AttackSpeed", 17);
		L.RegConstant("Attr_CastAcceleration", 18);
		L.RegConstant("Attr_MaxHp", 19);
		L.RegConstant("Attr_MaxSp", 20);
		L.RegConstant("Attr_GodPow", 21);
		L.RegConstant("Attr_STR_Percent", 31);
		L.RegConstant("Attr_AGI_Percent", 32);
		L.RegConstant("Attr_INT_Percent", 33);
		L.RegConstant("Attr_VIT_Percent", 34);
		L.RegConstant("Attr_DEX_Percent", 35);
		L.RegConstant("Attr_LUK_Percent", 36);
		L.RegConstant("Attr_Life_Percent", 37);
		L.RegConstant("Attr_Sp_Percent", 38);
		L.RegConstant("Attr_Attack_Percent", 39);
		L.RegConstant("Attr_MagicAttack_Percent", 40);
		L.RegConstant("Attr_Defense_Percent", 41);
		L.RegConstant("Attr_MagicDefense_Percent", 42);
		L.RegConstant("Attr_Hit_Percent", 43);
		L.RegConstant("Attr_Dodge_Percent", 44);
		L.RegConstant("Attr_Crit_Percent", 45);
		L.RegConstant("Attr_Ten_Percent", 46);
		L.RegConstant("Attr_AttackSpeed_Percent", 47);
		L.RegConstant("Attr_CastAcceleration_Percent", 48);
		L.RegConstant("Attr_MaxHp_Percent", 49);
		L.RegConstant("Attr_MaxSp_Percent", 50);
		L.RegConstant("Attr_RealHurt_Percent", 51);
		L.RegConstant("Attr_Nature_None_Damage_Percent", 71);
		L.RegConstant("Attr_Nature_Water_Damage_Percent", 72);
		L.RegConstant("Attr_Nature_Ground_Damage_Percent", 73);
		L.RegConstant("Attr_Nature_Fire_Damage_Percent", 74);
		L.RegConstant("Attr_Nature_Wind_Damage_Percent", 75);
		L.RegConstant("Attr_Nature_Saint_Damage_Percent", 76);
		L.RegConstant("Attr_Nature_Dark_Damage_Percent", 77);
		L.RegConstant("Attr_Nature_Read_Damage_Percent", 78);
		L.RegConstant("Attr_Nature_None_AntiDamage_Percent", 81);
		L.RegConstant("Attr_Nature_Water_AntiDamage_Percent", 82);
		L.RegConstant("Attr_Nature_Ground_AntiDamage_Percent", 83);
		L.RegConstant("Attr_Nature_Fire_AntiDamage_Percent", 84);
		L.RegConstant("Attr_Nature_Wind_AntiDamage_Percent", 85);
		L.RegConstant("Attr_Nature_Saint_AntiDamage_Percent", 86);
		L.RegConstant("Attr_Nature_Dark_AntiDamage_Percent", 87);
		L.RegConstant("Attr_Nature_Read_AntiDamage_Percent", 88);
		L.RegConstant("Attr_Penetration_Percent", 91);
		L.RegConstant("Attr_Magic_Penetration_Percent", 92);
		L.RegConstant("Attr_PhysicDamage_Percent", 93);
		L.RegConstant("Attr_MagicDamage_Percent", 94);
		L.RegConstant("Attr_Anti_PhysicDamage_Percent", 95);
		L.RegConstant("Attr_Anti_MagicDamage_Percent", 96);
		L.RegConstant("Attr_CritDamage_Percent", 97);
		L.RegConstant("Attr_PhysicDamageReflect_Percent", 98);
		L.RegConstant("Attr_MagicDamageReflect_Percent", 99);
		L.RegConstant("Attr_FixedSingTime_Percent", 100);
		L.RegConstant("Attr_VariableSingTime_Percent", 101);
		L.RegConstant("s_FirstAttrNum", 6);
		L.RegConstant("s_SecondAttrNum", 10);
		L.RegConstant("s_AttrNum", 30);
		L.RegConstant("s_AllAttrNum", 101);
		L.RegVar("valid", get_valid, set_valid);
		L.RegVar("IsHaving", get_IsHaving, set_IsHaving);
		L.RegVar("TriggerBuffs", get_TriggerBuffs, null);
		L.RegVar("AdditionAttrs", get_AdditionAttrs, null);
		L.RegVar("AttrPercents", get_AttrPercents, null);
		L.RegVar("IActorType", get_IActorType, null);
		L.RegVar("JobType", get_JobType, null);
		L.RegVar("AType", get_AType, null);
		L.RegVar("BaseId", get_BaseId, set_BaseId);
		L.RegVar("ID", get_ID, set_ID);
		L.RegVar("IsRecordActor", get_IsRecordActor, set_IsRecordActor);
		L.RegVar("AvatarData", get_AvatarData, null);
		L.RegVar("SkillMgr", get_SkillMgr, null);
		L.RegVar("PositionRule", get_PositionRule, null);
		L.RegVar("Rot", get_Rot, null);
		L.RegVar("Offset", get_Offset, null);
		L.RegVar("IsFront", get_IsFront, null);
		L.RegVar("IsBack", get_IsBack, null);
		L.RegVar("AvatarID", get_AvatarID, null);
		L.RegVar("Name", get_Name, set_Name);
		L.RegVar("Description", get_Description, null);
		L.RegVar("Profession", get_Profession, null);
		L.RegVar("JobStage", get_JobStage, null);
		L.RegVar("JobBranch", get_JobBranch, null);
		L.RegVar("PositionValue", get_PositionValue, set_PositionValue);
		L.RegVar("IgnoreLife", get_IgnoreLife, set_IgnoreLife);
		L.RegVar("FighterInstanceId", get_FighterInstanceId, set_FighterInstanceId);
		L.RegVar("IsHero", get_IsHero, null);
		L.RegVar("IsFellow", get_IsFellow, null);
		L.RegVar("IsNpc", get_IsNpc, null);
		L.RegVar("IsPet", get_IsPet, null);
		L.RegVar("IsBoss", get_IsBoss, set_IsBoss);
		L.RegVar("HeadIcon", get_HeadIcon, set_HeadIcon);
		L.RegVar("HeadFrameId", get_HeadFrameId, set_HeadFrameId);
		L.RegVar("BattleBigIcon", get_BattleBigIcon, null);
		L.RegVar("NatureId", get_NatureId, null);
		L.RegVar("ShowHpBar", get_ShowHpBar, null);
		L.RegVar("AnimCtrlName", get_AnimCtrlName, null);
		L.RegVar("ShowAnimCtrlName", get_ShowAnimCtrlName, null);
		L.RegVar("RageId", get_RageId, set_RageId);
		L.RegVar("IsMainRole", get_IsMainRole, set_IsMainRole);
		L.RegVar("NpcData", get_NpcData, null);
		L.RegVar("IsShowBoss", get_IsShowBoss, set_IsShowBoss);
		L.RegVar("Gender", get_Gender, set_Gender);
		L.RegVar("Level", get_Level, set_Level);
		L.RegVar("StrengthLevel", get_StrengthLevel, set_StrengthLevel);
		L.RegVar("ShowLevel", get_ShowLevel, set_ShowLevel);
		L.RegVar("Invincible", get_Invincible, set_Invincible);
		L.RegVar("MEquipTotalAttrs", get_MEquipTotalAttrs, set_MEquipTotalAttrs);
		L.RegVar("IsDisposed", get_IsDisposed, null);
		L.RegVar("SkillFrameEventName", get_SkillFrameEventName, null);
		L.RegVar("ProfessionIcon", get_ProfessionIcon, null);
		L.RegVar("CastSkillParam", get_CastSkillParam, null);
		L.RegVar("IsTransferred", get_IsTransferred, set_IsTransferred);
		L.RegVar("IdleSound", get_IdleSound, null);
		L.RegVar("RunSound", get_RunSound, null);
		L.RegVar("DieSound", get_DieSound, null);
		L.RegVar("HitSound", get_HitSound, null);
		L.RegVar("PetIcon", get_PetIcon, null);
		L.RegVar("BornEffectId", get_BornEffectId, null);
		L.RegVar("BaseSTR", get_BaseSTR, set_BaseSTR);
		L.RegVar("BaseAGI", get_BaseAGI, set_BaseAGI);
		L.RegVar("BaseINT", get_BaseINT, set_BaseINT);
		L.RegVar("BaseVIT", get_BaseVIT, set_BaseVIT);
		L.RegVar("BaseDEX", get_BaseDEX, set_BaseDEX);
		L.RegVar("BaseLUK", get_BaseLUK, set_BaseLUK);
		L.RegVar("STR", get_STR, null);
		L.RegVar("AGI", get_AGI, null);
		L.RegVar("INT", get_INT, null);
		L.RegVar("VIT", get_VIT, null);
		L.RegVar("DEX", get_DEX, null);
		L.RegVar("LUK", get_LUK, null);
		L.RegVar("BaseLife", get_BaseLife, null);
		L.RegVar("BaseSp", get_BaseSp, null);
		L.RegVar("BaseAttack", get_BaseAttack, null);
		L.RegVar("BaseMagicAttack", get_BaseMagicAttack, null);
		L.RegVar("BaseDefense", get_BaseDefense, null);
		L.RegVar("BaseMagicDefense", get_BaseMagicDefense, null);
		L.RegVar("BaseCrit", get_BaseCrit, null);
		L.RegVar("BaseCritDamage", get_BaseCritDamage, null);
		L.RegVar("BaseDodge", get_BaseDodge, null);
		L.RegVar("BaseHit", get_BaseHit, null);
		L.RegVar("BaseTen", get_BaseTen, null);
		L.RegVar("BaseAttackSpeed", get_BaseAttackSpeed, null);
		L.RegVar("Life", get_Life, null);
		L.RegVar("LocalLife", get_LocalLife, null);
		L.RegVar("Sp", get_Sp, null);
		L.RegVar("LocalSp", get_LocalSp, null);
		L.RegVar("MinAttack", get_MinAttack, null);
		L.RegVar("Attack", get_Attack, null);
		L.RegVar("LocalAttack", get_LocalAttack, null);
		L.RegVar("MinMagicAttack", get_MinMagicAttack, null);
		L.RegVar("MagicAttack", get_MagicAttack, null);
		L.RegVar("LocalMagicAttack", get_LocalMagicAttack, null);
		L.RegVar("Defense", get_Defense, null);
		L.RegVar("LocalDefense", get_LocalDefense, null);
		L.RegVar("MagicDefense", get_MagicDefense, null);
		L.RegVar("LocalMagicDefense", get_LocalMagicDefense, null);
		L.RegVar("Crit", get_Crit, null);
		L.RegVar("LocalCrit", get_LocalCrit, null);
		L.RegVar("CritDamagePercent", get_CritDamagePercent, null);
		L.RegVar("Dodge", get_Dodge, null);
		L.RegVar("LocalDodge", get_LocalDodge, null);
		L.RegVar("Hit", get_Hit, null);
		L.RegVar("LocalHit", get_LocalHit, null);
		L.RegVar("Ten", get_Ten, null);
		L.RegVar("LocalTen", get_LocalTen, null);
		L.RegVar("AttackSpeed", get_AttackSpeed, null);
		L.RegVar("LocalAttackSpeed", get_LocalAttackSpeed, null);
		L.RegVar("CastAcceleration", get_CastAcceleration, null);
		L.RegVar("LocalCastAcceleration", get_LocalCastAcceleration, null);
		L.RegVar("GodPower", get_GodPower, null);
		L.RegVar("LocalGodPower", get_LocalGodPower, null);
		L.RegVar("Penetration", get_Penetration, null);
		L.RegVar("MagicPenetration", get_MagicPenetration, null);
		L.RegVar("VariableSingTime", get_VariableSingTime, null);
		L.RegVar("PerfectDodgeRate", get_PerfectDodgeRate, null);
		L.RegVar("DefPercent", get_DefPercent, null);
		L.RegVar("MagicDefPercent", get_MagicDefPercent, null);
		L.RegVar("PetId", get_PetId, set_PetId);
		L.RegVar("PetData", get_PetData, null);
		L.RegVar("HasPet", get_HasPet, null);
		L.RegVar("DropBuffList", get_DropBuffList, null);
		L.RegVar("PveMark", get_PveMark, null);
		L.EndClass();
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int GetuId(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 1);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			long o = obj.GetuId();
			LuaDLL.tolua_pushint64(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int GetBaseId(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 1);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			long o = obj.GetBaseId();
			LuaDLL.tolua_pushint64(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int RefreshSkills(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			SkillParam[] arg0 = ToLua.CheckStructArray<SkillParam>(L, 2);
			obj.RefreshSkills(arg0);
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int Initialize(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 4);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			int arg1 = (int)LuaDLL.luaL_checknumber(L, 3);
			SkillParam[] arg2 = ToLua.CheckStructArray<SkillParam>(L, 4);
			obj.Initialize(arg0, arg1, arg2);
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int GetNverageSkillsLv(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 1);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			int o = obj.GetNverageSkillsLv();
			LuaDLL.lua_pushinteger(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int GetScale(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 1);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			float o = obj.GetScale();
			LuaDLL.lua_pushnumber(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int SetEquipTotalAttr(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 3);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			float arg1 = (float)LuaDLL.luaL_checknumber(L, 3);
			obj.SetEquipTotalAttr(arg0, arg1);
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int GetEquipTotalAttr(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			float o = obj.GetEquipTotalAttr(arg0);
			LuaDLL.lua_pushnumber(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int GetSeverSecondAttr(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			SFloat o = obj.GetSeverSecondAttr(arg0);
			ToLua.PushValue(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int SetServerSecondAttr(IntPtr L)
	{
		try
		{
			int count = LuaDLL.lua_gettop(L);

			if (count == 3 && TypeChecker.CheckTypes<double>(L, 3))
			{
				ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
				int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
				double arg1 = (double)LuaDLL.lua_tonumber(L, 3);
				obj.SetServerSecondAttr(arg0, arg1);
				return 0;
			}
			else if (count == 3 && TypeChecker.CheckTypes<SFloat>(L, 3))
			{
				ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
				int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
				SFloat arg1 = StackTraits<SFloat>.To(L, 3);
				obj.SetServerSecondAttr(arg0, arg1);
				return 0;
			}
			else
			{
				return LuaDLL.luaL_throw(L, "invalid arguments to method: ActorData.SetServerSecondAttr");
			}
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int ResetServerSecondAttr(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 1);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			obj.ResetServerSecondAttr();
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int GetAdditionalAttr(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			SFloat o = obj.GetAdditionalAttr(arg0);
			ToLua.PushValue(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int SetAdditionalAttr(IntPtr L)
	{
		try
		{
			int count = LuaDLL.lua_gettop(L);

			if (count == 3 && TypeChecker.CheckTypes<float>(L, 3))
			{
				ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
				int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
				float arg1 = (float)LuaDLL.lua_tonumber(L, 3);
				obj.SetAdditionalAttr(arg0, arg1);
				return 0;
			}
			else if (count == 3 && TypeChecker.CheckTypes<SFloat>(L, 3))
			{
				ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
				int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
				SFloat arg1 = StackTraits<SFloat>.To(L, 3);
				obj.SetAdditionalAttr(arg0, arg1);
				return 0;
			}
			else
			{
				return LuaDLL.luaL_throw(L, "invalid arguments to method: ActorData.SetAdditionalAttr");
			}
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int ResetAdditionalAttr(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 1);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			obj.ResetAdditionalAttr();
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int ResetAdditionalAttrPercent(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 1);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			obj.ResetAdditionalAttrPercent();
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int GetAdditionalAttrPercent(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			SFloat o = obj.GetAdditionalAttrPercent(arg0);
			ToLua.PushValue(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int SetAdditionalAttrPercent(IntPtr L)
	{
		try
		{
			int count = LuaDLL.lua_gettop(L);

			if (count == 3 && TypeChecker.CheckTypes<float>(L, 3))
			{
				ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
				int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
				float arg1 = (float)LuaDLL.lua_tonumber(L, 3);
				obj.SetAdditionalAttrPercent(arg0, arg1);
				return 0;
			}
			else if (count == 3 && TypeChecker.CheckTypes<SFloat>(L, 3))
			{
				ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
				int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
				SFloat arg1 = StackTraits<SFloat>.To(L, 3);
				obj.SetAdditionalAttrPercent(arg0, arg1);
				return 0;
			}
			else
			{
				return LuaDLL.luaL_throw(L, "invalid arguments to method: ActorData.SetAdditionalAttrPercent");
			}
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int GetFinalAttr(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			SFloat o = obj.GetFinalAttr(arg0);
			ToLua.PushValue(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int CloneAllAttributes(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			ActorData arg0 = (ActorData)ToLua.CheckObject<ActorData>(L, 2);
			obj.CloneAllAttributes(arg0);
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int CloneData(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			ActorData arg0 = (ActorData)ToLua.CheckObject<ActorData>(L, 2);
			obj.CloneData(arg0);
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int GetBaseSecondAttr(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			SFloat o = obj.GetBaseSecondAttr(arg0);
			ToLua.PushValue(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int GetLocalSecondAttr(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			SFloat o = obj.GetLocalSecondAttr(arg0);
			ToLua.PushValue(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int GetSecondAttr(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			SFloat o = obj.GetSecondAttr(arg0);
			ToLua.PushValue(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int GetFirstAttr(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			SFloat o = obj.GetFirstAttr(arg0);
			ToLua.PushValue(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int GetBaseFirstAttr(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			SFloat o = obj.GetBaseFirstAttr(arg0);
			ToLua.PushValue(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int SetBaseFirstAttr(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 3);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			SFloat arg1 = StackTraits<SFloat>.Check(L, 3);
			obj.SetBaseFirstAttr(arg0, arg1);
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int ResetBaseFirstAttr(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 1);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			obj.ResetBaseFirstAttr();
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int GetAttr(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			SFloat o = obj.GetAttr(arg0);
			ToLua.PushValue(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int GetPreviewAttr(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			int[] arg0 = ToLua.CheckNumberArray<int>(L, 2);
			System.Collections.Generic.Dictionary<int,float> o = obj.GetPreviewAttr(arg0);
			ToLua.PushSealed(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int GetPreviewLvUpLocalAttr(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			System.Collections.Generic.Dictionary<int,float> o = obj.GetPreviewLvUpLocalAttr(arg0);
			ToLua.PushSealed(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int GetPreviewLvUpAttr(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			System.Collections.Generic.Dictionary<int,float> o = obj.GetPreviewLvUpAttr(arg0);
			ToLua.PushSealed(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int SetBuffs(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			BuffParam[] arg0 = ToLua.CheckStructArray<BuffParam>(L, 2);
			obj.SetBuffs(arg0);
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int SetDropBuffs(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			BuffParam[] arg0 = ToLua.CheckStructArray<BuffParam>(L, 2);
			obj.SetDropBuffs(arg0);
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int SetPveMark(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			GvGMark arg0 = (GvGMark)ToLua.CheckObject<GvGMark>(L, 2);
			obj.SetPveMark(arg0);
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int ResetFirstSkill(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 1);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			obj.ResetFirstSkill();
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int SetAllAttributes(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 5);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			int[] arg0 = ToLua.CheckNumberArray<int>(L, 2);
			float[] arg1 = ToLua.CheckNumberArray<float>(L, 3);
			float[] arg2 = ToLua.CheckNumberArray<float>(L, 4);
			System.Collections.Generic.Dictionary<int,float> arg3 = (System.Collections.Generic.Dictionary<int,float>)ToLua.CheckObject(L, 5, typeof(System.Collections.Generic.Dictionary<int,float>));
			obj.SetAllAttributes(arg0, arg1, arg2, arg3);
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int SetPet(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			ActorData arg0 = (ActorData)ToLua.CheckObject<ActorData>(L, 2);
			obj.SetPet(arg0);
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int SetLevel(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 2);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			obj.SetLevel(arg0);
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int Dispose(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 1);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			obj.Dispose();
			return 0;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int CloneActorData(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 1);
			ActorData arg0 = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			ActorData o = ActorData.CloneActorData(arg0);
			ToLua.PushObject(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int CreateActorFromJson(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 1);
			JSONObject arg0 = (JSONObject)ToLua.CheckObject<JSONObject>(L, 1);
			ActorData o = ActorData.CreateActorFromJson(arg0);
			ToLua.PushObject(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int CreateNpcPlayerActor(IntPtr L)
	{
		try
		{
			int count = LuaDLL.lua_gettop(L);

			if (count == 3)
			{
				long arg0 = LuaDLL.tolua_checkint64(L, 1);
				int arg1 = (int)LuaDLL.luaL_checknumber(L, 2);
				int arg2 = (int)LuaDLL.luaL_checknumber(L, 3);
				ActorData o = ActorData.CreateNpcPlayerActor(arg0, arg1, arg2);
				ToLua.PushObject(L, o);
				return 1;
			}
			else if (count == 5)
			{
				int arg0 = (int)LuaDLL.luaL_checknumber(L, 1);
				int arg1 = (int)LuaDLL.luaL_checknumber(L, 2);
				int arg2 = (int)LuaDLL.luaL_checknumber(L, 3);
				int arg3 = (int)LuaDLL.luaL_checknumber(L, 4);
				int arg4 = (int)LuaDLL.luaL_checknumber(L, 5);
				ActorData o = ActorData.CreateNpcPlayerActor(arg0, arg1, arg2, arg3, arg4);
				ToLua.PushObject(L, o);
				return 1;
			}
			else
			{
				return LuaDLL.luaL_throw(L, "invalid arguments to method: ActorData.CreateNpcPlayerActor");
			}
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int CreateFellowActor(IntPtr L)
	{
		try
		{
			int count = LuaDLL.lua_gettop(L);

			if (count == 1 && TypeChecker.CheckTypes<ActorParam>(L, 1))
			{
				ActorParam arg0 = (ActorParam)ToLua.ToObject(L, 1);
				ActorData o = ActorData.CreateFellowActor(arg0);
				ToLua.PushObject(L, o);
				return 1;
			}
			else if (count == 1 && TypeChecker.CheckTypes<int>(L, 1))
			{
				int arg0 = (int)LuaDLL.lua_tonumber(L, 1);
				ActorData o = ActorData.CreateFellowActor(arg0);
				ToLua.PushObject(L, o);
				return 1;
			}
			else if (count == 4)
			{
				long arg0 = LuaDLL.tolua_checkint64(L, 1);
				int arg1 = (int)LuaDLL.luaL_checknumber(L, 2);
				int arg2 = (int)LuaDLL.luaL_checknumber(L, 3);
				SkillParam[] arg3 = ToLua.CheckStructArray<SkillParam>(L, 4);
				ActorData o = ActorData.CreateFellowActor(arg0, arg1, arg2, arg3);
				ToLua.PushObject(L, o);
				return 1;
			}
			else
			{
				return LuaDLL.luaL_throw(L, "invalid arguments to method: ActorData.CreateFellowActor");
			}
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int CreatePetActor(IntPtr L)
	{
		try
		{
			int count = LuaDLL.lua_gettop(L);

			if (count == 1)
			{
				ActorParam arg0 = (ActorParam)ToLua.CheckObject<ActorParam>(L, 1);
				ActorData o = ActorData.CreatePetActor(arg0);
				ToLua.PushObject(L, o);
				return 1;
			}
			else if (count == 4)
			{
				long arg0 = LuaDLL.tolua_checkint64(L, 1);
				int arg1 = (int)LuaDLL.luaL_checknumber(L, 2);
				int arg2 = (int)LuaDLL.luaL_checknumber(L, 3);
				SkillParam[] arg3 = ToLua.CheckStructArray<SkillParam>(L, 4);
				ActorData o = ActorData.CreatePetActor(arg0, arg1, arg2, arg3);
				ToLua.PushObject(L, o);
				return 1;
			}
			else
			{
				return LuaDLL.luaL_throw(L, "invalid arguments to method: ActorData.CreatePetActor");
			}
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int CreatePetBossActor(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 3);
			long arg0 = LuaDLL.tolua_checkint64(L, 1);
			int arg1 = (int)LuaDLL.luaL_checknumber(L, 2);
			int arg2 = (int)LuaDLL.luaL_checknumber(L, 3);
			ActorData o = ActorData.CreatePetBossActor(arg0, arg1, arg2);
			ToLua.PushObject(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int CreatePlayerActor(IntPtr L)
	{
		try
		{
			int count = LuaDLL.lua_gettop(L);

			if (count == 1 && TypeChecker.CheckTypes<LuaInterface.LuaTable>(L, 1))
			{
				LuaTable arg0 = ToLua.ToLuaTable(L, 1);
				ActorData o = ActorData.CreatePlayerActor(arg0);
				ToLua.PushObject(L, o);
				return 1;
			}
			else if (count == 1 && TypeChecker.CheckTypes<ActorParam>(L, 1))
			{
				ActorParam arg0 = (ActorParam)ToLua.ToObject(L, 1);
				ActorData o = ActorData.CreatePlayerActor(arg0);
				ToLua.PushObject(L, o);
				return 1;
			}
			else if (count == 1 && TypeChecker.CheckTypes<int>(L, 1))
			{
				int arg0 = (int)LuaDLL.lua_tonumber(L, 1);
				ActorData o = ActorData.CreatePlayerActor(arg0);
				ToLua.PushObject(L, o);
				return 1;
			}
			else if (count == 4)
			{
				long arg0 = LuaDLL.tolua_checkint64(L, 1);
				int arg1 = (int)LuaDLL.luaL_checknumber(L, 2);
				int arg2 = (int)LuaDLL.luaL_checknumber(L, 3);
				SkillParam[] arg3 = ToLua.CheckStructArray<SkillParam>(L, 4);
				ActorData o = ActorData.CreatePlayerActor(arg0, arg1, arg2, arg3);
				ToLua.PushObject(L, o);
				return 1;
			}
			else
			{
				return LuaDLL.luaL_throw(L, "invalid arguments to method: ActorData.CreatePlayerActor");
			}
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int ParseSkillParam(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 1);
			LuaTable arg0 = ToLua.CheckLuaTable(L, 1);
			System.Collections.Generic.List<SkillParam> o = ActorData.ParseSkillParam(arg0);
			ToLua.PushSealed(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int ParseBuffParam(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 1);
			LuaTable arg0 = ToLua.CheckLuaTable(L, 1);
			System.Collections.Generic.List<BuffParam> o = ActorData.ParseBuffParam(arg0);
			ToLua.PushSealed(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int ToJson(IntPtr L)
	{
		try
		{
			ToLua.CheckArgsCount(L, 1);
			ActorData obj = (ActorData)ToLua.CheckObject<ActorData>(L, 1);
			JSONObject o = obj.ToJson();
			ToLua.PushObject(L, o);
			return 1;
		}
		catch (Exception e)
		{
			return LuaDLL.toluaL_exception(L, e);
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_valid(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool ret = obj.valid;
			LuaDLL.lua_pushboolean(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index valid on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_IsHaving(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool ret = obj.IsHaving;
			LuaDLL.lua_pushboolean(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index IsHaving on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_TriggerBuffs(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			System.Collections.Generic.List<TriggerBuffData> ret = obj.TriggerBuffs;
			ToLua.PushSealed(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index TriggerBuffs on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_AdditionAttrs(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat[] ret = obj.AdditionAttrs;
			ToLua.Push(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index AdditionAttrs on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_AttrPercents(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat[] ret = obj.AttrPercents;
			ToLua.Push(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index AttrPercents on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_IActorType(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			int ret = obj.IActorType;
			LuaDLL.lua_pushinteger(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index IActorType on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_JobType(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			int ret = obj.JobType;
			LuaDLL.lua_pushinteger(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index JobType on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_AType(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			ActorType ret = obj.AType;
			ToLua.Push(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index AType on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_BaseId(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			int ret = obj.BaseId;
			LuaDLL.lua_pushinteger(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseId on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_ID(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			long ret = obj.ID;
			LuaDLL.tolua_pushint64(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index ID on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_IsRecordActor(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool ret = obj.IsRecordActor;
			LuaDLL.lua_pushboolean(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index IsRecordActor on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_AvatarData(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			AvatarData ret = obj.AvatarData;
			ToLua.PushObject(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index AvatarData on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_SkillMgr(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SkillManager ret = obj.SkillMgr;
			ToLua.PushObject(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index SkillMgr on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_PositionRule(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			Position_Type ret = obj.PositionRule;
			ToLua.Push(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index PositionRule on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_Rot(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			UnityEngine.Vector3 ret = obj.Rot;
			ToLua.Push(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index Rot on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_Offset(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			UnityEngine.Vector3 ret = obj.Offset;
			ToLua.Push(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index Offset on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_IsFront(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool ret = obj.IsFront;
			LuaDLL.lua_pushboolean(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index IsFront on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_IsBack(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool ret = obj.IsBack;
			LuaDLL.lua_pushboolean(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index IsBack on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_AvatarID(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			int ret = obj.AvatarID;
			LuaDLL.lua_pushinteger(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index AvatarID on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_Name(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			string ret = obj.Name;
			LuaDLL.lua_pushstring(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index Name on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_Description(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			string ret = obj.Description;
			LuaDLL.lua_pushstring(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index Description on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_Profession(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			ProfessionType ret = obj.Profession;
			ToLua.Push(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index Profession on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_JobStage(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			int ret = obj.JobStage;
			LuaDLL.lua_pushinteger(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index JobStage on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_JobBranch(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			int ret = obj.JobBranch;
			LuaDLL.lua_pushinteger(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index JobBranch on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_PositionValue(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			int ret = obj.PositionValue;
			LuaDLL.lua_pushinteger(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index PositionValue on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_IgnoreLife(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool ret = obj.IgnoreLife;
			LuaDLL.lua_pushboolean(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index IgnoreLife on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_FighterInstanceId(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			ulong ret = obj.FighterInstanceId;
			LuaDLL.tolua_pushuint64(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index FighterInstanceId on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_IsHero(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool ret = obj.IsHero;
			LuaDLL.lua_pushboolean(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index IsHero on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_IsFellow(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool ret = obj.IsFellow;
			LuaDLL.lua_pushboolean(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index IsFellow on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_IsNpc(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool ret = obj.IsNpc;
			LuaDLL.lua_pushboolean(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index IsNpc on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_IsPet(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool ret = obj.IsPet;
			LuaDLL.lua_pushboolean(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index IsPet on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_IsBoss(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool ret = obj.IsBoss;
			LuaDLL.lua_pushboolean(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index IsBoss on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_HeadIcon(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			string ret = obj.HeadIcon;
			LuaDLL.lua_pushstring(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index HeadIcon on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_HeadFrameId(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			int ret = obj.HeadFrameId;
			LuaDLL.lua_pushinteger(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index HeadFrameId on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_BattleBigIcon(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			string ret = obj.BattleBigIcon;
			LuaDLL.lua_pushstring(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BattleBigIcon on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_NatureId(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			int ret = obj.NatureId;
			LuaDLL.lua_pushinteger(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index NatureId on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_ShowHpBar(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool ret = obj.ShowHpBar;
			LuaDLL.lua_pushboolean(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index ShowHpBar on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_AnimCtrlName(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			string ret = obj.AnimCtrlName;
			LuaDLL.lua_pushstring(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index AnimCtrlName on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_ShowAnimCtrlName(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			string ret = obj.ShowAnimCtrlName;
			LuaDLL.lua_pushstring(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index ShowAnimCtrlName on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_RageId(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			int ret = obj.RageId;
			LuaDLL.lua_pushinteger(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index RageId on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_IsMainRole(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool ret = obj.IsMainRole;
			LuaDLL.lua_pushboolean(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index IsMainRole on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_NpcData(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			NpcBaseData ret = obj.NpcData;
			ToLua.PushObject(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index NpcData on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_IsShowBoss(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool ret = obj.IsShowBoss;
			LuaDLL.lua_pushboolean(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index IsShowBoss on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_Gender(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			int ret = obj.Gender;
			LuaDLL.lua_pushinteger(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index Gender on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_Level(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			int ret = obj.Level;
			LuaDLL.lua_pushinteger(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index Level on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_StrengthLevel(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			int ret = obj.StrengthLevel;
			LuaDLL.lua_pushinteger(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index StrengthLevel on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_ShowLevel(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			int ret = obj.ShowLevel;
			LuaDLL.lua_pushinteger(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index ShowLevel on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_Invincible(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SBool ret = obj.Invincible;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index Invincible on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_MEquipTotalAttrs(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			System.Collections.Generic.Dictionary<int,SFloat> ret = obj.MEquipTotalAttrs;
			ToLua.PushSealed(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index MEquipTotalAttrs on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_IsDisposed(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool ret = obj.IsDisposed;
			LuaDLL.lua_pushboolean(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index IsDisposed on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_SkillFrameEventName(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			string ret = obj.SkillFrameEventName;
			LuaDLL.lua_pushstring(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index SkillFrameEventName on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_ProfessionIcon(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			string ret = obj.ProfessionIcon;
			LuaDLL.lua_pushstring(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index ProfessionIcon on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_CastSkillParam(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			CastSkillData ret = obj.CastSkillParam;
			ToLua.PushObject(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index CastSkillParam on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_IsTransferred(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool ret = obj.IsTransferred;
			LuaDLL.lua_pushboolean(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index IsTransferred on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_IdleSound(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			string ret = obj.IdleSound;
			LuaDLL.lua_pushstring(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index IdleSound on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_RunSound(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			string ret = obj.RunSound;
			LuaDLL.lua_pushstring(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index RunSound on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_DieSound(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			string ret = obj.DieSound;
			LuaDLL.lua_pushstring(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index DieSound on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_HitSound(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			string ret = obj.HitSound;
			LuaDLL.lua_pushstring(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index HitSound on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_PetIcon(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			string ret = obj.PetIcon;
			LuaDLL.lua_pushstring(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index PetIcon on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_BornEffectId(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			int ret = obj.BornEffectId;
			LuaDLL.lua_pushinteger(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BornEffectId on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_BaseSTR(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SInt ret = obj.BaseSTR;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseSTR on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_BaseAGI(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SInt ret = obj.BaseAGI;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseAGI on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_BaseINT(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SInt ret = obj.BaseINT;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseINT on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_BaseVIT(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SInt ret = obj.BaseVIT;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseVIT on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_BaseDEX(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SInt ret = obj.BaseDEX;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseDEX on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_BaseLUK(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SInt ret = obj.BaseLUK;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseLUK on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_STR(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SInt ret = obj.STR;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index STR on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_AGI(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SInt ret = obj.AGI;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index AGI on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_INT(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SInt ret = obj.INT;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index INT on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_VIT(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SInt ret = obj.VIT;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index VIT on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_DEX(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SInt ret = obj.DEX;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index DEX on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_LUK(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SInt ret = obj.LUK;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index LUK on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_BaseLife(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.BaseLife;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseLife on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_BaseSp(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.BaseSp;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseSp on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_BaseAttack(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.BaseAttack;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseAttack on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_BaseMagicAttack(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.BaseMagicAttack;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseMagicAttack on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_BaseDefense(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.BaseDefense;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseDefense on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_BaseMagicDefense(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.BaseMagicDefense;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseMagicDefense on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_BaseCrit(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.BaseCrit;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseCrit on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_BaseCritDamage(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.BaseCritDamage;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseCritDamage on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_BaseDodge(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.BaseDodge;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseDodge on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_BaseHit(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.BaseHit;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseHit on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_BaseTen(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.BaseTen;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseTen on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_BaseAttackSpeed(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.BaseAttackSpeed;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseAttackSpeed on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_Life(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.Life;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index Life on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_LocalLife(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.LocalLife;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index LocalLife on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_Sp(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.Sp;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index Sp on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_LocalSp(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.LocalSp;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index LocalSp on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_MinAttack(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.MinAttack;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index MinAttack on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_Attack(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.Attack;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index Attack on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_LocalAttack(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.LocalAttack;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index LocalAttack on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_MinMagicAttack(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.MinMagicAttack;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index MinMagicAttack on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_MagicAttack(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.MagicAttack;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index MagicAttack on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_LocalMagicAttack(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.LocalMagicAttack;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index LocalMagicAttack on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_Defense(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.Defense;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index Defense on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_LocalDefense(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.LocalDefense;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index LocalDefense on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_MagicDefense(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.MagicDefense;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index MagicDefense on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_LocalMagicDefense(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.LocalMagicDefense;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index LocalMagicDefense on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_Crit(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.Crit;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index Crit on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_LocalCrit(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.LocalCrit;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index LocalCrit on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_CritDamagePercent(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.CritDamagePercent;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index CritDamagePercent on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_Dodge(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.Dodge;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index Dodge on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_LocalDodge(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.LocalDodge;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index LocalDodge on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_Hit(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.Hit;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index Hit on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_LocalHit(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.LocalHit;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index LocalHit on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_Ten(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.Ten;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index Ten on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_LocalTen(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.LocalTen;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index LocalTen on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_AttackSpeed(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.AttackSpeed;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index AttackSpeed on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_LocalAttackSpeed(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.LocalAttackSpeed;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index LocalAttackSpeed on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_CastAcceleration(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.CastAcceleration;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index CastAcceleration on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_LocalCastAcceleration(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.LocalCastAcceleration;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index LocalCastAcceleration on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_GodPower(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.GodPower;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index GodPower on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_LocalGodPower(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.LocalGodPower;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index LocalGodPower on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_Penetration(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.Penetration;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index Penetration on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_MagicPenetration(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.MagicPenetration;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index MagicPenetration on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_VariableSingTime(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.VariableSingTime;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index VariableSingTime on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_PerfectDodgeRate(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SInt ret = obj.PerfectDodgeRate;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index PerfectDodgeRate on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_DefPercent(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.DefPercent;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index DefPercent on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_MagicDefPercent(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SFloat ret = obj.MagicDefPercent;
			ToLua.PushValue(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index MagicDefPercent on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_PetId(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			long ret = obj.PetId;
			LuaDLL.tolua_pushint64(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index PetId on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_PetData(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			ActorData ret = obj.PetData;
			ToLua.PushObject(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index PetData on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_HasPet(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool ret = obj.HasPet;
			LuaDLL.lua_pushboolean(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index HasPet on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_DropBuffList(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			System.Collections.Generic.List<TriggerBuffData> ret = obj.DropBuffList;
			ToLua.PushSealed(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index DropBuffList on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int get_PveMark(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			GvGMark ret = obj.PveMark;
			ToLua.PushObject(L, ret);
			return 1;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index PveMark on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_valid(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool arg0 = LuaDLL.luaL_checkboolean(L, 2);
			obj.valid = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index valid on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_IsHaving(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool arg0 = LuaDLL.luaL_checkboolean(L, 2);
			obj.IsHaving = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index IsHaving on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_BaseId(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			obj.BaseId = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseId on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_ID(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			long arg0 = LuaDLL.tolua_checkint64(L, 2);
			obj.ID = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index ID on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_IsRecordActor(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool arg0 = LuaDLL.luaL_checkboolean(L, 2);
			obj.IsRecordActor = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index IsRecordActor on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_Name(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			string arg0 = ToLua.CheckString(L, 2);
			obj.Name = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index Name on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_PositionValue(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			obj.PositionValue = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index PositionValue on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_IgnoreLife(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool arg0 = LuaDLL.luaL_checkboolean(L, 2);
			obj.IgnoreLife = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index IgnoreLife on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_FighterInstanceId(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			ulong arg0 = LuaDLL.tolua_checkuint64(L, 2);
			obj.FighterInstanceId = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index FighterInstanceId on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_IsBoss(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool arg0 = LuaDLL.luaL_checkboolean(L, 2);
			obj.IsBoss = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index IsBoss on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_HeadIcon(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			string arg0 = ToLua.CheckString(L, 2);
			obj.HeadIcon = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index HeadIcon on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_HeadFrameId(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			obj.HeadFrameId = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index HeadFrameId on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_RageId(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			obj.RageId = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index RageId on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_IsMainRole(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool arg0 = LuaDLL.luaL_checkboolean(L, 2);
			obj.IsMainRole = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index IsMainRole on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_IsShowBoss(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool arg0 = LuaDLL.luaL_checkboolean(L, 2);
			obj.IsShowBoss = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index IsShowBoss on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_Gender(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			obj.Gender = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index Gender on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_Level(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			obj.Level = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index Level on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_StrengthLevel(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			obj.StrengthLevel = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index StrengthLevel on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_ShowLevel(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			int arg0 = (int)LuaDLL.luaL_checknumber(L, 2);
			obj.ShowLevel = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index ShowLevel on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_Invincible(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SBool arg0 = StackTraits<SBool>.Check(L, 2);
			obj.Invincible = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index Invincible on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_MEquipTotalAttrs(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			System.Collections.Generic.Dictionary<int,SFloat> arg0 = (System.Collections.Generic.Dictionary<int,SFloat>)ToLua.CheckObject(L, 2, typeof(System.Collections.Generic.Dictionary<int,SFloat>));
			obj.MEquipTotalAttrs = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index MEquipTotalAttrs on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_IsTransferred(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			bool arg0 = LuaDLL.luaL_checkboolean(L, 2);
			obj.IsTransferred = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index IsTransferred on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_BaseSTR(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SInt arg0 = StackTraits<SInt>.Check(L, 2);
			obj.BaseSTR = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseSTR on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_BaseAGI(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SInt arg0 = StackTraits<SInt>.Check(L, 2);
			obj.BaseAGI = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseAGI on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_BaseINT(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SInt arg0 = StackTraits<SInt>.Check(L, 2);
			obj.BaseINT = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseINT on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_BaseVIT(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SInt arg0 = StackTraits<SInt>.Check(L, 2);
			obj.BaseVIT = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseVIT on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_BaseDEX(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SInt arg0 = StackTraits<SInt>.Check(L, 2);
			obj.BaseDEX = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseDEX on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_BaseLUK(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			SInt arg0 = StackTraits<SInt>.Check(L, 2);
			obj.BaseLUK = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index BaseLUK on a nil value");
		}
	}

	[MonoPInvokeCallbackAttribute(typeof(LuaCSFunction))]
	static int set_PetId(IntPtr L)
	{
		object o = null;

		try
		{
			o = ToLua.ToObject(L, 1);
			ActorData obj = (ActorData)o;
			long arg0 = LuaDLL.tolua_checkint64(L, 2);
			obj.PetId = arg0;
			return 0;
		}
		catch(Exception e)
		{
			return LuaDLL.toluaL_exception(L, e, o, "attempt to index PetId on a nil value");
		}
	}
}