/*
** Lua binding: AllToLua
** Generated automatically by tolua++-1.0.92 on Thu Nov  7 00:09:47 2024.
*/

#ifndef __cplusplus
#include "stdlib.h"
#endif
#include "string.h"

#include "tolua++.h"

/* Exported function */
TOLUA_API int  tolua_AllToLua_open (lua_State* tolua_S);

#include "../Globals.h"
#include "../Vector3.h"
#include "../ChunkDef.h"
#include "../BiomeDef.h"
#include "../IniFile.h"
#include "../OSSupport/File.h"
#include "LuaFunctions.h"
#include "PluginManager.h"
#include "Plugin.h"
#include "PluginLua.h"
#include "LuaWindow.h"
#include "../BlockType.h"
#include "../BlockInfo.h"
#include "../StringUtils.h"
#include "../Defines.h"
#include "../ChatColor.h"
#include "../ClientHandle.h"
#include "../Color.h"
#include "../EffectID.h"
#include "../Server.h"
#include "../World.h"
#include "../Inventory.h"
#include "../Enchantments.h"
#include "../Item.h"
#include "../ItemGrid.h"
#include "../WebAdmin.h"
#include "../Root.h"
#include "../Cuboid.h"
#include "../BoundingBox.h"
#include "../BlockArea.h"
#include "../Generating/ChunkDesc.h"
#include "../CraftingRecipes.h"
#include "../UI/Window.h"
#include "../CompositeChat.h"
#include "../Map.h"
#include "../MapManager.h"
#include "../Scoreboard.h"
#include "../StatisticsManager.h"
#include "../Protocol/MojangAPI.h"
#include "../UUID.h"
#include "../Entities/Entity.h"
#include "../Entities/EnderCrystal.h"
#include "../Entities/Boat.h"
#include "../Entities/Pawn.h"
#include "../Entities/ProjectileEntity.h"
#include "../Entities/ArrowEntity.h"
#include "../Entities/EntityEffect.h"
#include "../Entities/ExpBottleEntity.h"
#include "../Entities/ExpOrb.h"
#include "../Entities/FallingBlock.h"
#include "../Entities/FireChargeEntity.h"
#include "../Entities/FireworkEntity.h"
#include "../Entities/Floater.h"
#include "../Entities/GhastFireballEntity.h"
#include "../Entities/HangingEntity.h"
#include "../Entities/ItemFrame.h"
#include "../Entities/LeashKnot.h"
#include "../Entities/Player.h"
#include "../Entities/Painting.h"
#include "../Entities/Pickup.h"
#include "../Entities/SplashPotionEntity.h"
#include "../Entities/ThrownEggEntity.h"
#include "../Entities/ThrownEnderPearlEntity.h"
#include "../Entities/ThrownSnowballEntity.h"
#include "../Entities/TNTEntity.h"
#include "../Entities/WitherSkullEntity.h"
#include "../Mobs/MonsterTypes.h"
#include "../Mobs/Monster.h"
#include "../BlockEntities/BlockEntity.h"
#include "../BlockEntities/BeaconEntity.h"
#include "../BlockEntities/BedEntity.h"
#include "../BlockEntities/BlockEntityWithItems.h"
#include "../BlockEntities/BrewingstandEntity.h"
#include "../BlockEntities/ChestEntity.h"
#include "../BlockEntities/CommandBlockEntity.h"
#include "../BlockEntities/DropSpenserEntity.h"
#include "../BlockEntities/DispenserEntity.h"
#include "../BlockEntities/DropperEntity.h"
#include "../BlockEntities/FurnaceEntity.h"
#include "../BlockEntities/HopperEntity.h"
#include "../BlockEntities/JukeboxEntity.h"
#include "../BlockEntities/NoteEntity.h"
#include "../BlockEntities/SignEntity.h"
#include "../BlockEntities/MobHeadEntity.h"
#include "../BlockEntities/MobSpawnerEntity.h"
#include "../BlockEntities/FlowerPotEntity.h"
#include "../Registries/CustomStatistics.h"

/* function to release collected object via destructor */
#ifdef __cplusplus

static int tolua_collect_cEnchantments (lua_State* tolua_S)
{
 cEnchantments* self = (cEnchantments*) tolua_tousertype(tolua_S,1,nullptr);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_cItem (lua_State* tolua_S)
{
 cItem* self = (cItem*) tolua_tousertype(tolua_S,1,nullptr);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_cUUID (lua_State* tolua_S)
{
 cUUID* self = (cUUID*) tolua_tousertype(tolua_S,1,nullptr);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_cIniFile (lua_State* tolua_S)
{
 cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,nullptr);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_cCraftingGrid (lua_State* tolua_S)
{
 cCraftingGrid* self = (cCraftingGrid*) tolua_tousertype(tolua_S,1,nullptr);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_cItems (lua_State* tolua_S)
{
 cItems* self = (cItems*) tolua_tousertype(tolua_S,1,nullptr);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_cBlockArea (lua_State* tolua_S)
{
 cBlockArea* self = (cBlockArea*) tolua_tousertype(tolua_S,1,nullptr);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_cBoundingBox (lua_State* tolua_S)
{
 cBoundingBox* self = (cBoundingBox*) tolua_tousertype(tolua_S,1,nullptr);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_Vector3_float_ (lua_State* tolua_S)
{
 Vector3<float>* self = (Vector3<float>*) tolua_tousertype(tolua_S,1,nullptr);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_cCuboid (lua_State* tolua_S)
{
 cCuboid* self = (cCuboid*) tolua_tousertype(tolua_S,1,nullptr);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_cBlockEntity (lua_State* tolua_S)
{
 cBlockEntity* self = (cBlockEntity*) tolua_tousertype(tolua_S,1,nullptr);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_cColor (lua_State* tolua_S)
{
 cColor* self = (cColor*) tolua_tousertype(tolua_S,1,nullptr);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_Vector3_double_ (lua_State* tolua_S)
{
 Vector3<double>* self = (Vector3<double>*) tolua_tousertype(tolua_S,1,nullptr);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_cLuaWindow (lua_State* tolua_S)
{
 cLuaWindow* self = (cLuaWindow*) tolua_tousertype(tolua_S,1,nullptr);
	Mtolua_delete(self);
	return 0;
}

static int tolua_collect_Vector3_int_ (lua_State* tolua_S)
{
 Vector3<int>* self = (Vector3<int>*) tolua_tousertype(tolua_S,1,nullptr);
	Mtolua_delete(self);
	return 0;
}
#endif


/* function to register type */
static void tolua_reg_types (lua_State* tolua_S)
{
 tolua_usertype(tolua_S,"cPainting");
 tolua_usertype(tolua_S,"cThrownEnderPearlEntity");
 tolua_usertype(tolua_S,"cWindow");
 tolua_usertype(tolua_S,"cBrewingstandEntity");
 tolua_usertype(tolua_S,"cEntity");
 tolua_usertype(tolua_S,"cCuboid");
 tolua_usertype(tolua_S,"cEnchantments");
 tolua_usertype(tolua_S,"cMonster");
 tolua_usertype(tolua_S,"cPluginLua");
 tolua_usertype(tolua_S,"cRoot");
 tolua_usertype(tolua_S,"cEnderCrystal");
 tolua_usertype(tolua_S,"cFile");
 tolua_usertype(tolua_S,"cItems");
 tolua_usertype(tolua_S,"cFireChargeEntity");
 tolua_usertype(tolua_S,"cWorld");
 tolua_usertype(tolua_S,"cChunkDesc");
 tolua_usertype(tolua_S,"cLazyArray<cItem>");
 tolua_usertype(tolua_S,"cBedEntity");
 tolua_usertype(tolua_S,"cPluginManager");
 tolua_usertype(tolua_S,"cObjective");
 tolua_usertype(tolua_S,"cCraftingRecipes");
 tolua_usertype(tolua_S,"cWitherSkullEntity");
 tolua_usertype(tolua_S,"cChestEntity");
 tolua_usertype(tolua_S,"cCraftingGrid");
 tolua_usertype(tolua_S,"cMobHeadEntity");
 tolua_usertype(tolua_S,"cMap");
 tolua_usertype(tolua_S,"cGhastFireballEntity");
 tolua_usertype(tolua_S,"cLeashKnot");
 tolua_usertype(tolua_S,"cBoat");
 tolua_usertype(tolua_S,"cEntityEffect");
 tolua_usertype(tolua_S,"AStringMap");
 tolua_usertype(tolua_S,"cListeners");
 tolua_usertype(tolua_S,"cItemFrame");
 tolua_usertype(tolua_S,"cSettingsRepositoryInterface");
 tolua_usertype(tolua_S,"cThrownSnowballEntity");
 tolua_usertype(tolua_S,"cFireworkEntity");
 tolua_usertype(tolua_S,"cMojangAPI");
 tolua_usertype(tolua_S,"cSplashPotionEntity");
 tolua_usertype(tolua_S,"TakeDamageInfo");
 tolua_usertype(tolua_S,"cFlowerPotEntity");
 tolua_usertype(tolua_S,"HTTPTemplateRequest");
 tolua_usertype(tolua_S,"cCraftingRecipe");
 tolua_usertype(tolua_S,"cPlugin");
 tolua_usertype(tolua_S,"cSignEntity");
 tolua_usertype(tolua_S,"cCompositeChat");
 tolua_usertype(tolua_S,"cItemGrid");
 tolua_usertype(tolua_S,"cBlockArea");
 tolua_usertype(tolua_S,"cHangingEntity");
 tolua_usertype(tolua_S,"cUUID");
 tolua_usertype(tolua_S,"cServer");
 tolua_usertype(tolua_S,"cJukeboxEntity");
 tolua_usertype(tolua_S,"cHopperEntity");
 tolua_usertype(tolua_S,"cFurnaceEntity");
 tolua_usertype(tolua_S,"cBoundingBox");
 tolua_usertype(tolua_S,"cDropperEntity");
 tolua_usertype(tolua_S,"cFireworkItem");
 tolua_usertype(tolua_S,"cDispenserEntity");
 tolua_usertype(tolua_S,"cFallingBlock");
 tolua_usertype(tolua_S,"StatisticsManager");
 tolua_usertype(tolua_S,"cFloater");
 tolua_usertype(tolua_S,"cScoreboard");
 tolua_usertype(tolua_S,"cChatColor");
 tolua_usertype(tolua_S,"cBlockEntityWithItems");
 tolua_usertype(tolua_S,"cBeaconEntity");
 tolua_usertype(tolua_S,"cProjectileEntity");
 tolua_usertype(tolua_S,"cTNTEntity");
 tolua_usertype(tolua_S,"cThrownEggEntity");
 tolua_usertype(tolua_S,"cItem");
 tolua_usertype(tolua_S,"cPickup");
 tolua_usertype(tolua_S,"cArrowEntity");
 tolua_usertype(tolua_S,"cDropSpenserEntity");
 tolua_usertype(tolua_S,"Vector3<float>");
 tolua_usertype(tolua_S,"cTeam");
 tolua_usertype(tolua_S,"cCommandBlockEntity");
 tolua_usertype(tolua_S,"cNoteEntity");
 tolua_usertype(tolua_S,"cBlockInfo");
 tolua_usertype(tolua_S,"cBlockEntity");
 tolua_usertype(tolua_S,"cCriticalSection");
 tolua_usertype(tolua_S,"Vector3<double>");
 tolua_usertype(tolua_S,"Vector3<int>");
 tolua_usertype(tolua_S,"cExpOrb");
 tolua_usertype(tolua_S,"cExpBottleEntity");
 tolua_usertype(tolua_S,"cLuaWindow");
 tolua_usertype(tolua_S,"cInventory");
 tolua_usertype(tolua_S,"cMobSpawnerEntity");
 tolua_usertype(tolua_S,"cIniFile");
 tolua_usertype(tolua_S,"EntityAnimation");
 tolua_usertype(tolua_S,"cClientHandle");
 tolua_usertype(tolua_S,"cPawn");
 tolua_usertype(tolua_S,"cPlayer");
 tolua_usertype(tolua_S,"HTTPFormData");
 tolua_usertype(tolua_S,"cBlockEntityWindowOwner");
 tolua_usertype(tolua_S,"cMapManager");
 tolua_usertype(tolua_S,"cColor");
 tolua_usertype(tolua_S,"cWebAdmin");
 tolua_usertype(tolua_S,"HTTPRequest");
 tolua_usertype(tolua_S,"AStringVector");
}

/* get function: x of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_get_Vector3_int__x
static int tolua_get_Vector3_int__x(lua_State* tolua_S)
{
  Vector3<int>* self = (Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",nullptr);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->x);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: x of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_set_Vector3_int__x
static int tolua_set_Vector3_int__x(lua_State* tolua_S)
{
  Vector3<int>* self = (Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",nullptr);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->x = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: y of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_get_Vector3_int__y
static int tolua_get_Vector3_int__y(lua_State* tolua_S)
{
  Vector3<int>* self = (Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",nullptr);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->y);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: y of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_set_Vector3_int__y
static int tolua_set_Vector3_int__y(lua_State* tolua_S)
{
  Vector3<int>* self = (Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",nullptr);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->y = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: z of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_get_Vector3_int__z
static int tolua_get_Vector3_int__z(lua_State* tolua_S)
{
  Vector3<int>* self = (Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'z'",nullptr);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->z);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: z of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_set_Vector3_int__z
static int tolua_set_Vector3_int__z(lua_State* tolua_S)
{
  Vector3<int>* self = (Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'z'",nullptr);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->z = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_new00
static int tolua_AllToLua_Vector3i_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   Vector3<int>* tolua_ret = (Vector3<int>*)  Mtolua_new((Vector3<int>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<int>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_new00_local
static int tolua_AllToLua_Vector3i_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   Vector3<int>* tolua_ret = (Vector3<int>*)  Mtolua_new((Vector3<int>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_new01
static int tolua_AllToLua_Vector3i_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<int>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  int a_x = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_y = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_z = ((int)  tolua_tonumber(tolua_S,4,0));
  {
   Vector3<int>* tolua_ret = (Vector3<int>*)  Mtolua_new((Vector3<int>)(a_x,a_y,a_z));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<int>");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3i_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_new01_local
static int tolua_AllToLua_Vector3i_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<int>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  int a_x = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_y = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_z = ((int)  tolua_tonumber(tolua_S,4,0));
  {
   Vector3<int>* tolua_ret = (Vector3<int>*)  Mtolua_new((Vector3<int>)(a_x,a_y,a_z));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3i_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_new02
static int tolua_AllToLua_Vector3i_new02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<int>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<float>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<float>* a_Rhs = ((const Vector3<float>*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   Vector3<int>* tolua_ret = (Vector3<int>*)  Mtolua_new((Vector3<int>)(*a_Rhs));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<int>");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3i_new01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_new02_local
static int tolua_AllToLua_Vector3i_new02_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<int>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<float>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<float>* a_Rhs = ((const Vector3<float>*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   Vector3<int>* tolua_ret = (Vector3<int>*)  Mtolua_new((Vector3<int>)(*a_Rhs));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3i_new01_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_new03
static int tolua_AllToLua_Vector3i_new03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<int>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<double>* a_Rhs = ((const Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   Vector3<int>* tolua_ret = (Vector3<int>*)  Mtolua_new((Vector3<int>)(*a_Rhs));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<int>");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3i_new02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_new03_local
static int tolua_AllToLua_Vector3i_new03_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<int>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<double>* a_Rhs = ((const Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   Vector3<int>* tolua_ret = (Vector3<int>*)  Mtolua_new((Vector3<int>)(*a_Rhs));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3i_new02_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_new04
static int tolua_AllToLua_Vector3i_new04(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<int>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<int>* a_Rhs = ((const Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   Vector3<int>* tolua_ret = (Vector3<int>*)  Mtolua_new((Vector3<int>)(*a_Rhs));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<int>");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3i_new03(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_new04_local
static int tolua_AllToLua_Vector3i_new04_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<int>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<int>* a_Rhs = ((const Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   Vector3<int>* tolua_ret = (Vector3<int>*)  Mtolua_new((Vector3<int>)(*a_Rhs));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3i_new03_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: Set of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_Set00
static int tolua_AllToLua_Vector3i_Set00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<int>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vector3<int>* self = (Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_x = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_y = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_z = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Set'", nullptr);
#endif
  {
   self->Set(a_x,a_y,a_z);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Set'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Normalize of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_Normalize00
static int tolua_AllToLua_Vector3i_Normalize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vector3<int>* self = (Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Normalize'", nullptr);
#endif
  {
   self->Normalize();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Normalize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: NormalizeCopy of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_NormalizeCopy00
static int tolua_AllToLua_Vector3i_NormalizeCopy00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<int>* self = (const Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NormalizeCopy'", nullptr);
#endif
  {
   Vector3<int> tolua_ret = (Vector3<int>)  self->NormalizeCopy();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'NormalizeCopy'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: HasNonZeroLength of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_HasNonZeroLength00
static int tolua_AllToLua_Vector3i_HasNonZeroLength00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<int>* self = (const Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HasNonZeroLength'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->HasNonZeroLength();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'HasNonZeroLength'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Length of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_Length00
static int tolua_AllToLua_Vector3i_Length00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<int>* self = (const Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Length'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->Length();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Length'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SqrLength of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_SqrLength00
static int tolua_AllToLua_Vector3i_SqrLength00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<int>* self = (const Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SqrLength'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->SqrLength();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SqrLength'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Dot of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_Dot00
static int tolua_AllToLua_Vector3i_Dot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<int>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<int>* self = (const Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<int>* a_Rhs = ((const Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Dot'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->Dot(*a_Rhs);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Dot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Abs of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_Abs00
static int tolua_AllToLua_Vector3i_Abs00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vector3<int>* self = (Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Abs'", nullptr);
#endif
  {
   self->Abs();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Abs'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Clamp of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_Clamp00
static int tolua_AllToLua_Vector3i_Clamp00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<int>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vector3<int>* self = (Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_Min = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_Max = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Clamp'", nullptr);
#endif
  {
   self->Clamp(a_Min,a_Max);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Clamp'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Cross of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_Cross00
static int tolua_AllToLua_Vector3i_Cross00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<int>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<int>* self = (const Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<int>* a_Rhs = ((const Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Cross'", nullptr);
#endif
  {
   Vector3<int> tolua_ret = (Vector3<int>)  self->Cross(*a_Rhs);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Cross'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Equals of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_Equals00
static int tolua_AllToLua_Vector3i_Equals00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<int>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<int>* self = (const Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<int>* a_Rhs = ((const Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Equals'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->Equals(*a_Rhs);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Equals'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: EqualsEps of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_EqualsEps00
static int tolua_AllToLua_Vector3i_EqualsEps00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<int>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<int>* self = (const Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<int>* a_Rhs = ((const Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
  int a_Eps = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'EqualsEps'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->EqualsEps(*a_Rhs,a_Eps);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'EqualsEps'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Move of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_Move00
static int tolua_AllToLua_Vector3i_Move00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<int>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vector3<int>* self = (Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_X = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_Y = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_Z = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Move'", nullptr);
#endif
  {
   self->Move(a_X,a_Y,a_Z);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Move'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Move of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_Move01
static int tolua_AllToLua_Vector3i_Move01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<int>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  Vector3<int>* self = (Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<int>* a_Diff = ((const Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Move'", nullptr);
#endif
  {
   self->Move(*a_Diff);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_Vector3i_Move00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: Floor of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_Floor00
static int tolua_AllToLua_Vector3i_Floor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<int>* self = (const Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Floor'", nullptr);
#endif
  {
   Vector3<int> tolua_ret = (Vector3<int>)  self->Floor();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Floor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Ceil of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_Ceil00
static int tolua_AllToLua_Vector3i_Ceil00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<int>* self = (const Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Ceil'", nullptr);
#endif
  {
   Vector3<int> tolua_ret = (Vector3<int>)  self->Ceil();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Ceil'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator+ of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i__add00
static int tolua_AllToLua_Vector3i__add00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<int>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<int>* self = (const Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<int>* a_Rhs = ((const Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'", nullptr);
#endif
  {
   Vector3<int> tolua_ret = (Vector3<int>)  self->operator+(*a_Rhs);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.add'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator- of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i__sub00
static int tolua_AllToLua_Vector3i__sub00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<int>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<int>* self = (const Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<int>* a_Rhs = ((const Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'", nullptr);
#endif
  {
   Vector3<int> tolua_ret = (Vector3<int>)  self->operator-(*a_Rhs);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.sub'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator- of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i__sub01
static int tolua_AllToLua_Vector3i__sub01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<int>* self = (const Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'", nullptr);
#endif
  {
   Vector3<int> tolua_ret = (Vector3<int>)  self->operator-();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3i__sub00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator* of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i__mul00
static int tolua_AllToLua_Vector3i__mul00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<int>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<int>* self = (const Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<int>* a_Rhs = ((const Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'", nullptr);
#endif
  {
   Vector3<int> tolua_ret = (Vector3<int>)  self->operator*(*a_Rhs);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.mul'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator/ of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i__div00
static int tolua_AllToLua_Vector3i__div00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<int>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vector3<int>* self = (Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<int>* a_Rhs = ((const Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator/'", nullptr);
#endif
  {
   Vector3<int> tolua_ret = (Vector3<int>)  self->operator/(*a_Rhs);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.div'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator* of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i__mul01
static int tolua_AllToLua_Vector3i__mul01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<int>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<int>* self = (const Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_v = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'", nullptr);
#endif
  {
   Vector3<int> tolua_ret = (Vector3<int>)  self->operator*(a_v);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3i__mul00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator/ of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i__div01
static int tolua_AllToLua_Vector3i__div01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<int>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<int>* self = (const Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_v = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator/'", nullptr);
#endif
  {
   Vector3<int> tolua_ret = (Vector3<int>)  self->operator/(a_v);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3i__div00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: addedX of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_addedX00
static int tolua_AllToLua_Vector3i_addedX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<int>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<int>* self = (const Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_AddX = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addedX'", nullptr);
#endif
  {
   Vector3<int> tolua_ret = (Vector3<int>)  self->addedX(a_AddX);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addedX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addedY of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_addedY00
static int tolua_AllToLua_Vector3i_addedY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<int>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<int>* self = (const Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_AddY = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addedY'", nullptr);
#endif
  {
   Vector3<int> tolua_ret = (Vector3<int>)  self->addedY(a_AddY);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addedY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addedZ of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_addedZ00
static int tolua_AllToLua_Vector3i_addedZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<int>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<int>* self = (const Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_AddZ = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addedZ'", nullptr);
#endif
  {
   Vector3<int> tolua_ret = (Vector3<int>)  self->addedZ(a_AddZ);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addedZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addedXZ of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_addedXZ00
static int tolua_AllToLua_Vector3i_addedXZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<int>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<int>* self = (const Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_AddX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_AddZ = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addedXZ'", nullptr);
#endif
  {
   Vector3<int> tolua_ret = (Vector3<int>)  self->addedXZ(a_AddX,a_AddZ);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addedXZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: LineCoeffToXYPlane of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_LineCoeffToXYPlane00
static int tolua_AllToLua_Vector3i_LineCoeffToXYPlane00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<int>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<int>* self = (const Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<int>* a_OtherEnd = ((const Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
  int a_Z = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'LineCoeffToXYPlane'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->LineCoeffToXYPlane(*a_OtherEnd,a_Z);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'LineCoeffToXYPlane'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: LineCoeffToXZPlane of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_LineCoeffToXZPlane00
static int tolua_AllToLua_Vector3i_LineCoeffToXZPlane00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<int>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<int>* self = (const Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<int>* a_OtherEnd = ((const Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
  int a_Y = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'LineCoeffToXZPlane'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->LineCoeffToXZPlane(*a_OtherEnd,a_Y);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'LineCoeffToXZPlane'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: LineCoeffToYZPlane of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_LineCoeffToYZPlane00
static int tolua_AllToLua_Vector3i_LineCoeffToYZPlane00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<int>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<int>* self = (const Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<int>* a_OtherEnd = ((const Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
  int a_X = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'LineCoeffToYZPlane'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->LineCoeffToYZPlane(*a_OtherEnd,a_X);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'LineCoeffToYZPlane'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: TurnCW of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_TurnCW00
static int tolua_AllToLua_Vector3i_TurnCW00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vector3<int>* self = (Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'TurnCW'", nullptr);
#endif
  {
   self->TurnCW();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'TurnCW'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: TurnCCW of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_TurnCCW00
static int tolua_AllToLua_Vector3i_TurnCCW00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<int>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vector3<int>* self = (Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'TurnCCW'", nullptr);
#endif
  {
   self->TurnCCW();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'TurnCCW'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EPS of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_get_Vector3_int__EPS
static int tolua_get_Vector3_int__EPS(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)Vector3<int>::EPS);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: NO_INTERSECTION of class  Vector3<int> */
#ifndef TOLUA_DISABLE_tolua_get_Vector3_int__NO_INTERSECTION
static int tolua_get_Vector3_int__NO_INTERSECTION(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)Vector3<int>::NO_INTERSECTION);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: x of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_get_Vector3_float__x
static int tolua_get_Vector3_float__x(lua_State* tolua_S)
{
  Vector3<float>* self = (Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",nullptr);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->x);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: x of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_set_Vector3_float__x
static int tolua_set_Vector3_float__x(lua_State* tolua_S)
{
  Vector3<float>* self = (Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",nullptr);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->x = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: y of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_get_Vector3_float__y
static int tolua_get_Vector3_float__y(lua_State* tolua_S)
{
  Vector3<float>* self = (Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",nullptr);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->y);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: y of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_set_Vector3_float__y
static int tolua_set_Vector3_float__y(lua_State* tolua_S)
{
  Vector3<float>* self = (Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",nullptr);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->y = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: z of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_get_Vector3_float__z
static int tolua_get_Vector3_float__z(lua_State* tolua_S)
{
  Vector3<float>* self = (Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'z'",nullptr);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->z);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: z of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_set_Vector3_float__z
static int tolua_set_Vector3_float__z(lua_State* tolua_S)
{
  Vector3<float>* self = (Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'z'",nullptr);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->z = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_new00
static int tolua_AllToLua_Vector3f_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<float>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   Vector3<float>* tolua_ret = (Vector3<float>*)  Mtolua_new((Vector3<float>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<float>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_new00_local
static int tolua_AllToLua_Vector3f_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<float>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   Vector3<float>* tolua_ret = (Vector3<float>*)  Mtolua_new((Vector3<float>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_new01
static int tolua_AllToLua_Vector3f_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<float>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  float a_x = ((float)  tolua_tonumber(tolua_S,2,0));
  float a_y = ((float)  tolua_tonumber(tolua_S,3,0));
  float a_z = ((float)  tolua_tonumber(tolua_S,4,0));
  {
   Vector3<float>* tolua_ret = (Vector3<float>*)  Mtolua_new((Vector3<float>)(a_x,a_y,a_z));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<float>");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3f_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_new01_local
static int tolua_AllToLua_Vector3f_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<float>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  float a_x = ((float)  tolua_tonumber(tolua_S,2,0));
  float a_y = ((float)  tolua_tonumber(tolua_S,3,0));
  float a_z = ((float)  tolua_tonumber(tolua_S,4,0));
  {
   Vector3<float>* tolua_ret = (Vector3<float>*)  Mtolua_new((Vector3<float>)(a_x,a_y,a_z));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3f_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_new02
static int tolua_AllToLua_Vector3f_new02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<float>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<float>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<float>* a_Rhs = ((const Vector3<float>*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   Vector3<float>* tolua_ret = (Vector3<float>*)  Mtolua_new((Vector3<float>)(*a_Rhs));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<float>");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3f_new01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_new02_local
static int tolua_AllToLua_Vector3f_new02_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<float>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<float>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<float>* a_Rhs = ((const Vector3<float>*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   Vector3<float>* tolua_ret = (Vector3<float>*)  Mtolua_new((Vector3<float>)(*a_Rhs));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3f_new01_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_new03
static int tolua_AllToLua_Vector3f_new03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<float>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<double>* a_Rhs = ((const Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   Vector3<float>* tolua_ret = (Vector3<float>*)  Mtolua_new((Vector3<float>)(*a_Rhs));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<float>");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3f_new02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_new03_local
static int tolua_AllToLua_Vector3f_new03_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<float>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<double>* a_Rhs = ((const Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   Vector3<float>* tolua_ret = (Vector3<float>*)  Mtolua_new((Vector3<float>)(*a_Rhs));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3f_new02_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_new04
static int tolua_AllToLua_Vector3f_new04(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<float>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<int>* a_Rhs = ((const Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   Vector3<float>* tolua_ret = (Vector3<float>*)  Mtolua_new((Vector3<float>)(*a_Rhs));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<float>");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3f_new03(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_new04_local
static int tolua_AllToLua_Vector3f_new04_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<float>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<int>* a_Rhs = ((const Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   Vector3<float>* tolua_ret = (Vector3<float>*)  Mtolua_new((Vector3<float>)(*a_Rhs));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3f_new03_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: Set of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_Set00
static int tolua_AllToLua_Vector3f_Set00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<float>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vector3<float>* self = (Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
  float a_x = ((float)  tolua_tonumber(tolua_S,2,0));
  float a_y = ((float)  tolua_tonumber(tolua_S,3,0));
  float a_z = ((float)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Set'", nullptr);
#endif
  {
   self->Set(a_x,a_y,a_z);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Set'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Normalize of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_Normalize00
static int tolua_AllToLua_Vector3f_Normalize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<float>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vector3<float>* self = (Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Normalize'", nullptr);
#endif
  {
   self->Normalize();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Normalize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: NormalizeCopy of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_NormalizeCopy00
static int tolua_AllToLua_Vector3f_NormalizeCopy00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<float>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<float>* self = (const Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NormalizeCopy'", nullptr);
#endif
  {
   Vector3<float> tolua_ret = (Vector3<float>)  self->NormalizeCopy();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<float>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<float>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'NormalizeCopy'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: HasNonZeroLength of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_HasNonZeroLength00
static int tolua_AllToLua_Vector3f_HasNonZeroLength00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<float>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<float>* self = (const Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HasNonZeroLength'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->HasNonZeroLength();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'HasNonZeroLength'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Length of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_Length00
static int tolua_AllToLua_Vector3f_Length00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<float>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<float>* self = (const Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Length'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->Length();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Length'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SqrLength of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_SqrLength00
static int tolua_AllToLua_Vector3f_SqrLength00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<float>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<float>* self = (const Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SqrLength'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->SqrLength();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SqrLength'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Dot of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_Dot00
static int tolua_AllToLua_Vector3f_Dot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<float>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<float>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<float>* self = (const Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<float>* a_Rhs = ((const Vector3<float>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Dot'", nullptr);
#endif
  {
   float tolua_ret = (float)  self->Dot(*a_Rhs);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Dot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Abs of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_Abs00
static int tolua_AllToLua_Vector3f_Abs00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<float>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vector3<float>* self = (Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Abs'", nullptr);
#endif
  {
   self->Abs();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Abs'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Clamp of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_Clamp00
static int tolua_AllToLua_Vector3f_Clamp00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<float>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vector3<float>* self = (Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
  float a_Min = ((float)  tolua_tonumber(tolua_S,2,0));
  float a_Max = ((float)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Clamp'", nullptr);
#endif
  {
   self->Clamp(a_Min,a_Max);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Clamp'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Cross of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_Cross00
static int tolua_AllToLua_Vector3f_Cross00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<float>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<float>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<float>* self = (const Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<float>* a_Rhs = ((const Vector3<float>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Cross'", nullptr);
#endif
  {
   Vector3<float> tolua_ret = (Vector3<float>)  self->Cross(*a_Rhs);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<float>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<float>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Cross'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Equals of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_Equals00
static int tolua_AllToLua_Vector3f_Equals00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<float>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<float>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<float>* self = (const Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<float>* a_Rhs = ((const Vector3<float>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Equals'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->Equals(*a_Rhs);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Equals'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: EqualsEps of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_EqualsEps00
static int tolua_AllToLua_Vector3f_EqualsEps00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<float>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<float>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<float>* self = (const Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<float>* a_Rhs = ((const Vector3<float>*)  tolua_tousertype(tolua_S,2,nullptr));
  float a_Eps = ((float)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'EqualsEps'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->EqualsEps(*a_Rhs,a_Eps);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'EqualsEps'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Move of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_Move00
static int tolua_AllToLua_Vector3f_Move00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<float>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vector3<float>* self = (Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
  float a_X = ((float)  tolua_tonumber(tolua_S,2,0));
  float a_Y = ((float)  tolua_tonumber(tolua_S,3,0));
  float a_Z = ((float)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Move'", nullptr);
#endif
  {
   self->Move(a_X,a_Y,a_Z);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Move'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Move of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_Move01
static int tolua_AllToLua_Vector3f_Move01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<float>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<float>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  Vector3<float>* self = (Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<float>* a_Diff = ((const Vector3<float>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Move'", nullptr);
#endif
  {
   self->Move(*a_Diff);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_Vector3f_Move00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: Floor of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_Floor00
static int tolua_AllToLua_Vector3f_Floor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<float>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<float>* self = (const Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Floor'", nullptr);
#endif
  {
   Vector3<int> tolua_ret = (Vector3<int>)  self->Floor();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Floor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Ceil of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_Ceil00
static int tolua_AllToLua_Vector3f_Ceil00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<float>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<float>* self = (const Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Ceil'", nullptr);
#endif
  {
   Vector3<int> tolua_ret = (Vector3<int>)  self->Ceil();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Ceil'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator+ of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f__add00
static int tolua_AllToLua_Vector3f__add00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<float>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<float>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<float>* self = (const Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<float>* a_Rhs = ((const Vector3<float>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'", nullptr);
#endif
  {
   Vector3<float> tolua_ret = (Vector3<float>)  self->operator+(*a_Rhs);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<float>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<float>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.add'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator- of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f__sub00
static int tolua_AllToLua_Vector3f__sub00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<float>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<float>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<float>* self = (const Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<float>* a_Rhs = ((const Vector3<float>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'", nullptr);
#endif
  {
   Vector3<float> tolua_ret = (Vector3<float>)  self->operator-(*a_Rhs);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<float>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<float>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.sub'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator- of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f__sub01
static int tolua_AllToLua_Vector3f__sub01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<float>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<float>* self = (const Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'", nullptr);
#endif
  {
   Vector3<float> tolua_ret = (Vector3<float>)  self->operator-();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<float>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<float>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3f__sub00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator* of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f__mul00
static int tolua_AllToLua_Vector3f__mul00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<float>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<float>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<float>* self = (const Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<float>* a_Rhs = ((const Vector3<float>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'", nullptr);
#endif
  {
   Vector3<float> tolua_ret = (Vector3<float>)  self->operator*(*a_Rhs);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<float>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<float>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.mul'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator/ of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f__div00
static int tolua_AllToLua_Vector3f__div00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<float>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<float>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vector3<float>* self = (Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<float>* a_Rhs = ((const Vector3<float>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator/'", nullptr);
#endif
  {
   Vector3<float> tolua_ret = (Vector3<float>)  self->operator/(*a_Rhs);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<float>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<float>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.div'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator* of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f__mul01
static int tolua_AllToLua_Vector3f__mul01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<float>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<float>* self = (const Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
  float a_v = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'", nullptr);
#endif
  {
   Vector3<float> tolua_ret = (Vector3<float>)  self->operator*(a_v);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<float>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<float>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3f__mul00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator/ of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f__div01
static int tolua_AllToLua_Vector3f__div01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<float>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<float>* self = (const Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
  float a_v = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator/'", nullptr);
#endif
  {
   Vector3<float> tolua_ret = (Vector3<float>)  self->operator/(a_v);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<float>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<float>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3f__div00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: addedX of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_addedX00
static int tolua_AllToLua_Vector3f_addedX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<float>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<float>* self = (const Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
  float a_AddX = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addedX'", nullptr);
#endif
  {
   Vector3<float> tolua_ret = (Vector3<float>)  self->addedX(a_AddX);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<float>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<float>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addedX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addedY of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_addedY00
static int tolua_AllToLua_Vector3f_addedY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<float>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<float>* self = (const Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
  float a_AddY = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addedY'", nullptr);
#endif
  {
   Vector3<float> tolua_ret = (Vector3<float>)  self->addedY(a_AddY);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<float>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<float>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addedY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addedZ of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_addedZ00
static int tolua_AllToLua_Vector3f_addedZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<float>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<float>* self = (const Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
  float a_AddZ = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addedZ'", nullptr);
#endif
  {
   Vector3<float> tolua_ret = (Vector3<float>)  self->addedZ(a_AddZ);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<float>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<float>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addedZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addedXZ of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_addedXZ00
static int tolua_AllToLua_Vector3f_addedXZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<float>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<float>* self = (const Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
  float a_AddX = ((float)  tolua_tonumber(tolua_S,2,0));
  float a_AddZ = ((float)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addedXZ'", nullptr);
#endif
  {
   Vector3<float> tolua_ret = (Vector3<float>)  self->addedXZ(a_AddX,a_AddZ);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<float>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<float>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<float>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addedXZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: LineCoeffToXYPlane of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_LineCoeffToXYPlane00
static int tolua_AllToLua_Vector3f_LineCoeffToXYPlane00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<float>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<float>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<float>* self = (const Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<float>* a_OtherEnd = ((const Vector3<float>*)  tolua_tousertype(tolua_S,2,nullptr));
  float a_Z = ((float)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'LineCoeffToXYPlane'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->LineCoeffToXYPlane(*a_OtherEnd,a_Z);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'LineCoeffToXYPlane'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: LineCoeffToXZPlane of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_LineCoeffToXZPlane00
static int tolua_AllToLua_Vector3f_LineCoeffToXZPlane00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<float>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<float>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<float>* self = (const Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<float>* a_OtherEnd = ((const Vector3<float>*)  tolua_tousertype(tolua_S,2,nullptr));
  float a_Y = ((float)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'LineCoeffToXZPlane'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->LineCoeffToXZPlane(*a_OtherEnd,a_Y);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'LineCoeffToXZPlane'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: LineCoeffToYZPlane of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_LineCoeffToYZPlane00
static int tolua_AllToLua_Vector3f_LineCoeffToYZPlane00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<float>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<float>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<float>* self = (const Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<float>* a_OtherEnd = ((const Vector3<float>*)  tolua_tousertype(tolua_S,2,nullptr));
  float a_X = ((float)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'LineCoeffToYZPlane'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->LineCoeffToYZPlane(*a_OtherEnd,a_X);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'LineCoeffToYZPlane'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: TurnCW of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_TurnCW00
static int tolua_AllToLua_Vector3f_TurnCW00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<float>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vector3<float>* self = (Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'TurnCW'", nullptr);
#endif
  {
   self->TurnCW();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'TurnCW'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: TurnCCW of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_TurnCCW00
static int tolua_AllToLua_Vector3f_TurnCCW00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<float>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vector3<float>* self = (Vector3<float>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'TurnCCW'", nullptr);
#endif
  {
   self->TurnCCW();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'TurnCCW'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EPS of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_get_Vector3_float__EPS
static int tolua_get_Vector3_float__EPS(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)Vector3<float>::EPS);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: NO_INTERSECTION of class  Vector3<float> */
#ifndef TOLUA_DISABLE_tolua_get_Vector3_float__NO_INTERSECTION
static int tolua_get_Vector3_float__NO_INTERSECTION(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)Vector3<float>::NO_INTERSECTION);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: x of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_get_Vector3_double__x
static int tolua_get_Vector3_double__x(lua_State* tolua_S)
{
  Vector3<double>* self = (Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",nullptr);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->x);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: x of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_set_Vector3_double__x
static int tolua_set_Vector3_double__x(lua_State* tolua_S)
{
  Vector3<double>* self = (Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",nullptr);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->x = ((double)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: y of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_get_Vector3_double__y
static int tolua_get_Vector3_double__y(lua_State* tolua_S)
{
  Vector3<double>* self = (Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",nullptr);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->y);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: y of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_set_Vector3_double__y
static int tolua_set_Vector3_double__y(lua_State* tolua_S)
{
  Vector3<double>* self = (Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",nullptr);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->y = ((double)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: z of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_get_Vector3_double__z
static int tolua_get_Vector3_double__z(lua_State* tolua_S)
{
  Vector3<double>* self = (Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'z'",nullptr);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->z);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: z of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_set_Vector3_double__z
static int tolua_set_Vector3_double__z(lua_State* tolua_S)
{
  Vector3<double>* self = (Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'z'",nullptr);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->z = ((double)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_new00
static int tolua_AllToLua_Vector3d_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<double>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   Vector3<double>* tolua_ret = (Vector3<double>*)  Mtolua_new((Vector3<double>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<double>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_new00_local
static int tolua_AllToLua_Vector3d_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<double>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   Vector3<double>* tolua_ret = (Vector3<double>*)  Mtolua_new((Vector3<double>)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_new01
static int tolua_AllToLua_Vector3d_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<double>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  double a_x = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_y = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_z = ((double)  tolua_tonumber(tolua_S,4,0));
  {
   Vector3<double>* tolua_ret = (Vector3<double>*)  Mtolua_new((Vector3<double>)(a_x,a_y,a_z));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<double>");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3d_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_new01_local
static int tolua_AllToLua_Vector3d_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<double>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  double a_x = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_y = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_z = ((double)  tolua_tonumber(tolua_S,4,0));
  {
   Vector3<double>* tolua_ret = (Vector3<double>*)  Mtolua_new((Vector3<double>)(a_x,a_y,a_z));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3d_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_new02
static int tolua_AllToLua_Vector3d_new02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<double>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<float>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<float>* a_Rhs = ((const Vector3<float>*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   Vector3<double>* tolua_ret = (Vector3<double>*)  Mtolua_new((Vector3<double>)(*a_Rhs));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<double>");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3d_new01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_new02_local
static int tolua_AllToLua_Vector3d_new02_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<double>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<float>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<float>* a_Rhs = ((const Vector3<float>*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   Vector3<double>* tolua_ret = (Vector3<double>*)  Mtolua_new((Vector3<double>)(*a_Rhs));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3d_new01_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_new03
static int tolua_AllToLua_Vector3d_new03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<double>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<double>* a_Rhs = ((const Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   Vector3<double>* tolua_ret = (Vector3<double>*)  Mtolua_new((Vector3<double>)(*a_Rhs));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<double>");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3d_new02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_new03_local
static int tolua_AllToLua_Vector3d_new03_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<double>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<double>* a_Rhs = ((const Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   Vector3<double>* tolua_ret = (Vector3<double>*)  Mtolua_new((Vector3<double>)(*a_Rhs));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3d_new02_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_new04
static int tolua_AllToLua_Vector3d_new04(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<double>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<int>* a_Rhs = ((const Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   Vector3<double>* tolua_ret = (Vector3<double>*)  Mtolua_new((Vector3<double>)(*a_Rhs));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<double>");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3d_new03(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_new04_local
static int tolua_AllToLua_Vector3d_new04_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vector3<double>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<int>* a_Rhs = ((const Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   Vector3<double>* tolua_ret = (Vector3<double>*)  Mtolua_new((Vector3<double>)(*a_Rhs));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3d_new03_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: Set of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_Set00
static int tolua_AllToLua_Vector3d_Set00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<double>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vector3<double>* self = (Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_x = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_y = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_z = ((double)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Set'", nullptr);
#endif
  {
   self->Set(a_x,a_y,a_z);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Set'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Normalize of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_Normalize00
static int tolua_AllToLua_Vector3d_Normalize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<double>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vector3<double>* self = (Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Normalize'", nullptr);
#endif
  {
   self->Normalize();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Normalize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: NormalizeCopy of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_NormalizeCopy00
static int tolua_AllToLua_Vector3d_NormalizeCopy00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<double>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<double>* self = (const Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NormalizeCopy'", nullptr);
#endif
  {
   Vector3<double> tolua_ret = (Vector3<double>)  self->NormalizeCopy();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<double>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<double>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'NormalizeCopy'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: HasNonZeroLength of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_HasNonZeroLength00
static int tolua_AllToLua_Vector3d_HasNonZeroLength00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<double>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<double>* self = (const Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HasNonZeroLength'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->HasNonZeroLength();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'HasNonZeroLength'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Length of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_Length00
static int tolua_AllToLua_Vector3d_Length00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<double>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<double>* self = (const Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Length'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->Length();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Length'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SqrLength of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_SqrLength00
static int tolua_AllToLua_Vector3d_SqrLength00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<double>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<double>* self = (const Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SqrLength'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->SqrLength();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SqrLength'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Dot of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_Dot00
static int tolua_AllToLua_Vector3d_Dot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<double>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<double>* self = (const Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<double>* a_Rhs = ((const Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Dot'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->Dot(*a_Rhs);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Dot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Abs of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_Abs00
static int tolua_AllToLua_Vector3d_Abs00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<double>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vector3<double>* self = (Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Abs'", nullptr);
#endif
  {
   self->Abs();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Abs'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Clamp of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_Clamp00
static int tolua_AllToLua_Vector3d_Clamp00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<double>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vector3<double>* self = (Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_Min = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_Max = ((double)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Clamp'", nullptr);
#endif
  {
   self->Clamp(a_Min,a_Max);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Clamp'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Cross of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_Cross00
static int tolua_AllToLua_Vector3d_Cross00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<double>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<double>* self = (const Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<double>* a_Rhs = ((const Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Cross'", nullptr);
#endif
  {
   Vector3<double> tolua_ret = (Vector3<double>)  self->Cross(*a_Rhs);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<double>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<double>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Cross'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Equals of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_Equals00
static int tolua_AllToLua_Vector3d_Equals00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<double>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<double>* self = (const Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<double>* a_Rhs = ((const Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Equals'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->Equals(*a_Rhs);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Equals'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: EqualsEps of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_EqualsEps00
static int tolua_AllToLua_Vector3d_EqualsEps00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<double>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<double>* self = (const Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<double>* a_Rhs = ((const Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  double a_Eps = ((double)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'EqualsEps'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->EqualsEps(*a_Rhs,a_Eps);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'EqualsEps'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Move of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_Move00
static int tolua_AllToLua_Vector3d_Move00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<double>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vector3<double>* self = (Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_X = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_Y = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_Z = ((double)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Move'", nullptr);
#endif
  {
   self->Move(a_X,a_Y,a_Z);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Move'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Move of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_Move01
static int tolua_AllToLua_Vector3d_Move01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<double>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  Vector3<double>* self = (Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<double>* a_Diff = ((const Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Move'", nullptr);
#endif
  {
   self->Move(*a_Diff);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_Vector3d_Move00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: Floor of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_Floor00
static int tolua_AllToLua_Vector3d_Floor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<double>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<double>* self = (const Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Floor'", nullptr);
#endif
  {
   Vector3<int> tolua_ret = (Vector3<int>)  self->Floor();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Floor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Ceil of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_Ceil00
static int tolua_AllToLua_Vector3d_Ceil00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<double>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<double>* self = (const Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Ceil'", nullptr);
#endif
  {
   Vector3<int> tolua_ret = (Vector3<int>)  self->Ceil();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Ceil'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator+ of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d__add00
static int tolua_AllToLua_Vector3d__add00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<double>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<double>* self = (const Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<double>* a_Rhs = ((const Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'", nullptr);
#endif
  {
   Vector3<double> tolua_ret = (Vector3<double>)  self->operator+(*a_Rhs);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<double>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<double>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.add'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator- of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d__sub00
static int tolua_AllToLua_Vector3d__sub00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<double>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<double>* self = (const Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<double>* a_Rhs = ((const Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'", nullptr);
#endif
  {
   Vector3<double> tolua_ret = (Vector3<double>)  self->operator-(*a_Rhs);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<double>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<double>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.sub'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator- of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d__sub01
static int tolua_AllToLua_Vector3d__sub01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<double>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<double>* self = (const Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'", nullptr);
#endif
  {
   Vector3<double> tolua_ret = (Vector3<double>)  self->operator-();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<double>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<double>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3d__sub00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator* of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d__mul00
static int tolua_AllToLua_Vector3d__mul00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<double>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<double>* self = (const Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<double>* a_Rhs = ((const Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'", nullptr);
#endif
  {
   Vector3<double> tolua_ret = (Vector3<double>)  self->operator*(*a_Rhs);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<double>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<double>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.mul'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator/ of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d__div00
static int tolua_AllToLua_Vector3d__div00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<double>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vector3<double>* self = (Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<double>* a_Rhs = ((const Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator/'", nullptr);
#endif
  {
   Vector3<double> tolua_ret = (Vector3<double>)  self->operator/(*a_Rhs);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<double>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<double>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.div'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator* of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d__mul01
static int tolua_AllToLua_Vector3d__mul01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<double>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<double>* self = (const Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_v = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'", nullptr);
#endif
  {
   Vector3<double> tolua_ret = (Vector3<double>)  self->operator*(a_v);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<double>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<double>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3d__mul00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator/ of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d__div01
static int tolua_AllToLua_Vector3d__div01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<double>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const Vector3<double>* self = (const Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_v = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator/'", nullptr);
#endif
  {
   Vector3<double> tolua_ret = (Vector3<double>)  self->operator/(a_v);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<double>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<double>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_Vector3d__div00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: addedX of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_addedX00
static int tolua_AllToLua_Vector3d_addedX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<double>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<double>* self = (const Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_AddX = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addedX'", nullptr);
#endif
  {
   Vector3<double> tolua_ret = (Vector3<double>)  self->addedX(a_AddX);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<double>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<double>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addedX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addedY of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_addedY00
static int tolua_AllToLua_Vector3d_addedY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<double>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<double>* self = (const Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_AddY = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addedY'", nullptr);
#endif
  {
   Vector3<double> tolua_ret = (Vector3<double>)  self->addedY(a_AddY);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<double>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<double>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addedY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addedZ of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_addedZ00
static int tolua_AllToLua_Vector3d_addedZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<double>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<double>* self = (const Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_AddZ = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addedZ'", nullptr);
#endif
  {
   Vector3<double> tolua_ret = (Vector3<double>)  self->addedZ(a_AddZ);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<double>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<double>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addedZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: addedXZ of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_addedXZ00
static int tolua_AllToLua_Vector3d_addedXZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<double>",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<double>* self = (const Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_AddX = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_AddZ = ((double)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'addedXZ'", nullptr);
#endif
  {
   Vector3<double> tolua_ret = (Vector3<double>)  self->addedXZ(a_AddX,a_AddZ);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<double>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<double>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'addedXZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: LineCoeffToXYPlane of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_LineCoeffToXYPlane00
static int tolua_AllToLua_Vector3d_LineCoeffToXYPlane00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<double>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<double>* self = (const Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<double>* a_OtherEnd = ((const Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  double a_Z = ((double)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'LineCoeffToXYPlane'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->LineCoeffToXYPlane(*a_OtherEnd,a_Z);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'LineCoeffToXYPlane'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: LineCoeffToXZPlane of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_LineCoeffToXZPlane00
static int tolua_AllToLua_Vector3d_LineCoeffToXZPlane00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<double>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<double>* self = (const Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<double>* a_OtherEnd = ((const Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  double a_Y = ((double)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'LineCoeffToXZPlane'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->LineCoeffToXZPlane(*a_OtherEnd,a_Y);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'LineCoeffToXZPlane'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: LineCoeffToYZPlane of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_LineCoeffToYZPlane00
static int tolua_AllToLua_Vector3d_LineCoeffToYZPlane00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vector3<double>",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vector3<double>* self = (const Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<double>* a_OtherEnd = ((const Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  double a_X = ((double)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'LineCoeffToYZPlane'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->LineCoeffToYZPlane(*a_OtherEnd,a_X);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'LineCoeffToYZPlane'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: TurnCW of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_TurnCW00
static int tolua_AllToLua_Vector3d_TurnCW00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<double>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vector3<double>* self = (Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'TurnCW'", nullptr);
#endif
  {
   self->TurnCW();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'TurnCW'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: TurnCCW of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_TurnCCW00
static int tolua_AllToLua_Vector3d_TurnCCW00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vector3<double>",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vector3<double>* self = (Vector3<double>*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'TurnCCW'", nullptr);
#endif
  {
   self->TurnCCW();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'TurnCCW'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EPS of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_get_Vector3_double__EPS
static int tolua_get_Vector3_double__EPS(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)Vector3<double>::EPS);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: NO_INTERSECTION of class  Vector3<double> */
#ifndef TOLUA_DISABLE_tolua_get_Vector3_double__NO_INTERSECTION
static int tolua_get_Vector3_double__NO_INTERSECTION(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)Vector3<double>::NO_INTERSECTION);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_isEMCSBiome (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= -1.0 && val <= 169.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "EMCSBiome";
	return 0;
}
/* function: StringToBiome */
#ifndef TOLUA_DISABLE_tolua_AllToLua_StringToBiome00
static int tolua_AllToLua_StringToBiome00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const AString a_BiomeString = ((const AString)  tolua_tocppstring(tolua_S,1,nullptr));
  {
   EMCSBiome tolua_ret = (EMCSBiome)  StringToBiome(a_BiomeString);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'StringToBiome'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: BiomeToString */
#ifndef TOLUA_DISABLE_tolua_AllToLua_BiomeToString00
static int tolua_AllToLua_BiomeToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  int a_Biome = ((int)  tolua_tonumber(tolua_S,1,0));
  {
   AString tolua_ret = (AString)  BiomeToString(a_Biome);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BiomeToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_isEMCSBiome (lua_State* L, int lo, int def, tolua_Error* err);
/* function: IsBiomeNoDownfall */
#ifndef TOLUA_DISABLE_tolua_AllToLua_IsBiomeNoDownfall00
static int tolua_AllToLua_IsBiomeNoDownfall00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isEMCSBiome(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EMCSBiome a_Biome = ((EMCSBiome) (  int)  tolua_tonumber(tolua_S,1,0));
  {
   bool tolua_ret = (bool)  IsBiomeNoDownfall(a_Biome);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsBiomeNoDownfall'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: IsBiomeOcean */
#ifndef TOLUA_DISABLE_tolua_AllToLua_IsBiomeOcean00
static int tolua_AllToLua_IsBiomeOcean00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  int a_Biome = ((int)  tolua_tonumber(tolua_S,1,0));
  {
   bool tolua_ret = (bool)  IsBiomeOcean(a_Biome);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsBiomeOcean'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_isEMCSBiome (lua_State* L, int lo, int def, tolua_Error* err);
/* function: IsBiomeVeryCold */
#ifndef TOLUA_DISABLE_tolua_AllToLua_IsBiomeVeryCold00
static int tolua_AllToLua_IsBiomeVeryCold00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isEMCSBiome(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EMCSBiome a_Biome = ((EMCSBiome) (  int)  tolua_tonumber(tolua_S,1,0));
  {
   bool tolua_ret = (bool)  IsBiomeVeryCold(a_Biome);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsBiomeVeryCold'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_isEMCSBiome (lua_State* L, int lo, int def, tolua_Error* err);
/* function: IsBiomeCold */
#ifndef TOLUA_DISABLE_tolua_AllToLua_IsBiomeCold00
static int tolua_AllToLua_IsBiomeCold00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isEMCSBiome(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EMCSBiome a_Biome = ((EMCSBiome) (  int)  tolua_tonumber(tolua_S,1,0));
  {
   bool tolua_ret = (bool)  IsBiomeCold(a_Biome);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsBiomeCold'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_isEMCSBiome (lua_State* L, int lo, int def, tolua_Error* err);
/* function: IsBiomeMountain */
#ifndef TOLUA_DISABLE_tolua_AllToLua_IsBiomeMountain00
static int tolua_AllToLua_IsBiomeMountain00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isEMCSBiome(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EMCSBiome a_Biome = ((EMCSBiome) (  int)  tolua_tonumber(tolua_S,1,0));
  {
   bool tolua_ret = (bool)  IsBiomeMountain(a_Biome);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsBiomeMountain'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_isEMCSBiome (lua_State* L, int lo, int def, tolua_Error* err);
/* function: IsBiomeMesa */
#ifndef TOLUA_DISABLE_tolua_AllToLua_IsBiomeMesa00
static int tolua_AllToLua_IsBiomeMesa00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isEMCSBiome(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EMCSBiome a_Biome = ((EMCSBiome) (  int)  tolua_tonumber(tolua_S,1,0));
  {
   bool tolua_ret = (bool)  IsBiomeMesa(a_Biome);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsBiomeMesa'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_isEMCSBiome (lua_State* L, int lo, int def, tolua_Error* err);
/* function: GetSnowStartHeight */
#ifndef TOLUA_DISABLE_tolua_AllToLua_GetSnowStartHeight00
static int tolua_AllToLua_GetSnowStartHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isEMCSBiome(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  EMCSBiome a_Biome = ((EMCSBiome) (  int)  tolua_tonumber(tolua_S,1,0));
  {
   int tolua_ret = (int)  GetSnowStartHeight(a_Biome);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSnowStartHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_is (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 0.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "";
	return 0;
}
/* method: new of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_new00
static int tolua_AllToLua_cIniFile_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   cIniFile* tolua_ret = (cIniFile*)  Mtolua_new((cIniFile)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cIniFile");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_new00_local
static int tolua_AllToLua_cIniFile_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   cIniFile* tolua_ret = (cIniFile*)  Mtolua_new((cIniFile)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cIniFile");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CaseSensitive of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_CaseSensitive00
static int tolua_AllToLua_cIniFile_CaseSensitive00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CaseSensitive'", nullptr);
#endif
  {
   self->CaseSensitive();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CaseSensitive'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CaseInsensitive of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_CaseInsensitive00
static int tolua_AllToLua_cIniFile_CaseInsensitive00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CaseInsensitive'", nullptr);
#endif
  {
   self->CaseInsensitive();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CaseInsensitive'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ReadFile of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_ReadFile00
static int tolua_AllToLua_cIniFile_ReadFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_FileName = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  bool a_AllowExampleRedirect = ((bool)  tolua_toboolean(tolua_S,3,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ReadFile'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->ReadFile(a_FileName,a_AllowExampleRedirect);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ReadFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: WriteFile of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_WriteFile00
static int tolua_AllToLua_cIniFile_WriteFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_FileName = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'WriteFile'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->WriteFile(a_FileName);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'WriteFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Flush of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_Flush00
static int tolua_AllToLua_cIniFile_Flush00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Flush'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->Flush();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Flush'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Clear of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_Clear00
static int tolua_AllToLua_cIniFile_Clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Clear'", nullptr);
#endif
  {
   self->Clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: HasValue of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_HasValue00
static int tolua_AllToLua_cIniFile_HasValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_KeyName = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString a_ValueName = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HasValue'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->HasValue(a_KeyName,a_ValueName);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'HasValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: FindKey of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_FindKey00
static int tolua_AllToLua_cIniFile_FindKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'FindKey'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->FindKey(keyname);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'FindKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: FindValue of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_FindValue00
static int tolua_AllToLua_cIniFile_FindValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
  const AString valuename = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'FindValue'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->FindValue(keyID,valuename);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'FindValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNumKeys of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetNumKeys00
static int tolua_AllToLua_cIniFile_GetNumKeys00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumKeys'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetNumKeys();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetNumKeys'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddKeyName of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_AddKeyName00
static int tolua_AllToLua_cIniFile_AddKeyName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddKeyName'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->AddKeyName(keyname);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddKeyName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetKeyName of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetKeyName00
static int tolua_AllToLua_cIniFile_GetKeyName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetKeyName'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetKeyName(keyID);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetKeyName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNumValues of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetNumValues00
static int tolua_AllToLua_cIniFile_GetNumValues00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumValues'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetNumValues(keyname);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetNumValues'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNumValues of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetNumValues01
static int tolua_AllToLua_cIniFile_GetNumValues01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumValues'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetNumValues(keyID);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cIniFile_GetNumValues00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetValueName of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValueName00
static int tolua_AllToLua_cIniFile_GetValueName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const int valueID = ((const int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValueName'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetValueName(keyname,valueID);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetValueName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetValueName of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValueName01
static int tolua_AllToLua_cIniFile_GetValueName01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
  const int valueID = ((const int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValueName'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetValueName(keyID,valueID);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cIniFile_GetValueName00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetValue of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValue00
static int tolua_AllToLua_cIniFile_GetValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString valuename = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValue'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetValue(keyname,valuename);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetValue of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValue01
static int tolua_AllToLua_cIniFile_GetValue01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString valuename = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
  const AString defValue = ((const AString)  tolua_tocppstring(tolua_S,4,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValue'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetValue(keyname,valuename,defValue);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cIniFile_GetValue00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetValue of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValue02
static int tolua_AllToLua_cIniFile_GetValue02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
  const int valueID = ((const int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValue'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetValue(keyID,valueID);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cIniFile_GetValue01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetValue of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValue03
static int tolua_AllToLua_cIniFile_GetValue03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
  const int valueID = ((const int)  tolua_tonumber(tolua_S,3,0));
  const AString defValue = ((const AString)  tolua_tocppstring(tolua_S,4,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValue'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetValue(keyID,valueID,defValue);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cIniFile_GetValue02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetValueF of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValueF00
static int tolua_AllToLua_cIniFile_GetValueF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString valuename = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
  const double defValue = ((const double)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValueF'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetValueF(keyname,valuename,defValue);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetValueF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetValueI of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValueI00
static int tolua_AllToLua_cIniFile_GetValueI00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString valuename = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
  const int defValue = ((const int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValueI'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetValueI(keyname,valuename,defValue);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetValueI'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetValueB of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValueB00
static int tolua_AllToLua_cIniFile_GetValueB00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString valuename = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
  const bool defValue = ((const bool)  tolua_toboolean(tolua_S,4,false));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValueB'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->GetValueB(keyname,valuename,defValue);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetValueB'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetValueSet of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValueSet00
static int tolua_AllToLua_cIniFile_GetValueSet00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString valuename = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValueSet'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetValueSet(keyname,valuename);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetValueSet'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetValueSet of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValueSet01
static int tolua_AllToLua_cIniFile_GetValueSet01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString valuename = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
  const AString defValue = ((const AString)  tolua_tocppstring(tolua_S,4,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValueSet'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetValueSet(keyname,valuename,defValue);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cIniFile_GetValueSet00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetValueSetF of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValueSetF00
static int tolua_AllToLua_cIniFile_GetValueSetF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString valuename = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
  const double defValue = ((const double)  tolua_tonumber(tolua_S,4,0.0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValueSetF'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetValueSetF(keyname,valuename,defValue);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetValueSetF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetValueSetI of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValueSetI00
static int tolua_AllToLua_cIniFile_GetValueSetI00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString valuename = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
  const int defValue = ((const int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValueSetI'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetValueSetI(keyname,valuename,defValue);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetValueSetI'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetValueSetI of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValueSetI01
static int tolua_AllToLua_cIniFile_GetValueSetI01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString valuename = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
  signed long const long defValue = ((signed long const long)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValueSetI'", nullptr);
#endif
  {
   signed long long tolua_ret = ( signed long long)  self->GetValueSetI(keyname,valuename,defValue);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cIniFile_GetValueSetI00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetValueSetB of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValueSetB00
static int tolua_AllToLua_cIniFile_GetValueSetB00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString valuename = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
  const bool defValue = ((const bool)  tolua_toboolean(tolua_S,4,false));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValueSetB'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->GetValueSetB(keyname,valuename,defValue);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetValueSetB'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddValue of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_AddValue00
static int tolua_AllToLua_cIniFile_AddValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_KeyName = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString a_ValueName = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
  const AString a_Value = ((const AString)  tolua_tocppstring(tolua_S,4,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddValue'", nullptr);
#endif
  {
   self->AddValue(a_KeyName,a_ValueName,a_Value);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddValueI of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_AddValueI00
static int tolua_AllToLua_cIniFile_AddValueI00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_KeyName = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString a_ValueName = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
  const int a_Value = ((const int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddValueI'", nullptr);
#endif
  {
   self->AddValueI(a_KeyName,a_ValueName,a_Value);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddValueI'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddValueB of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_AddValueB00
static int tolua_AllToLua_cIniFile_AddValueB00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_KeyName = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString a_ValueName = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
  const bool a_Value = ((const bool)  tolua_toboolean(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddValueB'", nullptr);
#endif
  {
   self->AddValueB(a_KeyName,a_ValueName,a_Value);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddValueB'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddValueF of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_AddValueF00
static int tolua_AllToLua_cIniFile_AddValueF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_KeyName = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString a_ValueName = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
  const double a_Value = ((const double)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddValueF'", nullptr);
#endif
  {
   self->AddValueF(a_KeyName,a_ValueName,a_Value);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddValueF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetValue of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_SetValue00
static int tolua_AllToLua_cIniFile_SetValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
  const int valueID = ((const int)  tolua_tonumber(tolua_S,3,0));
  const AString value = ((const AString)  tolua_tocppstring(tolua_S,4,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetValue'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->SetValue(keyID,valueID,value);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetValue of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_SetValue01
static int tolua_AllToLua_cIniFile_SetValue01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_KeyName = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString a_ValueName = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
  const AString a_Value = ((const AString)  tolua_tocppstring(tolua_S,4,nullptr));
  const bool a_CreateIfNotExists = ((const bool)  tolua_toboolean(tolua_S,5,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetValue'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->SetValue(a_KeyName,a_ValueName,a_Value,a_CreateIfNotExists);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cIniFile_SetValue00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetValueI of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_SetValueI00
static int tolua_AllToLua_cIniFile_SetValueI00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_KeyName = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString a_ValueName = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
  const int a_Value = ((const int)  tolua_tonumber(tolua_S,4,0));
  const bool a_CreateIfNotExists = ((const bool)  tolua_toboolean(tolua_S,5,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetValueI'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->SetValueI(a_KeyName,a_ValueName,a_Value,a_CreateIfNotExists);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetValueI'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetValueI of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_SetValueI01
static int tolua_AllToLua_cIniFile_SetValueI01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Keyname = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString a_ValueName = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
  signed long const long a_Value = ((signed long const long)  tolua_tonumber(tolua_S,4,0));
  const bool a_CreateIfNotExists = ((const bool)  tolua_toboolean(tolua_S,5,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetValueI'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->SetValueI(a_Keyname,a_ValueName,a_Value,a_CreateIfNotExists);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cIniFile_SetValueI00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetValueB of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_SetValueB00
static int tolua_AllToLua_cIniFile_SetValueB00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,4,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_KeyName = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString a_ValueName = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
  const bool a_Value = ((const bool)  tolua_toboolean(tolua_S,4,0));
  const bool a_CreateIfNotExists = ((const bool)  tolua_toboolean(tolua_S,5,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetValueB'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->SetValueB(a_KeyName,a_ValueName,a_Value,a_CreateIfNotExists);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetValueB'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetValueF of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_SetValueF00
static int tolua_AllToLua_cIniFile_SetValueF00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_KeyName = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString a_ValueName = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
  const double a_Value = ((const double)  tolua_tonumber(tolua_S,4,0));
  const bool a_CreateIfNotExists = ((const bool)  tolua_toboolean(tolua_S,5,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetValueF'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->SetValueF(a_KeyName,a_ValueName,a_Value,a_CreateIfNotExists);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetValueF'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DeleteValueByID of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_DeleteValueByID00
static int tolua_AllToLua_cIniFile_DeleteValueByID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
  const int valueID = ((const int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteValueByID'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->DeleteValueByID(keyID,valueID);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DeleteValueByID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DeleteValue of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_DeleteValue00
static int tolua_AllToLua_cIniFile_DeleteValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString valuename = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteValue'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->DeleteValue(keyname,valuename);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DeleteValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DeleteKey of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_DeleteKey00
static int tolua_AllToLua_cIniFile_DeleteKey00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteKey'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->DeleteKey(keyname);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DeleteKey'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNumHeaderComments of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetNumHeaderComments00
static int tolua_AllToLua_cIniFile_GetNumHeaderComments00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumHeaderComments'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetNumHeaderComments();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetNumHeaderComments'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddHeaderComment of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_AddHeaderComment00
static int tolua_AllToLua_cIniFile_AddHeaderComment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString comment = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddHeaderComment'", nullptr);
#endif
  {
   self->AddHeaderComment(comment);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddHeaderComment'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetHeaderComment of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetHeaderComment00
static int tolua_AllToLua_cIniFile_GetHeaderComment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const int commentID = ((const int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetHeaderComment'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetHeaderComment(commentID);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetHeaderComment'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DeleteHeaderComment of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_DeleteHeaderComment00
static int tolua_AllToLua_cIniFile_DeleteHeaderComment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  int commentID = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteHeaderComment'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->DeleteHeaderComment(commentID);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DeleteHeaderComment'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DeleteHeaderComments of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_DeleteHeaderComments00
static int tolua_AllToLua_cIniFile_DeleteHeaderComments00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteHeaderComments'", nullptr);
#endif
  {
   self->DeleteHeaderComments();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DeleteHeaderComments'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNumKeyComments of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetNumKeyComments00
static int tolua_AllToLua_cIniFile_GetNumKeyComments00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumKeyComments'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetNumKeyComments(keyID);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetNumKeyComments'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNumKeyComments of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetNumKeyComments01
static int tolua_AllToLua_cIniFile_GetNumKeyComments01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumKeyComments'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetNumKeyComments(keyname);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cIniFile_GetNumKeyComments00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddKeyComment of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_AddKeyComment00
static int tolua_AllToLua_cIniFile_AddKeyComment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
  const AString comment = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddKeyComment'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->AddKeyComment(keyID,comment);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddKeyComment'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddKeyComment of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_AddKeyComment01
static int tolua_AllToLua_cIniFile_AddKeyComment01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString comment = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddKeyComment'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->AddKeyComment(keyname,comment);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cIniFile_AddKeyComment00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetKeyComment of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetKeyComment00
static int tolua_AllToLua_cIniFile_GetKeyComment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
  const int commentID = ((const int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetKeyComment'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetKeyComment(keyID,commentID);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetKeyComment'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetKeyComment of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetKeyComment01
static int tolua_AllToLua_cIniFile_GetKeyComment01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const cIniFile* self = (const cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const int commentID = ((const int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetKeyComment'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetKeyComment(keyname,commentID);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cIniFile_GetKeyComment00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: DeleteKeyComment of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_DeleteKeyComment00
static int tolua_AllToLua_cIniFile_DeleteKeyComment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
  const int commentID = ((const int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteKeyComment'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->DeleteKeyComment(keyID,commentID);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DeleteKeyComment'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DeleteKeyComment of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_DeleteKeyComment01
static int tolua_AllToLua_cIniFile_DeleteKeyComment01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const int commentID = ((const int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteKeyComment'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->DeleteKeyComment(keyname,commentID);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cIniFile_DeleteKeyComment00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: DeleteKeyComments of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_DeleteKeyComments00
static int tolua_AllToLua_cIniFile_DeleteKeyComments00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const int keyID = ((const int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteKeyComments'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->DeleteKeyComments(keyID);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DeleteKeyComments'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DeleteKeyComments of class  cIniFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_DeleteKeyComments01
static int tolua_AllToLua_cIniFile_DeleteKeyComments01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cIniFile* self = (cIniFile*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString keyname = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteKeyComments'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->DeleteKeyComments(keyname);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cIniFile_DeleteKeyComments00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPathSeparator of class  cFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFile_GetPathSeparator00
static int tolua_AllToLua_cFile_GetPathSeparator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cFile",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   AString tolua_ret = (AString)  cFile::GetPathSeparator();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPathSeparator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetExecutableExt of class  cFile */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFile_GetExecutableExt00
static int tolua_AllToLua_cFile_GetExecutableExt00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cFile",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   AString tolua_ret = (AString)  cFile::GetExecutableExt();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetExecutableExt'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: GetTime */
#ifndef TOLUA_DISABLE_tolua_AllToLua_GetTime00
static int tolua_AllToLua_GetTime00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnoobj(tolua_S,1,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   unsigned int tolua_ret = (unsigned int)  GetTime();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetTime'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_isCommandResult (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 4.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "CommandResult";
	return 0;
}
int tolua_isePluginStatus (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 4.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "ePluginStatus";
	return 0;
}
int tolua_isPluginHook (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 70.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "PluginHook";
	return 0;
}
/* method: Get of class  cPluginManager */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_Get00
static int tolua_AllToLua_cPluginManager_Get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cPluginManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   cPluginManager* tolua_ret = (cPluginManager*)  cPluginManager::Get();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cPluginManager");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Get'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: RefreshPluginList of class  cPluginManager */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_RefreshPluginList00
static int tolua_AllToLua_cPluginManager_RefreshPluginList00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPluginManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPluginManager* self = (cPluginManager*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'RefreshPluginList'", nullptr);
#endif
  {
   self->RefreshPluginList();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'RefreshPluginList'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ReloadPlugins of class  cPluginManager */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_ReloadPlugins00
static int tolua_AllToLua_cPluginManager_ReloadPlugins00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPluginManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPluginManager* self = (cPluginManager*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ReloadPlugins'", nullptr);
#endif
  {
   self->ReloadPlugins();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ReloadPlugins'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNumPlugins of class  cPluginManager */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_GetNumPlugins00
static int tolua_AllToLua_cPluginManager_GetNumPlugins00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPluginManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPluginManager* self = (const cPluginManager*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumPlugins'", nullptr);
#endif
  {
   size_t tolua_ret = (size_t)  self->GetNumPlugins();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetNumPlugins'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNumLoadedPlugins of class  cPluginManager */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_GetNumLoadedPlugins00
static int tolua_AllToLua_cPluginManager_GetNumLoadedPlugins00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPluginManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPluginManager* self = (const cPluginManager*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumLoadedPlugins'", nullptr);
#endif
  {
   size_t tolua_ret = (size_t)  self->GetNumLoadedPlugins();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetNumLoadedPlugins'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: UnloadPlugin of class  cPluginManager */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_UnloadPlugin00
static int tolua_AllToLua_cPluginManager_UnloadPlugin00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPluginManager",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPluginManager* self = (cPluginManager*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_PluginFolder = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'UnloadPlugin'", nullptr);
#endif
  {
   self->UnloadPlugin(a_PluginFolder);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'UnloadPlugin'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ReloadPlugin of class  cPluginManager */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_ReloadPlugin00
static int tolua_AllToLua_cPluginManager_ReloadPlugin00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPluginManager",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPluginManager* self = (cPluginManager*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_PluginFolder = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ReloadPlugin'", nullptr);
#endif
  {
   self->ReloadPlugin(a_PluginFolder);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ReloadPlugin'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: LoadPlugin of class  cPluginManager */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_LoadPlugin00
static int tolua_AllToLua_cPluginManager_LoadPlugin00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPluginManager",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPluginManager* self = (cPluginManager*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_PluginFolder = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'LoadPlugin'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->LoadPlugin(a_PluginFolder);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'LoadPlugin'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsPluginLoaded of class  cPluginManager */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_IsPluginLoaded00
static int tolua_AllToLua_cPluginManager_IsPluginLoaded00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPluginManager",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPluginManager* self = (cPluginManager*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_PluginName = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsPluginLoaded'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsPluginLoaded(a_PluginName);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsPluginLoaded'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsCommandBound of class  cPluginManager */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_IsCommandBound00
static int tolua_AllToLua_cPluginManager_IsCommandBound00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPluginManager",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPluginManager* self = (cPluginManager*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Command = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsCommandBound'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsCommandBound(a_Command);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsCommandBound'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetCommandPermission of class  cPluginManager */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_GetCommandPermission00
static int tolua_AllToLua_cPluginManager_GetCommandPermission00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPluginManager",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPluginManager* self = (cPluginManager*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Command = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetCommandPermission'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetCommandPermission(a_Command);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetCommandPermission'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ExecuteCommand of class  cPluginManager */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_ExecuteCommand00
static int tolua_AllToLua_cPluginManager_ExecuteCommand00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPluginManager",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cPlayer",0,&tolua_err)) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPluginManager* self = (cPluginManager*)  tolua_tousertype(tolua_S,1,nullptr);
  cPlayer* a_Player = ((cPlayer*)  tolua_tousertype(tolua_S,2,nullptr));
  const AString a_Command = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ExecuteCommand'", nullptr);
#endif
  {
   cPluginManager::CommandResult tolua_ret = (cPluginManager::CommandResult)  self->ExecuteCommand(*a_Player,a_Command);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ExecuteCommand'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ForceExecuteCommand of class  cPluginManager */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_ForceExecuteCommand00
static int tolua_AllToLua_cPluginManager_ForceExecuteCommand00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPluginManager",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cPlayer",0,&tolua_err)) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPluginManager* self = (cPluginManager*)  tolua_tousertype(tolua_S,1,nullptr);
  cPlayer* a_Player = ((cPlayer*)  tolua_tousertype(tolua_S,2,nullptr));
  const AString a_Command = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ForceExecuteCommand'", nullptr);
#endif
  {
   cPluginManager::CommandResult tolua_ret = (cPluginManager::CommandResult)  self->ForceExecuteCommand(*a_Player,a_Command);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ForceExecuteCommand'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsConsoleCommandBound of class  cPluginManager */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_IsConsoleCommandBound00
static int tolua_AllToLua_cPluginManager_IsConsoleCommandBound00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPluginManager",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPluginManager* self = (cPluginManager*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Command = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsConsoleCommandBound'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsConsoleCommandBound(a_Command);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsConsoleCommandBound'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPluginFolderName of class  cPluginManager */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_GetPluginFolderName00
static int tolua_AllToLua_cPluginManager_GetPluginFolderName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPluginManager",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPluginManager* self = (cPluginManager*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_PluginName = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPluginFolderName'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetPluginFolderName(a_PluginName);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPluginFolderName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPluginsPath of class  cPluginManager */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_GetPluginsPath00
static int tolua_AllToLua_cPluginManager_GetPluginsPath00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cPluginManager",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   AString tolua_ret = (AString)  cPluginManager::GetPluginsPath();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPluginsPath'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetName of class  cPlugin */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_GetName00
static int tolua_AllToLua_cPlugin_GetName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlugin",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlugin* self = (const cPlugin*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetName'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetName of class  cPlugin */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_SetName00
static int tolua_AllToLua_cPlugin_SetName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlugin",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlugin* self = (cPlugin*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Name = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetName'", nullptr);
#endif
  {
   self->SetName(a_Name);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetVersion of class  cPlugin */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_GetVersion00
static int tolua_AllToLua_cPlugin_GetVersion00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlugin",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlugin* self = (const cPlugin*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetVersion'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetVersion();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetVersion'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetVersion of class  cPlugin */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_SetVersion00
static int tolua_AllToLua_cPlugin_SetVersion00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlugin",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlugin* self = (cPlugin*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_Version = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetVersion'", nullptr);
#endif
  {
   self->SetVersion(a_Version);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetVersion'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetFolderName of class  cPlugin */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_GetFolderName00
static int tolua_AllToLua_cPlugin_GetFolderName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlugin",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlugin* self = (const cPlugin*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetFolderName'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetFolderName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetFolderName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetLocalFolder of class  cPlugin */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_GetLocalFolder00
static int tolua_AllToLua_cPlugin_GetLocalFolder00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlugin",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlugin* self = (const cPlugin*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetLocalFolder'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetLocalFolder();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetLocalFolder'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetLoadError of class  cPlugin */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_GetLoadError00
static int tolua_AllToLua_cPlugin_GetLoadError00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlugin",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlugin* self = (const cPlugin*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetLoadError'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetLoadError();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetLoadError'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetStatus of class  cPlugin */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_GetStatus00
static int tolua_AllToLua_cPlugin_GetStatus00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlugin",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlugin* self = (const cPlugin*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetStatus'", nullptr);
#endif
  {
   cPluginManager::ePluginStatus tolua_ret = (cPluginManager::ePluginStatus)  self->GetStatus();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetStatus'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsLoaded of class  cPlugin */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_IsLoaded00
static int tolua_AllToLua_cPlugin_IsLoaded00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlugin",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlugin* self = (const cPlugin*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsLoaded'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsLoaded();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsLoaded'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: delete of class  cLuaWindow */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cLuaWindow_delete00
static int tolua_AllToLua_cLuaWindow_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cLuaWindow",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cLuaWindow* self = (cLuaWindow*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", nullptr);
#endif
  Mtolua_delete(self);
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetContents of class  cLuaWindow */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cLuaWindow_GetContents00
static int tolua_AllToLua_cLuaWindow_GetContents00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cLuaWindow",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cLuaWindow* self = (cLuaWindow*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetContents'", nullptr);
#endif
  {
   cItemGrid& tolua_ret = (cItemGrid&)  self->GetContents();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"cItemGrid");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetContents'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_isENUM_BLOCK_TYPE (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 259.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "ENUM_BLOCK_TYPE";
	return 0;
}
int tolua_isENUM_ITEM_TYPE (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= -1.0 && val <= 2270.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "ENUM_ITEM_TYPE";
	return 0;
}
int tolua_isENUM_BLOCK_META (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 15.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "ENUM_BLOCK_META";
	return 0;
}
int tolua_isENUM_ITEM_META (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 200.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "ENUM_ITEM_META";
	return 0;
}
/* function: BlockStringToType */
#ifndef TOLUA_DISABLE_tolua_AllToLua_BlockStringToType00
static int tolua_AllToLua_BlockStringToType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const AString a_BlockTypeString = ((const AString)  tolua_tocppstring(tolua_S,1,nullptr));
  {
   int tolua_ret = (int)  BlockStringToType(a_BlockTypeString);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BlockStringToType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: StringToItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_StringToItem00
static int tolua_AllToLua_StringToItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const AString a_ItemTypeString = ((const AString)  tolua_tocppstring(tolua_S,1,nullptr));
  cItem* a_Item = ((cItem*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   bool tolua_ret = (bool)  StringToItem(a_ItemTypeString,*a_Item);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'StringToItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: ItemToString */
#ifndef TOLUA_DISABLE_tolua_AllToLua_ItemToString00
static int tolua_AllToLua_ItemToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     (tolua_isvaluenil(tolua_S,1,&tolua_err) || !tolua_isusertype(tolua_S,1,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,1,nullptr));
  {
   AString tolua_ret = (AString)  ItemToString(*a_Item);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ItemToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: ItemTypeToString */
#ifndef TOLUA_DISABLE_tolua_AllToLua_ItemTypeToString00
static int tolua_AllToLua_ItemTypeToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,1,0));
  {
   AString tolua_ret = (AString)  ItemTypeToString(a_ItemType);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ItemTypeToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: ItemToFullString */
#ifndef TOLUA_DISABLE_tolua_AllToLua_ItemToFullString00
static int tolua_AllToLua_ItemToFullString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     (tolua_isvaluenil(tolua_S,1,&tolua_err) || !tolua_isusertype(tolua_S,1,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,1,nullptr));
  {
   AString tolua_ret = (AString)  ItemToFullString(*a_Item);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ItemToFullString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: GetIniItemSet */
#ifndef TOLUA_DISABLE_tolua_AllToLua_GetIniItemSet00
static int tolua_AllToLua_GetIniItemSet00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     (tolua_isvaluenil(tolua_S,1,&tolua_err) || !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err)) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isstring(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cIniFile* a_IniFile = ((cIniFile*)  tolua_tousertype(tolua_S,1,nullptr));
  const char* a_Section = ((const char*)  tolua_tostring(tolua_S,2,nullptr));
  const char* a_Key = ((const char*)  tolua_tostring(tolua_S,3,nullptr));
  const char* a_Default = ((const char*)  tolua_tostring(tolua_S,4,nullptr));
  {
   cItem tolua_ret = (cItem)  GetIniItemSet(*a_IniFile,a_Section,a_Key,a_Default);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cItem)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cItem));
     tolua_pushusertype(tolua_S,tolua_obj,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetIniItemSet'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetLightValue of class  cBlockInfo */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockInfo_GetLightValue00
static int tolua_AllToLua_cBlockInfo_GetLightValue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBlockInfo",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  unsigned char Block = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
  {
   unsigned char tolua_ret = (unsigned char)  cBlockInfo::GetLightValue(Block);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetLightValue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSpreadLightFalloff of class  cBlockInfo */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockInfo_GetSpreadLightFalloff00
static int tolua_AllToLua_cBlockInfo_GetSpreadLightFalloff00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBlockInfo",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  unsigned char Block = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
  {
   unsigned char tolua_ret = (unsigned char)  cBlockInfo::GetSpreadLightFalloff(Block);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSpreadLightFalloff'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CanBeTerraformed of class  cBlockInfo */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockInfo_CanBeTerraformed00
static int tolua_AllToLua_cBlockInfo_CanBeTerraformed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBlockInfo",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  unsigned char Block = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
  {
   bool tolua_ret = (bool)  cBlockInfo::CanBeTerraformed(Block);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CanBeTerraformed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: FullyOccupiesVoxel of class  cBlockInfo */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockInfo_FullyOccupiesVoxel00
static int tolua_AllToLua_cBlockInfo_FullyOccupiesVoxel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBlockInfo",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  unsigned char Block = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
  {
   bool tolua_ret = (bool)  cBlockInfo::FullyOccupiesVoxel(Block);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'FullyOccupiesVoxel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsClickedThrough of class  cBlockInfo */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockInfo_IsClickedThrough00
static int tolua_AllToLua_cBlockInfo_IsClickedThrough00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBlockInfo",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  unsigned char a_Block = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
  {
   bool tolua_ret = (bool)  cBlockInfo::IsClickedThrough(a_Block);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsClickedThrough'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsOneHitDig of class  cBlockInfo */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockInfo_IsOneHitDig00
static int tolua_AllToLua_cBlockInfo_IsOneHitDig00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBlockInfo",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  unsigned char Block = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
  {
   bool tolua_ret = (bool)  cBlockInfo::IsOneHitDig(Block);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsOneHitDig'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsPistonBreakable of class  cBlockInfo */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockInfo_IsPistonBreakable00
static int tolua_AllToLua_cBlockInfo_IsPistonBreakable00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBlockInfo",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  unsigned char Block = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
  {
   bool tolua_ret = (bool)  cBlockInfo::IsPistonBreakable(Block);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsPistonBreakable'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsRainBlocker of class  cBlockInfo */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockInfo_IsRainBlocker00
static int tolua_AllToLua_cBlockInfo_IsRainBlocker00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBlockInfo",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  unsigned char Block = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
  {
   bool tolua_ret = (bool)  cBlockInfo::IsRainBlocker(Block);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsRainBlocker'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsSkylightDispersant of class  cBlockInfo */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockInfo_IsSkylightDispersant00
static int tolua_AllToLua_cBlockInfo_IsSkylightDispersant00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBlockInfo",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  unsigned char Block = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
  {
   bool tolua_ret = (bool)  cBlockInfo::IsSkylightDispersant(Block);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsSkylightDispersant'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsSnowable of class  cBlockInfo */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockInfo_IsSnowable00
static int tolua_AllToLua_cBlockInfo_IsSnowable00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBlockInfo",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  unsigned char Block = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
  {
   bool tolua_ret = (bool)  cBlockInfo::IsSnowable(Block);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsSnowable'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsSolid of class  cBlockInfo */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockInfo_IsSolid00
static int tolua_AllToLua_cBlockInfo_IsSolid00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBlockInfo",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  unsigned char Block = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
  {
   bool tolua_ret = (bool)  cBlockInfo::IsSolid(Block);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsSolid'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsTransparent of class  cBlockInfo */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockInfo_IsTransparent00
static int tolua_AllToLua_cBlockInfo_IsTransparent00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBlockInfo",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  unsigned char Block = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
  {
   bool tolua_ret = (bool)  cBlockInfo::IsTransparent(Block);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsTransparent'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsUseableBySpectator of class  cBlockInfo */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockInfo_IsUseableBySpectator00
static int tolua_AllToLua_cBlockInfo_IsUseableBySpectator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBlockInfo",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  unsigned char Block = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
  {
   bool tolua_ret = (bool)  cBlockInfo::IsUseableBySpectator(Block);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsUseableBySpectator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetBlockHeight of class  cBlockInfo */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockInfo_GetBlockHeight00
static int tolua_AllToLua_cBlockInfo_GetBlockHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBlockInfo",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  unsigned char Block = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
  {
   float tolua_ret = (float)  cBlockInfo::GetBlockHeight(Block);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetBlockHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetHardness of class  cBlockInfo */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockInfo_GetHardness00
static int tolua_AllToLua_cBlockInfo_GetHardness00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBlockInfo",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  unsigned char Block = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
  {
   float tolua_ret = (float)  cBlockInfo::GetHardness(Block);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetHardness'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: TrimString */
#ifndef TOLUA_DISABLE_tolua_AllToLua_TrimString00
static int tolua_AllToLua_TrimString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const AString str = ((const AString)  tolua_tocppstring(tolua_S,1,nullptr));
  {
   AString tolua_ret = (AString)  TrimString(str);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'TrimString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: NoCaseCompare */
#ifndef TOLUA_DISABLE_tolua_AllToLua_NoCaseCompare00
static int tolua_AllToLua_NoCaseCompare00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const AString s1 = ((const AString)  tolua_tocppstring(tolua_S,1,nullptr));
  const AString s2 = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  {
   int tolua_ret = (int)  NoCaseCompare(s1,s2);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'NoCaseCompare'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: ReplaceString */
#ifndef TOLUA_DISABLE_tolua_AllToLua_ReplaceString00
static int tolua_AllToLua_ReplaceString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  AString iHayStack = ((AString)  tolua_tocppstring(tolua_S,1,nullptr));
  const AString iNeedle = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString iReplaceWith = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
  {
   ReplaceString(iHayStack,iNeedle,iReplaceWith);
   tolua_pushcppstring(tolua_S,(const char*)iHayStack);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ReplaceString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: EscapeString */
#ifndef TOLUA_DISABLE_tolua_AllToLua_EscapeString00
static int tolua_AllToLua_EscapeString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,1,nullptr));
  {
   AString tolua_ret = (AString)  EscapeString(a_Message);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'EscapeString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: StripColorCodes */
#ifndef TOLUA_DISABLE_tolua_AllToLua_StripColorCodes00
static int tolua_AllToLua_StripColorCodes00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,1,nullptr));
  {
   AString tolua_ret = (AString)  StripColorCodes(a_Message);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'StripColorCodes'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseBlockFace (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= -1.0 && val <= 9.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eBlockFace";
	return 0;
}
int tolua_iseClickAction (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 255.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eClickAction";
	return 0;
}
int tolua_iseGameMode (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= -1.0 && val <= 9.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eGameMode";
	return 0;
}
int tolua_iseChatType (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 2.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eChatType";
	return 0;
}
int tolua_iseWeather (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 6.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eWeather";
	return 0;
}
int tolua_iseMobHeadType (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 5.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eMobHeadType";
	return 0;
}
int tolua_iseMobHeadRotation (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 15.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eMobHeadRotation";
	return 0;
}
int tolua_iseSkinPart (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 127.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eSkinPart";
	return 0;
}
int tolua_iseDimension (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= -1.0 && val <= 255.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eDimension";
	return 0;
}
int tolua_iseDamageType (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 41.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eDamageType";
	return 0;
}
int tolua_iseExplosionSource (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 10.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eExplosionSource";
	return 0;
}
int tolua_iseShrapnelLevel (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 2.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eShrapnelLevel";
	return 0;
}
int tolua_iseSpreadSource (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 4.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eSpreadSource";
	return 0;
}
int tolua_iseMessageType (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 14.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eMessageType";
	return 0;
}
int tolua_isBannerPattern (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 39.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "BannerPattern";
	return 0;
}
int tolua_isBossBarColor (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 6.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "BossBarColor";
	return 0;
}
int tolua_isBossBarDivisionType (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 4.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "BossBarDivisionType";
	return 0;
}
/* function: ClickActionToString */
#ifndef TOLUA_DISABLE_tolua_AllToLua_ClickActionToString00
static int tolua_AllToLua_ClickActionToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  int a_ClickAction = ((int)  tolua_tonumber(tolua_S,1,0));
  {
   const char* tolua_ret = (const char*)  ClickActionToString(a_ClickAction);
   tolua_pushstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ClickActionToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseBlockFace (lua_State* L, int lo, int def, tolua_Error* err);
/* function: MirrorBlockFaceY */
#ifndef TOLUA_DISABLE_tolua_AllToLua_MirrorBlockFaceY00
static int tolua_AllToLua_MirrorBlockFaceY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_iseBlockFace(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  eBlockFace a_BlockFace = ((eBlockFace) (  int)  tolua_tonumber(tolua_S,1,0));
  {
   eBlockFace tolua_ret = (eBlockFace)  MirrorBlockFaceY(a_BlockFace);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'MirrorBlockFaceY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseBlockFace (lua_State* L, int lo, int def, tolua_Error* err);
/* function: RotateBlockFaceCCW */
#ifndef TOLUA_DISABLE_tolua_AllToLua_RotateBlockFaceCCW00
static int tolua_AllToLua_RotateBlockFaceCCW00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_iseBlockFace(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  eBlockFace a_BlockFace = ((eBlockFace) (  int)  tolua_tonumber(tolua_S,1,0));
  {
   eBlockFace tolua_ret = (eBlockFace)  RotateBlockFaceCCW(a_BlockFace);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'RotateBlockFaceCCW'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseBlockFace (lua_State* L, int lo, int def, tolua_Error* err);
/* function: RotateBlockFaceCW */
#ifndef TOLUA_DISABLE_tolua_AllToLua_RotateBlockFaceCW00
static int tolua_AllToLua_RotateBlockFaceCW00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_iseBlockFace(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  eBlockFace a_BlockFace = ((eBlockFace) (  int)  tolua_tonumber(tolua_S,1,0));
  {
   eBlockFace tolua_ret = (eBlockFace)  RotateBlockFaceCW(a_BlockFace);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'RotateBlockFaceCW'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseBlockFace (lua_State* L, int lo, int def, tolua_Error* err);
/* function: ReverseBlockFace */
#ifndef TOLUA_DISABLE_tolua_AllToLua_ReverseBlockFace00
static int tolua_AllToLua_ReverseBlockFace00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_iseBlockFace(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  eBlockFace a_BlockFace = ((eBlockFace) (  int)  tolua_tonumber(tolua_S,1,0));
  {
   eBlockFace tolua_ret = (eBlockFace)  ReverseBlockFace(a_BlockFace);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ReverseBlockFace'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseBlockFace (lua_State* L, int lo, int def, tolua_Error* err);
/* function: BlockFaceToString */
#ifndef TOLUA_DISABLE_tolua_AllToLua_BlockFaceToString00
static int tolua_AllToLua_BlockFaceToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_iseBlockFace(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  eBlockFace a_BlockFace = ((eBlockFace) (  int)  tolua_tonumber(tolua_S,1,0));
  {
   AString tolua_ret = (AString)  BlockFaceToString(a_BlockFace);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BlockFaceToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: IsValidBlock */
#ifndef TOLUA_DISABLE_tolua_AllToLua_IsValidBlock00
static int tolua_AllToLua_IsValidBlock00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  int a_BlockType = ((int)  tolua_tonumber(tolua_S,1,0));
  {
   bool tolua_ret = (bool)  IsValidBlock(a_BlockType);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsValidBlock'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: IsValidItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_IsValidItem00
static int tolua_AllToLua_IsValidItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  int a_ItemType = ((int)  tolua_tonumber(tolua_S,1,0));
  {
   bool tolua_ret = (bool)  IsValidItem(a_ItemType);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsValidItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: StringToDimension */
#ifndef TOLUA_DISABLE_tolua_AllToLua_StringToDimension00
static int tolua_AllToLua_StringToDimension00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const AString a_DimensionString = ((const AString)  tolua_tocppstring(tolua_S,1,nullptr));
  {
   eDimension tolua_ret = (eDimension)  StringToDimension(a_DimensionString);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'StringToDimension'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseDimension (lua_State* L, int lo, int def, tolua_Error* err);
/* function: DimensionToString */
#ifndef TOLUA_DISABLE_tolua_AllToLua_DimensionToString00
static int tolua_AllToLua_DimensionToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_iseDimension(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  eDimension a_Dimension = ((eDimension) (  int)  tolua_tonumber(tolua_S,1,0));
  {
   AString tolua_ret = (AString)  DimensionToString(a_Dimension);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DimensionToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseDamageType (lua_State* L, int lo, int def, tolua_Error* err);
/* function: DamageTypeToString */
#ifndef TOLUA_DISABLE_tolua_AllToLua_DamageTypeToString00
static int tolua_AllToLua_DamageTypeToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_iseDamageType(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  eDamageType a_DamageType = ((eDamageType) (  int)  tolua_tonumber(tolua_S,1,0));
  {
   AString tolua_ret = (AString)  DamageTypeToString(a_DamageType);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DamageTypeToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: StringToDamageType */
#ifndef TOLUA_DISABLE_tolua_AllToLua_StringToDamageType00
static int tolua_AllToLua_StringToDamageType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const AString a_DamageString = ((const AString)  tolua_tocppstring(tolua_S,1,nullptr));
  {
   eDamageType tolua_ret = (eDamageType)  StringToDamageType(a_DamageString);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'StringToDamageType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseBlockFace (lua_State* L, int lo, int def, tolua_Error* err);
/* function: AddFaceDirection */
#ifndef TOLUA_DISABLE_tolua_AllToLua_AddFaceDirection00
static int tolua_AllToLua_AddFaceDirection00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_iseBlockFace(tolua_S,4,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  int a_BlockX = ((int)  tolua_tonumber(tolua_S,1,0));
  int a_BlockY = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_BlockZ = ((int)  tolua_tonumber(tolua_S,3,0));
  eBlockFace a_BlockFace = ((eBlockFace) (  int)  tolua_tonumber(tolua_S,4,0));
  bool a_bInverse = ((bool)  tolua_toboolean(tolua_S,5,false));
  {
   AddFaceDirection(a_BlockX,a_BlockY,a_BlockZ,a_BlockFace,a_bInverse);
   tolua_pushnumber(tolua_S,(lua_Number)a_BlockX);
   tolua_pushnumber(tolua_S,(lua_Number)a_BlockY);
   tolua_pushnumber(tolua_S,(lua_Number)a_BlockZ);
  }
 }
 return 3;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddFaceDirection'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseBlockFace (lua_State* L, int lo, int def, tolua_Error* err);
/* function: AddFaceDirection */
#ifndef TOLUA_DISABLE_tolua_AllToLua_AddFaceDirection01
static int tolua_AllToLua_AddFaceDirection01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     (tolua_isvaluenil(tolua_S,1,&tolua_err) || !tolua_isusertype(tolua_S,1,"Vector3<int>",0,&tolua_err)) ||
     !tolua_iseBlockFace(tolua_S,2,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
   Vector3<int> a_Pos = *((  Vector3<int>*)  tolua_tousertype(tolua_S,1,nullptr));
  eBlockFace a_BlockFace = ((eBlockFace) (  int)  tolua_tonumber(tolua_S,2,0));
  bool a_InvertDirection = ((bool)  tolua_toboolean(tolua_S,3,false));
  {
    Vector3<int> tolua_ret = (  Vector3<int>)  AddFaceDirection(a_Pos,a_BlockFace,a_InvertDirection);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_AddFaceDirection00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* function: NormalizeAngleDegrees */
#ifndef TOLUA_DISABLE_tolua_AllToLua_NormalizeAngleDegrees00
static int tolua_AllToLua_NormalizeAngleDegrees00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const double a_Degrees = ((const double)  tolua_tonumber(tolua_S,1,0));
  {
   double tolua_ret = (double)  NormalizeAngleDegrees(a_Degrees);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'NormalizeAngleDegrees'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: ItemCategory::IsPickaxe */
#ifndef TOLUA_DISABLE_tolua_AllToLua_ItemCategory_IsPickaxe00
static int tolua_AllToLua_ItemCategory_IsPickaxe00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,1,0));
  {
   bool tolua_ret = (bool)  ItemCategory::IsPickaxe(a_ItemType);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsPickaxe'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: ItemCategory::IsAxe */
#ifndef TOLUA_DISABLE_tolua_AllToLua_ItemCategory_IsAxe00
static int tolua_AllToLua_ItemCategory_IsAxe00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,1,0));
  {
   bool tolua_ret = (bool)  ItemCategory::IsAxe(a_ItemType);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsAxe'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: ItemCategory::IsSword */
#ifndef TOLUA_DISABLE_tolua_AllToLua_ItemCategory_IsSword00
static int tolua_AllToLua_ItemCategory_IsSword00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,1,0));
  {
   bool tolua_ret = (bool)  ItemCategory::IsSword(a_ItemType);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsSword'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: ItemCategory::IsHoe */
#ifndef TOLUA_DISABLE_tolua_AllToLua_ItemCategory_IsHoe00
static int tolua_AllToLua_ItemCategory_IsHoe00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,1,0));
  {
   bool tolua_ret = (bool)  ItemCategory::IsHoe(a_ItemType);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsHoe'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: ItemCategory::IsShovel */
#ifndef TOLUA_DISABLE_tolua_AllToLua_ItemCategory_IsShovel00
static int tolua_AllToLua_ItemCategory_IsShovel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,1,0));
  {
   bool tolua_ret = (bool)  ItemCategory::IsShovel(a_ItemType);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsShovel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: ItemCategory::IsTool */
#ifndef TOLUA_DISABLE_tolua_AllToLua_ItemCategory_IsTool00
static int tolua_AllToLua_ItemCategory_IsTool00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,1,0));
  {
   bool tolua_ret = (bool)  ItemCategory::IsTool(a_ItemType);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsTool'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: ItemCategory::IsHelmet */
#ifndef TOLUA_DISABLE_tolua_AllToLua_ItemCategory_IsHelmet00
static int tolua_AllToLua_ItemCategory_IsHelmet00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,1,0));
  {
   bool tolua_ret = (bool)  ItemCategory::IsHelmet(a_ItemType);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsHelmet'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: ItemCategory::IsChestPlate */
#ifndef TOLUA_DISABLE_tolua_AllToLua_ItemCategory_IsChestPlate00
static int tolua_AllToLua_ItemCategory_IsChestPlate00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,1,0));
  {
   bool tolua_ret = (bool)  ItemCategory::IsChestPlate(a_ItemType);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsChestPlate'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: ItemCategory::IsLeggings */
#ifndef TOLUA_DISABLE_tolua_AllToLua_ItemCategory_IsLeggings00
static int tolua_AllToLua_ItemCategory_IsLeggings00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,1,0));
  {
   bool tolua_ret = (bool)  ItemCategory::IsLeggings(a_ItemType);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsLeggings'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: ItemCategory::IsBoots */
#ifndef TOLUA_DISABLE_tolua_AllToLua_ItemCategory_IsBoots00
static int tolua_AllToLua_ItemCategory_IsBoots00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,1,0));
  {
   bool tolua_ret = (bool)  ItemCategory::IsBoots(a_ItemType);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsBoots'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: ItemCategory::IsMinecart */
#ifndef TOLUA_DISABLE_tolua_AllToLua_ItemCategory_IsMinecart00
static int tolua_AllToLua_ItemCategory_IsMinecart00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,1,0));
  {
   bool tolua_ret = (bool)  ItemCategory::IsMinecart(a_ItemType);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsMinecart'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: ItemCategory::IsArmor */
#ifndef TOLUA_DISABLE_tolua_AllToLua_ItemCategory_IsArmor00
static int tolua_AllToLua_ItemCategory_IsArmor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,1,0));
  {
   bool tolua_ret = (bool)  ItemCategory::IsArmor(a_ItemType);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsArmor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: ItemCategory::IsHorseArmor */
#ifndef TOLUA_DISABLE_tolua_AllToLua_ItemCategory_IsHorseArmor00
static int tolua_AllToLua_ItemCategory_IsHorseArmor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,1,0));
  {
   bool tolua_ret = (bool)  ItemCategory::IsHorseArmor(a_ItemType);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsHorseArmor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: ItemCategory::IsVillagerFood */
#ifndef TOLUA_DISABLE_tolua_AllToLua_ItemCategory_IsVillagerFood00
static int tolua_AllToLua_ItemCategory_IsVillagerFood00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,1,0));
  {
   bool tolua_ret = (bool)  ItemCategory::IsVillagerFood(a_ItemType);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsVillagerFood'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Delimiter of class  cChatColor */
#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Delimiter
static int tolua_get_cChatColor_Delimiter(lua_State* tolua_S)
{
  tolua_pushstring(tolua_S,(const char*)cChatColor::Delimiter);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Color of class  cChatColor */
#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Color
static int tolua_get_cChatColor_Color(lua_State* tolua_S)
{
  tolua_pushstring(tolua_S,(const char*)cChatColor::Color);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Black of class  cChatColor */
#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Black
static int tolua_get_cChatColor_Black(lua_State* tolua_S)
{
  tolua_pushstring(tolua_S,(const char*)cChatColor::Black);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Navy of class  cChatColor */
#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Navy
static int tolua_get_cChatColor_Navy(lua_State* tolua_S)
{
  tolua_pushstring(tolua_S,(const char*)cChatColor::Navy);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Green of class  cChatColor */
#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Green
static int tolua_get_cChatColor_Green(lua_State* tolua_S)
{
  tolua_pushstring(tolua_S,(const char*)cChatColor::Green);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Blue of class  cChatColor */
#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Blue
static int tolua_get_cChatColor_Blue(lua_State* tolua_S)
{
  tolua_pushstring(tolua_S,(const char*)cChatColor::Blue);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Red of class  cChatColor */
#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Red
static int tolua_get_cChatColor_Red(lua_State* tolua_S)
{
  tolua_pushstring(tolua_S,(const char*)cChatColor::Red);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Purple of class  cChatColor */
#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Purple
static int tolua_get_cChatColor_Purple(lua_State* tolua_S)
{
  tolua_pushstring(tolua_S,(const char*)cChatColor::Purple);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Gold of class  cChatColor */
#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Gold
static int tolua_get_cChatColor_Gold(lua_State* tolua_S)
{
  tolua_pushstring(tolua_S,(const char*)cChatColor::Gold);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: LightGray of class  cChatColor */
#ifndef TOLUA_DISABLE_tolua_get_cChatColor_LightGray
static int tolua_get_cChatColor_LightGray(lua_State* tolua_S)
{
  tolua_pushstring(tolua_S,(const char*)cChatColor::LightGray);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Gray of class  cChatColor */
#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Gray
static int tolua_get_cChatColor_Gray(lua_State* tolua_S)
{
  tolua_pushstring(tolua_S,(const char*)cChatColor::Gray);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DarkPurple of class  cChatColor */
#ifndef TOLUA_DISABLE_tolua_get_cChatColor_DarkPurple
static int tolua_get_cChatColor_DarkPurple(lua_State* tolua_S)
{
  tolua_pushstring(tolua_S,(const char*)cChatColor::DarkPurple);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: LightGreen of class  cChatColor */
#ifndef TOLUA_DISABLE_tolua_get_cChatColor_LightGreen
static int tolua_get_cChatColor_LightGreen(lua_State* tolua_S)
{
  tolua_pushstring(tolua_S,(const char*)cChatColor::LightGreen);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: LightBlue of class  cChatColor */
#ifndef TOLUA_DISABLE_tolua_get_cChatColor_LightBlue
static int tolua_get_cChatColor_LightBlue(lua_State* tolua_S)
{
  tolua_pushstring(tolua_S,(const char*)cChatColor::LightBlue);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Rose of class  cChatColor */
#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Rose
static int tolua_get_cChatColor_Rose(lua_State* tolua_S)
{
  tolua_pushstring(tolua_S,(const char*)cChatColor::Rose);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: LightPurple of class  cChatColor */
#ifndef TOLUA_DISABLE_tolua_get_cChatColor_LightPurple
static int tolua_get_cChatColor_LightPurple(lua_State* tolua_S)
{
  tolua_pushstring(tolua_S,(const char*)cChatColor::LightPurple);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Yellow of class  cChatColor */
#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Yellow
static int tolua_get_cChatColor_Yellow(lua_State* tolua_S)
{
  tolua_pushstring(tolua_S,(const char*)cChatColor::Yellow);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: White of class  cChatColor */
#ifndef TOLUA_DISABLE_tolua_get_cChatColor_White
static int tolua_get_cChatColor_White(lua_State* tolua_S)
{
  tolua_pushstring(tolua_S,(const char*)cChatColor::White);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Random of class  cChatColor */
#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Random
static int tolua_get_cChatColor_Random(lua_State* tolua_S)
{
  tolua_pushstring(tolua_S,(const char*)cChatColor::Random);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Bold of class  cChatColor */
#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Bold
static int tolua_get_cChatColor_Bold(lua_State* tolua_S)
{
  tolua_pushstring(tolua_S,(const char*)cChatColor::Bold);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Strikethrough of class  cChatColor */
#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Strikethrough
static int tolua_get_cChatColor_Strikethrough(lua_State* tolua_S)
{
  tolua_pushstring(tolua_S,(const char*)cChatColor::Strikethrough);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Underlined of class  cChatColor */
#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Underlined
static int tolua_get_cChatColor_Underlined(lua_State* tolua_S)
{
  tolua_pushstring(tolua_S,(const char*)cChatColor::Underlined);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Italic of class  cChatColor */
#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Italic
static int tolua_get_cChatColor_Italic(lua_State* tolua_S)
{
  tolua_pushstring(tolua_S,(const char*)cChatColor::Italic);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Plain of class  cChatColor */
#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Plain
static int tolua_get_cChatColor_Plain(lua_State* tolua_S)
{
  tolua_pushstring(tolua_S,(const char*)cChatColor::Plain);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetIPString of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_GetIPString00
static int tolua_AllToLua_cClientHandle_GetIPString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cClientHandle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cClientHandle* self = (const cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetIPString'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetIPString();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetIPString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPlayer of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_GetPlayer00
static int tolua_AllToLua_cClientHandle_GetPlayer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPlayer'", nullptr);
#endif
  {
   cPlayer* tolua_ret = (cPlayer*)  self->GetPlayer();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cPlayer");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPlayer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Kick of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_Kick00
static int tolua_AllToLua_cClientHandle_Kick00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Reason = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Kick'", nullptr);
#endif
  {
   self->Kick(a_Reason);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Kick'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendBlockBreakAnim of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendBlockBreakAnim00
static int tolua_AllToLua_cClientHandle_SendBlockBreakAnim00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"Vector3<int>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  unsigned int a_EntityID = (( unsigned int)  tolua_tonumber(tolua_S,2,0));
   Vector3<int> a_BlockPos = *((  Vector3<int>*)  tolua_tousertype(tolua_S,3,nullptr));
  char a_Stage = ((char)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendBlockBreakAnim'", nullptr);
#endif
  {
   self->SendBlockBreakAnim(a_EntityID,a_BlockPos,a_Stage);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendBlockBreakAnim'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendBlockChange of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendBlockChange00
static int tolua_AllToLua_cClientHandle_SendBlockChange00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<int> a_BlockPos = *((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
  unsigned char a_BlockType = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
  unsigned char a_BlockMeta = (( unsigned char)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendBlockChange'", nullptr);
#endif
  {
   self->SendBlockChange(a_BlockPos,a_BlockType,a_BlockMeta);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendBlockChange'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_isBossBarColor (lua_State* L, int lo, int def, tolua_Error* err);
int tolua_isBossBarDivisionType (lua_State* L, int lo, int def, tolua_Error* err);
/* method: SendBossBarAdd of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendBossBarAdd00
static int tolua_AllToLua_cClientHandle_SendBossBarAdd00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cCompositeChat",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isBossBarColor(tolua_S,5,0,&tolua_err) ||
     !tolua_isBossBarDivisionType(tolua_S,6,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,7,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,8,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,9,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,10,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  unsigned int a_UniqueID = (( unsigned int)  tolua_tonumber(tolua_S,2,0));
  const cCompositeChat* a_Title = ((const cCompositeChat*)  tolua_tousertype(tolua_S,3,nullptr));
  float a_FractionFilled = ((float)  tolua_tonumber(tolua_S,4,0));
  BossBarColor a_Color = ((BossBarColor) (  int)  tolua_tonumber(tolua_S,5,0));
  BossBarDivisionType a_DivisionType = ((BossBarDivisionType) (  int)  tolua_tonumber(tolua_S,6,0));
  bool a_DarkenSky = ((bool)  tolua_toboolean(tolua_S,7,0));
  bool a_PlayEndMusic = ((bool)  tolua_toboolean(tolua_S,8,0));
  bool a_CreateFog = ((bool)  tolua_toboolean(tolua_S,9,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendBossBarAdd'", nullptr);
#endif
  {
   self->SendBossBarAdd(a_UniqueID,*a_Title,a_FractionFilled,a_Color,a_DivisionType,a_DarkenSky,a_PlayEndMusic,a_CreateFog);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendBossBarAdd'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendBossBarUpdateFlags of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendBossBarUpdateFlags00
static int tolua_AllToLua_cClientHandle_SendBossBarUpdateFlags00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,4,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  unsigned int a_UniqueID = (( unsigned int)  tolua_tonumber(tolua_S,2,0));
  bool a_DarkenSky = ((bool)  tolua_toboolean(tolua_S,3,0));
  bool a_PlayEndMusic = ((bool)  tolua_toboolean(tolua_S,4,0));
  bool a_CreateFog = ((bool)  tolua_toboolean(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendBossBarUpdateFlags'", nullptr);
#endif
  {
   self->SendBossBarUpdateFlags(a_UniqueID,a_DarkenSky,a_PlayEndMusic,a_CreateFog);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendBossBarUpdateFlags'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_isBossBarColor (lua_State* L, int lo, int def, tolua_Error* err);
int tolua_isBossBarDivisionType (lua_State* L, int lo, int def, tolua_Error* err);
/* method: SendBossBarUpdateStyle of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendBossBarUpdateStyle00
static int tolua_AllToLua_cClientHandle_SendBossBarUpdateStyle00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isBossBarColor(tolua_S,3,0,&tolua_err) ||
     !tolua_isBossBarDivisionType(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  unsigned int a_UniqueID = (( unsigned int)  tolua_tonumber(tolua_S,2,0));
  BossBarColor a_Color = ((BossBarColor) (  int)  tolua_tonumber(tolua_S,3,0));
  BossBarDivisionType a_DivisionType = ((BossBarDivisionType) (  int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendBossBarUpdateStyle'", nullptr);
#endif
  {
   self->SendBossBarUpdateStyle(a_UniqueID,a_Color,a_DivisionType);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendBossBarUpdateStyle'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendBossBarUpdateTitle of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendBossBarUpdateTitle00
static int tolua_AllToLua_cClientHandle_SendBossBarUpdateTitle00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cCompositeChat",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  unsigned int a_UniqueID = (( unsigned int)  tolua_tonumber(tolua_S,2,0));
  const cCompositeChat* a_Title = ((const cCompositeChat*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendBossBarUpdateTitle'", nullptr);
#endif
  {
   self->SendBossBarUpdateTitle(a_UniqueID,*a_Title);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendBossBarUpdateTitle'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendBossBarRemove of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendBossBarRemove00
static int tolua_AllToLua_cClientHandle_SendBossBarRemove00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  unsigned int a_UniqueID = (( unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendBossBarRemove'", nullptr);
#endif
  {
   self->SendBossBarRemove(a_UniqueID);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendBossBarRemove'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendBossBarUpdateHealth of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendBossBarUpdateHealth00
static int tolua_AllToLua_cClientHandle_SendBossBarUpdateHealth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  unsigned int a_UniqueID = (( unsigned int)  tolua_tonumber(tolua_S,2,0));
  float a_FractionFilled = ((float)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendBossBarUpdateHealth'", nullptr);
#endif
  {
   self->SendBossBarUpdateHealth(a_UniqueID,a_FractionFilled);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendBossBarUpdateHealth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendCollectEntity of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendCollectEntity00
static int tolua_AllToLua_cClientHandle_SendCollectEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cEntity",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cEntity",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  const cEntity* a_Collected = ((const cEntity*)  tolua_tousertype(tolua_S,2,nullptr));
  const cEntity* a_Collector = ((const cEntity*)  tolua_tousertype(tolua_S,3,nullptr));
  unsigned a_Count = ((unsigned)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendCollectEntity'", nullptr);
#endif
  {
   self->SendCollectEntity(*a_Collected,*a_Collector,a_Count);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendCollectEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendDestroyEntity of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendDestroyEntity00
static int tolua_AllToLua_cClientHandle_SendDestroyEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cEntity",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  const cEntity* a_Entity = ((const cEntity*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendDestroyEntity'", nullptr);
#endif
  {
   self->SendDestroyEntity(*a_Entity);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendDestroyEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendDetachEntity of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendDetachEntity00
static int tolua_AllToLua_cClientHandle_SendDetachEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cEntity",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cEntity",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  const cEntity* a_Entity = ((const cEntity*)  tolua_tousertype(tolua_S,2,nullptr));
  const cEntity* a_PreviousVehicle = ((const cEntity*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendDetachEntity'", nullptr);
#endif
  {
   self->SendDetachEntity(*a_Entity,*a_PreviousVehicle);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendDetachEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendEditSign of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendEditSign00
static int tolua_AllToLua_cClientHandle_SendEditSign00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<int> a_BlockPos = *((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendEditSign'", nullptr);
#endif
  {
   self->SendEditSign(a_BlockPos);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendEditSign'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendEntityAnimation of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendEntityAnimation00
static int tolua_AllToLua_cClientHandle_SendEntityAnimation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cEntity",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"EntityAnimation",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  const cEntity* a_Entity = ((const cEntity*)  tolua_tousertype(tolua_S,2,nullptr));
  EntityAnimation a_Animation = *((EntityAnimation*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendEntityAnimation'", nullptr);
#endif
  {
   self->SendEntityAnimation(*a_Entity,a_Animation);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendEntityAnimation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendHideTitle of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendHideTitle00
static int tolua_AllToLua_cClientHandle_SendHideTitle00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendHideTitle'", nullptr);
#endif
  {
   self->SendHideTitle();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendHideTitle'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendLeashEntity of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendLeashEntity00
static int tolua_AllToLua_cClientHandle_SendLeashEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cEntity",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cEntity",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  const cEntity* a_Entity = ((const cEntity*)  tolua_tousertype(tolua_S,2,nullptr));
  const cEntity* a_EntityLeashedTo = ((const cEntity*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendLeashEntity'", nullptr);
#endif
  {
   self->SendLeashEntity(*a_Entity,*a_EntityLeashedTo);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendLeashEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendPlayerListHeaderFooter of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendPlayerListHeaderFooter00
static int tolua_AllToLua_cClientHandle_SendPlayerListHeaderFooter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cCompositeChat",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cCompositeChat",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  const cCompositeChat* a_Header = ((const cCompositeChat*)  tolua_tousertype(tolua_S,2,nullptr));
  const cCompositeChat* a_Footer = ((const cCompositeChat*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendPlayerListHeaderFooter'", nullptr);
#endif
  {
   self->SendPlayerListHeaderFooter(*a_Header,*a_Footer);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendPlayerListHeaderFooter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendResourcePack of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendResourcePack00
static int tolua_AllToLua_cClientHandle_SendResourcePack00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_ResourcePackUrl = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendResourcePack'", nullptr);
#endif
  {
   self->SendResourcePack(a_ResourcePackUrl);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendResourcePack'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendResetTitle of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendResetTitle00
static int tolua_AllToLua_cClientHandle_SendResetTitle00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendResetTitle'", nullptr);
#endif
  {
   self->SendResetTitle();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendResetTitle'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendSetSubTitle of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendSetSubTitle00
static int tolua_AllToLua_cClientHandle_SendSetSubTitle00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cCompositeChat",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  const cCompositeChat* a_SubTitle = ((const cCompositeChat*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendSetSubTitle'", nullptr);
#endif
  {
   self->SendSetSubTitle(*a_SubTitle);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendSetSubTitle'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendSetRawSubTitle of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendSetRawSubTitle00
static int tolua_AllToLua_cClientHandle_SendSetRawSubTitle00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_SubTitle = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendSetRawSubTitle'", nullptr);
#endif
  {
   self->SendSetRawSubTitle(a_SubTitle);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendSetRawSubTitle'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendSetTitle of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendSetTitle00
static int tolua_AllToLua_cClientHandle_SendSetTitle00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cCompositeChat",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  const cCompositeChat* a_Title = ((const cCompositeChat*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendSetTitle'", nullptr);
#endif
  {
   self->SendSetTitle(*a_Title);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendSetTitle'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendSetRawTitle of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendSetRawTitle00
static int tolua_AllToLua_cClientHandle_SendSetRawTitle00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Title = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendSetRawTitle'", nullptr);
#endif
  {
   self->SendSetRawTitle(a_Title);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendSetRawTitle'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendSoundEffect of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendSoundEffect00
static int tolua_AllToLua_cClientHandle_SendSoundEffect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_SoundName = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  double a_X = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_Y = ((double)  tolua_tonumber(tolua_S,4,0));
  double a_Z = ((double)  tolua_tonumber(tolua_S,5,0));
  float a_Volume = ((float)  tolua_tonumber(tolua_S,6,0));
  float a_Pitch = ((float)  tolua_tonumber(tolua_S,7,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendSoundEffect'", nullptr);
#endif
  {
   self->SendSoundEffect(a_SoundName,a_X,a_Y,a_Z,a_Volume,a_Pitch);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendSoundEffect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendSoundEffect of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendSoundEffect01
static int tolua_AllToLua_cClientHandle_SendSoundEffect01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_SoundName = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
   Vector3<double> a_Position = *((  Vector3<double>*)  tolua_tousertype(tolua_S,3,nullptr));
  float a_Volume = ((float)  tolua_tonumber(tolua_S,4,0));
  float a_Pitch = ((float)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendSoundEffect'", nullptr);
#endif
  {
   self->SendSoundEffect(a_SoundName,a_Position,a_Volume,a_Pitch);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cClientHandle_SendSoundEffect00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendThunderbolt of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendThunderbolt00
static int tolua_AllToLua_cClientHandle_SendThunderbolt00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<int> a_BlockPos = *((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendThunderbolt'", nullptr);
#endif
  {
   self->SendThunderbolt(a_BlockPos);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendThunderbolt'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendTitleTimes of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendTitleTimes00
static int tolua_AllToLua_cClientHandle_SendTitleTimes00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_FadeInTicks = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_DisplayTicks = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_FadeOutTicks = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendTitleTimes'", nullptr);
#endif
  {
   self->SendTitleTimes(a_FadeInTicks,a_DisplayTicks,a_FadeOutTicks);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendTitleTimes'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendUnleashEntity of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SendUnleashEntity00
static int tolua_AllToLua_cClientHandle_SendUnleashEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cEntity",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  const cEntity* a_Entity = ((const cEntity*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendUnleashEntity'", nullptr);
#endif
  {
   self->SendUnleashEntity(*a_Entity);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendUnleashEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetUsername of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_GetUsername00
static int tolua_AllToLua_cClientHandle_GetUsername00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cClientHandle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cClientHandle* self = (const cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetUsername'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetUsername();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetUsername'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPing of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_GetPing00
static int tolua_AllToLua_cClientHandle_GetPing00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cClientHandle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cClientHandle* self = (const cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPing'", nullptr);
#endif
  {
   short tolua_ret = (short)  self->GetPing();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPing'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetViewDistance of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SetViewDistance00
static int tolua_AllToLua_cClientHandle_SetViewDistance00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_ViewDistance = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetViewDistance'", nullptr);
#endif
  {
   self->SetViewDistance(a_ViewDistance);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetViewDistance'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetViewDistance of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_GetViewDistance00
static int tolua_AllToLua_cClientHandle_GetViewDistance00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cClientHandle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cClientHandle* self = (const cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetViewDistance'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetViewDistance();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetViewDistance'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetRequestedViewDistance of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_GetRequestedViewDistance00
static int tolua_AllToLua_cClientHandle_GetRequestedViewDistance00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cClientHandle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cClientHandle* self = (const cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetRequestedViewDistance'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetRequestedViewDistance();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetRequestedViewDistance'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetLocale of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SetLocale00
static int tolua_AllToLua_cClientHandle_SetLocale00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Locale = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetLocale'", nullptr);
#endif
  {
   self->SetLocale(a_Locale);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetLocale'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetLocale of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_GetLocale00
static int tolua_AllToLua_cClientHandle_GetLocale00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cClientHandle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cClientHandle* self = (const cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetLocale'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetLocale();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetLocale'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetUniqueID of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_GetUniqueID00
static int tolua_AllToLua_cClientHandle_GetUniqueID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cClientHandle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cClientHandle* self = (const cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetUniqueID'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetUniqueID();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetUniqueID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: HasPluginChannel of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_HasPluginChannel00
static int tolua_AllToLua_cClientHandle_HasPluginChannel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_PluginChannel = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HasPluginChannel'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->HasPluginChannel(a_PluginChannel);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'HasPluginChannel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetClientBrand of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_SetClientBrand00
static int tolua_AllToLua_cClientHandle_SetClientBrand00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cClientHandle* self = (cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_ClientBrand = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetClientBrand'", nullptr);
#endif
  {
   self->SetClientBrand(a_ClientBrand);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetClientBrand'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetClientBrand of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_GetClientBrand00
static int tolua_AllToLua_cClientHandle_GetClientBrand00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cClientHandle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cClientHandle* self = (const cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetClientBrand'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetClientBrand();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetClientBrand'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetForgeMods of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_GetForgeMods00
static int tolua_AllToLua_cClientHandle_GetForgeMods00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cClientHandle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cClientHandle* self = (const cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetForgeMods'", nullptr);
#endif
  {
   const AStringMap& tolua_ret = (const AStringMap&)  self->GetForgeMods();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const AStringMap");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetForgeMods'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsForgeClient of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_IsForgeClient00
static int tolua_AllToLua_cClientHandle_IsForgeClient00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cClientHandle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cClientHandle* self = (const cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsForgeClient'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsForgeClient();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsForgeClient'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetProtocolVersion of class  cClientHandle */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_GetProtocolVersion00
static int tolua_AllToLua_cClientHandle_GetProtocolVersion00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cClientHandle",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cClientHandle* self = (const cClientHandle*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetProtocolVersion'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->GetProtocolVersion();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetProtocolVersion'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseColorLimits (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 4294967295.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eColorLimits";
	return 0;
}
/* method: new of class  cColor */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cColor_new00
static int tolua_AllToLua_cColor_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   cColor* tolua_ret = (cColor*)  Mtolua_new((cColor)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cColor");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cColor */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cColor_new00_local
static int tolua_AllToLua_cColor_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   cColor* tolua_ret = (cColor*)  Mtolua_new((cColor)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  cColor */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cColor_new01
static int tolua_AllToLua_cColor_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  unsigned char a_Red = ((unsigned char)  tolua_tonumber(tolua_S,2,0));
  unsigned char a_Green = ((unsigned char)  tolua_tonumber(tolua_S,3,0));
  unsigned char a_Blue = ((unsigned char)  tolua_tonumber(tolua_S,4,0));
  {
   cColor* tolua_ret = (cColor*)  Mtolua_new((cColor)(a_Red,a_Green,a_Blue));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cColor");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cColor_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cColor */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cColor_new01_local
static int tolua_AllToLua_cColor_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  unsigned char a_Red = ((unsigned char)  tolua_tonumber(tolua_S,2,0));
  unsigned char a_Green = ((unsigned char)  tolua_tonumber(tolua_S,3,0));
  unsigned char a_Blue = ((unsigned char)  tolua_tonumber(tolua_S,4,0));
  {
   cColor* tolua_ret = (cColor*)  Mtolua_new((cColor)(a_Red,a_Green,a_Blue));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cColor");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cColor_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsValid of class  cColor */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cColor_IsValid00
static int tolua_AllToLua_cColor_IsValid00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cColor* self = (const cColor*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsValid'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsValid();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsValid'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetColor of class  cColor */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cColor_SetColor00
static int tolua_AllToLua_cColor_SetColor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cColor* self = (cColor*)  tolua_tousertype(tolua_S,1,nullptr);
  unsigned char a_Red = ((unsigned char)  tolua_tonumber(tolua_S,2,0));
  unsigned char a_Green = ((unsigned char)  tolua_tonumber(tolua_S,3,0));
  unsigned char a_Blue = ((unsigned char)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetColor'", nullptr);
#endif
  {
   self->SetColor(a_Red,a_Green,a_Blue);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetColor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetRed of class  cColor */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cColor_SetRed00
static int tolua_AllToLua_cColor_SetRed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cColor* self = (cColor*)  tolua_tousertype(tolua_S,1,nullptr);
  unsigned char a_Red = ((unsigned char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetRed'", nullptr);
#endif
  {
   self->SetRed(a_Red);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetRed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetGreen of class  cColor */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cColor_SetGreen00
static int tolua_AllToLua_cColor_SetGreen00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cColor* self = (cColor*)  tolua_tousertype(tolua_S,1,nullptr);
  unsigned char a_Green = ((unsigned char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetGreen'", nullptr);
#endif
  {
   self->SetGreen(a_Green);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetGreen'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetBlue of class  cColor */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cColor_SetBlue00
static int tolua_AllToLua_cColor_SetBlue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cColor",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cColor* self = (cColor*)  tolua_tousertype(tolua_S,1,nullptr);
  unsigned char a_Blue = ((unsigned char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetBlue'", nullptr);
#endif
  {
   self->SetBlue(a_Blue);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetBlue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetRed of class  cColor */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cColor_GetRed00
static int tolua_AllToLua_cColor_GetRed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cColor* self = (const cColor*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetRed'", nullptr);
#endif
  {
   unsigned char tolua_ret = (unsigned char)  self->GetRed();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetRed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetGreen of class  cColor */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cColor_GetGreen00
static int tolua_AllToLua_cColor_GetGreen00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cColor* self = (const cColor*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetGreen'", nullptr);
#endif
  {
   unsigned char tolua_ret = (unsigned char)  self->GetGreen();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetGreen'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetBlue of class  cColor */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cColor_GetBlue00
static int tolua_AllToLua_cColor_GetBlue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cColor* self = (const cColor*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetBlue'", nullptr);
#endif
  {
   unsigned char tolua_ret = (unsigned char)  self->GetBlue();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetBlue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Clear of class  cColor */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cColor_Clear00
static int tolua_AllToLua_cColor_Clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cColor",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cColor* self = (cColor*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Clear'", nullptr);
#endif
  {
   self->Clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_isEffectID (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 3001.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "EffectID";
	return 0;
}
int tolua_isSmokeDirection (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 8.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "SmokeDirection";
	return 0;
}
/* method: GetDescription of class  cServer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cServer_GetDescription00
static int tolua_AllToLua_cServer_GetDescription00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cServer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cServer* self = (const cServer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetDescription'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetDescription();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetDescription'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetShutdownMessage of class  cServer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cServer_GetShutdownMessage00
static int tolua_AllToLua_cServer_GetShutdownMessage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cServer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cServer* self = (const cServer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetShutdownMessage'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetShutdownMessage();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetShutdownMessage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMaxPlayers of class  cServer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cServer_GetMaxPlayers00
static int tolua_AllToLua_cServer_GetMaxPlayers00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cServer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cServer* self = (const cServer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMaxPlayers'", nullptr);
#endif
  {
   size_t tolua_ret = (size_t)  self->GetMaxPlayers();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMaxPlayers'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNumPlayers of class  cServer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cServer_GetNumPlayers00
static int tolua_AllToLua_cServer_GetNumPlayers00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cServer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cServer* self = (const cServer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumPlayers'", nullptr);
#endif
  {
   size_t tolua_ret = (size_t)  self->GetNumPlayers();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetNumPlayers'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetMaxPlayers of class  cServer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cServer_SetMaxPlayers00
static int tolua_AllToLua_cServer_SetMaxPlayers00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cServer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cServer* self = (cServer*)  tolua_tousertype(tolua_S,1,nullptr);
  size_t a_MaxPlayers = ((size_t)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetMaxPlayers'", nullptr);
#endif
  {
   self->SetMaxPlayers(a_MaxPlayers);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetMaxPlayers'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: UnregisterForgeMod of class  cServer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cServer_UnregisterForgeMod00
static int tolua_AllToLua_cServer_UnregisterForgeMod00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cServer",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cServer* self = (cServer*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_ModName = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  unsigned int a_ProtocolVersionNumber = (( unsigned int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'UnregisterForgeMod'", nullptr);
#endif
  {
   self->UnregisterForgeMod(a_ModName,a_ProtocolVersionNumber);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'UnregisterForgeMod'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsPlayerInQueue of class  cServer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cServer_IsPlayerInQueue00
static int tolua_AllToLua_cServer_IsPlayerInQueue00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cServer",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cServer* self = (cServer*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Username = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsPlayerInQueue'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsPlayerInQueue(a_Username);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsPlayerInQueue'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DoesAllowMultiLogin of class  cServer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cServer_DoesAllowMultiLogin00
static int tolua_AllToLua_cServer_DoesAllowMultiLogin00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cServer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cServer* self = (cServer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DoesAllowMultiLogin'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->DoesAllowMultiLogin();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DoesAllowMultiLogin'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsHardcore of class  cServer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cServer_IsHardcore00
static int tolua_AllToLua_cServer_IsHardcore00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cServer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cServer* self = (const cServer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsHardcore'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsHardcore();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsHardcore'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetServerID of class  cServer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cServer_GetServerID00
static int tolua_AllToLua_cServer_GetServerID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cServer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cServer* self = (const cServer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetServerID'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetServerID();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetServerID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ShouldAuthenticate of class  cServer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cServer_ShouldAuthenticate00
static int tolua_AllToLua_cServer_ShouldAuthenticate00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cServer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cServer* self = (const cServer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ShouldAuthenticate'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->ShouldAuthenticate();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ShouldAuthenticate'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsSavingEnabled of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_IsSavingEnabled00
static int tolua_AllToLua_cWorld_IsSavingEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsSavingEnabled'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsSavingEnabled();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsSavingEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSavingEnabled of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetSavingEnabled00
static int tolua_AllToLua_cWorld_SetSavingEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_IsSavingEnabled = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSavingEnabled'", nullptr);
#endif
  {
   self->SetSavingEnabled(a_IsSavingEnabled);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetSavingEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetTicksUntilWeatherChange of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetTicksUntilWeatherChange00
static int tolua_AllToLua_cWorld_GetTicksUntilWeatherChange00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetTicksUntilWeatherChange'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetTicksUntilWeatherChange();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetTicksUntilWeatherChange'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsDaylightCycleEnabled of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_IsDaylightCycleEnabled00
static int tolua_AllToLua_cWorld_IsDaylightCycleEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsDaylightCycleEnabled'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsDaylightCycleEnabled();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsDaylightCycleEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetDaylightCycleEnabled of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetDaylightCycleEnabled00
static int tolua_AllToLua_cWorld_SetDaylightCycleEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_IsDaylightCycleEnabled = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetDaylightCycleEnabled'", nullptr);
#endif
  {
   self->SetDaylightCycleEnabled(a_IsDaylightCycleEnabled);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetDaylightCycleEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetTicksUntilWeatherChange of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetTicksUntilWeatherChange00
static int tolua_AllToLua_cWorld_SetTicksUntilWeatherChange00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_WeatherInterval = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetTicksUntilWeatherChange'", nullptr);
#endif
  {
   self->SetTicksUntilWeatherChange(a_WeatherInterval);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetTicksUntilWeatherChange'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseWeather (lua_State* L, int lo, int def, tolua_Error* err);
/* method: GetDefaultWeatherInterval of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetDefaultWeatherInterval00
static int tolua_AllToLua_cWorld_GetDefaultWeatherInterval00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_iseWeather(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  eWeather a_Weather = ((eWeather) (  int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetDefaultWeatherInterval'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetDefaultWeatherInterval(a_Weather);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetDefaultWeatherInterval'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetGameMode of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetGameMode00
static int tolua_AllToLua_cWorld_GetGameMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetGameMode'", nullptr);
#endif
  {
   eGameMode tolua_ret = (eGameMode)  self->GetGameMode();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetGameMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsGameModeCreative of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_IsGameModeCreative00
static int tolua_AllToLua_cWorld_IsGameModeCreative00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsGameModeCreative'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsGameModeCreative();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsGameModeCreative'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsGameModeSurvival of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_IsGameModeSurvival00
static int tolua_AllToLua_cWorld_IsGameModeSurvival00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsGameModeSurvival'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsGameModeSurvival();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsGameModeSurvival'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsGameModeAdventure of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_IsGameModeAdventure00
static int tolua_AllToLua_cWorld_IsGameModeAdventure00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsGameModeAdventure'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsGameModeAdventure();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsGameModeAdventure'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsGameModeSpectator of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_IsGameModeSpectator00
static int tolua_AllToLua_cWorld_IsGameModeSpectator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsGameModeSpectator'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsGameModeSpectator();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsGameModeSpectator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsPVPEnabled of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_IsPVPEnabled00
static int tolua_AllToLua_cWorld_IsPVPEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsPVPEnabled'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsPVPEnabled();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsPVPEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsFarmlandTramplingEnabled of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_IsFarmlandTramplingEnabled00
static int tolua_AllToLua_cWorld_IsFarmlandTramplingEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsFarmlandTramplingEnabled'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsFarmlandTramplingEnabled();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsFarmlandTramplingEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsDeepSnowEnabled of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_IsDeepSnowEnabled00
static int tolua_AllToLua_cWorld_IsDeepSnowEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsDeepSnowEnabled'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsDeepSnowEnabled();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsDeepSnowEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ShouldLavaSpawnFire of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_ShouldLavaSpawnFire00
static int tolua_AllToLua_cWorld_ShouldLavaSpawnFire00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ShouldLavaSpawnFire'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->ShouldLavaSpawnFire();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ShouldLavaSpawnFire'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: VillagersShouldHarvestCrops of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_VillagersShouldHarvestCrops00
static int tolua_AllToLua_cWorld_VillagersShouldHarvestCrops00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'VillagersShouldHarvestCrops'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->VillagersShouldHarvestCrops();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'VillagersShouldHarvestCrops'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetDimension of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetDimension00
static int tolua_AllToLua_cWorld_GetDimension00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetDimension'", nullptr);
#endif
  {
   eDimension tolua_ret = (eDimension)  self->GetDimension();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetDimension'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetHeight of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetHeight00
static int tolua_AllToLua_cWorld_GetHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_BlockX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_BlockZ = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetHeight'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetHeight(a_BlockX,a_BlockZ);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseMessageType (lua_State* L, int lo, int def, tolua_Error* err);
/* method: BroadcastChat of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_BroadcastChat00
static int tolua_AllToLua_cWorld_BroadcastChat00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"const cClientHandle",1,&tolua_err) ||
     !tolua_iseMessageType(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const cClientHandle* a_Exclude = ((const cClientHandle*)  tolua_tousertype(tolua_S,3,nullptr));
  eMessageType a_ChatPrefix = ((eMessageType) (  int)  tolua_tonumber(tolua_S,4,mtCustom));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BroadcastChat'", nullptr);
#endif
  {
   self->BroadcastChat(a_Message,a_Exclude,a_ChatPrefix);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BroadcastChat'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: BroadcastChatInfo of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_BroadcastChatInfo00
static int tolua_AllToLua_cWorld_BroadcastChatInfo00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"const cClientHandle",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const cClientHandle* a_Exclude = ((const cClientHandle*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BroadcastChatInfo'", nullptr);
#endif
  {
   self->BroadcastChatInfo(a_Message,a_Exclude);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BroadcastChatInfo'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: BroadcastChatFailure of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_BroadcastChatFailure00
static int tolua_AllToLua_cWorld_BroadcastChatFailure00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"const cClientHandle",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const cClientHandle* a_Exclude = ((const cClientHandle*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BroadcastChatFailure'", nullptr);
#endif
  {
   self->BroadcastChatFailure(a_Message,a_Exclude);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BroadcastChatFailure'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: BroadcastChatSuccess of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_BroadcastChatSuccess00
static int tolua_AllToLua_cWorld_BroadcastChatSuccess00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"const cClientHandle",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const cClientHandle* a_Exclude = ((const cClientHandle*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BroadcastChatSuccess'", nullptr);
#endif
  {
   self->BroadcastChatSuccess(a_Message,a_Exclude);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BroadcastChatSuccess'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: BroadcastChatWarning of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_BroadcastChatWarning00
static int tolua_AllToLua_cWorld_BroadcastChatWarning00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"const cClientHandle",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const cClientHandle* a_Exclude = ((const cClientHandle*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BroadcastChatWarning'", nullptr);
#endif
  {
   self->BroadcastChatWarning(a_Message,a_Exclude);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BroadcastChatWarning'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: BroadcastChatFatal of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_BroadcastChatFatal00
static int tolua_AllToLua_cWorld_BroadcastChatFatal00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"const cClientHandle",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const cClientHandle* a_Exclude = ((const cClientHandle*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BroadcastChatFatal'", nullptr);
#endif
  {
   self->BroadcastChatFatal(a_Message,a_Exclude);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BroadcastChatFatal'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: BroadcastChatDeath of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_BroadcastChatDeath00
static int tolua_AllToLua_cWorld_BroadcastChatDeath00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"const cClientHandle",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const cClientHandle* a_Exclude = ((const cClientHandle*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BroadcastChatDeath'", nullptr);
#endif
  {
   self->BroadcastChatDeath(a_Message,a_Exclude);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BroadcastChatDeath'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: BroadcastChat of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_BroadcastChat01
static int tolua_AllToLua_cWorld_BroadcastChat01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cCompositeChat",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"const cClientHandle",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  const cCompositeChat* a_Message = ((const cCompositeChat*)  tolua_tousertype(tolua_S,2,nullptr));
  const cClientHandle* a_Exclude = ((const cClientHandle*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BroadcastChat'", nullptr);
#endif
  {
   self->BroadcastChat(*a_Message,a_Exclude);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cWorld_BroadcastChat00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: BroadcastEntityAnimation of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_BroadcastEntityAnimation00
static int tolua_AllToLua_cWorld_BroadcastEntityAnimation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cEntity",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"EntityAnimation",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,4,"const cClientHandle",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  const cEntity* a_Entity = ((const cEntity*)  tolua_tousertype(tolua_S,2,nullptr));
  EntityAnimation a_Animation = *((EntityAnimation*)  tolua_tousertype(tolua_S,3,nullptr));
  const cClientHandle* a_Exclude = ((const cClientHandle*)  tolua_tousertype(tolua_S,4,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BroadcastEntityAnimation'", nullptr);
#endif
  {
   self->BroadcastEntityAnimation(*a_Entity,a_Animation,a_Exclude);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BroadcastEntityAnimation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: BroadcastPlayerListHeaderFooter of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_BroadcastPlayerListHeaderFooter00
static int tolua_AllToLua_cWorld_BroadcastPlayerListHeaderFooter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cCompositeChat",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cCompositeChat",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  const cCompositeChat* a_Header = ((const cCompositeChat*)  tolua_tousertype(tolua_S,2,nullptr));
  const cCompositeChat* a_Footer = ((const cCompositeChat*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BroadcastPlayerListHeaderFooter'", nullptr);
#endif
  {
   self->BroadcastPlayerListHeaderFooter(*a_Header,*a_Footer);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BroadcastPlayerListHeaderFooter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: QueueUnloadUnusedChunks of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_QueueUnloadUnusedChunks00
static int tolua_AllToLua_cWorld_QueueUnloadUnusedChunks00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'QueueUnloadUnusedChunks'", nullptr);
#endif
  {
   self->QueueUnloadUnusedChunks();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'QueueUnloadUnusedChunks'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetCommandBlockCommand of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetCommandBlockCommand00
static int tolua_AllToLua_cWorld_SetCommandBlockCommand00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_BlockX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_BlockY = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_BlockZ = ((int)  tolua_tonumber(tolua_S,4,0));
  const AString a_Command = ((const AString)  tolua_tocppstring(tolua_S,5,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetCommandBlockCommand'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->SetCommandBlockCommand(a_BlockX,a_BlockY,a_BlockZ,a_Command);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetCommandBlockCommand'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsTrapdoorOpen of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_IsTrapdoorOpen00
static int tolua_AllToLua_cWorld_IsTrapdoorOpen00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_BlockX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_BlockY = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_BlockZ = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsTrapdoorOpen'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsTrapdoorOpen(a_BlockX,a_BlockY,a_BlockZ);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsTrapdoorOpen'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetTrapdoorOpen of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetTrapdoorOpen00
static int tolua_AllToLua_cWorld_SetTrapdoorOpen00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_BlockX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_BlockY = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_BlockZ = ((int)  tolua_tonumber(tolua_S,4,0));
  bool a_Open = ((bool)  tolua_toboolean(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetTrapdoorOpen'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->SetTrapdoorOpen(a_BlockX,a_BlockY,a_BlockZ,a_Open);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetTrapdoorOpen'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: RegenerateChunk of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_RegenerateChunk00
static int tolua_AllToLua_cWorld_RegenerateChunk00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_ChunkX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_ChunkZ = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'RegenerateChunk'", nullptr);
#endif
  {
   self->RegenerateChunk(a_ChunkX,a_ChunkZ);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'RegenerateChunk'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GenerateChunk of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GenerateChunk00
static int tolua_AllToLua_cWorld_GenerateChunk00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_ChunkX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_ChunkZ = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GenerateChunk'", nullptr);
#endif
  {
   self->GenerateChunk(a_ChunkX,a_ChunkZ);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GenerateChunk'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpawnItemPickups of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SpawnItemPickups00
static int tolua_AllToLua_cWorld_SpawnItemPickups00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItems",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"Vector3<int>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItems* a_Pickups = ((const cItems*)  tolua_tousertype(tolua_S,2,nullptr));
   Vector3<int> a_BlockPos = *((  Vector3<int>*)  tolua_tousertype(tolua_S,3,nullptr));
  double a_FlyAwaySpeed = ((double)  tolua_tonumber(tolua_S,4,1.0));
  bool a_IsPlayerCreated = ((bool)  tolua_toboolean(tolua_S,5,false));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnItemPickups'", nullptr);
#endif
  {
   self->SpawnItemPickups(*a_Pickups,a_BlockPos,a_FlyAwaySpeed,a_IsPlayerCreated);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SpawnItemPickups'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpawnItemPickups of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SpawnItemPickups01
static int tolua_AllToLua_cWorld_SpawnItemPickups01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItems",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItems* a_Pickups = ((const cItems*)  tolua_tousertype(tolua_S,2,nullptr));
   Vector3<double> a_Pos = *((  Vector3<double>*)  tolua_tousertype(tolua_S,3,nullptr));
  double a_FlyAwaySpeed = ((double)  tolua_tonumber(tolua_S,4,1.0));
  bool a_IsPlayerCreated = ((bool)  tolua_toboolean(tolua_S,5,false));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnItemPickups'", nullptr);
#endif
  {
   self->SpawnItemPickups(*a_Pickups,a_Pos,a_FlyAwaySpeed,a_IsPlayerCreated);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cWorld_SpawnItemPickups00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpawnItemPickups of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SpawnItemPickups02
static int tolua_AllToLua_cWorld_SpawnItemPickups02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItems",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,1,&tolua_err) ||
     !tolua_isboolean(tolua_S,7,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItems* a_Pickups = ((const cItems*)  tolua_tousertype(tolua_S,2,nullptr));
  double a_BlockX = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_BlockY = ((double)  tolua_tonumber(tolua_S,4,0));
  double a_BlockZ = ((double)  tolua_tonumber(tolua_S,5,0));
  double a_FlyAwaySpeed = ((double)  tolua_tonumber(tolua_S,6,1.0));
  bool a_IsPlayerCreated = ((bool)  tolua_toboolean(tolua_S,7,false));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnItemPickups'", nullptr);
#endif
  {
   self->SpawnItemPickups(*a_Pickups,a_BlockX,a_BlockY,a_BlockZ,a_FlyAwaySpeed,a_IsPlayerCreated);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cWorld_SpawnItemPickups01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpawnItemPickups of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SpawnItemPickups03
static int tolua_AllToLua_cWorld_SpawnItemPickups03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItems",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"Vector3<double>",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItems* a_Pickups = ((const cItems*)  tolua_tousertype(tolua_S,2,nullptr));
   Vector3<double> a_Pos = *((  Vector3<double>*)  tolua_tousertype(tolua_S,3,nullptr));
   Vector3<double> a_Speed = *((  Vector3<double>*)  tolua_tousertype(tolua_S,4,nullptr));
  bool a_IsPlayerCreated = ((bool)  tolua_toboolean(tolua_S,5,false));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnItemPickups'", nullptr);
#endif
  {
   self->SpawnItemPickups(*a_Pickups,a_Pos,a_Speed,a_IsPlayerCreated);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cWorld_SpawnItemPickups02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpawnItemPickups of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SpawnItemPickups04
static int tolua_AllToLua_cWorld_SpawnItemPickups04(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItems",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,8,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,9,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,10,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItems* a_Pickups = ((const cItems*)  tolua_tousertype(tolua_S,2,nullptr));
  double a_BlockX = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_BlockY = ((double)  tolua_tonumber(tolua_S,4,0));
  double a_BlockZ = ((double)  tolua_tonumber(tolua_S,5,0));
  double a_SpeedX = ((double)  tolua_tonumber(tolua_S,6,0));
  double a_SpeedY = ((double)  tolua_tonumber(tolua_S,7,0));
  double a_SpeedZ = ((double)  tolua_tonumber(tolua_S,8,0));
  bool a_IsPlayerCreated = ((bool)  tolua_toboolean(tolua_S,9,false));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnItemPickups'", nullptr);
#endif
  {
   self->SpawnItemPickups(*a_Pickups,a_BlockX,a_BlockY,a_BlockZ,a_SpeedX,a_SpeedY,a_SpeedZ,a_IsPlayerCreated);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cWorld_SpawnItemPickups03(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpawnItemPickup of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SpawnItemPickup00
static int tolua_AllToLua_cWorld_SpawnItemPickup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<double>",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cItem",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"Vector3<float>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
     !tolua_isboolean(tolua_S,6,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<double> a_Pos = *((  Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,3,nullptr));
   Vector3<float> a_Speed = *((  Vector3<float>*)  tolua_tousertype(tolua_S,4,nullptr));
  int a_LifetimeTicks = ((int)  tolua_tonumber(tolua_S,5,6000));
  bool a_CanCombine = ((bool)  tolua_toboolean(tolua_S,6,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnItemPickup'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->SpawnItemPickup(a_Pos,*a_Item,a_Speed,a_LifetimeTicks,a_CanCombine);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SpawnItemPickup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpawnItemPickup of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SpawnItemPickup01
static int tolua_AllToLua_cWorld_SpawnItemPickup01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"const cItem",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,6,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,7,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,8,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,9,1,&tolua_err) ||
     !tolua_isboolean(tolua_S,10,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,11,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_PosX = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_PosY = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_PosZ = ((double)  tolua_tonumber(tolua_S,4,0));
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,5,nullptr));
  float a_SpeedX = ((float)  tolua_tonumber(tolua_S,6,0.f));
  float a_SpeedY = ((float)  tolua_tonumber(tolua_S,7,0.f));
  float a_SpeedZ = ((float)  tolua_tonumber(tolua_S,8,0.f));
  int a_LifetimeTicks = ((int)  tolua_tonumber(tolua_S,9,6000));
  bool a_CanCombine = ((bool)  tolua_toboolean(tolua_S,10,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnItemPickup'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->SpawnItemPickup(a_PosX,a_PosY,a_PosZ,*a_Item,a_SpeedX,a_SpeedY,a_SpeedZ,a_LifetimeTicks,a_CanCombine);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cWorld_SpawnItemPickup00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpawnFallingBlock of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SpawnFallingBlock00
static int tolua_AllToLua_cWorld_SpawnFallingBlock00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<double> a_Pos = *((  Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  unsigned char a_BlockType = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
  unsigned char a_BlockMeta = (( unsigned char)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnFallingBlock'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->SpawnFallingBlock(a_Pos,a_BlockType,a_BlockMeta);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SpawnFallingBlock'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpawnFallingBlock of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SpawnFallingBlock01
static int tolua_AllToLua_cWorld_SpawnFallingBlock01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<int> a_BlockPos = *((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
  unsigned char a_BlockType = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
  unsigned char a_BlockMeta = (( unsigned char)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnFallingBlock'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->SpawnFallingBlock(a_BlockPos,a_BlockType,a_BlockMeta);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cWorld_SpawnFallingBlock00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpawnFallingBlock of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SpawnFallingBlock02
static int tolua_AllToLua_cWorld_SpawnFallingBlock02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_X = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_Y = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_Z = ((int)  tolua_tonumber(tolua_S,4,0));
  unsigned char a_BlockType = (( unsigned char)  tolua_tonumber(tolua_S,5,0));
  unsigned char a_BlockMeta = (( unsigned char)  tolua_tonumber(tolua_S,6,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnFallingBlock'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->SpawnFallingBlock(a_X,a_Y,a_Z,a_BlockType,a_BlockMeta);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cWorld_SpawnFallingBlock01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpawnMinecart of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SpawnMinecart00
static int tolua_AllToLua_cWorld_SpawnMinecart00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<double> a_Pos = *((  Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  int a_MinecartType = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnMinecart'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->SpawnMinecart(a_Pos,a_MinecartType);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SpawnMinecart'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpawnMinecart of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SpawnMinecart01
static int tolua_AllToLua_cWorld_SpawnMinecart01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const cItem",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<double> a_Pos = *((  Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  int a_MinecartType = ((int)  tolua_tonumber(tolua_S,3,0));
  const cItem* a_Content = ((const cItem*)  tolua_tousertype(tolua_S,4,nullptr));
  int a_BlockHeight = ((int)  tolua_tonumber(tolua_S,5,1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnMinecart'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->SpawnMinecart(a_Pos,a_MinecartType,*a_Content,a_BlockHeight);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cWorld_SpawnMinecart00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpawnMinecart of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SpawnMinecart02
static int tolua_AllToLua_cWorld_SpawnMinecart02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_X = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_Y = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_Z = ((double)  tolua_tonumber(tolua_S,4,0));
  int a_MinecartType = ((int)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnMinecart'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->SpawnMinecart(a_X,a_Y,a_Z,a_MinecartType);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cWorld_SpawnMinecart01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpawnMinecart of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SpawnMinecart03
static int tolua_AllToLua_cWorld_SpawnMinecart03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"const cItem",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,7,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_X = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_Y = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_Z = ((double)  tolua_tonumber(tolua_S,4,0));
  int a_MinecartType = ((int)  tolua_tonumber(tolua_S,5,0));
  const cItem* a_Content = ((const cItem*)  tolua_tousertype(tolua_S,6,nullptr));
  int a_BlockHeight = ((int)  tolua_tonumber(tolua_S,7,1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnMinecart'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->SpawnMinecart(a_X,a_Y,a_Z,a_MinecartType,*a_Content,a_BlockHeight);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cWorld_SpawnMinecart02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpawnBoat of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SpawnBoat00
static int tolua_AllToLua_cWorld_SpawnBoat00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_X = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_Y = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_Z = ((double)  tolua_tonumber(tolua_S,4,0));
  cBoat::eMaterial a_Material = ((cBoat::eMaterial) (  int)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnBoat'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->SpawnBoat(a_X,a_Y,a_Z,a_Material);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SpawnBoat'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpawnBoat of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SpawnBoat01
static int tolua_AllToLua_cWorld_SpawnBoat01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<double> a_Pos = *((  Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  cBoat::eMaterial a_Material = ((cBoat::eMaterial) (  int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnBoat'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->SpawnBoat(a_Pos,a_Material);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cWorld_SpawnBoat00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpawnExperienceOrb of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SpawnExperienceOrb00
static int tolua_AllToLua_cWorld_SpawnExperienceOrb00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<double> a_Pos = *((  Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  int a_Reward = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnExperienceOrb'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->SpawnExperienceOrb(a_Pos,a_Reward);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SpawnExperienceOrb'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpawnExperienceOrb of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SpawnExperienceOrb01
static int tolua_AllToLua_cWorld_SpawnExperienceOrb01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_X = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_Y = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_Z = ((double)  tolua_tonumber(tolua_S,4,0));
  int a_Reward = ((int)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnExperienceOrb'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->SpawnExperienceOrb(a_X,a_Y,a_Z,a_Reward);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cWorld_SpawnExperienceOrb00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpawnPrimedTNT of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SpawnPrimedTNT00
static int tolua_AllToLua_cWorld_SpawnPrimedTNT00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,1,&tolua_err) ||
     !tolua_isboolean(tolua_S,7,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_X = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_Y = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_Z = ((double)  tolua_tonumber(tolua_S,4,0));
  int a_FuseTimeInSec = ((int)  tolua_tonumber(tolua_S,5,80));
  double a_InitialVelocityCoeff = ((double)  tolua_tonumber(tolua_S,6,1));
  bool a_ShouldPlayFuseSound = ((bool)  tolua_toboolean(tolua_S,7,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnPrimedTNT'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->SpawnPrimedTNT(a_X,a_Y,a_Z,a_FuseTimeInSec,a_InitialVelocityCoeff,a_ShouldPlayFuseSound);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SpawnPrimedTNT'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpawnPrimedTNT of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SpawnPrimedTNT01
static int tolua_AllToLua_cWorld_SpawnPrimedTNT01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<double> a_Pos = *((  Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  int a_FuseTimeInSec = ((int)  tolua_tonumber(tolua_S,3,80));
  double a_InitialVelocityCoeff = ((double)  tolua_tonumber(tolua_S,4,1));
  bool a_ShouldPlayFuseSound = ((bool)  tolua_toboolean(tolua_S,5,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnPrimedTNT'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->SpawnPrimedTNT(a_Pos,a_FuseTimeInSec,a_InitialVelocityCoeff,a_ShouldPlayFuseSound);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cWorld_SpawnPrimedTNT00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpawnEnderCrystal of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SpawnEnderCrystal00
static int tolua_AllToLua_cWorld_SpawnEnderCrystal00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<double> a_Pos = *((  Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  bool a_ShowBottom = ((bool)  tolua_toboolean(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnEnderCrystal'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->SpawnEnderCrystal(a_Pos,a_ShowBottom);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SpawnEnderCrystal'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DigBlock of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_DigBlock00
static int tolua_AllToLua_cWorld_DigBlock00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"const cEntity",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<int> a_BlockPos = *((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
  const cEntity* a_Digger = ((const cEntity*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DigBlock'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->DigBlock(a_BlockPos,a_Digger);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DigBlock'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DigBlock of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_DigBlock01
static int tolua_AllToLua_cWorld_DigBlock01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"cEntity",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_X = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_Y = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_Z = ((int)  tolua_tonumber(tolua_S,4,0));
  cEntity* a_Digger = ((cEntity*)  tolua_tousertype(tolua_S,5,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DigBlock'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->DigBlock(a_X,a_Y,a_Z,a_Digger);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cWorld_DigBlock00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: DropBlockAsPickups of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_DropBlockAsPickups00
static int tolua_AllToLua_cWorld_DropBlockAsPickups00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"const cEntity",1,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"const cItem",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<int> a_BlockPos = *((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
  const cEntity* a_Digger = ((const cEntity*)  tolua_tousertype(tolua_S,3,nullptr));
  const cItem* a_Tool = ((const cItem*)  tolua_tousertype(tolua_S,4,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DropBlockAsPickups'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->DropBlockAsPickups(a_BlockPos,a_Digger,a_Tool);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DropBlockAsPickups'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: PickupsFromBlock of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_PickupsFromBlock00
static int tolua_AllToLua_cWorld_PickupsFromBlock00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,3,"const cEntity",1,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"const cItem",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<int> a_BlockPos = *((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
  const cEntity* a_Digger = ((const cEntity*)  tolua_tousertype(tolua_S,3,nullptr));
  const cItem* a_Tool = ((const cItem*)  tolua_tousertype(tolua_S,4,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'PickupsFromBlock'", nullptr);
#endif
  {
   cItems tolua_ret = (cItems)  self->PickupsFromBlock(a_BlockPos,a_Digger,a_Tool);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cItems)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cItems");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cItems));
     tolua_pushusertype(tolua_S,tolua_obj,"cItems");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'PickupsFromBlock'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendBlockTo of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SendBlockTo00
static int tolua_AllToLua_cWorld_SendBlockTo00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"const cPlayer",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_X = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_Y = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_Z = ((int)  tolua_tonumber(tolua_S,4,0));
  const cPlayer* a_Player = ((const cPlayer*)  tolua_tousertype(tolua_S,5,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendBlockTo'", nullptr);
#endif
  {
   self->SendBlockTo(a_X,a_Y,a_Z,*a_Player);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendBlockTo'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSpawn of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetSpawn00
static int tolua_AllToLua_cWorld_SetSpawn00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_X = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_Y = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_Z = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSpawn'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->SetSpawn(a_X,a_Y,a_Z);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetSpawn'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSpawnX of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetSpawnX00
static int tolua_AllToLua_cWorld_GetSpawnX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSpawnX'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetSpawnX();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSpawnX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSpawnY of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetSpawnY00
static int tolua_AllToLua_cWorld_GetSpawnY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSpawnY'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetSpawnY();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSpawnY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSpawnZ of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetSpawnZ00
static int tolua_AllToLua_cWorld_GetSpawnZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSpawnZ'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetSpawnZ();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSpawnZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: WakeUpSimulators of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_WakeUpSimulators00
static int tolua_AllToLua_cWorld_WakeUpSimulators00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<int> a_Block = *((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'WakeUpSimulators'", nullptr);
#endif
  {
   self->WakeUpSimulators(a_Block);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'WakeUpSimulators'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: WakeUpSimulatorsInArea of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_WakeUpSimulatorsInArea00
static int tolua_AllToLua_cWorld_WakeUpSimulatorsInArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cCuboid",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  const cCuboid* a_Area = ((const cCuboid*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'WakeUpSimulatorsInArea'", nullptr);
#endif
  {
   self->WakeUpSimulatorsInArea(*a_Area);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'WakeUpSimulatorsInArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: UseBlockEntity of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_UseBlockEntity00
static int tolua_AllToLua_cWorld_UseBlockEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"cPlayer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  cPlayer* a_Player = ((cPlayer*)  tolua_tousertype(tolua_S,2,nullptr));
  int a_BlockX = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_BlockY = ((int)  tolua_tonumber(tolua_S,4,0));
  int a_BlockZ = ((int)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'UseBlockEntity'", nullptr);
#endif
  {
   self->UseBlockEntity(a_Player,a_BlockX,a_BlockY,a_BlockZ);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'UseBlockEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GrowPlantAt of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GrowPlantAt00
static int tolua_AllToLua_cWorld_GrowPlantAt00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<int> a_BlockPos = *((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
  int a_NumStages = ((int)  tolua_tonumber(tolua_S,3,1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GrowPlantAt'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GrowPlantAt(a_BlockPos,a_NumStages);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GrowPlantAt'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GrowRipePlant of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GrowRipePlant00
static int tolua_AllToLua_cWorld_GrowRipePlant00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<int> a_BlockPos = *((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GrowRipePlant'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->GrowRipePlant(a_BlockPos);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GrowRipePlant'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GrowRipePlant of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GrowRipePlant01
static int tolua_AllToLua_cWorld_GrowRipePlant01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_BlockX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_BlockY = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_BlockZ = ((int)  tolua_tonumber(tolua_S,4,0));
  bool a_IsByBonemeal = ((bool)  tolua_toboolean(tolua_S,5,false));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GrowRipePlant'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->GrowRipePlant(a_BlockX,a_BlockY,a_BlockZ,a_IsByBonemeal);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cWorld_GrowRipePlant00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetBiomeAt of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetBiomeAt00
static int tolua_AllToLua_cWorld_GetBiomeAt00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_BlockX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_BlockZ = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetBiomeAt'", nullptr);
#endif
  {
   EMCSBiome tolua_ret = (EMCSBiome)  self->GetBiomeAt(a_BlockX,a_BlockZ);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetBiomeAt'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_isEMCSBiome (lua_State* L, int lo, int def, tolua_Error* err);
/* method: SetBiomeAt of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetBiomeAt00
static int tolua_AllToLua_cWorld_SetBiomeAt00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isEMCSBiome(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_BlockX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_BlockZ = ((int)  tolua_tonumber(tolua_S,3,0));
  EMCSBiome a_Biome = ((EMCSBiome) (  int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetBiomeAt'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->SetBiomeAt(a_BlockX,a_BlockZ,a_Biome);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetBiomeAt'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_isEMCSBiome (lua_State* L, int lo, int def, tolua_Error* err);
/* method: SetAreaBiome of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetAreaBiome00
static int tolua_AllToLua_cWorld_SetAreaBiome00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isEMCSBiome(tolua_S,6,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_MinX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_MaxX = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_MinZ = ((int)  tolua_tonumber(tolua_S,4,0));
  int a_MaxZ = ((int)  tolua_tonumber(tolua_S,5,0));
  EMCSBiome a_Biome = ((EMCSBiome) (  int)  tolua_tonumber(tolua_S,6,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetAreaBiome'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->SetAreaBiome(a_MinX,a_MaxX,a_MinZ,a_MaxZ,a_Biome);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetAreaBiome'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_isEMCSBiome (lua_State* L, int lo, int def, tolua_Error* err);
/* method: SetAreaBiome of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetAreaBiome01
static int tolua_AllToLua_cWorld_SetAreaBiome01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cCuboid",0,&tolua_err)) ||
     !tolua_isEMCSBiome(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  const cCuboid* a_Area = ((const cCuboid*)  tolua_tousertype(tolua_S,2,nullptr));
  EMCSBiome a_Biome = ((EMCSBiome) (  int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetAreaBiome'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->SetAreaBiome(*a_Area,a_Biome);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cWorld_SetAreaBiome00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetName of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetName00
static int tolua_AllToLua_cWorld_GetName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetName'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetDataPath of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetDataPath00
static int tolua_AllToLua_cWorld_GetDataPath00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetDataPath'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetDataPath();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetDataPath'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetIniFileName of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetIniFileName00
static int tolua_AllToLua_cWorld_GetIniFileName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetIniFileName'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetIniFileName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetIniFileName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetScoreBoard of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetScoreBoard00
static int tolua_AllToLua_cWorld_GetScoreBoard00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetScoreBoard'", nullptr);
#endif
  {
   cScoreboard& tolua_ret = (cScoreboard&)  self->GetScoreBoard();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"cScoreboard");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetScoreBoard'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMapManager of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetMapManager00
static int tolua_AllToLua_cWorld_GetMapManager00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMapManager'", nullptr);
#endif
  {
   cMapManager& tolua_ret = (cMapManager&)  self->GetMapManager();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"cMapManager");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMapManager'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AreCommandBlocksEnabled of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_AreCommandBlocksEnabled00
static int tolua_AllToLua_cWorld_AreCommandBlocksEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AreCommandBlocksEnabled'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->AreCommandBlocksEnabled();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AreCommandBlocksEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetCommandBlocksEnabled of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetCommandBlocksEnabled00
static int tolua_AllToLua_cWorld_SetCommandBlocksEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_Flag = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetCommandBlocksEnabled'", nullptr);
#endif
  {
   self->SetCommandBlocksEnabled(a_Flag);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetCommandBlocksEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetTNTShrapnelLevel of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetTNTShrapnelLevel00
static int tolua_AllToLua_cWorld_GetTNTShrapnelLevel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetTNTShrapnelLevel'", nullptr);
#endif
  {
   eShrapnelLevel tolua_ret = (eShrapnelLevel)  self->GetTNTShrapnelLevel();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetTNTShrapnelLevel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseShrapnelLevel (lua_State* L, int lo, int def, tolua_Error* err);
/* method: SetTNTShrapnelLevel of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetTNTShrapnelLevel00
static int tolua_AllToLua_cWorld_SetTNTShrapnelLevel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_iseShrapnelLevel(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  eShrapnelLevel a_Flag = ((eShrapnelLevel) (  int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetTNTShrapnelLevel'", nullptr);
#endif
  {
   self->SetTNTShrapnelLevel(a_Flag);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetTNTShrapnelLevel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMaxViewDistance of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetMaxViewDistance00
static int tolua_AllToLua_cWorld_GetMaxViewDistance00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMaxViewDistance'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetMaxViewDistance();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMaxViewDistance'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetMaxViewDistance of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetMaxViewDistance00
static int tolua_AllToLua_cWorld_SetMaxViewDistance00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_MaxViewDistance = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetMaxViewDistance'", nullptr);
#endif
  {
   self->SetMaxViewDistance(a_MaxViewDistance);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetMaxViewDistance'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ShouldUseChatPrefixes of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_ShouldUseChatPrefixes00
static int tolua_AllToLua_cWorld_ShouldUseChatPrefixes00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ShouldUseChatPrefixes'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->ShouldUseChatPrefixes();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ShouldUseChatPrefixes'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetShouldUseChatPrefixes of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetShouldUseChatPrefixes00
static int tolua_AllToLua_cWorld_SetShouldUseChatPrefixes00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_Flag = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetShouldUseChatPrefixes'", nullptr);
#endif
  {
   self->SetShouldUseChatPrefixes(a_Flag);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetShouldUseChatPrefixes'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ShouldBroadcastDeathMessages of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_ShouldBroadcastDeathMessages00
static int tolua_AllToLua_cWorld_ShouldBroadcastDeathMessages00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ShouldBroadcastDeathMessages'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->ShouldBroadcastDeathMessages();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ShouldBroadcastDeathMessages'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ShouldBroadcastAchievementMessages of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_ShouldBroadcastAchievementMessages00
static int tolua_AllToLua_cWorld_ShouldBroadcastAchievementMessages00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ShouldBroadcastAchievementMessages'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->ShouldBroadcastAchievementMessages();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ShouldBroadcastAchievementMessages'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetLinkedNetherWorldName of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetLinkedNetherWorldName00
static int tolua_AllToLua_cWorld_GetLinkedNetherWorldName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetLinkedNetherWorldName'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetLinkedNetherWorldName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetLinkedNetherWorldName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetLinkedNetherWorldName of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetLinkedNetherWorldName00
static int tolua_AllToLua_cWorld_SetLinkedNetherWorldName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Name = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetLinkedNetherWorldName'", nullptr);
#endif
  {
   self->SetLinkedNetherWorldName(a_Name);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetLinkedNetherWorldName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetLinkedEndWorldName of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetLinkedEndWorldName00
static int tolua_AllToLua_cWorld_GetLinkedEndWorldName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetLinkedEndWorldName'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetLinkedEndWorldName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetLinkedEndWorldName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetLinkedEndWorldName of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetLinkedEndWorldName00
static int tolua_AllToLua_cWorld_SetLinkedEndWorldName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Name = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetLinkedEndWorldName'", nullptr);
#endif
  {
   self->SetLinkedEndWorldName(a_Name);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetLinkedEndWorldName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetLinkedOverworldName of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetLinkedOverworldName00
static int tolua_AllToLua_cWorld_GetLinkedOverworldName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetLinkedOverworldName'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetLinkedOverworldName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetLinkedOverworldName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetLinkedOverworldName of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetLinkedOverworldName00
static int tolua_AllToLua_cWorld_SetLinkedOverworldName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Name = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetLinkedOverworldName'", nullptr);
#endif
  {
   self->SetLinkedOverworldName(a_Name);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetLinkedOverworldName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMinNetherPortalWidth of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetMinNetherPortalWidth00
static int tolua_AllToLua_cWorld_GetMinNetherPortalWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMinNetherPortalWidth'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetMinNetherPortalWidth();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMinNetherPortalWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMaxNetherPortalWidth of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetMaxNetherPortalWidth00
static int tolua_AllToLua_cWorld_GetMaxNetherPortalWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMaxNetherPortalWidth'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetMaxNetherPortalWidth();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMaxNetherPortalWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetMinNetherPortalWidth of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetMinNetherPortalWidth00
static int tolua_AllToLua_cWorld_SetMinNetherPortalWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_NewMinWidth = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetMinNetherPortalWidth'", nullptr);
#endif
  {
   self->SetMinNetherPortalWidth(a_NewMinWidth);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetMinNetherPortalWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetMaxNetherPortalWidth of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetMaxNetherPortalWidth00
static int tolua_AllToLua_cWorld_SetMaxNetherPortalWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_NewMaxWidth = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetMaxNetherPortalWidth'", nullptr);
#endif
  {
   self->SetMaxNetherPortalWidth(a_NewMaxWidth);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetMaxNetherPortalWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMinNetherPortalHeight of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetMinNetherPortalHeight00
static int tolua_AllToLua_cWorld_GetMinNetherPortalHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMinNetherPortalHeight'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetMinNetherPortalHeight();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMinNetherPortalHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMaxNetherPortalHeight of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetMaxNetherPortalHeight00
static int tolua_AllToLua_cWorld_GetMaxNetherPortalHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMaxNetherPortalHeight'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetMaxNetherPortalHeight();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMaxNetherPortalHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetMinNetherPortalHeight of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetMinNetherPortalHeight00
static int tolua_AllToLua_cWorld_SetMinNetherPortalHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_NewMinHeight = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetMinNetherPortalHeight'", nullptr);
#endif
  {
   self->SetMinNetherPortalHeight(a_NewMinHeight);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetMinNetherPortalHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetMaxNetherPortalHeight of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetMaxNetherPortalHeight00
static int tolua_AllToLua_cWorld_SetMaxNetherPortalHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_NewMaxHeight = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetMaxNetherPortalHeight'", nullptr);
#endif
  {
   self->SetMaxNetherPortalHeight(a_NewMaxHeight);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetMaxNetherPortalHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: QueueSaveAllChunks of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_QueueSaveAllChunks00
static int tolua_AllToLua_cWorld_QueueSaveAllChunks00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'QueueSaveAllChunks'", nullptr);
#endif
  {
   self->QueueSaveAllChunks();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'QueueSaveAllChunks'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNumChunks of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetNumChunks00
static int tolua_AllToLua_cWorld_GetNumChunks00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumChunks'", nullptr);
#endif
  {
   size_t tolua_ret = (size_t)  self->GetNumChunks();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetNumChunks'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNumUnusedDirtyChunks of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetNumUnusedDirtyChunks00
static int tolua_AllToLua_cWorld_GetNumUnusedDirtyChunks00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumUnusedDirtyChunks'", nullptr);
#endif
  {
   size_t tolua_ret = (size_t)  self->GetNumUnusedDirtyChunks();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetNumUnusedDirtyChunks'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetGeneratorQueueLength of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetGeneratorQueueLength00
static int tolua_AllToLua_cWorld_GetGeneratorQueueLength00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetGeneratorQueueLength'", nullptr);
#endif
  {
   size_t tolua_ret = (size_t)  self->GetGeneratorQueueLength();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetGeneratorQueueLength'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetLightingQueueLength of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetLightingQueueLength00
static int tolua_AllToLua_cWorld_GetLightingQueueLength00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetLightingQueueLength'", nullptr);
#endif
  {
   size_t tolua_ret = (size_t)  self->GetLightingQueueLength();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetLightingQueueLength'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetStorageLoadQueueLength of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetStorageLoadQueueLength00
static int tolua_AllToLua_cWorld_GetStorageLoadQueueLength00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetStorageLoadQueueLength'", nullptr);
#endif
  {
   size_t tolua_ret = (size_t)  self->GetStorageLoadQueueLength();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetStorageLoadQueueLength'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetStorageSaveQueueLength of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetStorageSaveQueueLength00
static int tolua_AllToLua_cWorld_GetStorageSaveQueueLength00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetStorageSaveQueueLength'", nullptr);
#endif
  {
   size_t tolua_ret = (size_t)  self->GetStorageSaveQueueLength();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetStorageSaveQueueLength'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: QueueBlockForTick of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_QueueBlockForTick00
static int tolua_AllToLua_cWorld_QueueBlockForTick00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_BlockX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_BlockY = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_BlockZ = ((int)  tolua_tonumber(tolua_S,4,0));
  int a_TicksToWait = ((int)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'QueueBlockForTick'", nullptr);
#endif
  {
   self->QueueBlockForTick(a_BlockX,a_BlockY,a_BlockZ,a_TicksToWait);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'QueueBlockForTick'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CastThunderbolt of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_CastThunderbolt00
static int tolua_AllToLua_cWorld_CastThunderbolt00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<int> a_Block = *((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CastThunderbolt'", nullptr);
#endif
  {
   self->CastThunderbolt(a_Block);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CastThunderbolt'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CastThunderbolt of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_CastThunderbolt01
static int tolua_AllToLua_cWorld_CastThunderbolt01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_BlockX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_BlockY = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_BlockZ = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CastThunderbolt'", nullptr);
#endif
  {
   self->CastThunderbolt(a_BlockX,a_BlockY,a_BlockZ);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cWorld_CastThunderbolt00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseWeather (lua_State* L, int lo, int def, tolua_Error* err);
/* method: SetWeather of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetWeather00
static int tolua_AllToLua_cWorld_SetWeather00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_iseWeather(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  eWeather a_NewWeather = ((eWeather) (  int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetWeather'", nullptr);
#endif
  {
   self->SetWeather(a_NewWeather);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetWeather'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ChangeWeather of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_ChangeWeather00
static int tolua_AllToLua_cWorld_ChangeWeather00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ChangeWeather'", nullptr);
#endif
  {
   self->ChangeWeather();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ChangeWeather'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetWeather of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetWeather00
static int tolua_AllToLua_cWorld_GetWeather00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetWeather'", nullptr);
#endif
  {
   eWeather tolua_ret = (eWeather)  self->GetWeather();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetWeather'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsWeatherSunny of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_IsWeatherSunny00
static int tolua_AllToLua_cWorld_IsWeatherSunny00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsWeatherSunny'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsWeatherSunny();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsWeatherSunny'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsWeatherSunnyAt of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_IsWeatherSunnyAt00
static int tolua_AllToLua_cWorld_IsWeatherSunnyAt00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_BlockX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_BlockZ = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsWeatherSunnyAt'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsWeatherSunnyAt(a_BlockX,a_BlockZ);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsWeatherSunnyAt'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsWeatherRain of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_IsWeatherRain00
static int tolua_AllToLua_cWorld_IsWeatherRain00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsWeatherRain'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsWeatherRain();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsWeatherRain'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsWeatherRainAt of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_IsWeatherRainAt00
static int tolua_AllToLua_cWorld_IsWeatherRainAt00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_BlockX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_BlockZ = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsWeatherRainAt'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsWeatherRainAt(a_BlockX,a_BlockZ);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsWeatherRainAt'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsWeatherStorm of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_IsWeatherStorm00
static int tolua_AllToLua_cWorld_IsWeatherStorm00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsWeatherStorm'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsWeatherStorm();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsWeatherStorm'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsWeatherStormAt of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_IsWeatherStormAt00
static int tolua_AllToLua_cWorld_IsWeatherStormAt00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_BlockX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_BlockZ = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsWeatherStormAt'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsWeatherStormAt(a_BlockX,a_BlockZ);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsWeatherStormAt'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsWeatherWet of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_IsWeatherWet00
static int tolua_AllToLua_cWorld_IsWeatherWet00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsWeatherWet'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsWeatherWet();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsWeatherWet'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsWeatherWetAt of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_IsWeatherWetAt00
static int tolua_AllToLua_cWorld_IsWeatherWetAt00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_BlockX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_BlockZ = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsWeatherWetAt'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsWeatherWetAt(a_BlockX,a_BlockZ);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsWeatherWetAt'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsWeatherWetAtXYZ of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_IsWeatherWetAtXYZ00
static int tolua_AllToLua_cWorld_IsWeatherWetAtXYZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<int> a_Position = *((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsWeatherWetAtXYZ'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsWeatherWetAtXYZ(a_Position);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsWeatherWetAtXYZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSeed of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetSeed00
static int tolua_AllToLua_cWorld_GetSeed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSeed'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetSeed();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSeed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetNextBlockToTick of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetNextBlockToTick00
static int tolua_AllToLua_cWorld_SetNextBlockToTick00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<int> a_BlockPos = *((const Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetNextBlockToTick'", nullptr);
#endif
  {
   self->SetNextBlockToTick(a_BlockPos);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetNextBlockToTick'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMaxSugarcaneHeight of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetMaxSugarcaneHeight00
static int tolua_AllToLua_cWorld_GetMaxSugarcaneHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMaxSugarcaneHeight'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetMaxSugarcaneHeight();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMaxSugarcaneHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMaxCactusHeight of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetMaxCactusHeight00
static int tolua_AllToLua_cWorld_GetMaxCactusHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMaxCactusHeight'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetMaxCactusHeight();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMaxCactusHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsBlockDirectlyWatered of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_IsBlockDirectlyWatered00
static int tolua_AllToLua_cWorld_IsBlockDirectlyWatered00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_BlockX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_BlockY = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_BlockZ = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsBlockDirectlyWatered'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsBlockDirectlyWatered(a_BlockX,a_BlockY,a_BlockZ);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsBlockDirectlyWatered'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseMonsterType (lua_State* L, int lo, int def, tolua_Error* err);
/* method: SpawnMob of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SpawnMob00
static int tolua_AllToLua_cWorld_SpawnMob00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_iseMonsterType(tolua_S,5,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,6,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_PosX = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_PosY = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_PosZ = ((double)  tolua_tonumber(tolua_S,4,0));
  eMonsterType a_MonsterType = ((eMonsterType) (  int)  tolua_tonumber(tolua_S,5,0));
  bool a_Baby = ((bool)  tolua_toboolean(tolua_S,6,false));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnMob'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->SpawnMob(a_PosX,a_PosY,a_PosZ,a_MonsterType,a_Baby);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SpawnMob'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CreateProjectile of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_CreateProjectile00
static int tolua_AllToLua_cWorld_CreateProjectile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"cEntity",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"const cItem",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,6,"const Vector3<double>",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<double> a_Pos = *((  Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  cProjectileEntity::eKind a_Kind = ((cProjectileEntity::eKind) (  int)  tolua_tonumber(tolua_S,3,0));
  cEntity* a_Creator = ((cEntity*)  tolua_tousertype(tolua_S,4,nullptr));
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,5,nullptr));
  const Vector3<double>* a_Speed = ((const Vector3<double>*)  tolua_tousertype(tolua_S,6,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CreateProjectile'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->CreateProjectile(a_Pos,a_Kind,a_Creator,a_Item,a_Speed);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CreateProjectile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CreateProjectile of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_CreateProjectile01
static int tolua_AllToLua_cWorld_CreateProjectile01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,6,"cEntity",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,7,"const cItem",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,8,"const Vector3<double>",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,9,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_PosX = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_PosY = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_PosZ = ((double)  tolua_tonumber(tolua_S,4,0));
  cProjectileEntity::eKind a_Kind = ((cProjectileEntity::eKind) (  int)  tolua_tonumber(tolua_S,5,0));
  cEntity* a_Creator = ((cEntity*)  tolua_tousertype(tolua_S,6,nullptr));
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,7,nullptr));
  const Vector3<double>* a_Speed = ((const Vector3<double>*)  tolua_tousertype(tolua_S,8,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CreateProjectile'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->CreateProjectile(a_PosX,a_PosY,a_PosZ,a_Kind,a_Creator,a_Item,a_Speed);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cWorld_CreateProjectile00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetChunkAlwaysTicked of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetChunkAlwaysTicked00
static int tolua_AllToLua_cWorld_SetChunkAlwaysTicked00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* self = (cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_ChunkX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_ChunkZ = ((int)  tolua_tonumber(tolua_S,3,0));
  bool a_AlwaysTicked = ((bool)  tolua_toboolean(tolua_S,4,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetChunkAlwaysTicked'", nullptr);
#endif
  {
   self->SetChunkAlwaysTicked(a_ChunkX,a_ChunkZ,a_AlwaysTicked);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetChunkAlwaysTicked'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsSlimeChunk of class  cWorld */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_IsSlimeChunk00
static int tolua_AllToLua_cWorld_IsSlimeChunk00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWorld",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWorld* self = (const cWorld*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_ChunkX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_ChunkZ = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsSlimeChunk'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsSlimeChunk(a_ChunkX,a_ChunkZ);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsSlimeChunk'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Clear of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_Clear00
static int tolua_AllToLua_cInventory_Clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Clear'", nullptr);
#endif
  {
   self->Clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: HowManyCanFit of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_HowManyCanFit00
static int tolua_AllToLua_cInventory_HowManyCanFit00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isboolean(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_ItemStack = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
  bool a_ConsiderEmptySlots = ((bool)  tolua_toboolean(tolua_S,3,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HowManyCanFit'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->HowManyCanFit(*a_ItemStack,a_ConsiderEmptySlots);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'HowManyCanFit'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: HowManyCanFit of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_HowManyCanFit01
static int tolua_AllToLua_cInventory_HowManyCanFit01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_ItemStack = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
  int a_BeginSlotNum = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_EndSlotNum = ((int)  tolua_tonumber(tolua_S,4,0));
  bool a_ConsiderEmptySlots = ((bool)  tolua_toboolean(tolua_S,5,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HowManyCanFit'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->HowManyCanFit(*a_ItemStack,a_BeginSlotNum,a_EndSlotNum,a_ConsiderEmptySlots);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cInventory_HowManyCanFit00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddItem of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_AddItem00
static int tolua_AllToLua_cInventory_AddItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isboolean(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_ItemStack = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
  bool a_AllowNewStacks = ((bool)  tolua_toboolean(tolua_S,3,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddItem'", nullptr);
#endif
  {
   char tolua_ret = (char)  self->AddItem(*a_ItemStack,a_AllowNewStacks);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddItems of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_AddItems00
static int tolua_AllToLua_cInventory_AddItems00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cItems",0,&tolua_err)) ||
     !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
  cItems* a_ItemStackList = ((cItems*)  tolua_tousertype(tolua_S,2,nullptr));
  bool a_AllowNewStacks = ((bool)  tolua_toboolean(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddItems'", nullptr);
#endif
  {
   char tolua_ret = (char)  self->AddItems(*a_ItemStackList,a_AllowNewStacks);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddItems'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: RemoveItem of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_RemoveItem00
static int tolua_AllToLua_cInventory_RemoveItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_ItemStack = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'RemoveItem'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->RemoveItem(*a_ItemStack);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'RemoveItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: FindItem of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_FindItem00
static int tolua_AllToLua_cInventory_FindItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_RecipeItem = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'FindItem'", nullptr);
#endif
  {
   cItem* tolua_ret = (cItem*)  self->FindItem(*a_RecipeItem);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'FindItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: RemoveOneEquippedItem of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_RemoveOneEquippedItem00
static int tolua_AllToLua_cInventory_RemoveOneEquippedItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'RemoveOneEquippedItem'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->RemoveOneEquippedItem();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'RemoveOneEquippedItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ReplaceOneEquippedItem of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_ReplaceOneEquippedItem00
static int tolua_AllToLua_cInventory_ReplaceOneEquippedItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isboolean(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
  bool a_TryOtherSlots = ((bool)  tolua_toboolean(tolua_S,3,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ReplaceOneEquippedItem'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->ReplaceOneEquippedItem(*a_Item,a_TryOtherSlots);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ReplaceOneEquippedItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: HowManyItems of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_HowManyItems00
static int tolua_AllToLua_cInventory_HowManyItems00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HowManyItems'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->HowManyItems(*a_Item);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'HowManyItems'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: HasItems of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_HasItems00
static int tolua_AllToLua_cInventory_HasItems00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_ItemStack = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HasItems'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->HasItems(*a_ItemStack);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'HasItems'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendEquippedSlot of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_SendEquippedSlot00
static int tolua_AllToLua_cInventory_SendEquippedSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendEquippedSlot'", nullptr);
#endif
  {
   self->SendEquippedSlot();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendEquippedSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetArmorGrid of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_GetArmorGrid00
static int tolua_AllToLua_cInventory_GetArmorGrid00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetArmorGrid'", nullptr);
#endif
  {
   cItemGrid& tolua_ret = (cItemGrid&)  self->GetArmorGrid();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"cItemGrid");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetArmorGrid'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetInventoryGrid of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_GetInventoryGrid00
static int tolua_AllToLua_cInventory_GetInventoryGrid00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetInventoryGrid'", nullptr);
#endif
  {
   cItemGrid& tolua_ret = (cItemGrid&)  self->GetInventoryGrid();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"cItemGrid");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetInventoryGrid'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetHotbarGrid of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_GetHotbarGrid00
static int tolua_AllToLua_cInventory_GetHotbarGrid00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetHotbarGrid'", nullptr);
#endif
  {
   cItemGrid& tolua_ret = (cItemGrid&)  self->GetHotbarGrid();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"cItemGrid");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetHotbarGrid'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetOwner of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_GetOwner00
static int tolua_AllToLua_cInventory_GetOwner00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetOwner'", nullptr);
#endif
  {
   cPlayer& tolua_ret = (cPlayer&)  self->GetOwner();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"cPlayer");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetOwner'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CopyToItems of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_CopyToItems00
static int tolua_AllToLua_cInventory_CopyToItems00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cItems",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
  cItems* a_Items = ((cItems*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CopyToItems'", nullptr);
#endif
  {
   self->CopyToItems(*a_Items);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CopyToItems'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSlot of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_GetSlot00
static int tolua_AllToLua_cInventory_GetSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cInventory",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cInventory* self = (const cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_SlotNum = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSlot'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetSlot(a_SlotNum);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetArmorSlot of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_GetArmorSlot00
static int tolua_AllToLua_cInventory_GetArmorSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cInventory",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cInventory* self = (const cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_ArmorSlotNum = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetArmorSlot'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetArmorSlot(a_ArmorSlotNum);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetArmorSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetInventorySlot of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_GetInventorySlot00
static int tolua_AllToLua_cInventory_GetInventorySlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cInventory",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cInventory* self = (const cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_InventorySlotNum = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetInventorySlot'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetInventorySlot(a_InventorySlotNum);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetInventorySlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetHotbarSlot of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_GetHotbarSlot00
static int tolua_AllToLua_cInventory_GetHotbarSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cInventory",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cInventory* self = (const cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_HotBarSlotNum = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetHotbarSlot'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetHotbarSlot(a_HotBarSlotNum);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetHotbarSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetShieldSlot of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_GetShieldSlot00
static int tolua_AllToLua_cInventory_GetShieldSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cInventory",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cInventory* self = (const cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetShieldSlot'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetShieldSlot();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetShieldSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetEquippedItem of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_GetEquippedItem00
static int tolua_AllToLua_cInventory_GetEquippedItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cInventory",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cInventory* self = (const cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEquippedItem'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetEquippedItem();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetEquippedItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSlot of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_SetSlot00
static int tolua_AllToLua_cInventory_SetSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_SlotNum = ((int)  tolua_tonumber(tolua_S,2,0));
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSlot'", nullptr);
#endif
  {
   self->SetSlot(a_SlotNum,*a_Item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetArmorSlot of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_SetArmorSlot00
static int tolua_AllToLua_cInventory_SetArmorSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_ArmorSlotNum = ((int)  tolua_tonumber(tolua_S,2,0));
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetArmorSlot'", nullptr);
#endif
  {
   self->SetArmorSlot(a_ArmorSlotNum,*a_Item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetArmorSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetInventorySlot of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_SetInventorySlot00
static int tolua_AllToLua_cInventory_SetInventorySlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_InventorySlotNum = ((int)  tolua_tonumber(tolua_S,2,0));
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetInventorySlot'", nullptr);
#endif
  {
   self->SetInventorySlot(a_InventorySlotNum,*a_Item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetInventorySlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetHotbarSlot of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_SetHotbarSlot00
static int tolua_AllToLua_cInventory_SetHotbarSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_HotBarSlotNum = ((int)  tolua_tonumber(tolua_S,2,0));
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetHotbarSlot'", nullptr);
#endif
  {
   self->SetHotbarSlot(a_HotBarSlotNum,*a_Item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetHotbarSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetShieldSlot of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_SetShieldSlot00
static int tolua_AllToLua_cInventory_SetShieldSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetShieldSlot'", nullptr);
#endif
  {
   self->SetShieldSlot(*a_Item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetShieldSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetEquippedItem of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_SetEquippedItem00
static int tolua_AllToLua_cInventory_SetEquippedItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetEquippedItem'", nullptr);
#endif
  {
   self->SetEquippedItem(*a_Item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetEquippedItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetEquippedSlotNum of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_SetEquippedSlotNum00
static int tolua_AllToLua_cInventory_SetEquippedSlotNum00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_SlotNum = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetEquippedSlotNum'", nullptr);
#endif
  {
   self->SetEquippedSlotNum(a_SlotNum);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetEquippedSlotNum'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetEquippedSlotNum of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_GetEquippedSlotNum00
static int tolua_AllToLua_cInventory_GetEquippedSlotNum00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEquippedSlotNum'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetEquippedSlotNum();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetEquippedSlotNum'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ChangeSlotCount of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_ChangeSlotCount00
static int tolua_AllToLua_cInventory_ChangeSlotCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_SlotNum = ((int)  tolua_tonumber(tolua_S,2,0));
  char a_AddToCount = ((char)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ChangeSlotCount'", nullptr);
#endif
  {
   char tolua_ret = (char)  self->ChangeSlotCount(a_SlotNum,a_AddToCount);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ChangeSlotCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DamageItem of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_DamageItem00
static int tolua_AllToLua_cInventory_DamageItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_SlotNum = ((int)  tolua_tonumber(tolua_S,2,0));
  short a_Amount = ((short)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DamageItem'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->DamageItem(a_SlotNum,a_Amount);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DamageItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DamageEquippedItem of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_DamageEquippedItem00
static int tolua_AllToLua_cInventory_DamageEquippedItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cInventory* self = (cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
  short a_Amount = ((short)  tolua_tonumber(tolua_S,2,1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DamageEquippedItem'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->DamageEquippedItem(a_Amount);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DamageEquippedItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetEquippedHelmet of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_GetEquippedHelmet00
static int tolua_AllToLua_cInventory_GetEquippedHelmet00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cInventory",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cInventory* self = (const cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEquippedHelmet'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetEquippedHelmet();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetEquippedHelmet'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetEquippedChestplate of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_GetEquippedChestplate00
static int tolua_AllToLua_cInventory_GetEquippedChestplate00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cInventory",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cInventory* self = (const cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEquippedChestplate'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetEquippedChestplate();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetEquippedChestplate'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetEquippedLeggings of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_GetEquippedLeggings00
static int tolua_AllToLua_cInventory_GetEquippedLeggings00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cInventory",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cInventory* self = (const cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEquippedLeggings'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetEquippedLeggings();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetEquippedLeggings'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetEquippedBoots of class  cInventory */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_GetEquippedBoots00
static int tolua_AllToLua_cInventory_GetEquippedBoots00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cInventory",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cInventory* self = (const cInventory*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEquippedBoots'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetEquippedBoots();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetEquippedBoots'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseEnchantment (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 62.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eEnchantment";
	return 0;
}
/* method: new of class  cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments_new00
static int tolua_AllToLua_cEnchantments_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cEnchantments",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   cEnchantments* tolua_ret = (cEnchantments*)  Mtolua_new((cEnchantments)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cEnchantments");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments_new00_local
static int tolua_AllToLua_cEnchantments_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cEnchantments",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   cEnchantments* tolua_ret = (cEnchantments*)  Mtolua_new((cEnchantments)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cEnchantments");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments_new01
static int tolua_AllToLua_cEnchantments_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cEnchantments",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const AString a_StringSpec = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  {
   cEnchantments* tolua_ret = (cEnchantments*)  Mtolua_new((cEnchantments)(a_StringSpec));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cEnchantments");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cEnchantments_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments_new01_local
static int tolua_AllToLua_cEnchantments_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cEnchantments",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const AString a_StringSpec = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  {
   cEnchantments* tolua_ret = (cEnchantments*)  Mtolua_new((cEnchantments)(a_StringSpec));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cEnchantments");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cEnchantments_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: Add of class  cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments_Add00
static int tolua_AllToLua_cEnchantments_Add00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEnchantments",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cEnchantments",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEnchantments* self = (cEnchantments*)  tolua_tousertype(tolua_S,1,nullptr);
  const cEnchantments* a_Other = ((const cEnchantments*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Add'", nullptr);
#endif
  {
   self->Add(*a_Other);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Add'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddFromString of class  cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments_AddFromString00
static int tolua_AllToLua_cEnchantments_AddFromString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEnchantments",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEnchantments* self = (cEnchantments*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_StringSpec = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddFromString'", nullptr);
#endif
  {
   self->AddFromString(a_StringSpec);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddFromString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Count of class  cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments_Count00
static int tolua_AllToLua_cEnchantments_Count00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEnchantments",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEnchantments* self = (const cEnchantments*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Count'", nullptr);
#endif
  {
   size_t tolua_ret = (size_t)  self->Count();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Count'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ToString of class  cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments_ToString00
static int tolua_AllToLua_cEnchantments_ToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEnchantments",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEnchantments* self = (const cEnchantments*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ToString'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->ToString();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetLevel of class  cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments_GetLevel00
static int tolua_AllToLua_cEnchantments_GetLevel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEnchantments",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEnchantments* self = (const cEnchantments*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_EnchantmentID = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetLevel'", nullptr);
#endif
  {
   unsigned int tolua_ret = (unsigned int)  self->GetLevel(a_EnchantmentID);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetLevel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetLevel of class  cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments_SetLevel00
static int tolua_AllToLua_cEnchantments_SetLevel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEnchantments",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEnchantments* self = (cEnchantments*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_EnchantmentID = ((int)  tolua_tonumber(tolua_S,2,0));
  unsigned int a_Level = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetLevel'", nullptr);
#endif
  {
   self->SetLevel(a_EnchantmentID,a_Level);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetLevel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Clear of class  cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments_Clear00
static int tolua_AllToLua_cEnchantments_Clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEnchantments",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEnchantments* self = (cEnchantments*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Clear'", nullptr);
#endif
  {
   self->Clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsEmpty of class  cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments_IsEmpty00
static int tolua_AllToLua_cEnchantments_IsEmpty00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEnchantments",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEnchantments* self = (const cEnchantments*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsEmpty'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsEmpty();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsEmpty'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CanAddEnchantment of class  cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments_CanAddEnchantment00
static int tolua_AllToLua_cEnchantments_CanAddEnchantment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEnchantments",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEnchantments* self = (const cEnchantments*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_EnchantmentID = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CanAddEnchantment'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->CanAddEnchantment(a_EnchantmentID);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CanAddEnchantment'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: StringToEnchantmentID of class  cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments_StringToEnchantmentID00
static int tolua_AllToLua_cEnchantments_StringToEnchantmentID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cEnchantments",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const AString a_EnchantmentName = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  {
   int tolua_ret = (int)  cEnchantments::StringToEnchantmentID(a_EnchantmentName);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'StringToEnchantmentID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator== of class  cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments__eq00
static int tolua_AllToLua_cEnchantments__eq00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEnchantments",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cEnchantments",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEnchantments* self = (const cEnchantments*)  tolua_tousertype(tolua_S,1,nullptr);
  const cEnchantments* a_Other = ((const cEnchantments*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator=='", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->operator==(*a_Other);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.eq'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_new00
static int tolua_AllToLua_cItem_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cItem",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   cItem* tolua_ret = (cItem*)  Mtolua_new((cItem)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_new00_local
static int tolua_AllToLua_cItem_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cItem",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   cItem* tolua_ret = (cItem*)  Mtolua_new((cItem)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_new01
static int tolua_AllToLua_cItem_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cItem",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,2,0));
  char a_ItemCount = ((char)  tolua_tonumber(tolua_S,3,1));
  short a_ItemDamage = ((short)  tolua_tonumber(tolua_S,4,0));
  {
   cItem* tolua_ret = (cItem*)  Mtolua_new((cItem)(a_ItemType,a_ItemCount,a_ItemDamage));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cItem");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cItem_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_new01_local
static int tolua_AllToLua_cItem_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cItem",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,2,0));
  char a_ItemCount = ((char)  tolua_tonumber(tolua_S,3,1));
  short a_ItemDamage = ((short)  tolua_tonumber(tolua_S,4,0));
  {
   cItem* tolua_ret = (cItem*)  Mtolua_new((cItem)(a_ItemType,a_ItemCount,a_ItemDamage));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cItem_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_new02
static int tolua_AllToLua_cItem_new02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cItem",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,2,0));
  char a_ItemCount = ((char)  tolua_tonumber(tolua_S,3,0));
  short a_ItemDamage = ((short)  tolua_tonumber(tolua_S,4,0));
  const AString a_Enchantments = ((const AString)  tolua_tocppstring(tolua_S,5,nullptr));
  {
   cItem* tolua_ret = (cItem*)  Mtolua_new((cItem)(a_ItemType,a_ItemCount,a_ItemDamage,a_Enchantments));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cItem");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cItem_new01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_new02_local
static int tolua_AllToLua_cItem_new02_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cItem",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,2,0));
  char a_ItemCount = ((char)  tolua_tonumber(tolua_S,3,0));
  short a_ItemDamage = ((short)  tolua_tonumber(tolua_S,4,0));
  const AString a_Enchantments = ((const AString)  tolua_tocppstring(tolua_S,5,nullptr));
  {
   cItem* tolua_ret = (cItem*)  Mtolua_new((cItem)(a_ItemType,a_ItemCount,a_ItemDamage,a_Enchantments));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cItem_new01_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_new03
static int tolua_AllToLua_cItem_new03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cItem",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,6,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,2,0));
  char a_ItemCount = ((char)  tolua_tonumber(tolua_S,3,0));
  short a_ItemDamage = ((short)  tolua_tonumber(tolua_S,4,0));
  const AString a_Enchantments = ((const AString)  tolua_tocppstring(tolua_S,5,nullptr));
  const AString a_CustomName = ((const AString)  tolua_tocppstring(tolua_S,6,nullptr));
  {
   cItem* tolua_ret = (cItem*)  Mtolua_new((cItem)(a_ItemType,a_ItemCount,a_ItemDamage,a_Enchantments,a_CustomName));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cItem");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cItem_new02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_new03_local
static int tolua_AllToLua_cItem_new03_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cItem",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,6,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,2,0));
  char a_ItemCount = ((char)  tolua_tonumber(tolua_S,3,0));
  short a_ItemDamage = ((short)  tolua_tonumber(tolua_S,4,0));
  const AString a_Enchantments = ((const AString)  tolua_tocppstring(tolua_S,5,nullptr));
  const AString a_CustomName = ((const AString)  tolua_tocppstring(tolua_S,6,nullptr));
  {
   cItem* tolua_ret = (cItem*)  Mtolua_new((cItem)(a_ItemType,a_ItemCount,a_ItemDamage,a_Enchantments,a_CustomName));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cItem_new02_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_new04
static int tolua_AllToLua_cItem_new04(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cItem",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,6,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,7,&tolua_err) || !tolua_isusertype(tolua_S,7,"const AStringVector",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,2,0));
  char a_ItemCount = ((char)  tolua_tonumber(tolua_S,3,0));
  short a_ItemDamage = ((short)  tolua_tonumber(tolua_S,4,0));
  const AString a_Enchantments = ((const AString)  tolua_tocppstring(tolua_S,5,nullptr));
  const AString a_CustomName = ((const AString)  tolua_tocppstring(tolua_S,6,nullptr));
  const AStringVector* a_LoreTable = ((const AStringVector*)  tolua_tousertype(tolua_S,7,nullptr));
  {
   cItem* tolua_ret = (cItem*)  Mtolua_new((cItem)(a_ItemType,a_ItemCount,a_ItemDamage,a_Enchantments,a_CustomName,*a_LoreTable));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cItem");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cItem_new03(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_new04_local
static int tolua_AllToLua_cItem_new04_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cItem",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,6,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,7,&tolua_err) || !tolua_isusertype(tolua_S,7,"const AStringVector",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,2,0));
  char a_ItemCount = ((char)  tolua_tonumber(tolua_S,3,0));
  short a_ItemDamage = ((short)  tolua_tonumber(tolua_S,4,0));
  const AString a_Enchantments = ((const AString)  tolua_tocppstring(tolua_S,5,nullptr));
  const AString a_CustomName = ((const AString)  tolua_tocppstring(tolua_S,6,nullptr));
  const AStringVector* a_LoreTable = ((const AStringVector*)  tolua_tousertype(tolua_S,7,nullptr));
  {
   cItem* tolua_ret = (cItem*)  Mtolua_new((cItem)(a_ItemType,a_ItemCount,a_ItemDamage,a_Enchantments,a_CustomName,*a_LoreTable));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cItem_new03_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_new05
static int tolua_AllToLua_cItem_new05(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cItem",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const cItem* a_CopyFrom = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   cItem* tolua_ret = (cItem*)  Mtolua_new((cItem)(*a_CopyFrom));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cItem");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cItem_new04(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_new05_local
static int tolua_AllToLua_cItem_new05_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cItem",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const cItem* a_CopyFrom = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   cItem* tolua_ret = (cItem*)  Mtolua_new((cItem)(*a_CopyFrom));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cItem_new04_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: Empty of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_Empty00
static int tolua_AllToLua_cItem_Empty00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItem",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItem* self = (cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Empty'", nullptr);
#endif
  {
   self->Empty();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Empty'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Clear of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_Clear00
static int tolua_AllToLua_cItem_Clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItem",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItem* self = (cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Clear'", nullptr);
#endif
  {
   self->Clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsEmpty of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_IsEmpty00
static int tolua_AllToLua_cItem_IsEmpty00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItem",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItem* self = (const cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsEmpty'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsEmpty();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsEmpty'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsEqual of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_IsEqual00
static int tolua_AllToLua_cItem_IsEqual00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItem",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItem* self = (const cItem*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsEqual'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsEqual(*a_Item);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsEqual'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsSameType of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_IsSameType00
static int tolua_AllToLua_cItem_IsSameType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItem",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItem* self = (const cItem*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsSameType'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsSameType(*a_Item);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsSameType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsBothNameAndLoreEmpty of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_IsBothNameAndLoreEmpty00
static int tolua_AllToLua_cItem_IsBothNameAndLoreEmpty00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItem",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItem* self = (const cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsBothNameAndLoreEmpty'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsBothNameAndLoreEmpty();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsBothNameAndLoreEmpty'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsCustomNameEmpty of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_IsCustomNameEmpty00
static int tolua_AllToLua_cItem_IsCustomNameEmpty00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItem",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItem* self = (const cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsCustomNameEmpty'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsCustomNameEmpty();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsCustomNameEmpty'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsLoreEmpty of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_IsLoreEmpty00
static int tolua_AllToLua_cItem_IsLoreEmpty00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItem",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItem* self = (const cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsLoreEmpty'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsLoreEmpty();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsLoreEmpty'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CopyOne of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_CopyOne00
static int tolua_AllToLua_cItem_CopyOne00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItem",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItem* self = (const cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CopyOne'", nullptr);
#endif
  {
   cItem tolua_ret = (cItem)  self->CopyOne();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cItem)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cItem));
     tolua_pushusertype(tolua_S,tolua_obj,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CopyOne'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddCount of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_AddCount00
static int tolua_AllToLua_cItem_AddCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItem",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItem* self = (cItem*)  tolua_tousertype(tolua_S,1,nullptr);
  char a_AmountToAdd = ((char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddCount'", nullptr);
#endif
  {
   cItem& tolua_ret = (cItem&)  self->AddCount(a_AmountToAdd);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMaxDamage of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_GetMaxDamage00
static int tolua_AllToLua_cItem_GetMaxDamage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItem",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItem* self = (const cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMaxDamage'", nullptr);
#endif
  {
   short tolua_ret = (short)  self->GetMaxDamage();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMaxDamage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DamageItem of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_DamageItem00
static int tolua_AllToLua_cItem_DamageItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItem",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItem* self = (cItem*)  tolua_tousertype(tolua_S,1,nullptr);
  short a_Amount = ((short)  tolua_tonumber(tolua_S,2,1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DamageItem'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->DamageItem(a_Amount);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DamageItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsDamageable of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_IsDamageable00
static int tolua_AllToLua_cItem_IsDamageable00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItem",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItem* self = (const cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsDamageable'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsDamageable();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsDamageable'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsFullStack of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_IsFullStack00
static int tolua_AllToLua_cItem_IsFullStack00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItem",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItem* self = (const cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsFullStack'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsFullStack();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsFullStack'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMaxStackSize of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_GetMaxStackSize00
static int tolua_AllToLua_cItem_GetMaxStackSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItem",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItem* self = (const cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMaxStackSize'", nullptr);
#endif
  {
   char tolua_ret = (char)  self->GetMaxStackSize();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMaxStackSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsEnchantable of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_IsEnchantable00
static int tolua_AllToLua_cItem_IsEnchantable00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cItem",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,2,0));
  bool a_FromBook = ((bool)  tolua_toboolean(tolua_S,3,false));
  {
   bool tolua_ret = (bool)  cItem::IsEnchantable(a_ItemType,a_FromBook);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsEnchantable'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetEnchantability of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_GetEnchantability00
static int tolua_AllToLua_cItem_GetEnchantability00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItem",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItem* self = (cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEnchantability'", nullptr);
#endif
  {
   unsigned tolua_ret = (unsigned)  self->GetEnchantability();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetEnchantability'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddEnchantment of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_AddEnchantment00
static int tolua_AllToLua_cItem_AddEnchantment00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItem",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItem* self = (cItem*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_EnchantmentID = ((int)  tolua_tonumber(tolua_S,2,0));
  unsigned int a_Level = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
  bool a_FromBook = ((bool)  tolua_toboolean(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddEnchantment'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->AddEnchantment(a_EnchantmentID,a_Level,a_FromBook);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddEnchantment'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddEnchantmentsFromItem of class  cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_AddEnchantmentsFromItem00
static int tolua_AllToLua_cItem_AddEnchantmentsFromItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItem",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItem* self = (cItem*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_Other = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddEnchantmentsFromItem'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->AddEnchantmentsFromItem(*a_Other);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddEnchantmentsFromItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: m_ItemType of class  cItem */
#ifndef TOLUA_DISABLE_tolua_get_cItem_m_ItemType
static int tolua_get_cItem_m_ItemType(lua_State* tolua_S)
{
  cItem* self = (cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_ItemType'",nullptr);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->m_ItemType);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: m_ItemType of class  cItem */
#ifndef TOLUA_DISABLE_tolua_set_cItem_m_ItemType
static int tolua_set_cItem_m_ItemType(lua_State* tolua_S)
{
  cItem* self = (cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_ItemType'",nullptr);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->m_ItemType = ((short)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: m_ItemCount of class  cItem */
#ifndef TOLUA_DISABLE_tolua_get_cItem_m_ItemCount
static int tolua_get_cItem_m_ItemCount(lua_State* tolua_S)
{
  cItem* self = (cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_ItemCount'",nullptr);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->m_ItemCount);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: m_ItemCount of class  cItem */
#ifndef TOLUA_DISABLE_tolua_set_cItem_m_ItemCount
static int tolua_set_cItem_m_ItemCount(lua_State* tolua_S)
{
  cItem* self = (cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_ItemCount'",nullptr);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->m_ItemCount = ((char)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: m_ItemDamage of class  cItem */
#ifndef TOLUA_DISABLE_tolua_get_cItem_m_ItemDamage
static int tolua_get_cItem_m_ItemDamage(lua_State* tolua_S)
{
  cItem* self = (cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_ItemDamage'",nullptr);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->m_ItemDamage);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: m_ItemDamage of class  cItem */
#ifndef TOLUA_DISABLE_tolua_set_cItem_m_ItemDamage
static int tolua_set_cItem_m_ItemDamage(lua_State* tolua_S)
{
  cItem* self = (cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_ItemDamage'",nullptr);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->m_ItemDamage = ((short)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: m_Enchantments of class  cItem */
#ifndef TOLUA_DISABLE_tolua_get_cItem_m_Enchantments
static int tolua_get_cItem_m_Enchantments(lua_State* tolua_S)
{
  cItem* self = (cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_Enchantments'",nullptr);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->m_Enchantments,"cEnchantments");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: m_Enchantments of class  cItem */
#ifndef TOLUA_DISABLE_tolua_set_cItem_m_Enchantments
static int tolua_set_cItem_m_Enchantments(lua_State* tolua_S)
{
  cItem* self = (cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_Enchantments'",nullptr);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cEnchantments",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->m_Enchantments = *((cEnchantments*)  tolua_tousertype(tolua_S,2,nullptr))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: m_CustomName of class  cItem */
#ifndef TOLUA_DISABLE_tolua_get_cItem_m_CustomName
static int tolua_get_cItem_m_CustomName(lua_State* tolua_S)
{
  cItem* self = (cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_CustomName'",nullptr);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->m_CustomName);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: m_CustomName of class  cItem */
#ifndef TOLUA_DISABLE_tolua_set_cItem_m_CustomName
static int tolua_set_cItem_m_CustomName(lua_State* tolua_S)
{
  cItem* self = (cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_CustomName'",nullptr);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->m_CustomName = ((AString)  tolua_tocppstring(tolua_S,2,nullptr))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: m_RepairCost of class  cItem */
#ifndef TOLUA_DISABLE_tolua_get_cItem_m_RepairCost
static int tolua_get_cItem_m_RepairCost(lua_State* tolua_S)
{
  cItem* self = (cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_RepairCost'",nullptr);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->m_RepairCost);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: m_RepairCost of class  cItem */
#ifndef TOLUA_DISABLE_tolua_set_cItem_m_RepairCost
static int tolua_set_cItem_m_RepairCost(lua_State* tolua_S)
{
  cItem* self = (cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_RepairCost'",nullptr);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->m_RepairCost = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: m_FireworkItem of class  cItem */
#ifndef TOLUA_DISABLE_tolua_get_cItem_m_FireworkItem
static int tolua_get_cItem_m_FireworkItem(lua_State* tolua_S)
{
  cItem* self = (cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_FireworkItem'",nullptr);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->m_FireworkItem,"cFireworkItem");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: m_FireworkItem of class  cItem */
#ifndef TOLUA_DISABLE_tolua_set_cItem_m_FireworkItem
static int tolua_set_cItem_m_FireworkItem(lua_State* tolua_S)
{
  cItem* self = (cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_FireworkItem'",nullptr);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cFireworkItem",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->m_FireworkItem = *((cFireworkItem*)  tolua_tousertype(tolua_S,2,nullptr))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: m_ItemColor of class  cItem */
#ifndef TOLUA_DISABLE_tolua_get_cItem_m_ItemColor
static int tolua_get_cItem_m_ItemColor(lua_State* tolua_S)
{
  cItem* self = (cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_ItemColor'",nullptr);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->m_ItemColor,"cColor");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: m_ItemColor of class  cItem */
#ifndef TOLUA_DISABLE_tolua_set_cItem_m_ItemColor
static int tolua_set_cItem_m_ItemColor(lua_State* tolua_S)
{
  cItem* self = (cItem*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_ItemColor'",nullptr);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cColor",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->m_ItemColor = *((cColor*)  tolua_tousertype(tolua_S,2,nullptr))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  cItems */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItems_new00
static int tolua_AllToLua_cItems_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cItems",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   cItems* tolua_ret = (cItems*)  Mtolua_new((cItems)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cItems");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cItems */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItems_new00_local
static int tolua_AllToLua_cItems_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cItems",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   cItems* tolua_ret = (cItems*)  Mtolua_new((cItems)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cItems");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Get of class  cItems */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItems_Get00
static int tolua_AllToLua_cItems_Get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItems",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItems* self = (cItems*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_Idx = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Get'", nullptr);
#endif
  {
   cItem* tolua_ret = (cItem*)  self->Get(a_Idx);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Get'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Set of class  cItems */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItems_Set00
static int tolua_AllToLua_cItems_Set00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItems",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItems* self = (cItems*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_Idx = ((int)  tolua_tonumber(tolua_S,2,0));
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Set'", nullptr);
#endif
  {
   self->Set(a_Idx,*a_Item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Set'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Add of class  cItems */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItems_Add00
static int tolua_AllToLua_cItems_Add00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItems",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItems* self = (cItems*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Add'", nullptr);
#endif
  {
   self->Add(*a_Item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Add'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Add of class  cItems */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItems_Add01
static int tolua_AllToLua_cItems_Add01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItems",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cItems* self = (cItems*)  tolua_tousertype(tolua_S,1,nullptr);
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Add'", nullptr);
#endif
  {
   self->Add(a_ItemType);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cItems_Add00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: Add of class  cItems */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItems_Add02
static int tolua_AllToLua_cItems_Add02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItems",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cItems* self = (cItems*)  tolua_tousertype(tolua_S,1,nullptr);
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,2,0));
  char a_ItemCount = ((char)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Add'", nullptr);
#endif
  {
   self->Add(a_ItemType,a_ItemCount);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cItems_Add01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: Delete of class  cItems */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItems_Delete00
static int tolua_AllToLua_cItems_Delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItems",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItems* self = (cItems*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_Idx = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Delete'", nullptr);
#endif
  {
   self->Delete(a_Idx);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Delete'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Clear of class  cItems */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItems_Clear00
static int tolua_AllToLua_cItems_Clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItems",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItems* self = (cItems*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Clear'", nullptr);
#endif
  {
   self->Clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Size of class  cItems */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItems_Size00
static int tolua_AllToLua_cItems_Size00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItems",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItems* self = (const cItems*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Size'", nullptr);
#endif
  {
   size_t tolua_ret = (size_t)  self->Size();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Size'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Set of class  cItems */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItems_Set01
static int tolua_AllToLua_cItems_Set01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItems",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cItems* self = (cItems*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_Idx = ((int)  tolua_tonumber(tolua_S,2,0));
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,3,0));
  char a_ItemCount = ((char)  tolua_tonumber(tolua_S,4,0));
  short a_ItemDamage = ((short)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Set'", nullptr);
#endif
  {
   self->Set(a_Idx,a_ItemType,a_ItemCount,a_ItemDamage);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cItems_Set00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: Contains of class  cItems */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItems_Contains00
static int tolua_AllToLua_cItems_Contains00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItems",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItems* self = (cItems*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Contains'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->Contains(*a_Item);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Contains'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ContainsType of class  cItems */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItems_ContainsType00
static int tolua_AllToLua_cItems_ContainsType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItems",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItems* self = (cItems*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ContainsType'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->ContainsType(*a_Item);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ContainsType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Add of class  cItems */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItems_Add03
static int tolua_AllToLua_cItems_Add03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItems",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cItems* self = (cItems*)  tolua_tousertype(tolua_S,1,nullptr);
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,2,0));
  char a_ItemCount = ((char)  tolua_tonumber(tolua_S,3,0));
  short a_ItemDamage = ((short)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Add'", nullptr);
#endif
  {
   self->Add(a_ItemType,a_ItemCount,a_ItemDamage);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cItems_Add02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddItemGrid of class  cItems */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItems_AddItemGrid00
static int tolua_AllToLua_cItems_AddItemGrid00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItems",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItemGrid",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItems* self = (cItems*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItemGrid* a_ItemGrid = ((const cItemGrid*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddItemGrid'", nullptr);
#endif
  {
   self->AddItemGrid(*a_ItemGrid);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddItemGrid'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetWidth of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_GetWidth00
static int tolua_AllToLua_cItemGrid_GetWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItemGrid",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItemGrid* self = (const cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetWidth'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetWidth();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetHeight of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_GetHeight00
static int tolua_AllToLua_cItemGrid_GetHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItemGrid",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItemGrid* self = (const cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetHeight'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetHeight();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNumSlots of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_GetNumSlots00
static int tolua_AllToLua_cItemGrid_GetNumSlots00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItemGrid",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItemGrid* self = (const cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumSlots'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetNumSlots();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetNumSlots'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSlotNum of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_GetSlotNum00
static int tolua_AllToLua_cItemGrid_GetSlotNum00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItemGrid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItemGrid* self = (const cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_X = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_Y = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSlotNum'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetSlotNum(a_X,a_Y);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSlotNum'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSlot of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_GetSlot00
static int tolua_AllToLua_cItemGrid_GetSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItemGrid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItemGrid* self = (const cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_X = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_Y = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSlot'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetSlot(a_X,a_Y);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSlot of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_GetSlot01
static int tolua_AllToLua_cItemGrid_GetSlot01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItemGrid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const cItemGrid* self = (const cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_SlotNum = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSlot'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetSlot(a_SlotNum);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cItemGrid_GetSlot00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSlot of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_SetSlot00
static int tolua_AllToLua_cItemGrid_SetSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItemGrid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItemGrid* self = (cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_X = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_Y = ((int)  tolua_tonumber(tolua_S,3,0));
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,4,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSlot'", nullptr);
#endif
  {
   self->SetSlot(a_X,a_Y,*a_Item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSlot of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_SetSlot01
static int tolua_AllToLua_cItemGrid_SetSlot01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItemGrid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cItemGrid* self = (cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_X = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_Y = ((int)  tolua_tonumber(tolua_S,3,0));
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,4,0));
  char a_ItemCount = ((char)  tolua_tonumber(tolua_S,5,0));
  short a_ItemDamage = ((short)  tolua_tonumber(tolua_S,6,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSlot'", nullptr);
#endif
  {
   self->SetSlot(a_X,a_Y,a_ItemType,a_ItemCount,a_ItemDamage);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cItemGrid_SetSlot00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSlot of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_SetSlot02
static int tolua_AllToLua_cItemGrid_SetSlot02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItemGrid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cItemGrid* self = (cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_SlotNum = ((int)  tolua_tonumber(tolua_S,2,0));
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSlot'", nullptr);
#endif
  {
   self->SetSlot(a_SlotNum,*a_Item);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cItemGrid_SetSlot01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSlot of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_SetSlot03
static int tolua_AllToLua_cItemGrid_SetSlot03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItemGrid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cItemGrid* self = (cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_SlotNum = ((int)  tolua_tonumber(tolua_S,2,0));
  short a_ItemType = ((short)  tolua_tonumber(tolua_S,3,0));
  char a_ItemCount = ((char)  tolua_tonumber(tolua_S,4,0));
  short a_ItemDamage = ((short)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSlot'", nullptr);
#endif
  {
   self->SetSlot(a_SlotNum,a_ItemType,a_ItemCount,a_ItemDamage);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cItemGrid_SetSlot02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: EmptySlot of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_EmptySlot00
static int tolua_AllToLua_cItemGrid_EmptySlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItemGrid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItemGrid* self = (cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_X = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_Y = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'EmptySlot'", nullptr);
#endif
  {
   self->EmptySlot(a_X,a_Y);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'EmptySlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: EmptySlot of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_EmptySlot01
static int tolua_AllToLua_cItemGrid_EmptySlot01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItemGrid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cItemGrid* self = (cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_SlotNum = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'EmptySlot'", nullptr);
#endif
  {
   self->EmptySlot(a_SlotNum);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cItemGrid_EmptySlot00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsSlotEmpty of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_IsSlotEmpty00
static int tolua_AllToLua_cItemGrid_IsSlotEmpty00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItemGrid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItemGrid* self = (const cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_SlotNum = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsSlotEmpty'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsSlotEmpty(a_SlotNum);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsSlotEmpty'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsSlotEmpty of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_IsSlotEmpty01
static int tolua_AllToLua_cItemGrid_IsSlotEmpty01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItemGrid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const cItemGrid* self = (const cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_X = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_Y = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsSlotEmpty'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsSlotEmpty(a_X,a_Y);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cItemGrid_IsSlotEmpty00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: Clear of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_Clear00
static int tolua_AllToLua_cItemGrid_Clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItemGrid",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItemGrid* self = (cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Clear'", nullptr);
#endif
  {
   self->Clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: HowManyCanFit of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_HowManyCanFit00
static int tolua_AllToLua_cItemGrid_HowManyCanFit00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItemGrid",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isboolean(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItemGrid* self = (cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_ItemStack = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
  bool a_AllowNewStacks = ((bool)  tolua_toboolean(tolua_S,3,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HowManyCanFit'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->HowManyCanFit(*a_ItemStack,a_AllowNewStacks);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'HowManyCanFit'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddItem of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_AddItem00
static int tolua_AllToLua_cItemGrid_AddItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItemGrid",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cItem",0,&tolua_err)) ||
     !tolua_isboolean(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItemGrid* self = (cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  cItem* a_ItemStack = ((cItem*)  tolua_tousertype(tolua_S,2,nullptr));
  bool a_AllowNewStacks = ((bool)  tolua_toboolean(tolua_S,3,true));
  int a_PrioritySlot = ((int)  tolua_tonumber(tolua_S,4,-1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddItem'", nullptr);
#endif
  {
   char tolua_ret = (char)  self->AddItem(*a_ItemStack,a_AllowNewStacks,a_PrioritySlot);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddItems of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_AddItems00
static int tolua_AllToLua_cItemGrid_AddItems00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItemGrid",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cItems",0,&tolua_err)) ||
     !tolua_isboolean(tolua_S,3,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItemGrid* self = (cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  cItems* a_ItemStackList = ((cItems*)  tolua_tousertype(tolua_S,2,nullptr));
  bool a_AllowNewStacks = ((bool)  tolua_toboolean(tolua_S,3,true));
  int a_PrioritySlot = ((int)  tolua_tonumber(tolua_S,4,-1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddItems'", nullptr);
#endif
  {
   char tolua_ret = (char)  self->AddItems(*a_ItemStackList,a_AllowNewStacks,a_PrioritySlot);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddItems'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: RemoveItem of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_RemoveItem00
static int tolua_AllToLua_cItemGrid_RemoveItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItemGrid",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItemGrid* self = (cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_ItemStack = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'RemoveItem'", nullptr);
#endif
  {
   char tolua_ret = (char)  self->RemoveItem(*a_ItemStack);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'RemoveItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: FindItem of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_FindItem00
static int tolua_AllToLua_cItemGrid_FindItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItemGrid",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItemGrid* self = (cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_RecipeItem = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'FindItem'", nullptr);
#endif
  {
   cItem* tolua_ret = (cItem*)  self->FindItem(*a_RecipeItem);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'FindItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ChangeSlotCount of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_ChangeSlotCount00
static int tolua_AllToLua_cItemGrid_ChangeSlotCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItemGrid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItemGrid* self = (cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_SlotNum = ((int)  tolua_tonumber(tolua_S,2,0));
  char a_AddToCount = ((char)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ChangeSlotCount'", nullptr);
#endif
  {
   char tolua_ret = (char)  self->ChangeSlotCount(a_SlotNum,a_AddToCount);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ChangeSlotCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ChangeSlotCount of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_ChangeSlotCount01
static int tolua_AllToLua_cItemGrid_ChangeSlotCount01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItemGrid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cItemGrid* self = (cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_X = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_Y = ((int)  tolua_tonumber(tolua_S,3,0));
  char a_AddToCount = ((char)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ChangeSlotCount'", nullptr);
#endif
  {
   char tolua_ret = (char)  self->ChangeSlotCount(a_X,a_Y,a_AddToCount);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cItemGrid_ChangeSlotCount00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: RemoveOneItem of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_RemoveOneItem00
static int tolua_AllToLua_cItemGrid_RemoveOneItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItemGrid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItemGrid* self = (cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_SlotNum = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'RemoveOneItem'", nullptr);
#endif
  {
   cItem tolua_ret = (cItem)  self->RemoveOneItem(a_SlotNum);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cItem)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cItem));
     tolua_pushusertype(tolua_S,tolua_obj,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'RemoveOneItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: RemoveOneItem of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_RemoveOneItem01
static int tolua_AllToLua_cItemGrid_RemoveOneItem01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItemGrid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cItemGrid* self = (cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_X = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_Y = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'RemoveOneItem'", nullptr);
#endif
  {
   cItem tolua_ret = (cItem)  self->RemoveOneItem(a_X,a_Y);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cItem)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cItem));
     tolua_pushusertype(tolua_S,tolua_obj,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cItemGrid_RemoveOneItem00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: HowManyItems of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_HowManyItems00
static int tolua_AllToLua_cItemGrid_HowManyItems00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItemGrid",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItemGrid* self = (cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HowManyItems'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->HowManyItems(*a_Item);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'HowManyItems'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: HasItems of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_HasItems00
static int tolua_AllToLua_cItemGrid_HasItems00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItemGrid",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItemGrid* self = (cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_ItemStack = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HasItems'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->HasItems(*a_ItemStack);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'HasItems'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetFirstEmptySlot of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_GetFirstEmptySlot00
static int tolua_AllToLua_cItemGrid_GetFirstEmptySlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItemGrid",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItemGrid* self = (const cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetFirstEmptySlot'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetFirstEmptySlot();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetFirstEmptySlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetFirstUsedSlot of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_GetFirstUsedSlot00
static int tolua_AllToLua_cItemGrid_GetFirstUsedSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItemGrid",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItemGrid* self = (const cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetFirstUsedSlot'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetFirstUsedSlot();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetFirstUsedSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetLastEmptySlot of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_GetLastEmptySlot00
static int tolua_AllToLua_cItemGrid_GetLastEmptySlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItemGrid",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItemGrid* self = (const cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetLastEmptySlot'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetLastEmptySlot();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetLastEmptySlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetLastUsedSlot of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_GetLastUsedSlot00
static int tolua_AllToLua_cItemGrid_GetLastUsedSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItemGrid",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItemGrid* self = (const cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetLastUsedSlot'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetLastUsedSlot();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetLastUsedSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNextEmptySlot of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_GetNextEmptySlot00
static int tolua_AllToLua_cItemGrid_GetNextEmptySlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItemGrid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItemGrid* self = (const cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_StartFrom = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNextEmptySlot'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetNextEmptySlot(a_StartFrom);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetNextEmptySlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNextUsedSlot of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_GetNextUsedSlot00
static int tolua_AllToLua_cItemGrid_GetNextUsedSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItemGrid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItemGrid* self = (const cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_StartFrom = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNextUsedSlot'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetNextUsedSlot(a_StartFrom);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetNextUsedSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CopyToItems of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_CopyToItems00
static int tolua_AllToLua_cItemGrid_CopyToItems00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItemGrid",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cItems",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItemGrid* self = (const cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  cItems* a_Items = ((cItems*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CopyToItems'", nullptr);
#endif
  {
   self->CopyToItems(*a_Items);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CopyToItems'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DamageItem of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_DamageItem00
static int tolua_AllToLua_cItemGrid_DamageItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItemGrid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItemGrid* self = (cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_SlotNum = ((int)  tolua_tonumber(tolua_S,2,0));
  short a_Amount = ((short)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DamageItem'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->DamageItem(a_SlotNum,a_Amount);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DamageItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DamageItem of class  cItemGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemGrid_DamageItem01
static int tolua_AllToLua_cItemGrid_DamageItem01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItemGrid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cItemGrid* self = (cItemGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_X = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_Y = ((int)  tolua_tonumber(tolua_S,3,0));
  short a_Amount = ((short)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DamageItem'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->DamageItem(a_X,a_Y,a_Amount);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cItemGrid_DamageItem00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Name of class  HTTPFormData */
#ifndef TOLUA_DISABLE_tolua_get_HTTPFormData_Name
static int tolua_get_HTTPFormData_Name(lua_State* tolua_S)
{
  HTTPFormData* self = (HTTPFormData*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name'",nullptr);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Name);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Name of class  HTTPFormData */
#ifndef TOLUA_DISABLE_tolua_set_HTTPFormData_Name
static int tolua_set_HTTPFormData_Name(lua_State* tolua_S)
{
  HTTPFormData* self = (HTTPFormData*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Name'",nullptr);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Name = ((std::string)  tolua_tocppstring(tolua_S,2,nullptr))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Value of class  HTTPFormData */
#ifndef TOLUA_DISABLE_tolua_get_HTTPFormData_Value
static int tolua_get_HTTPFormData_Value(lua_State* tolua_S)
{
  HTTPFormData* self = (HTTPFormData*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Value'",nullptr);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Value);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Value of class  HTTPFormData */
#ifndef TOLUA_DISABLE_tolua_set_HTTPFormData_Value
static int tolua_set_HTTPFormData_Value(lua_State* tolua_S)
{
  HTTPFormData* self = (HTTPFormData*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Value'",nullptr);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Value = ((std::string)  tolua_tocppstring(tolua_S,2,nullptr))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Type of class  HTTPFormData */
#ifndef TOLUA_DISABLE_tolua_get_HTTPFormData_Type
static int tolua_get_HTTPFormData_Type(lua_State* tolua_S)
{
  HTTPFormData* self = (HTTPFormData*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Type'",nullptr);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Type);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Type of class  HTTPFormData */
#ifndef TOLUA_DISABLE_tolua_set_HTTPFormData_Type
static int tolua_set_HTTPFormData_Type(lua_State* tolua_S)
{
  HTTPFormData* self = (HTTPFormData*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Type'",nullptr);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Type = ((std::string)  tolua_tocppstring(tolua_S,2,nullptr))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: URL of class  HTTPRequest */
#ifndef TOLUA_DISABLE_tolua_get_HTTPRequest_URL
static int tolua_get_HTTPRequest_URL(lua_State* tolua_S)
{
  HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'URL'",nullptr);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->URL);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: URL of class  HTTPRequest */
#ifndef TOLUA_DISABLE_tolua_set_HTTPRequest_URL
static int tolua_set_HTTPRequest_URL(lua_State* tolua_S)
{
  HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'URL'",nullptr);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->URL = ((AString)  tolua_tocppstring(tolua_S,2,nullptr))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Method of class  HTTPRequest */
#ifndef TOLUA_DISABLE_tolua_get_HTTPRequest_Method
static int tolua_get_HTTPRequest_Method(lua_State* tolua_S)
{
  HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Method'",nullptr);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Method);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Method of class  HTTPRequest */
#ifndef TOLUA_DISABLE_tolua_set_HTTPRequest_Method
static int tolua_set_HTTPRequest_Method(lua_State* tolua_S)
{
  HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Method'",nullptr);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Method = ((AString)  tolua_tocppstring(tolua_S,2,nullptr))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Path of class  HTTPRequest */
#ifndef TOLUA_DISABLE_tolua_get_HTTPRequest_Path
static int tolua_get_HTTPRequest_Path(lua_State* tolua_S)
{
  HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Path'",nullptr);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Path);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Path of class  HTTPRequest */
#ifndef TOLUA_DISABLE_tolua_set_HTTPRequest_Path
static int tolua_set_HTTPRequest_Path(lua_State* tolua_S)
{
  HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Path'",nullptr);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Path = ((AString)  tolua_tocppstring(tolua_S,2,nullptr))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Username of class  HTTPRequest */
#ifndef TOLUA_DISABLE_tolua_get_HTTPRequest_Username
static int tolua_get_HTTPRequest_Username(lua_State* tolua_S)
{
  HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Username'",nullptr);
#endif
  tolua_pushcppstring(tolua_S,(const char*)self->Username);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Username of class  HTTPRequest */
#ifndef TOLUA_DISABLE_tolua_set_HTTPRequest_Username
static int tolua_set_HTTPRequest_Username(lua_State* tolua_S)
{
  HTTPRequest* self = (HTTPRequest*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Username'",nullptr);
  if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Username = ((AString)  tolua_tocppstring(tolua_S,2,nullptr))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Request of class  HTTPTemplateRequest */
#ifndef TOLUA_DISABLE_tolua_get_HTTPTemplateRequest_Request
static int tolua_get_HTTPTemplateRequest_Request(lua_State* tolua_S)
{
  HTTPTemplateRequest* self = (HTTPTemplateRequest*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Request'",nullptr);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->Request,"HTTPRequest");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Request of class  HTTPTemplateRequest */
#ifndef TOLUA_DISABLE_tolua_set_HTTPTemplateRequest_Request
static int tolua_set_HTTPTemplateRequest_Request(lua_State* tolua_S)
{
  HTTPTemplateRequest* self = (HTTPTemplateRequest*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Request'",nullptr);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"HTTPRequest",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Request = *((HTTPRequest*)  tolua_tousertype(tolua_S,2,nullptr))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: Reload of class  cWebAdmin */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWebAdmin_Reload00
static int tolua_AllToLua_cWebAdmin_Reload00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWebAdmin",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWebAdmin* self = (cWebAdmin*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Reload'", nullptr);
#endif
  {
   self->Reload();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Reload'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPorts of class  cWebAdmin */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWebAdmin_GetPorts00
static int tolua_AllToLua_cWebAdmin_GetPorts00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWebAdmin",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWebAdmin* self = (const cWebAdmin*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPorts'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetPorts();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPorts'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetBaseURL of class  cWebAdmin */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWebAdmin_GetBaseURL00
static int tolua_AllToLua_cWebAdmin_GetBaseURL00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cWebAdmin",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const AString a_URL = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  {
   AString tolua_ret = (AString)  cWebAdmin::GetBaseURL(a_URL);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetBaseURL'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetContentTypeFromFileExt of class  cWebAdmin */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWebAdmin_GetContentTypeFromFileExt00
static int tolua_AllToLua_cWebAdmin_GetContentTypeFromFileExt00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cWebAdmin",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const AString a_FileExtension = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  {
   AString tolua_ret = (AString)  cWebAdmin::GetContentTypeFromFileExt(a_FileExtension);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetContentTypeFromFileExt'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetHTMLEscapedString of class  cWebAdmin */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWebAdmin_GetHTMLEscapedString00
static int tolua_AllToLua_cWebAdmin_GetHTMLEscapedString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cWebAdmin",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const AString a_Input = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  {
   AString tolua_ret = (AString)  cWebAdmin::GetHTMLEscapedString(a_Input);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetHTMLEscapedString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Get of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_Get00
static int tolua_AllToLua_cRoot_Get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cRoot",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   cRoot* tolua_ret = (cRoot*)  cRoot::Get();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cRoot");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Get'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetServer of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_GetServer00
static int tolua_AllToLua_cRoot_GetServer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cRoot* self = (cRoot*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetServer'", nullptr);
#endif
  {
   cServer* tolua_ret = (cServer*)  self->GetServer();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cServer");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetServer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetDefaultWorld of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_GetDefaultWorld00
static int tolua_AllToLua_cRoot_GetDefaultWorld00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cRoot* self = (cRoot*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetDefaultWorld'", nullptr);
#endif
  {
   cWorld* tolua_ret = (cWorld*)  self->GetDefaultWorld();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cWorld");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetDefaultWorld'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetWorld of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_GetWorld00
static int tolua_AllToLua_cRoot_GetWorld00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cRoot* self = (cRoot*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_WorldName = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetWorld'", nullptr);
#endif
  {
   cWorld* tolua_ret = (cWorld*)  self->GetWorld(a_WorldName);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cWorld");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetWorld'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetServerUpTime of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_GetServerUpTime00
static int tolua_AllToLua_cRoot_GetServerUpTime00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cRoot* self = (cRoot*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetServerUpTime'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetServerUpTime();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetServerUpTime'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetCraftingRecipes of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_GetCraftingRecipes00
static int tolua_AllToLua_cRoot_GetCraftingRecipes00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cRoot* self = (cRoot*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetCraftingRecipes'", nullptr);
#endif
  {
   cCraftingRecipes* tolua_ret = (cCraftingRecipes*)  self->GetCraftingRecipes();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cCraftingRecipes");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetCraftingRecipes'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetFurnaceFuelBurnTime of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_GetFurnaceFuelBurnTime00
static int tolua_AllToLua_cRoot_GetFurnaceFuelBurnTime00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cRoot",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItem* a_Fuel = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   int tolua_ret = (int)  cRoot::GetFurnaceFuelBurnTime(*a_Fuel);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetFurnaceFuelBurnTime'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetWebAdmin of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_GetWebAdmin00
static int tolua_AllToLua_cRoot_GetWebAdmin00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cRoot* self = (cRoot*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetWebAdmin'", nullptr);
#endif
  {
   cWebAdmin* tolua_ret = (cWebAdmin*)  self->GetWebAdmin();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cWebAdmin");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetWebAdmin'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPluginManager of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_GetPluginManager00
static int tolua_AllToLua_cRoot_GetPluginManager00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cRoot* self = (cRoot*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPluginManager'", nullptr);
#endif
  {
   cPluginManager* tolua_ret = (cPluginManager*)  self->GetPluginManager();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cPluginManager");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPluginManager'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: QueueExecuteConsoleCommand of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_QueueExecuteConsoleCommand00
static int tolua_AllToLua_cRoot_QueueExecuteConsoleCommand00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cRoot* self = (cRoot*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Cmd = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'QueueExecuteConsoleCommand'", nullptr);
#endif
  {
   self->QueueExecuteConsoleCommand(a_Cmd);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'QueueExecuteConsoleCommand'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetTotalChunkCount of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_GetTotalChunkCount00
static int tolua_AllToLua_cRoot_GetTotalChunkCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cRoot* self = (cRoot*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetTotalChunkCount'", nullptr);
#endif
  {
   size_t tolua_ret = (size_t)  self->GetTotalChunkCount();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetTotalChunkCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SaveAllChunks of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_SaveAllChunks00
static int tolua_AllToLua_cRoot_SaveAllChunks00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cRoot* self = (cRoot*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SaveAllChunks'", nullptr);
#endif
  {
   self->SaveAllChunks();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SaveAllChunks'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSavingEnabled of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_SetSavingEnabled00
static int tolua_AllToLua_cRoot_SetSavingEnabled00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cRoot* self = (cRoot*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_SavingEnabled = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSavingEnabled'", nullptr);
#endif
  {
   self->SetSavingEnabled(a_SavingEnabled);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetSavingEnabled'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: BroadcastPlayerListsHeaderFooter of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_BroadcastPlayerListsHeaderFooter00
static int tolua_AllToLua_cRoot_BroadcastPlayerListsHeaderFooter00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cCompositeChat",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cCompositeChat",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cRoot* self = (cRoot*)  tolua_tousertype(tolua_S,1,nullptr);
  const cCompositeChat* a_Header = ((const cCompositeChat*)  tolua_tousertype(tolua_S,2,nullptr));
  const cCompositeChat* a_Footer = ((const cCompositeChat*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BroadcastPlayerListsHeaderFooter'", nullptr);
#endif
  {
   self->BroadcastPlayerListsHeaderFooter(*a_Header,*a_Footer);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BroadcastPlayerListsHeaderFooter'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseMessageType (lua_State* L, int lo, int def, tolua_Error* err);
/* method: BroadcastChat of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_BroadcastChat00
static int tolua_AllToLua_cRoot_BroadcastChat00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iseMessageType(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cRoot* self = (cRoot*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  eMessageType a_ChatPrefix = ((eMessageType) (  int)  tolua_tonumber(tolua_S,3,mtCustom));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BroadcastChat'", nullptr);
#endif
  {
   self->BroadcastChat(a_Message,a_ChatPrefix);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BroadcastChat'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: BroadcastChat of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_BroadcastChat01
static int tolua_AllToLua_cRoot_BroadcastChat01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cCompositeChat",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cRoot* self = (cRoot*)  tolua_tousertype(tolua_S,1,nullptr);
  const cCompositeChat* a_Message = ((const cCompositeChat*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BroadcastChat'", nullptr);
#endif
  {
   self->BroadcastChat(*a_Message);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cRoot_BroadcastChat00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: BroadcastChatDeath of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_BroadcastChatDeath00
static int tolua_AllToLua_cRoot_BroadcastChatDeath00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cRoot* self = (cRoot*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BroadcastChatDeath'", nullptr);
#endif
  {
   self->BroadcastChatDeath(a_Message);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BroadcastChatDeath'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: BroadcastChatFailure of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_BroadcastChatFailure00
static int tolua_AllToLua_cRoot_BroadcastChatFailure00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cRoot* self = (cRoot*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BroadcastChatFailure'", nullptr);
#endif
  {
   self->BroadcastChatFailure(a_Message);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BroadcastChatFailure'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: BroadcastChatFatal of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_BroadcastChatFatal00
static int tolua_AllToLua_cRoot_BroadcastChatFatal00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cRoot* self = (cRoot*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BroadcastChatFatal'", nullptr);
#endif
  {
   self->BroadcastChatFatal(a_Message);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BroadcastChatFatal'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: BroadcastChatInfo of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_BroadcastChatInfo00
static int tolua_AllToLua_cRoot_BroadcastChatInfo00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cRoot* self = (cRoot*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BroadcastChatInfo'", nullptr);
#endif
  {
   self->BroadcastChatInfo(a_Message);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BroadcastChatInfo'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: BroadcastChatJoin of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_BroadcastChatJoin00
static int tolua_AllToLua_cRoot_BroadcastChatJoin00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cRoot* self = (cRoot*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BroadcastChatJoin'", nullptr);
#endif
  {
   self->BroadcastChatJoin(a_Message);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BroadcastChatJoin'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: BroadcastChatLeave of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_BroadcastChatLeave00
static int tolua_AllToLua_cRoot_BroadcastChatLeave00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cRoot* self = (cRoot*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BroadcastChatLeave'", nullptr);
#endif
  {
   self->BroadcastChatLeave(a_Message);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BroadcastChatLeave'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: BroadcastChatSuccess of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_BroadcastChatSuccess00
static int tolua_AllToLua_cRoot_BroadcastChatSuccess00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cRoot* self = (cRoot*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BroadcastChatSuccess'", nullptr);
#endif
  {
   self->BroadcastChatSuccess(a_Message);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BroadcastChatSuccess'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: BroadcastChatWarning of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_BroadcastChatWarning00
static int tolua_AllToLua_cRoot_BroadcastChatWarning00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cRoot* self = (cRoot*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BroadcastChatWarning'", nullptr);
#endif
  {
   self->BroadcastChatWarning(a_Message);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BroadcastChatWarning'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetProtocolVersionTextFromInt of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_GetProtocolVersionTextFromInt00
static int tolua_AllToLua_cRoot_GetProtocolVersionTextFromInt00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cRoot",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  int a_ProtocolVersionNum = ((int)  tolua_tonumber(tolua_S,2,0));
  {
   AString tolua_ret = (AString)  cRoot::GetProtocolVersionTextFromInt(a_ProtocolVersionNum);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetProtocolVersionTextFromInt'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetVirtualRAMUsage of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_GetVirtualRAMUsage00
static int tolua_AllToLua_cRoot_GetVirtualRAMUsage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cRoot",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   int tolua_ret = (int)  cRoot::GetVirtualRAMUsage();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetVirtualRAMUsage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPhysicalRAMUsage of class  cRoot */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_GetPhysicalRAMUsage00
static int tolua_AllToLua_cRoot_GetPhysicalRAMUsage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cRoot",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   int tolua_ret = (int)  cRoot::GetPhysicalRAMUsage();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPhysicalRAMUsage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: p1 of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_get_cCuboid_p1
static int tolua_get_cCuboid_p1(lua_State* tolua_S)
{
  cCuboid* self = (cCuboid*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'p1'",nullptr);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->p1,"Vector3<int>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: p1 of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_set_cCuboid_p1
static int tolua_set_cCuboid_p1(lua_State* tolua_S)
{
  cCuboid* self = (cCuboid*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'p1'",nullptr);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->p1 = *((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: p2 of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_get_cCuboid_p2
static int tolua_get_cCuboid_p2(lua_State* tolua_S)
{
  cCuboid* self = (cCuboid*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'p2'",nullptr);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->p2,"Vector3<int>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: p2 of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_set_cCuboid_p2
static int tolua_set_cCuboid_p2(lua_State* tolua_S)
{
  cCuboid* self = (cCuboid*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'p2'",nullptr);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->p2 = *((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_new00
static int tolua_AllToLua_cCuboid_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cCuboid",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   cCuboid* tolua_ret = (cCuboid*)  Mtolua_new((cCuboid)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cCuboid");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_new00_local
static int tolua_AllToLua_cCuboid_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cCuboid",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   cCuboid* tolua_ret = (cCuboid*)  Mtolua_new((cCuboid)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cCuboid");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_new01
static int tolua_AllToLua_cCuboid_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cCuboid",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
   Vector3<int> a_p1 = *((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
   Vector3<int> a_p2 = *((  Vector3<int>*)  tolua_tousertype(tolua_S,3,nullptr));
  {
   cCuboid* tolua_ret = (cCuboid*)  Mtolua_new((cCuboid)(a_p1,a_p2));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cCuboid");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cCuboid_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_new01_local
static int tolua_AllToLua_cCuboid_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cCuboid",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
   Vector3<int> a_p1 = *((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
   Vector3<int> a_p2 = *((  Vector3<int>*)  tolua_tousertype(tolua_S,3,nullptr));
  {
   cCuboid* tolua_ret = (cCuboid*)  Mtolua_new((cCuboid)(a_p1,a_p2));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cCuboid");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cCuboid_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_new02
static int tolua_AllToLua_cCuboid_new02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cCuboid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  int a_X1 = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_Y1 = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_Z1 = ((int)  tolua_tonumber(tolua_S,4,0));
  {
   cCuboid* tolua_ret = (cCuboid*)  Mtolua_new((cCuboid)(a_X1,a_Y1,a_Z1));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cCuboid");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cCuboid_new01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_new02_local
static int tolua_AllToLua_cCuboid_new02_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cCuboid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  int a_X1 = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_Y1 = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_Z1 = ((int)  tolua_tonumber(tolua_S,4,0));
  {
   cCuboid* tolua_ret = (cCuboid*)  Mtolua_new((cCuboid)(a_X1,a_Y1,a_Z1));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cCuboid");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cCuboid_new01_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_new03
static int tolua_AllToLua_cCuboid_new03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cCuboid",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cCuboid",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const cCuboid* a_Cuboid = ((const cCuboid*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   cCuboid* tolua_ret = (cCuboid*)  Mtolua_new((cCuboid)(*a_Cuboid));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cCuboid");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cCuboid_new02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_new03_local
static int tolua_AllToLua_cCuboid_new03_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cCuboid",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cCuboid",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const cCuboid* a_Cuboid = ((const cCuboid*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   cCuboid* tolua_ret = (cCuboid*)  Mtolua_new((cCuboid)(*a_Cuboid));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cCuboid");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cCuboid_new02_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: Sort of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_Sort00
static int tolua_AllToLua_cCuboid_Sort00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cCuboid",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cCuboid* self = (cCuboid*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Sort'", nullptr);
#endif
  {
   self->Sort();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Sort'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DifX of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_DifX00
static int tolua_AllToLua_cCuboid_DifX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cCuboid",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cCuboid* self = (const cCuboid*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DifX'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->DifX();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DifX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DifY of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_DifY00
static int tolua_AllToLua_cCuboid_DifY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cCuboid",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cCuboid* self = (const cCuboid*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DifY'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->DifY();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DifY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DifZ of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_DifZ00
static int tolua_AllToLua_cCuboid_DifZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cCuboid",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cCuboid* self = (const cCuboid*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DifZ'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->DifZ();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DifZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetVolume of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_GetVolume00
static int tolua_AllToLua_cCuboid_GetVolume00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cCuboid",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cCuboid* self = (const cCuboid*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetVolume'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetVolume();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetVolume'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DoesIntersect of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_DoesIntersect00
static int tolua_AllToLua_cCuboid_DoesIntersect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cCuboid",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cCuboid",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cCuboid* self = (const cCuboid*)  tolua_tousertype(tolua_S,1,nullptr);
  const cCuboid* a_Other = ((const cCuboid*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DoesIntersect'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->DoesIntersect(*a_Other);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DoesIntersect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsCompletelyInside of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_IsCompletelyInside00
static int tolua_AllToLua_cCuboid_IsCompletelyInside00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cCuboid",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cCuboid",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cCuboid* self = (const cCuboid*)  tolua_tousertype(tolua_S,1,nullptr);
  const cCuboid* a_Outer = ((const cCuboid*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsCompletelyInside'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsCompletelyInside(*a_Outer);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsCompletelyInside'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Expand of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_Expand00
static int tolua_AllToLua_cCuboid_Expand00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cCuboid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cCuboid* self = (cCuboid*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_SubMinX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_AddMaxX = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_SubMinY = ((int)  tolua_tonumber(tolua_S,4,0));
  int a_AddMaxY = ((int)  tolua_tonumber(tolua_S,5,0));
  int a_SubMinZ = ((int)  tolua_tonumber(tolua_S,6,0));
  int a_AddMaxZ = ((int)  tolua_tonumber(tolua_S,7,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Expand'", nullptr);
#endif
  {
   self->Expand(a_SubMinX,a_AddMaxX,a_SubMinY,a_AddMaxY,a_SubMinZ,a_AddMaxZ);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Expand'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Clamp of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_Clamp00
static int tolua_AllToLua_cCuboid_Clamp00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cCuboid",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cCuboid",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cCuboid* self = (cCuboid*)  tolua_tousertype(tolua_S,1,nullptr);
  const cCuboid* a_Limits = ((const cCuboid*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Clamp'", nullptr);
#endif
  {
   self->Clamp(*a_Limits);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Clamp'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ClampSize of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_ClampSize00
static int tolua_AllToLua_cCuboid_ClampSize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cCuboid",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cCuboid* self = (cCuboid*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<int> a_MaxSize = *((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ClampSize'", nullptr);
#endif
  {
   self->ClampSize(a_MaxSize);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ClampSize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ClampX of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_ClampX00
static int tolua_AllToLua_cCuboid_ClampX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cCuboid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cCuboid* self = (cCuboid*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_MinX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_MaxX = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ClampX'", nullptr);
#endif
  {
   self->ClampX(a_MinX,a_MaxX);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ClampX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ClampY of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_ClampY00
static int tolua_AllToLua_cCuboid_ClampY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cCuboid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cCuboid* self = (cCuboid*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_MinY = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_MaxY = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ClampY'", nullptr);
#endif
  {
   self->ClampY(a_MinY,a_MaxY);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ClampY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ClampZ of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_ClampZ00
static int tolua_AllToLua_cCuboid_ClampZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cCuboid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cCuboid* self = (cCuboid*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_MinZ = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_MaxZ = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ClampZ'", nullptr);
#endif
  {
   self->ClampZ(a_MinZ,a_MaxZ);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ClampZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsSorted of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_IsSorted00
static int tolua_AllToLua_cCuboid_IsSorted00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cCuboid",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cCuboid* self = (const cCuboid*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsSorted'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsSorted();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsSorted'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Engulf of class  cCuboid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_Engulf00
static int tolua_AllToLua_cCuboid_Engulf00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cCuboid",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cCuboid* self = (cCuboid*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<int> a_Point = *((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Engulf'", nullptr);
#endif
  {
   self->Engulf(a_Point);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Engulf'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_new00
static int tolua_AllToLua_cBoundingBox_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBoundingBox",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  double a_MinX = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_MaxX = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_MinY = ((double)  tolua_tonumber(tolua_S,4,0));
  double a_MaxY = ((double)  tolua_tonumber(tolua_S,5,0));
  double a_MinZ = ((double)  tolua_tonumber(tolua_S,6,0));
  double a_MaxZ = ((double)  tolua_tonumber(tolua_S,7,0));
  {
   cBoundingBox* tolua_ret = (cBoundingBox*)  Mtolua_new((cBoundingBox)(a_MinX,a_MaxX,a_MinY,a_MaxY,a_MinZ,a_MaxZ));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cBoundingBox");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_new00_local
static int tolua_AllToLua_cBoundingBox_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBoundingBox",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  double a_MinX = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_MaxX = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_MinY = ((double)  tolua_tonumber(tolua_S,4,0));
  double a_MaxY = ((double)  tolua_tonumber(tolua_S,5,0));
  double a_MinZ = ((double)  tolua_tonumber(tolua_S,6,0));
  double a_MaxZ = ((double)  tolua_tonumber(tolua_S,7,0));
  {
   cBoundingBox* tolua_ret = (cBoundingBox*)  Mtolua_new((cBoundingBox)(a_MinX,a_MaxX,a_MinY,a_MaxY,a_MinZ,a_MaxZ));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cBoundingBox");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_new01
static int tolua_AllToLua_cBoundingBox_new01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBoundingBox",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<double>",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
   Vector3<double> a_Min = *((  Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
   Vector3<double> a_Max = *((  Vector3<double>*)  tolua_tousertype(tolua_S,3,nullptr));
  {
   cBoundingBox* tolua_ret = (cBoundingBox*)  Mtolua_new((cBoundingBox)(a_Min,a_Max));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cBoundingBox");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cBoundingBox_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_new01_local
static int tolua_AllToLua_cBoundingBox_new01_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBoundingBox",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<double>",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
   Vector3<double> a_Min = *((  Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
   Vector3<double> a_Max = *((  Vector3<double>*)  tolua_tousertype(tolua_S,3,nullptr));
  {
   cBoundingBox* tolua_ret = (cBoundingBox*)  Mtolua_new((cBoundingBox)(a_Min,a_Max));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cBoundingBox");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cBoundingBox_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_new02
static int tolua_AllToLua_cBoundingBox_new02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBoundingBox",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
   Vector3<double> a_Pos = *((  Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  double a_Radius = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_Height = ((double)  tolua_tonumber(tolua_S,4,0));
  {
   cBoundingBox* tolua_ret = (cBoundingBox*)  Mtolua_new((cBoundingBox)(a_Pos,a_Radius,a_Height));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cBoundingBox");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cBoundingBox_new01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_new02_local
static int tolua_AllToLua_cBoundingBox_new02_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBoundingBox",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
   Vector3<double> a_Pos = *((  Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  double a_Radius = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_Height = ((double)  tolua_tonumber(tolua_S,4,0));
  {
   cBoundingBox* tolua_ret = (cBoundingBox*)  Mtolua_new((cBoundingBox)(a_Pos,a_Radius,a_Height));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cBoundingBox");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cBoundingBox_new01_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_new03
static int tolua_AllToLua_cBoundingBox_new03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBoundingBox",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
   Vector3<double> a_Pos = *((  Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  double a_Radius = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_Height = ((double)  tolua_tonumber(tolua_S,4,0));
  double a_VerticalOffset = ((double)  tolua_tonumber(tolua_S,5,0));
  {
   cBoundingBox* tolua_ret = (cBoundingBox*)  Mtolua_new((cBoundingBox)(a_Pos,a_Radius,a_Height,a_VerticalOffset));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cBoundingBox");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cBoundingBox_new02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_new03_local
static int tolua_AllToLua_cBoundingBox_new03_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBoundingBox",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
   Vector3<double> a_Pos = *((  Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  double a_Radius = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_Height = ((double)  tolua_tonumber(tolua_S,4,0));
  double a_VerticalOffset = ((double)  tolua_tonumber(tolua_S,5,0));
  {
   cBoundingBox* tolua_ret = (cBoundingBox*)  Mtolua_new((cBoundingBox)(a_Pos,a_Radius,a_Height,a_VerticalOffset));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cBoundingBox");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cBoundingBox_new02_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_new04
static int tolua_AllToLua_cBoundingBox_new04(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBoundingBox",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
   Vector3<double> a_Pos = *((  Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  double a_CubeLength = ((double)  tolua_tonumber(tolua_S,3,0));
  {
   cBoundingBox* tolua_ret = (cBoundingBox*)  Mtolua_new((cBoundingBox)(a_Pos,a_CubeLength));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cBoundingBox");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cBoundingBox_new03(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_new04_local
static int tolua_AllToLua_cBoundingBox_new04_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBoundingBox",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
   Vector3<double> a_Pos = *((  Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
  double a_CubeLength = ((double)  tolua_tonumber(tolua_S,3,0));
  {
   cBoundingBox* tolua_ret = (cBoundingBox*)  Mtolua_new((cBoundingBox)(a_Pos,a_CubeLength));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cBoundingBox");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cBoundingBox_new03_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_new05
static int tolua_AllToLua_cBoundingBox_new05(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBoundingBox",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cBoundingBox",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const cBoundingBox* a_Orig = ((const cBoundingBox*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   cBoundingBox* tolua_ret = (cBoundingBox*)  Mtolua_new((cBoundingBox)(*a_Orig));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cBoundingBox");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cBoundingBox_new04(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_new05_local
static int tolua_AllToLua_cBoundingBox_new05_local(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBoundingBox",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cBoundingBox",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const cBoundingBox* a_Orig = ((const cBoundingBox*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   cBoundingBox* tolua_ret = (cBoundingBox*)  Mtolua_new((cBoundingBox)(*a_Orig));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cBoundingBox");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cBoundingBox_new04_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: Move of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_Move00
static int tolua_AllToLua_cBoundingBox_Move00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBoundingBox",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBoundingBox* self = (cBoundingBox*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_OffX = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_OffY = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_OffZ = ((double)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Move'", nullptr);
#endif
  {
   self->Move(a_OffX,a_OffY,a_OffZ);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Move'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Move of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_Move01
static int tolua_AllToLua_cBoundingBox_Move01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBoundingBox",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cBoundingBox* self = (cBoundingBox*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<double> a_Off = *((  Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Move'", nullptr);
#endif
  {
   self->Move(a_Off);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cBoundingBox_Move00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: Expand of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_Expand00
static int tolua_AllToLua_cBoundingBox_Expand00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBoundingBox",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBoundingBox* self = (cBoundingBox*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_ExpandX = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_ExpandY = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_ExpandZ = ((double)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Expand'", nullptr);
#endif
  {
   self->Expand(a_ExpandX,a_ExpandY,a_ExpandZ);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Expand'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DoesIntersect of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_DoesIntersect00
static int tolua_AllToLua_cBoundingBox_DoesIntersect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBoundingBox",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cBoundingBox",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBoundingBox* self = (cBoundingBox*)  tolua_tousertype(tolua_S,1,nullptr);
  const cBoundingBox* a_Other = ((const cBoundingBox*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DoesIntersect'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->DoesIntersect(*a_Other);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DoesIntersect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Union of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_Union00
static int tolua_AllToLua_cBoundingBox_Union00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBoundingBox",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cBoundingBox",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBoundingBox* self = (cBoundingBox*)  tolua_tousertype(tolua_S,1,nullptr);
  const cBoundingBox* a_Other = ((const cBoundingBox*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Union'", nullptr);
#endif
  {
   cBoundingBox tolua_ret = (cBoundingBox)  self->Union(*a_Other);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cBoundingBox)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cBoundingBox");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cBoundingBox));
     tolua_pushusertype(tolua_S,tolua_obj,"cBoundingBox");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Union'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsInside of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_IsInside00
static int tolua_AllToLua_cBoundingBox_IsInside00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBoundingBox",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBoundingBox* self = (cBoundingBox*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<double> a_Point = *((  Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsInside'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsInside(a_Point);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsInside'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsInside of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_IsInside01
static int tolua_AllToLua_cBoundingBox_IsInside01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBoundingBox",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cBoundingBox* self = (cBoundingBox*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_X = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_Y = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_Z = ((double)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsInside'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsInside(a_X,a_Y,a_Z);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cBoundingBox_IsInside00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsInside of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_IsInside02
static int tolua_AllToLua_cBoundingBox_IsInside02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBoundingBox",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cBoundingBox",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cBoundingBox* self = (cBoundingBox*)  tolua_tousertype(tolua_S,1,nullptr);
  cBoundingBox* a_Other = ((cBoundingBox*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsInside'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsInside(*a_Other);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cBoundingBox_IsInside01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsInside of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_IsInside03
static int tolua_AllToLua_cBoundingBox_IsInside03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBoundingBox",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<double>",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cBoundingBox* self = (cBoundingBox*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<double> a_Min = *((  Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
   Vector3<double> a_Max = *((  Vector3<double>*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsInside'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsInside(a_Min,a_Max);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cBoundingBox_IsInside02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsInside of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_IsInside04
static int tolua_AllToLua_cBoundingBox_IsInside04(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBoundingBox",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<double>",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"Vector3<double>",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
   Vector3<double> a_Min = *((  Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
   Vector3<double> a_Max = *((  Vector3<double>*)  tolua_tousertype(tolua_S,3,nullptr));
   Vector3<double> a_Point = *((  Vector3<double>*)  tolua_tousertype(tolua_S,4,nullptr));
  {
   bool tolua_ret = (bool)  cBoundingBox::IsInside(a_Min,a_Max,a_Point);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cBoundingBox_IsInside03(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsInside of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_IsInside05
static int tolua_AllToLua_cBoundingBox_IsInside05(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBoundingBox",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<double>",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
   Vector3<double> a_Min = *((  Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
   Vector3<double> a_Max = *((  Vector3<double>*)  tolua_tousertype(tolua_S,3,nullptr));
  double a_X = ((double)  tolua_tonumber(tolua_S,4,0));
  double a_Y = ((double)  tolua_tonumber(tolua_S,5,0));
  double a_Z = ((double)  tolua_tonumber(tolua_S,6,0));
  {
   bool tolua_ret = (bool)  cBoundingBox::IsInside(a_Min,a_Max,a_X,a_Y,a_Z);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cBoundingBox_IsInside04(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMinX of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_GetMinX00
static int tolua_AllToLua_cBoundingBox_GetMinX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBoundingBox",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBoundingBox* self = (const cBoundingBox*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMinX'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetMinX();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMinX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMinY of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_GetMinY00
static int tolua_AllToLua_cBoundingBox_GetMinY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBoundingBox",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBoundingBox* self = (const cBoundingBox*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMinY'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetMinY();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMinY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMinZ of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_GetMinZ00
static int tolua_AllToLua_cBoundingBox_GetMinZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBoundingBox",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBoundingBox* self = (const cBoundingBox*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMinZ'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetMinZ();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMinZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMaxX of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_GetMaxX00
static int tolua_AllToLua_cBoundingBox_GetMaxX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBoundingBox",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBoundingBox* self = (const cBoundingBox*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMaxX'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetMaxX();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMaxX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMaxY of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_GetMaxY00
static int tolua_AllToLua_cBoundingBox_GetMaxY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBoundingBox",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBoundingBox* self = (const cBoundingBox*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMaxY'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetMaxY();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMaxY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMaxZ of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_GetMaxZ00
static int tolua_AllToLua_cBoundingBox_GetMaxZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBoundingBox",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBoundingBox* self = (const cBoundingBox*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMaxZ'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetMaxZ();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMaxZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMin of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_GetMin00
static int tolua_AllToLua_cBoundingBox_GetMin00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBoundingBox",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBoundingBox* self = (const cBoundingBox*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMin'", nullptr);
#endif
  {
    Vector3<double> tolua_ret = (  Vector3<double>)  self->GetMin();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<double>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<double>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMin'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMax of class  cBoundingBox */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoundingBox_GetMax00
static int tolua_AllToLua_cBoundingBox_GetMax00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBoundingBox",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBoundingBox* self = (const cBoundingBox*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMax'", nullptr);
#endif
  {
    Vector3<double> tolua_ret = (  Vector3<double>)  self->GetMax();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<double>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<double>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMax'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseMergeStrategy (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 7.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eMergeStrategy";
	return 0;
}
/* method: new of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_new00
static int tolua_AllToLua_cBlockArea_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   cBlockArea* tolua_ret = (cBlockArea*)  Mtolua_new((cBlockArea)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cBlockArea");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_new00_local
static int tolua_AllToLua_cBlockArea_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   cBlockArea* tolua_ret = (cBlockArea*)  Mtolua_new((cBlockArea)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cBlockArea");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsValidDataTypeCombination of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_IsValidDataTypeCombination00
static int tolua_AllToLua_cBlockArea_IsValidDataTypeCombination00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  int a_DataTypes = ((int)  tolua_tonumber(tolua_S,2,0));
  {
   bool tolua_ret = (bool)  cBlockArea::IsValidDataTypeCombination(a_DataTypes);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsValidDataTypeCombination'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Clear of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_Clear00
static int tolua_AllToLua_cBlockArea_Clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBlockArea* self = (cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Clear'", nullptr);
#endif
  {
   self->Clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetOrigin of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_SetOrigin00
static int tolua_AllToLua_cBlockArea_SetOrigin00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBlockArea* self = (cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_OriginX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_OriginY = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_OriginZ = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetOrigin'", nullptr);
#endif
  {
   self->SetOrigin(a_OriginX,a_OriginY,a_OriginZ);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetOrigin'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetOrigin of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_SetOrigin01
static int tolua_AllToLua_cBlockArea_SetOrigin01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cBlockArea* self = (cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<int>* a_Origin = ((const Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetOrigin'", nullptr);
#endif
  {
   self->SetOrigin(*a_Origin);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cBlockArea_SetOrigin00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsValidRelCoords of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_IsValidRelCoords00
static int tolua_AllToLua_cBlockArea_IsValidRelCoords00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockArea",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockArea* self = (const cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_RelX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_RelY = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_RelZ = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsValidRelCoords'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsValidRelCoords(a_RelX,a_RelY,a_RelZ);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsValidRelCoords'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsValidRelCoords of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_IsValidRelCoords01
static int tolua_AllToLua_cBlockArea_IsValidRelCoords01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockArea",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const cBlockArea* self = (const cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<int>* a_RelCoords = ((const Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsValidRelCoords'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsValidRelCoords(*a_RelCoords);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cBlockArea_IsValidRelCoords00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsValidCoords of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_IsValidCoords00
static int tolua_AllToLua_cBlockArea_IsValidCoords00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockArea",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockArea* self = (const cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_BlockX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_BlockY = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_BlockZ = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsValidCoords'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsValidCoords(a_BlockX,a_BlockY,a_BlockZ);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsValidCoords'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsValidCoords of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_IsValidCoords01
static int tolua_AllToLua_cBlockArea_IsValidCoords01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockArea",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const cBlockArea* self = (const cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<int>* a_Coords = ((const Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsValidCoords'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsValidCoords(*a_Coords);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cBlockArea_IsValidCoords00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: CopyTo of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_CopyTo00
static int tolua_AllToLua_cBlockArea_CopyTo00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockArea",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cBlockArea",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockArea* self = (const cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
  cBlockArea* a_Into = ((cBlockArea*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CopyTo'", nullptr);
#endif
  {
   self->CopyTo(*a_Into);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CopyTo'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CopyFrom of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_CopyFrom00
static int tolua_AllToLua_cBlockArea_CopyFrom00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cBlockArea",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBlockArea* self = (cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
  const cBlockArea* a_From = ((const cBlockArea*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CopyFrom'", nullptr);
#endif
  {
   self->CopyFrom(*a_From);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CopyFrom'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DumpToRawFile of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_DumpToRawFile00
static int tolua_AllToLua_cBlockArea_DumpToRawFile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBlockArea* self = (cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_FileName = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DumpToRawFile'", nullptr);
#endif
  {
   self->DumpToRawFile(a_FileName);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DumpToRawFile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Crop of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_Crop00
static int tolua_AllToLua_cBlockArea_Crop00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBlockArea* self = (cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_AddMinX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_SubMaxX = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_AddMinY = ((int)  tolua_tonumber(tolua_S,4,0));
  int a_SubMaxY = ((int)  tolua_tonumber(tolua_S,5,0));
  int a_AddMinZ = ((int)  tolua_tonumber(tolua_S,6,0));
  int a_SubMaxZ = ((int)  tolua_tonumber(tolua_S,7,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Crop'", nullptr);
#endif
  {
   self->Crop(a_AddMinX,a_SubMaxX,a_AddMinY,a_SubMaxY,a_AddMinZ,a_SubMaxZ);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Crop'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Expand of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_Expand00
static int tolua_AllToLua_cBlockArea_Expand00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBlockArea* self = (cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_SubMinX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_AddMaxX = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_SubMinY = ((int)  tolua_tonumber(tolua_S,4,0));
  int a_AddMaxY = ((int)  tolua_tonumber(tolua_S,5,0));
  int a_SubMinZ = ((int)  tolua_tonumber(tolua_S,6,0));
  int a_AddMaxZ = ((int)  tolua_tonumber(tolua_S,7,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Expand'", nullptr);
#endif
  {
   self->Expand(a_SubMinX,a_AddMaxX,a_SubMinY,a_AddMaxY,a_SubMinZ,a_AddMaxZ);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Expand'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Merge of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_Merge00
static int tolua_AllToLua_cBlockArea_Merge00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cBlockArea",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBlockArea* self = (cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
  const cBlockArea* a_Src = ((const cBlockArea*)  tolua_tousertype(tolua_S,2,nullptr));
  int a_RelX = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_RelY = ((int)  tolua_tonumber(tolua_S,4,0));
  int a_RelZ = ((int)  tolua_tonumber(tolua_S,5,0));
  cBlockArea::eMergeStrategy a_Strategy = ((cBlockArea::eMergeStrategy) (  int)  tolua_tonumber(tolua_S,6,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Merge'", nullptr);
#endif
  {
   self->Merge(*a_Src,a_RelX,a_RelY,a_RelZ,a_Strategy);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Merge'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Merge of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_Merge01
static int tolua_AllToLua_cBlockArea_Merge01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cBlockArea",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cBlockArea* self = (cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
  const cBlockArea* a_Src = ((const cBlockArea*)  tolua_tousertype(tolua_S,2,nullptr));
  const Vector3<int>* a_RelMinCoords = ((const Vector3<int>*)  tolua_tousertype(tolua_S,3,nullptr));
  cBlockArea::eMergeStrategy a_Strategy = ((cBlockArea::eMergeStrategy) (  int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Merge'", nullptr);
#endif
  {
   self->Merge(*a_Src,*a_RelMinCoords,a_Strategy);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cBlockArea_Merge00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: Fill of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_Fill00
static int tolua_AllToLua_cBlockArea_Fill00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBlockArea* self = (cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_DataTypes = ((int)  tolua_tonumber(tolua_S,2,0));
  unsigned char a_BlockType = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
  unsigned char a_BlockMeta = (( unsigned char)  tolua_tonumber(tolua_S,4,0));
  unsigned char a_BlockLight = (( unsigned char)  tolua_tonumber(tolua_S,5,0));
  unsigned char a_BlockSkyLight = (( unsigned char)  tolua_tonumber(tolua_S,6,0x0f));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Fill'", nullptr);
#endif
  {
   self->Fill(a_DataTypes,a_BlockType,a_BlockMeta,a_BlockLight,a_BlockSkyLight);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Fill'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: RotateCCW of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_RotateCCW00
static int tolua_AllToLua_cBlockArea_RotateCCW00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBlockArea* self = (cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'RotateCCW'", nullptr);
#endif
  {
   self->RotateCCW();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'RotateCCW'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: RotateCW of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_RotateCW00
static int tolua_AllToLua_cBlockArea_RotateCW00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBlockArea* self = (cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'RotateCW'", nullptr);
#endif
  {
   self->RotateCW();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'RotateCW'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: MirrorXY of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_MirrorXY00
static int tolua_AllToLua_cBlockArea_MirrorXY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBlockArea* self = (cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'MirrorXY'", nullptr);
#endif
  {
   self->MirrorXY();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'MirrorXY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: MirrorXZ of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_MirrorXZ00
static int tolua_AllToLua_cBlockArea_MirrorXZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBlockArea* self = (cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'MirrorXZ'", nullptr);
#endif
  {
   self->MirrorXZ();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'MirrorXZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: MirrorYZ of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_MirrorYZ00
static int tolua_AllToLua_cBlockArea_MirrorYZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBlockArea* self = (cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'MirrorYZ'", nullptr);
#endif
  {
   self->MirrorYZ();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'MirrorYZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: RotateCCWNoMeta of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_RotateCCWNoMeta00
static int tolua_AllToLua_cBlockArea_RotateCCWNoMeta00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBlockArea* self = (cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'RotateCCWNoMeta'", nullptr);
#endif
  {
   self->RotateCCWNoMeta();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'RotateCCWNoMeta'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: RotateCWNoMeta of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_RotateCWNoMeta00
static int tolua_AllToLua_cBlockArea_RotateCWNoMeta00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBlockArea* self = (cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'RotateCWNoMeta'", nullptr);
#endif
  {
   self->RotateCWNoMeta();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'RotateCWNoMeta'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: MirrorXYNoMeta of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_MirrorXYNoMeta00
static int tolua_AllToLua_cBlockArea_MirrorXYNoMeta00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBlockArea* self = (cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'MirrorXYNoMeta'", nullptr);
#endif
  {
   self->MirrorXYNoMeta();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'MirrorXYNoMeta'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: MirrorXZNoMeta of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_MirrorXZNoMeta00
static int tolua_AllToLua_cBlockArea_MirrorXZNoMeta00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBlockArea* self = (cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'MirrorXZNoMeta'", nullptr);
#endif
  {
   self->MirrorXZNoMeta();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'MirrorXZNoMeta'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: MirrorYZNoMeta of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_MirrorYZNoMeta00
static int tolua_AllToLua_cBlockArea_MirrorYZNoMeta00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBlockArea* self = (cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'MirrorYZNoMeta'", nullptr);
#endif
  {
   self->MirrorYZNoMeta();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'MirrorYZNoMeta'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetWEOffset of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_SetWEOffset00
static int tolua_AllToLua_cBlockArea_SetWEOffset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBlockArea* self = (cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_OffsetX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_OffsetY = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_OffsetZ = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetWEOffset'", nullptr);
#endif
  {
   self->SetWEOffset(a_OffsetX,a_OffsetY,a_OffsetZ);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetWEOffset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetWEOffset of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_SetWEOffset01
static int tolua_AllToLua_cBlockArea_SetWEOffset01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockArea",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cBlockArea* self = (cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<int>* a_Offset = ((const Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetWEOffset'", nullptr);
#endif
  {
   self->SetWEOffset(*a_Offset);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cBlockArea_SetWEOffset00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetWEOffset of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_GetWEOffset00
static int tolua_AllToLua_cBlockArea_GetWEOffset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockArea* self = (const cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetWEOffset'", nullptr);
#endif
  {
    const Vector3<int>& tolua_ret = (  const Vector3<int>&)  self->GetWEOffset();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Vector3<int>");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetWEOffset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetBounds of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_GetBounds00
static int tolua_AllToLua_cBlockArea_GetBounds00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockArea* self = (const cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetBounds'", nullptr);
#endif
  {
   cCuboid tolua_ret = (cCuboid)  self->GetBounds();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cCuboid)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cCuboid");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cCuboid));
     tolua_pushusertype(tolua_S,tolua_obj,"cCuboid");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetBounds'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSizeX of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_GetSizeX00
static int tolua_AllToLua_cBlockArea_GetSizeX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockArea* self = (const cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSizeX'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetSizeX();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSizeX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSizeY of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_GetSizeY00
static int tolua_AllToLua_cBlockArea_GetSizeY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockArea* self = (const cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSizeY'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetSizeY();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSizeY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSizeZ of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_GetSizeZ00
static int tolua_AllToLua_cBlockArea_GetSizeZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockArea* self = (const cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSizeZ'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetSizeZ();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSizeZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetVolume of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_GetVolume00
static int tolua_AllToLua_cBlockArea_GetVolume00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockArea* self = (const cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetVolume'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetVolume();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetVolume'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetOriginX of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_GetOriginX00
static int tolua_AllToLua_cBlockArea_GetOriginX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockArea* self = (const cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetOriginX'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetOriginX();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetOriginX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetOriginY of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_GetOriginY00
static int tolua_AllToLua_cBlockArea_GetOriginY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockArea* self = (const cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetOriginY'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetOriginY();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetOriginY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetOriginZ of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_GetOriginZ00
static int tolua_AllToLua_cBlockArea_GetOriginZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockArea* self = (const cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetOriginZ'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetOriginZ();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetOriginZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetDataTypes of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_GetDataTypes00
static int tolua_AllToLua_cBlockArea_GetDataTypes00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockArea* self = (const cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetDataTypes'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetDataTypes();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetDataTypes'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: HasBlockTypes of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_HasBlockTypes00
static int tolua_AllToLua_cBlockArea_HasBlockTypes00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockArea* self = (const cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HasBlockTypes'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->HasBlockTypes();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'HasBlockTypes'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: HasBlockMetas of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_HasBlockMetas00
static int tolua_AllToLua_cBlockArea_HasBlockMetas00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockArea* self = (const cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HasBlockMetas'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->HasBlockMetas();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'HasBlockMetas'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: HasBlockLights of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_HasBlockLights00
static int tolua_AllToLua_cBlockArea_HasBlockLights00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockArea* self = (const cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HasBlockLights'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->HasBlockLights();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'HasBlockLights'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: HasBlockSkyLights of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_HasBlockSkyLights00
static int tolua_AllToLua_cBlockArea_HasBlockSkyLights00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockArea* self = (const cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HasBlockSkyLights'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->HasBlockSkyLights();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'HasBlockSkyLights'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: HasBlockEntities of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_HasBlockEntities00
static int tolua_AllToLua_cBlockArea_HasBlockEntities00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockArea* self = (const cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HasBlockEntities'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->HasBlockEntities();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'HasBlockEntities'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CountNonAirBlocks of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_CountNonAirBlocks00
static int tolua_AllToLua_cBlockArea_CountNonAirBlocks00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockArea",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockArea* self = (const cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CountNonAirBlocks'", nullptr);
#endif
  {
   size_t tolua_ret = (size_t)  self->CountNonAirBlocks();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CountNonAirBlocks'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CountSpecificBlocks of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_CountSpecificBlocks00
static int tolua_AllToLua_cBlockArea_CountSpecificBlocks00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockArea",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockArea* self = (const cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
  unsigned char a_BlockType = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CountSpecificBlocks'", nullptr);
#endif
  {
   size_t tolua_ret = (size_t)  self->CountSpecificBlocks(a_BlockType);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CountSpecificBlocks'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CountSpecificBlocks of class  cBlockArea */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockArea_CountSpecificBlocks01
static int tolua_AllToLua_cBlockArea_CountSpecificBlocks01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockArea",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const cBlockArea* self = (const cBlockArea*)  tolua_tousertype(tolua_S,1,nullptr);
  unsigned char a_BlockType = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
  unsigned char a_BlockMeta = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CountSpecificBlocks'", nullptr);
#endif
  {
   size_t tolua_ret = (size_t)  self->CountSpecificBlocks(a_BlockType,a_BlockMeta);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cBlockArea_CountSpecificBlocks00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetChunkX of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_GetChunkX00
static int tolua_AllToLua_cChunkDesc_GetChunkX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cChunkDesc",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cChunkDesc* self = (const cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetChunkX'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetChunkX();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetChunkX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetChunkZ of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_GetChunkZ00
static int tolua_AllToLua_cChunkDesc_GetChunkZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cChunkDesc",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cChunkDesc* self = (const cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetChunkZ'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetChunkZ();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetChunkZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: FillBlocks of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_FillBlocks00
static int tolua_AllToLua_cChunkDesc_FillBlocks00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cChunkDesc",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cChunkDesc* self = (cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  unsigned char a_BlockType = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
  unsigned char a_BlockMeta = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'FillBlocks'", nullptr);
#endif
  {
   self->FillBlocks(a_BlockType,a_BlockMeta);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'FillBlocks'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetBlockTypeMeta of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_SetBlockTypeMeta00
static int tolua_AllToLua_cChunkDesc_SetBlockTypeMeta00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cChunkDesc",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cChunkDesc* self = (cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_RelX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_RelY = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_RelZ = ((int)  tolua_tonumber(tolua_S,4,0));
  unsigned char a_BlockType = (( unsigned char)  tolua_tonumber(tolua_S,5,0));
  unsigned char a_BlockMeta = (( unsigned char)  tolua_tonumber(tolua_S,6,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetBlockTypeMeta'", nullptr);
#endif
  {
   self->SetBlockTypeMeta(a_RelX,a_RelY,a_RelZ,a_BlockType,a_BlockMeta);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetBlockTypeMeta'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetBlockType of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_SetBlockType00
static int tolua_AllToLua_cChunkDesc_SetBlockType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cChunkDesc",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cChunkDesc* self = (cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_RelX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_RelY = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_RelZ = ((int)  tolua_tonumber(tolua_S,4,0));
  unsigned char a_BlockType = (( unsigned char)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetBlockType'", nullptr);
#endif
  {
   self->SetBlockType(a_RelX,a_RelY,a_RelZ,a_BlockType);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetBlockType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetBlockType of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_GetBlockType00
static int tolua_AllToLua_cChunkDesc_GetBlockType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cChunkDesc",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cChunkDesc* self = (const cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_RelX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_RelY = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_RelZ = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetBlockType'", nullptr);
#endif
  {
   unsigned char tolua_ret = ( unsigned char)  self->GetBlockType(a_RelX,a_RelY,a_RelZ);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetBlockType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetBlockMeta of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_SetBlockMeta00
static int tolua_AllToLua_cChunkDesc_SetBlockMeta00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cChunkDesc",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cChunkDesc* self = (cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_RelX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_RelY = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_RelZ = ((int)  tolua_tonumber(tolua_S,4,0));
  unsigned char a_BlockMeta = (( unsigned char)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetBlockMeta'", nullptr);
#endif
  {
   self->SetBlockMeta(a_RelX,a_RelY,a_RelZ,a_BlockMeta);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetBlockMeta'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetBlockMeta of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_GetBlockMeta00
static int tolua_AllToLua_cChunkDesc_GetBlockMeta00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cChunkDesc",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cChunkDesc* self = (const cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_RelX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_RelY = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_RelZ = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetBlockMeta'", nullptr);
#endif
  {
   unsigned char tolua_ret = ( unsigned char)  self->GetBlockMeta(a_RelX,a_RelY,a_RelZ);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetBlockMeta'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_isEMCSBiome (lua_State* L, int lo, int def, tolua_Error* err);
/* method: SetBiome of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_SetBiome00
static int tolua_AllToLua_cChunkDesc_SetBiome00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cChunkDesc",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isEMCSBiome(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cChunkDesc* self = (cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_RelX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_RelZ = ((int)  tolua_tonumber(tolua_S,3,0));
  EMCSBiome a_BiomeID = ((EMCSBiome) (  int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetBiome'", nullptr);
#endif
  {
   self->SetBiome(a_RelX,a_RelZ,a_BiomeID);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetBiome'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetBiome of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_GetBiome00
static int tolua_AllToLua_cChunkDesc_GetBiome00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cChunkDesc",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cChunkDesc* self = (const cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_RelX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_RelZ = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetBiome'", nullptr);
#endif
  {
   EMCSBiome tolua_ret = (EMCSBiome)  self->GetBiome(a_RelX,a_RelZ);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetBiome'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetHeight of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_SetHeight00
static int tolua_AllToLua_cChunkDesc_SetHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cChunkDesc",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cChunkDesc* self = (cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_RelX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_RelZ = ((int)  tolua_tonumber(tolua_S,3,0));
  unsigned char a_Height = (( unsigned char)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetHeight'", nullptr);
#endif
  {
   self->SetHeight(a_RelX,a_RelZ,a_Height);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetHeight of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_GetHeight00
static int tolua_AllToLua_cChunkDesc_GetHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cChunkDesc",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cChunkDesc* self = (const cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_RelX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_RelZ = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetHeight'", nullptr);
#endif
  {
   unsigned char tolua_ret = ( unsigned char)  self->GetHeight(a_RelX,a_RelZ);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetUseDefaultBiomes of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_SetUseDefaultBiomes00
static int tolua_AllToLua_cChunkDesc_SetUseDefaultBiomes00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cChunkDesc",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cChunkDesc* self = (cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_bUseDefaultBiomes = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetUseDefaultBiomes'", nullptr);
#endif
  {
   self->SetUseDefaultBiomes(a_bUseDefaultBiomes);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetUseDefaultBiomes'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsUsingDefaultBiomes of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_IsUsingDefaultBiomes00
static int tolua_AllToLua_cChunkDesc_IsUsingDefaultBiomes00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cChunkDesc",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cChunkDesc* self = (const cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsUsingDefaultBiomes'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsUsingDefaultBiomes();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsUsingDefaultBiomes'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetUseDefaultHeight of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_SetUseDefaultHeight00
static int tolua_AllToLua_cChunkDesc_SetUseDefaultHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cChunkDesc",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cChunkDesc* self = (cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_bUseDefaultHeight = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetUseDefaultHeight'", nullptr);
#endif
  {
   self->SetUseDefaultHeight(a_bUseDefaultHeight);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetUseDefaultHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsUsingDefaultHeight of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_IsUsingDefaultHeight00
static int tolua_AllToLua_cChunkDesc_IsUsingDefaultHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cChunkDesc",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cChunkDesc* self = (const cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsUsingDefaultHeight'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsUsingDefaultHeight();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsUsingDefaultHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetUseDefaultComposition of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_SetUseDefaultComposition00
static int tolua_AllToLua_cChunkDesc_SetUseDefaultComposition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cChunkDesc",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cChunkDesc* self = (cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_bUseDefaultComposition = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetUseDefaultComposition'", nullptr);
#endif
  {
   self->SetUseDefaultComposition(a_bUseDefaultComposition);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetUseDefaultComposition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsUsingDefaultComposition of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_IsUsingDefaultComposition00
static int tolua_AllToLua_cChunkDesc_IsUsingDefaultComposition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cChunkDesc",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cChunkDesc* self = (const cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsUsingDefaultComposition'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsUsingDefaultComposition();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsUsingDefaultComposition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetUseDefaultFinish of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_SetUseDefaultFinish00
static int tolua_AllToLua_cChunkDesc_SetUseDefaultFinish00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cChunkDesc",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cChunkDesc* self = (cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_bUseDefaultFinish = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetUseDefaultFinish'", nullptr);
#endif
  {
   self->SetUseDefaultFinish(a_bUseDefaultFinish);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetUseDefaultFinish'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsUsingDefaultFinish of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_IsUsingDefaultFinish00
static int tolua_AllToLua_cChunkDesc_IsUsingDefaultFinish00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cChunkDesc",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cChunkDesc* self = (const cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsUsingDefaultFinish'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsUsingDefaultFinish();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsUsingDefaultFinish'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: WriteBlockArea of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_WriteBlockArea00
static int tolua_AllToLua_cChunkDesc_WriteBlockArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cChunkDesc",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cBlockArea",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cChunkDesc* self = (cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  const cBlockArea* a_BlockArea = ((const cBlockArea*)  tolua_tousertype(tolua_S,2,nullptr));
  int a_RelX = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_RelY = ((int)  tolua_tonumber(tolua_S,4,0));
  int a_RelZ = ((int)  tolua_tonumber(tolua_S,5,0));
  cBlockArea::eMergeStrategy a_MergeStrategy = ((cBlockArea::eMergeStrategy) (  int)  tolua_tonumber(tolua_S,6,cBlockArea::msOverwrite));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'WriteBlockArea'", nullptr);
#endif
  {
   self->WriteBlockArea(*a_BlockArea,a_RelX,a_RelY,a_RelZ,a_MergeStrategy);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'WriteBlockArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ReadBlockArea of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_ReadBlockArea00
static int tolua_AllToLua_cChunkDesc_ReadBlockArea00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cChunkDesc",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cBlockArea",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,8,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,9,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cChunkDesc* self = (cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  cBlockArea* a_Dest = ((cBlockArea*)  tolua_tousertype(tolua_S,2,nullptr));
  int a_MinRelX = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_MaxRelX = ((int)  tolua_tonumber(tolua_S,4,0));
  int a_MinRelY = ((int)  tolua_tonumber(tolua_S,5,0));
  int a_MaxRelY = ((int)  tolua_tonumber(tolua_S,6,0));
  int a_MinRelZ = ((int)  tolua_tonumber(tolua_S,7,0));
  int a_MaxRelZ = ((int)  tolua_tonumber(tolua_S,8,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ReadBlockArea'", nullptr);
#endif
  {
   self->ReadBlockArea(*a_Dest,a_MinRelX,a_MaxRelX,a_MinRelY,a_MaxRelY,a_MinRelZ,a_MaxRelZ);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ReadBlockArea'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMaxHeight of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_GetMaxHeight00
static int tolua_AllToLua_cChunkDesc_GetMaxHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cChunkDesc",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cChunkDesc* self = (const cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMaxHeight'", nullptr);
#endif
  {
   unsigned char tolua_ret = ( unsigned char)  self->GetMaxHeight();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMaxHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMinHeight of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_GetMinHeight00
static int tolua_AllToLua_cChunkDesc_GetMinHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cChunkDesc",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cChunkDesc* self = (const cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMinHeight'", nullptr);
#endif
  {
   unsigned char tolua_ret = ( unsigned char)  self->GetMinHeight();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMinHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: FillRelCuboid of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_FillRelCuboid00
static int tolua_AllToLua_cChunkDesc_FillRelCuboid00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cChunkDesc",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,8,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,9,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,10,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cChunkDesc* self = (cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_MinX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_MaxX = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_MinY = ((int)  tolua_tonumber(tolua_S,4,0));
  int a_MaxY = ((int)  tolua_tonumber(tolua_S,5,0));
  int a_MinZ = ((int)  tolua_tonumber(tolua_S,6,0));
  int a_MaxZ = ((int)  tolua_tonumber(tolua_S,7,0));
  unsigned char a_BlockType = (( unsigned char)  tolua_tonumber(tolua_S,8,0));
  unsigned char a_BlockMeta = (( unsigned char)  tolua_tonumber(tolua_S,9,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'FillRelCuboid'", nullptr);
#endif
  {
   self->FillRelCuboid(a_MinX,a_MaxX,a_MinY,a_MaxY,a_MinZ,a_MaxZ,a_BlockType,a_BlockMeta);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'FillRelCuboid'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: FillRelCuboid of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_FillRelCuboid01
static int tolua_AllToLua_cChunkDesc_FillRelCuboid01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cChunkDesc",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cCuboid",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cChunkDesc* self = (cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  const cCuboid* a_RelCuboid = ((const cCuboid*)  tolua_tousertype(tolua_S,2,nullptr));
  unsigned char a_BlockType = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
  unsigned char a_BlockMeta = (( unsigned char)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'FillRelCuboid'", nullptr);
#endif
  {
   self->FillRelCuboid(*a_RelCuboid,a_BlockType,a_BlockMeta);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cChunkDesc_FillRelCuboid00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: ReplaceRelCuboid of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_ReplaceRelCuboid00
static int tolua_AllToLua_cChunkDesc_ReplaceRelCuboid00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cChunkDesc",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,8,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,9,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,10,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,11,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,12,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cChunkDesc* self = (cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_MinX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_MaxX = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_MinY = ((int)  tolua_tonumber(tolua_S,4,0));
  int a_MaxY = ((int)  tolua_tonumber(tolua_S,5,0));
  int a_MinZ = ((int)  tolua_tonumber(tolua_S,6,0));
  int a_MaxZ = ((int)  tolua_tonumber(tolua_S,7,0));
  unsigned char a_SrcType = (( unsigned char)  tolua_tonumber(tolua_S,8,0));
  unsigned char a_SrcMeta = (( unsigned char)  tolua_tonumber(tolua_S,9,0));
  unsigned char a_DstType = (( unsigned char)  tolua_tonumber(tolua_S,10,0));
  unsigned char a_DstMeta = (( unsigned char)  tolua_tonumber(tolua_S,11,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ReplaceRelCuboid'", nullptr);
#endif
  {
   self->ReplaceRelCuboid(a_MinX,a_MaxX,a_MinY,a_MaxY,a_MinZ,a_MaxZ,a_SrcType,a_SrcMeta,a_DstType,a_DstMeta);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ReplaceRelCuboid'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ReplaceRelCuboid of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_ReplaceRelCuboid01
static int tolua_AllToLua_cChunkDesc_ReplaceRelCuboid01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cChunkDesc",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cCuboid",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cChunkDesc* self = (cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  const cCuboid* a_RelCuboid = ((const cCuboid*)  tolua_tousertype(tolua_S,2,nullptr));
  unsigned char a_SrcType = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
  unsigned char a_SrcMeta = (( unsigned char)  tolua_tonumber(tolua_S,4,0));
  unsigned char a_DstType = (( unsigned char)  tolua_tonumber(tolua_S,5,0));
  unsigned char a_DstMeta = (( unsigned char)  tolua_tonumber(tolua_S,6,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ReplaceRelCuboid'", nullptr);
#endif
  {
   self->ReplaceRelCuboid(*a_RelCuboid,a_SrcType,a_SrcMeta,a_DstType,a_DstMeta);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cChunkDesc_ReplaceRelCuboid00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: FloorRelCuboid of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_FloorRelCuboid00
static int tolua_AllToLua_cChunkDesc_FloorRelCuboid00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cChunkDesc",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,8,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,9,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,10,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cChunkDesc* self = (cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_MinX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_MaxX = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_MinY = ((int)  tolua_tonumber(tolua_S,4,0));
  int a_MaxY = ((int)  tolua_tonumber(tolua_S,5,0));
  int a_MinZ = ((int)  tolua_tonumber(tolua_S,6,0));
  int a_MaxZ = ((int)  tolua_tonumber(tolua_S,7,0));
  unsigned char a_DstType = (( unsigned char)  tolua_tonumber(tolua_S,8,0));
  unsigned char a_DstMeta = (( unsigned char)  tolua_tonumber(tolua_S,9,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'FloorRelCuboid'", nullptr);
#endif
  {
   self->FloorRelCuboid(a_MinX,a_MaxX,a_MinY,a_MaxY,a_MinZ,a_MaxZ,a_DstType,a_DstMeta);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'FloorRelCuboid'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: FloorRelCuboid of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_FloorRelCuboid01
static int tolua_AllToLua_cChunkDesc_FloorRelCuboid01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cChunkDesc",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cCuboid",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cChunkDesc* self = (cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  const cCuboid* a_RelCuboid = ((const cCuboid*)  tolua_tousertype(tolua_S,2,nullptr));
  unsigned char a_DstType = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
  unsigned char a_DstMeta = (( unsigned char)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'FloorRelCuboid'", nullptr);
#endif
  {
   self->FloorRelCuboid(*a_RelCuboid,a_DstType,a_DstMeta);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cChunkDesc_FloorRelCuboid00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: RandomFillRelCuboid of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_RandomFillRelCuboid00
static int tolua_AllToLua_cChunkDesc_RandomFillRelCuboid00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cChunkDesc",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,8,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,9,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,10,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,11,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,12,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cChunkDesc* self = (cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_MinX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_MaxX = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_MinY = ((int)  tolua_tonumber(tolua_S,4,0));
  int a_MaxY = ((int)  tolua_tonumber(tolua_S,5,0));
  int a_MinZ = ((int)  tolua_tonumber(tolua_S,6,0));
  int a_MaxZ = ((int)  tolua_tonumber(tolua_S,7,0));
  unsigned char a_BlockType = (( unsigned char)  tolua_tonumber(tolua_S,8,0));
  unsigned char a_BlockMeta = (( unsigned char)  tolua_tonumber(tolua_S,9,0));
  int a_RandomSeed = ((int)  tolua_tonumber(tolua_S,10,0));
  int a_ChanceOutOf10k = ((int)  tolua_tonumber(tolua_S,11,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'RandomFillRelCuboid'", nullptr);
#endif
  {
   self->RandomFillRelCuboid(a_MinX,a_MaxX,a_MinY,a_MaxY,a_MinZ,a_MaxZ,a_BlockType,a_BlockMeta,a_RandomSeed,a_ChanceOutOf10k);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'RandomFillRelCuboid'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: RandomFillRelCuboid of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_RandomFillRelCuboid01
static int tolua_AllToLua_cChunkDesc_RandomFillRelCuboid01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cChunkDesc",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cCuboid",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cChunkDesc* self = (cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  const cCuboid* a_RelCuboid = ((const cCuboid*)  tolua_tousertype(tolua_S,2,nullptr));
  unsigned char a_BlockType = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
  unsigned char a_BlockMeta = (( unsigned char)  tolua_tonumber(tolua_S,4,0));
  int a_RandomSeed = ((int)  tolua_tonumber(tolua_S,5,0));
  int a_ChanceOutOf10k = ((int)  tolua_tonumber(tolua_S,6,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'RandomFillRelCuboid'", nullptr);
#endif
  {
   self->RandomFillRelCuboid(*a_RelCuboid,a_BlockType,a_BlockMeta,a_RandomSeed,a_ChanceOutOf10k);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cChunkDesc_RandomFillRelCuboid00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetBlockEntity of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_GetBlockEntity00
static int tolua_AllToLua_cChunkDesc_GetBlockEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cChunkDesc",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cChunkDesc* self = (cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_RelX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_RelY = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_RelZ = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetBlockEntity'", nullptr);
#endif
  {
   cBlockEntity* tolua_ret = (cBlockEntity*)  self->GetBlockEntity(a_RelX,a_RelY,a_RelZ);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cBlockEntity");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetBlockEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: UpdateHeightmap of class  cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_UpdateHeightmap00
static int tolua_AllToLua_cChunkDesc_UpdateHeightmap00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cChunkDesc",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cChunkDesc* self = (cChunkDesc*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'UpdateHeightmap'", nullptr);
#endif
  {
   self->UpdateHeightmap();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'UpdateHeightmap'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  cCraftingGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCraftingGrid_new00
static int tolua_AllToLua_cCraftingGrid_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cCraftingGrid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  int a_Width = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_Height = ((int)  tolua_tonumber(tolua_S,3,0));
  {
   cCraftingGrid* tolua_ret = (cCraftingGrid*)  Mtolua_new((cCraftingGrid)(a_Width,a_Height));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cCraftingGrid");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cCraftingGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCraftingGrid_new00_local
static int tolua_AllToLua_cCraftingGrid_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cCraftingGrid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  int a_Width = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_Height = ((int)  tolua_tonumber(tolua_S,3,0));
  {
   cCraftingGrid* tolua_ret = (cCraftingGrid*)  Mtolua_new((cCraftingGrid)(a_Width,a_Height));
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cCraftingGrid");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetWidth of class  cCraftingGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCraftingGrid_GetWidth00
static int tolua_AllToLua_cCraftingGrid_GetWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cCraftingGrid",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cCraftingGrid* self = (const cCraftingGrid*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetWidth'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetWidth();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetHeight of class  cCraftingGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCraftingGrid_GetHeight00
static int tolua_AllToLua_cCraftingGrid_GetHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cCraftingGrid",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cCraftingGrid* self = (const cCraftingGrid*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetHeight'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetHeight();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetItem of class  cCraftingGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCraftingGrid_GetItem00
static int tolua_AllToLua_cCraftingGrid_GetItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cCraftingGrid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cCraftingGrid* self = (const cCraftingGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  int x = ((int)  tolua_tonumber(tolua_S,2,0));
  int y = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetItem'", nullptr);
#endif
  {
   cItem& tolua_ret = (cItem&)  self->GetItem(x,y);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_isENUM_ITEM_TYPE (lua_State* L, int lo, int def, tolua_Error* err);
/* method: SetItem of class  cCraftingGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCraftingGrid_SetItem00
static int tolua_AllToLua_cCraftingGrid_SetItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cCraftingGrid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isENUM_ITEM_TYPE(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cCraftingGrid* self = (cCraftingGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  int x = ((int)  tolua_tonumber(tolua_S,2,0));
  int y = ((int)  tolua_tonumber(tolua_S,3,0));
  ENUM_ITEM_TYPE a_ItemType = ((ENUM_ITEM_TYPE) (  short)  tolua_tonumber(tolua_S,4,0));
  char a_ItemCount = ((char)  tolua_tonumber(tolua_S,5,0));
  short a_ItemHealth = ((short)  tolua_tonumber(tolua_S,6,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetItem'", nullptr);
#endif
  {
   self->SetItem(x,y,a_ItemType,a_ItemCount,a_ItemHealth);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetItem of class  cCraftingGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCraftingGrid_SetItem01
static int tolua_AllToLua_cCraftingGrid_SetItem01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cCraftingGrid",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cCraftingGrid* self = (cCraftingGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  int x = ((int)  tolua_tonumber(tolua_S,2,0));
  int y = ((int)  tolua_tonumber(tolua_S,3,0));
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,4,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetItem'", nullptr);
#endif
  {
   self->SetItem(x,y,*a_Item);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cCraftingGrid_SetItem00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: Clear of class  cCraftingGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCraftingGrid_Clear00
static int tolua_AllToLua_cCraftingGrid_Clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cCraftingGrid",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cCraftingGrid* self = (cCraftingGrid*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Clear'", nullptr);
#endif
  {
   self->Clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ConsumeGrid of class  cCraftingGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCraftingGrid_ConsumeGrid00
static int tolua_AllToLua_cCraftingGrid_ConsumeGrid00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cCraftingGrid",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cCraftingGrid",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cCraftingGrid* self = (cCraftingGrid*)  tolua_tousertype(tolua_S,1,nullptr);
  const cCraftingGrid* a_Grid = ((const cCraftingGrid*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ConsumeGrid'", nullptr);
#endif
  {
   self->ConsumeGrid(*a_Grid);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ConsumeGrid'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Dump of class  cCraftingGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCraftingGrid_Dump00
static int tolua_AllToLua_cCraftingGrid_Dump00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cCraftingGrid",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cCraftingGrid* self = (cCraftingGrid*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Dump'", nullptr);
#endif
  {
   self->Dump();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Dump'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Clear of class  cCraftingRecipe */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCraftingRecipe_Clear00
static int tolua_AllToLua_cCraftingRecipe_Clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cCraftingRecipe",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cCraftingRecipe* self = (cCraftingRecipe*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Clear'", nullptr);
#endif
  {
   self->Clear();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Clear'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetIngredientsWidth of class  cCraftingRecipe */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCraftingRecipe_GetIngredientsWidth00
static int tolua_AllToLua_cCraftingRecipe_GetIngredientsWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cCraftingRecipe",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cCraftingRecipe* self = (const cCraftingRecipe*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetIngredientsWidth'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetIngredientsWidth();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetIngredientsWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetIngredientsHeight of class  cCraftingRecipe */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCraftingRecipe_GetIngredientsHeight00
static int tolua_AllToLua_cCraftingRecipe_GetIngredientsHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cCraftingRecipe",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cCraftingRecipe* self = (const cCraftingRecipe*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetIngredientsHeight'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetIngredientsHeight();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetIngredientsHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetIngredient of class  cCraftingRecipe */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCraftingRecipe_GetIngredient00
static int tolua_AllToLua_cCraftingRecipe_GetIngredient00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cCraftingRecipe",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cCraftingRecipe* self = (const cCraftingRecipe*)  tolua_tousertype(tolua_S,1,nullptr);
  int x = ((int)  tolua_tonumber(tolua_S,2,0));
  int y = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetIngredient'", nullptr);
#endif
  {
   cItem& tolua_ret = (cItem&)  self->GetIngredient(x,y);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetIngredient'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetResult of class  cCraftingRecipe */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCraftingRecipe_GetResult00
static int tolua_AllToLua_cCraftingRecipe_GetResult00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cCraftingRecipe",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cCraftingRecipe* self = (const cCraftingRecipe*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetResult'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetResult();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetResult'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_isENUM_ITEM_TYPE (lua_State* L, int lo, int def, tolua_Error* err);
/* method: SetResult of class  cCraftingRecipe */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCraftingRecipe_SetResult00
static int tolua_AllToLua_cCraftingRecipe_SetResult00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cCraftingRecipe",0,&tolua_err) ||
     !tolua_isENUM_ITEM_TYPE(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cCraftingRecipe* self = (cCraftingRecipe*)  tolua_tousertype(tolua_S,1,nullptr);
  ENUM_ITEM_TYPE a_ItemType = ((ENUM_ITEM_TYPE) (  short)  tolua_tonumber(tolua_S,2,0));
  char a_ItemCount = ((char)  tolua_tonumber(tolua_S,3,0));
  short a_ItemHealth = ((short)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetResult'", nullptr);
#endif
  {
   self->SetResult(a_ItemType,a_ItemCount,a_ItemHealth);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetResult'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetResult of class  cCraftingRecipe */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCraftingRecipe_SetResult01
static int tolua_AllToLua_cCraftingRecipe_SetResult01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cCraftingRecipe",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cCraftingRecipe* self = (cCraftingRecipe*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetResult'", nullptr);
#endif
  {
   self->SetResult(*a_Item);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cCraftingRecipe_SetResult00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_isENUM_ITEM_TYPE (lua_State* L, int lo, int def, tolua_Error* err);
/* method: SetIngredient of class  cCraftingRecipe */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCraftingRecipe_SetIngredient00
static int tolua_AllToLua_cCraftingRecipe_SetIngredient00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cCraftingRecipe",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isENUM_ITEM_TYPE(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cCraftingRecipe* self = (cCraftingRecipe*)  tolua_tousertype(tolua_S,1,nullptr);
  int x = ((int)  tolua_tonumber(tolua_S,2,0));
  int y = ((int)  tolua_tonumber(tolua_S,3,0));
  ENUM_ITEM_TYPE a_ItemType = ((ENUM_ITEM_TYPE) (  short)  tolua_tonumber(tolua_S,4,0));
  char a_ItemCount = ((char)  tolua_tonumber(tolua_S,5,0));
  short a_ItemHealth = ((short)  tolua_tonumber(tolua_S,6,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetIngredient'", nullptr);
#endif
  {
   self->SetIngredient(x,y,a_ItemType,a_ItemCount,a_ItemHealth);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetIngredient'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetIngredient of class  cCraftingRecipe */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCraftingRecipe_SetIngredient01
static int tolua_AllToLua_cCraftingRecipe_SetIngredient01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cCraftingRecipe",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cCraftingRecipe* self = (cCraftingRecipe*)  tolua_tousertype(tolua_S,1,nullptr);
  int x = ((int)  tolua_tonumber(tolua_S,2,0));
  int y = ((int)  tolua_tonumber(tolua_S,3,0));
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,4,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetIngredient'", nullptr);
#endif
  {
   self->SetIngredient(x,y,*a_Item);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cCraftingRecipe_SetIngredient00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: ConsumeIngredients of class  cCraftingRecipe */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCraftingRecipe_ConsumeIngredients00
static int tolua_AllToLua_cCraftingRecipe_ConsumeIngredients00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cCraftingRecipe",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cCraftingGrid",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cCraftingRecipe* self = (cCraftingRecipe*)  tolua_tousertype(tolua_S,1,nullptr);
  cCraftingGrid* a_CraftingGrid = ((cCraftingGrid*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ConsumeIngredients'", nullptr);
#endif
  {
   self->ConsumeIngredients(*a_CraftingGrid);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ConsumeIngredients'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Dump of class  cCraftingRecipe */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCraftingRecipe_Dump00
static int tolua_AllToLua_cCraftingRecipe_Dump00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cCraftingRecipe",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cCraftingRecipe* self = (cCraftingRecipe*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Dump'", nullptr);
#endif
  {
   self->Dump();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Dump'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_isWindowType (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= -1.0 && val <= 11.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "WindowType";
	return 0;
}
/* method: GetWindowID of class  cWindow */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWindow_GetWindowID00
static int tolua_AllToLua_cWindow_GetWindowID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWindow",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWindow* self = (const cWindow*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetWindowID'", nullptr);
#endif
  {
   char tolua_ret = (char)  self->GetWindowID();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetWindowID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetWindowType of class  cWindow */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWindow_GetWindowType00
static int tolua_AllToLua_cWindow_GetWindowType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWindow",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWindow* self = (const cWindow*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetWindowType'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetWindowType();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetWindowType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetWindowTypeName of class  cWindow */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWindow_GetWindowTypeName00
static int tolua_AllToLua_cWindow_GetWindowTypeName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWindow",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWindow* self = (const cWindow*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetWindowTypeName'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetWindowTypeName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetWindowTypeName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSlot of class  cWindow */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWindow_GetSlot00
static int tolua_AllToLua_cWindow_GetSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWindow",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cPlayer",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWindow* self = (const cWindow*)  tolua_tousertype(tolua_S,1,nullptr);
  cPlayer* a_Player = ((cPlayer*)  tolua_tousertype(tolua_S,2,nullptr));
  int a_SlotNum = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSlot'", nullptr);
#endif
  {
   const cItem* tolua_ret = (const cItem*)  self->GetSlot(*a_Player,a_SlotNum);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSlot of class  cWindow */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWindow_SetSlot00
static int tolua_AllToLua_cWindow_SetSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWindow",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cPlayer",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWindow* self = (cWindow*)  tolua_tousertype(tolua_S,1,nullptr);
  cPlayer* a_Player = ((cPlayer*)  tolua_tousertype(tolua_S,2,nullptr));
  int a_SlotNum = ((int)  tolua_tonumber(tolua_S,3,0));
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,4,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSlot'", nullptr);
#endif
  {
   self->SetSlot(*a_Player,a_SlotNum,*a_Item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsSlotInPlayerMainInventory of class  cWindow */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWindow_IsSlotInPlayerMainInventory00
static int tolua_AllToLua_cWindow_IsSlotInPlayerMainInventory00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWindow",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWindow* self = (const cWindow*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_SlotNum = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsSlotInPlayerMainInventory'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsSlotInPlayerMainInventory(a_SlotNum);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsSlotInPlayerMainInventory'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsSlotInPlayerHotbar of class  cWindow */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWindow_IsSlotInPlayerHotbar00
static int tolua_AllToLua_cWindow_IsSlotInPlayerHotbar00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWindow",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWindow* self = (const cWindow*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_SlotNum = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsSlotInPlayerHotbar'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsSlotInPlayerHotbar(a_SlotNum);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsSlotInPlayerHotbar'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsSlotInPlayerInventory of class  cWindow */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWindow_IsSlotInPlayerInventory00
static int tolua_AllToLua_cWindow_IsSlotInPlayerInventory00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWindow",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWindow* self = (const cWindow*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_SlotNum = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsSlotInPlayerInventory'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsSlotInPlayerInventory(a_SlotNum);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsSlotInPlayerInventory'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetWindowTitle of class  cWindow */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWindow_GetWindowTitle00
static int tolua_AllToLua_cWindow_GetWindowTitle00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cWindow",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cWindow* self = (const cWindow*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetWindowTitle'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetWindowTitle();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetWindowTitle'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetWindowTitle of class  cWindow */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWindow_SetWindowTitle00
static int tolua_AllToLua_cWindow_SetWindowTitle00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWindow",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWindow* self = (cWindow*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_WindowTitle = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetWindowTitle'", nullptr);
#endif
  {
   self->SetWindowTitle(a_WindowTitle);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetWindowTitle'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetProperty of class  cWindow */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cWindow_SetProperty00
static int tolua_AllToLua_cWindow_SetProperty00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cWindow",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWindow* self = (cWindow*)  tolua_tousertype(tolua_S,1,nullptr);
  size_t a_Property = ((size_t)  tolua_tonumber(tolua_S,2,0));
  short a_Value = ((short)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetProperty'", nullptr);
#endif
  {
   self->SetProperty(a_Property,a_Value);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetProperty'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMessageType of class  cCompositeChat */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCompositeChat_GetMessageType00
static int tolua_AllToLua_cCompositeChat_GetMessageType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cCompositeChat",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cCompositeChat* self = (const cCompositeChat*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMessageType'", nullptr);
#endif
  {
   eMessageType tolua_ret = (eMessageType)  self->GetMessageType();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMessageType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetAdditionalMessageTypeData of class  cCompositeChat */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCompositeChat_GetAdditionalMessageTypeData00
static int tolua_AllToLua_cCompositeChat_GetAdditionalMessageTypeData00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cCompositeChat",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cCompositeChat* self = (const cCompositeChat*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetAdditionalMessageTypeData'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetAdditionalMessageTypeData();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetAdditionalMessageTypeData'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ExtractText of class  cCompositeChat */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCompositeChat_ExtractText00
static int tolua_AllToLua_cCompositeChat_ExtractText00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cCompositeChat",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cCompositeChat* self = (const cCompositeChat*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ExtractText'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->ExtractText();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ExtractText'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CreateJsonString of class  cCompositeChat */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCompositeChat_CreateJsonString00
static int tolua_AllToLua_cCompositeChat_CreateJsonString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cCompositeChat",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cCompositeChat* self = (const cCompositeChat*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_ShouldUseChatPrefixes = ((bool)  tolua_toboolean(tolua_S,2,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CreateJsonString'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->CreateJsonString(a_ShouldUseChatPrefixes);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CreateJsonString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseBaseColor (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 52.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eBaseColor";
	return 0;
}
/* method: Resize of class  cMap */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMap_Resize00
static int tolua_AllToLua_cMap_Resize00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMap",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMap* self = (cMap*)  tolua_tousertype(tolua_S,1,nullptr);
  unsigned int a_Width = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
  unsigned int a_Height = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Resize'", nullptr);
#endif
  {
   self->Resize(a_Width,a_Height);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Resize'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetPosition of class  cMap */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMap_SetPosition00
static int tolua_AllToLua_cMap_SetPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMap",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMap* self = (cMap*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_CenterX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_CenterZ = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetPosition'", nullptr);
#endif
  {
   self->SetPosition(a_CenterX,a_CenterZ);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetScale of class  cMap */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMap_SetScale00
static int tolua_AllToLua_cMap_SetScale00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMap",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMap* self = (cMap*)  tolua_tousertype(tolua_S,1,nullptr);
  unsigned int a_Scale = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetScale'", nullptr);
#endif
  {
   self->SetScale(a_Scale);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetScale'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetPixel of class  cMap */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMap_SetPixel00
static int tolua_AllToLua_cMap_SetPixel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMap",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMap* self = (cMap*)  tolua_tousertype(tolua_S,1,nullptr);
  unsigned int a_X = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
  unsigned int a_Z = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
   Byte a_Data = ((  Byte)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetPixel'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->SetPixel(a_X,a_Z,a_Data);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetPixel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPixel of class  cMap */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMap_GetPixel00
static int tolua_AllToLua_cMap_GetPixel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMap",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMap* self = (cMap*)  tolua_tousertype(tolua_S,1,nullptr);
  unsigned int a_X = ((unsigned int)  tolua_tonumber(tolua_S,2,0));
  unsigned int a_Z = ((unsigned int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPixel'", nullptr);
#endif
  {
    Byte tolua_ret = (  Byte)  self->GetPixel(a_X,a_Z);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPixel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetWidth of class  cMap */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMap_GetWidth00
static int tolua_AllToLua_cMap_GetWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMap",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMap* self = (const cMap*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetWidth'", nullptr);
#endif
  {
   unsigned int tolua_ret = (unsigned int)  self->GetWidth();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetHeight of class  cMap */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMap_GetHeight00
static int tolua_AllToLua_cMap_GetHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMap",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMap* self = (const cMap*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetHeight'", nullptr);
#endif
  {
   unsigned int tolua_ret = (unsigned int)  self->GetHeight();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetScale of class  cMap */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMap_GetScale00
static int tolua_AllToLua_cMap_GetScale00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMap",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMap* self = (const cMap*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetScale'", nullptr);
#endif
  {
   unsigned int tolua_ret = (unsigned int)  self->GetScale();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetScale'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetCenterX of class  cMap */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMap_GetCenterX00
static int tolua_AllToLua_cMap_GetCenterX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMap",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMap* self = (const cMap*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetCenterX'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetCenterX();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetCenterX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetCenterZ of class  cMap */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMap_GetCenterZ00
static int tolua_AllToLua_cMap_GetCenterZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMap",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMap* self = (const cMap*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetCenterZ'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetCenterZ();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetCenterZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetID of class  cMap */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMap_GetID00
static int tolua_AllToLua_cMap_GetID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMap",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMap* self = (const cMap*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetID'", nullptr);
#endif
  {
   unsigned int tolua_ret = (unsigned int)  self->GetID();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetWorld of class  cMap */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMap_GetWorld00
static int tolua_AllToLua_cMap_GetWorld00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMap",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMap* self = (cMap*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetWorld'", nullptr);
#endif
  {
   cWorld* tolua_ret = (cWorld*)  self->GetWorld();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cWorld");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetWorld'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetName of class  cMap */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMap_GetName00
static int tolua_AllToLua_cMap_GetName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMap",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMap* self = (cMap*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetName'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetDimension of class  cMap */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMap_GetDimension00
static int tolua_AllToLua_cMap_GetDimension00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMap",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMap* self = (const cMap*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetDimension'", nullptr);
#endif
  {
   eDimension tolua_ret = (eDimension)  self->GetDimension();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetDimension'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNumPixels of class  cMap */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMap_GetNumPixels00
static int tolua_AllToLua_cMap_GetNumPixels00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMap",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMap* self = (const cMap*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumPixels'", nullptr);
#endif
  {
   unsigned int tolua_ret = (unsigned int)  self->GetNumPixels();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetNumPixels'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPixelWidth of class  cMap */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMap_GetPixelWidth00
static int tolua_AllToLua_cMap_GetPixelWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMap",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMap* self = (const cMap*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPixelWidth'", nullptr);
#endif
  {
   unsigned int tolua_ret = (unsigned int)  self->GetPixelWidth();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPixelWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseType (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 12.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eType";
	return 0;
}
/* method: GetType of class  cObjective */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cObjective_GetType00
static int tolua_AllToLua_cObjective_GetType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cObjective",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cObjective* self = (const cObjective*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetType'", nullptr);
#endif
  {
   cObjective::eType tolua_ret = (cObjective::eType)  self->GetType();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetName of class  cObjective */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cObjective_GetName00
static int tolua_AllToLua_cObjective_GetName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cObjective",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cObjective* self = (const cObjective*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetName'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetDisplayName of class  cObjective */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cObjective_GetDisplayName00
static int tolua_AllToLua_cObjective_GetDisplayName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cObjective",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cObjective* self = (const cObjective*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetDisplayName'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetDisplayName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetDisplayName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Reset of class  cObjective */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cObjective_Reset00
static int tolua_AllToLua_cObjective_Reset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cObjective",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cObjective* self = (cObjective*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Reset'", nullptr);
#endif
  {
   self->Reset();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Reset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetScore of class  cObjective */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cObjective_GetScore00
static int tolua_AllToLua_cObjective_GetScore00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cObjective",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cObjective* self = (const cObjective*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Name = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetScore'", nullptr);
#endif
  {
    int tolua_ret = (  int)  self->GetScore(a_Name);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetScore'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetScore of class  cObjective */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cObjective_SetScore00
static int tolua_AllToLua_cObjective_SetScore00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cObjective",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cObjective* self = (cObjective*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Name = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
   int a_Score = ((  int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetScore'", nullptr);
#endif
  {
   self->SetScore(a_Name,a_Score);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetScore'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ResetScore of class  cObjective */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cObjective_ResetScore00
static int tolua_AllToLua_cObjective_ResetScore00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cObjective",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cObjective* self = (cObjective*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Name = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ResetScore'", nullptr);
#endif
  {
   self->ResetScore(a_Name);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ResetScore'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddScore of class  cObjective */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cObjective_AddScore00
static int tolua_AllToLua_cObjective_AddScore00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cObjective",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cObjective* self = (cObjective*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Name = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
   int a_Delta = ((  int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddScore'", nullptr);
#endif
  {
    int tolua_ret = (  int)  self->AddScore(a_Name,a_Delta);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddScore'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SubScore of class  cObjective */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cObjective_SubScore00
static int tolua_AllToLua_cObjective_SubScore00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cObjective",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cObjective* self = (cObjective*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Name = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
   int a_Delta = ((  int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SubScore'", nullptr);
#endif
  {
    int tolua_ret = (  int)  self->SubScore(a_Name,a_Delta);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SubScore'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetDisplayName of class  cObjective */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cObjective_SetDisplayName00
static int tolua_AllToLua_cObjective_SetDisplayName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cObjective",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cObjective* self = (cObjective*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Name = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetDisplayName'", nullptr);
#endif
  {
   self->SetDisplayName(a_Name);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetDisplayName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddPlayer of class  cTeam */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cTeam_AddPlayer00
static int tolua_AllToLua_cTeam_AddPlayer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cTeam",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cTeam* self = (cTeam*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Name = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddPlayer'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->AddPlayer(a_Name);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddPlayer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: RemovePlayer of class  cTeam */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cTeam_RemovePlayer00
static int tolua_AllToLua_cTeam_RemovePlayer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cTeam",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cTeam* self = (cTeam*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Name = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'RemovePlayer'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->RemovePlayer(a_Name);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'RemovePlayer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: HasPlayer of class  cTeam */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cTeam_HasPlayer00
static int tolua_AllToLua_cTeam_HasPlayer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cTeam",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cTeam* self = (const cTeam*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Name = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HasPlayer'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->HasPlayer(a_Name);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'HasPlayer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Reset of class  cTeam */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cTeam_Reset00
static int tolua_AllToLua_cTeam_Reset00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cTeam",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cTeam* self = (cTeam*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Reset'", nullptr);
#endif
  {
   self->Reset();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Reset'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNumPlayers of class  cTeam */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cTeam_GetNumPlayers00
static int tolua_AllToLua_cTeam_GetNumPlayers00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cTeam",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cTeam* self = (const cTeam*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumPlayers'", nullptr);
#endif
  {
   size_t tolua_ret = (size_t)  self->GetNumPlayers();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetNumPlayers'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AllowsFriendlyFire of class  cTeam */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cTeam_AllowsFriendlyFire00
static int tolua_AllToLua_cTeam_AllowsFriendlyFire00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cTeam",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cTeam* self = (const cTeam*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AllowsFriendlyFire'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->AllowsFriendlyFire();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AllowsFriendlyFire'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CanSeeFriendlyInvisible of class  cTeam */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cTeam_CanSeeFriendlyInvisible00
static int tolua_AllToLua_cTeam_CanSeeFriendlyInvisible00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cTeam",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cTeam* self = (const cTeam*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CanSeeFriendlyInvisible'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->CanSeeFriendlyInvisible();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CanSeeFriendlyInvisible'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetDisplayName of class  cTeam */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cTeam_GetDisplayName00
static int tolua_AllToLua_cTeam_GetDisplayName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cTeam",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cTeam* self = (const cTeam*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetDisplayName'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetDisplayName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetDisplayName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetName of class  cTeam */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cTeam_GetName00
static int tolua_AllToLua_cTeam_GetName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cTeam",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cTeam* self = (const cTeam*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetName'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPrefix of class  cTeam */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cTeam_GetPrefix00
static int tolua_AllToLua_cTeam_GetPrefix00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cTeam",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cTeam* self = (const cTeam*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPrefix'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetPrefix();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPrefix'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSuffix of class  cTeam */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cTeam_GetSuffix00
static int tolua_AllToLua_cTeam_GetSuffix00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cTeam",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cTeam* self = (const cTeam*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSuffix'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetSuffix();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSuffix'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetFriendlyFire of class  cTeam */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cTeam_SetFriendlyFire00
static int tolua_AllToLua_cTeam_SetFriendlyFire00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cTeam",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cTeam* self = (cTeam*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_Flag = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetFriendlyFire'", nullptr);
#endif
  {
   self->SetFriendlyFire(a_Flag);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetFriendlyFire'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetCanSeeFriendlyInvisible of class  cTeam */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cTeam_SetCanSeeFriendlyInvisible00
static int tolua_AllToLua_cTeam_SetCanSeeFriendlyInvisible00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cTeam",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cTeam* self = (cTeam*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_Flag = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetCanSeeFriendlyInvisible'", nullptr);
#endif
  {
   self->SetCanSeeFriendlyInvisible(a_Flag);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetCanSeeFriendlyInvisible'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetDisplayName of class  cTeam */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cTeam_SetDisplayName00
static int tolua_AllToLua_cTeam_SetDisplayName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cTeam",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cTeam* self = (cTeam*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Name = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetDisplayName'", nullptr);
#endif
  {
   self->SetDisplayName(a_Name);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetDisplayName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetPrefix of class  cTeam */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cTeam_SetPrefix00
static int tolua_AllToLua_cTeam_SetPrefix00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cTeam",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cTeam* self = (cTeam*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Prefix = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetPrefix'", nullptr);
#endif
  {
   self->SetPrefix(a_Prefix);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetPrefix'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSuffix of class  cTeam */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cTeam_SetSuffix00
static int tolua_AllToLua_cTeam_SetSuffix00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cTeam",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cTeam* self = (cTeam*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Suffix = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSuffix'", nullptr);
#endif
  {
   self->SetSuffix(a_Suffix);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetSuffix'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseDisplaySlot (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 3.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eDisplaySlot";
	return 0;
}
/* method: RegisterObjective of class  cScoreboard */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cScoreboard_RegisterObjective00
static int tolua_AllToLua_cScoreboard_RegisterObjective00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cScoreboard",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cScoreboard* self = (cScoreboard*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Name = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString a_DisplayName = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
  cObjective::eType a_Type = ((cObjective::eType) (  int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'RegisterObjective'", nullptr);
#endif
  {
   cObjective* tolua_ret = (cObjective*)  self->RegisterObjective(a_Name,a_DisplayName,a_Type);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cObjective");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'RegisterObjective'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: RemoveObjective of class  cScoreboard */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cScoreboard_RemoveObjective00
static int tolua_AllToLua_cScoreboard_RemoveObjective00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cScoreboard",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cScoreboard* self = (cScoreboard*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Name = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'RemoveObjective'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->RemoveObjective(a_Name);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'RemoveObjective'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetObjective of class  cScoreboard */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cScoreboard_GetObjective00
static int tolua_AllToLua_cScoreboard_GetObjective00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cScoreboard",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cScoreboard* self = (cScoreboard*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Name = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetObjective'", nullptr);
#endif
  {
   cObjective* tolua_ret = (cObjective*)  self->GetObjective(a_Name);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cObjective");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetObjective'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: RegisterTeam of class  cScoreboard */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cScoreboard_RegisterTeam00
static int tolua_AllToLua_cScoreboard_RegisterTeam00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cScoreboard",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cScoreboard* self = (cScoreboard*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Name = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString a_DisplayName = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
  const AString a_Prefix = ((const AString)  tolua_tocppstring(tolua_S,4,nullptr));
  const AString a_Suffix = ((const AString)  tolua_tocppstring(tolua_S,5,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'RegisterTeam'", nullptr);
#endif
  {
   cTeam* tolua_ret = (cTeam*)  self->RegisterTeam(a_Name,a_DisplayName,a_Prefix,a_Suffix);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cTeam");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'RegisterTeam'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: RemoveTeam of class  cScoreboard */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cScoreboard_RemoveTeam00
static int tolua_AllToLua_cScoreboard_RemoveTeam00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cScoreboard",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cScoreboard* self = (cScoreboard*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Name = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'RemoveTeam'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->RemoveTeam(a_Name);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'RemoveTeam'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetTeam of class  cScoreboard */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cScoreboard_GetTeam00
static int tolua_AllToLua_cScoreboard_GetTeam00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cScoreboard",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cScoreboard* self = (cScoreboard*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Name = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetTeam'", nullptr);
#endif
  {
   cTeam* tolua_ret = (cTeam*)  self->GetTeam(a_Name);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cTeam");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetTeam'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetDisplay of class  cScoreboard */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cScoreboard_SetDisplay00
static int tolua_AllToLua_cScoreboard_SetDisplay00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cScoreboard",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cScoreboard* self = (cScoreboard*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Objective = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  cScoreboard::eDisplaySlot a_Slot = ((cScoreboard::eDisplaySlot) (  int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetDisplay'", nullptr);
#endif
  {
   self->SetDisplay(a_Objective,a_Slot);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetDisplay'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetObjectiveIn of class  cScoreboard */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cScoreboard_GetObjectiveIn00
static int tolua_AllToLua_cScoreboard_GetObjectiveIn00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cScoreboard",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cScoreboard* self = (cScoreboard*)  tolua_tousertype(tolua_S,1,nullptr);
  cScoreboard::eDisplaySlot a_Slot = ((cScoreboard::eDisplaySlot) (  int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetObjectiveIn'", nullptr);
#endif
  {
   cObjective* tolua_ret = (cObjective*)  self->GetObjectiveIn(a_Slot);
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cObjective");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetObjectiveIn'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNumObjectives of class  cScoreboard */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cScoreboard_GetNumObjectives00
static int tolua_AllToLua_cScoreboard_GetNumObjectives00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cScoreboard",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cScoreboard* self = (const cScoreboard*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumObjectives'", nullptr);
#endif
  {
   size_t tolua_ret = (size_t)  self->GetNumObjectives();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetNumObjectives'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNumTeams of class  cScoreboard */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cScoreboard_GetNumTeams00
static int tolua_AllToLua_cScoreboard_GetNumTeams00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cScoreboard",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cScoreboard* self = (const cScoreboard*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumTeams'", nullptr);
#endif
  {
   size_t tolua_ret = (size_t)  self->GetNumTeams();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetNumTeams'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddPlayerScore of class  cScoreboard */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cScoreboard_AddPlayerScore00
static int tolua_AllToLua_cScoreboard_AddPlayerScore00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cScoreboard",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cScoreboard* self = (cScoreboard*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Name = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  cObjective::eType a_Type = ((cObjective::eType) (  int)  tolua_tonumber(tolua_S,3,0));
   int a_Value = ((  int)  tolua_tonumber(tolua_S,4,1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddPlayerScore'", nullptr);
#endif
  {
   self->AddPlayerScore(a_Name,a_Type,a_Value);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddPlayerScore'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new of class  cUUID */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cUUID_new00
static int tolua_AllToLua_cUUID_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cUUID",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   cUUID* tolua_ret = (cUUID*)  Mtolua_new((cUUID)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cUUID");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: new_local of class  cUUID */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cUUID_new00_local
static int tolua_AllToLua_cUUID_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cUUID",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   cUUID* tolua_ret = (cUUID*)  Mtolua_new((cUUID)());
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cUUID");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Compare of class  cUUID */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cUUID_Compare00
static int tolua_AllToLua_cUUID_Compare00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cUUID",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cUUID",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cUUID* self = (const cUUID*)  tolua_tousertype(tolua_S,1,nullptr);
  const cUUID* a_Other = ((const cUUID*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Compare'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->Compare(*a_Other);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Compare'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsNil of class  cUUID */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cUUID_IsNil00
static int tolua_AllToLua_cUUID_IsNil00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cUUID",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cUUID* self = (const cUUID*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsNil'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsNil();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsNil'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: FromString of class  cUUID */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cUUID_FromString00
static int tolua_AllToLua_cUUID_FromString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cUUID",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cUUID* self = (cUUID*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_StringUUID = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'FromString'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->FromString(a_StringUUID);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'FromString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ToShortString of class  cUUID */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cUUID_ToShortString00
static int tolua_AllToLua_cUUID_ToShortString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cUUID",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cUUID* self = (const cUUID*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ToShortString'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->ToShortString();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ToShortString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ToLongString of class  cUUID */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cUUID_ToLongString00
static int tolua_AllToLua_cUUID_ToLongString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cUUID",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cUUID* self = (const cUUID*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ToLongString'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->ToLongString();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ToLongString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Version of class  cUUID */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cUUID_Version00
static int tolua_AllToLua_cUUID_Version00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cUUID",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cUUID* self = (const cUUID*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Version'", nullptr);
#endif
  {
   unsigned char tolua_ret = ( unsigned char)  self->Version();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Version'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Variant of class  cUUID */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cUUID_Variant00
static int tolua_AllToLua_cUUID_Variant00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cUUID",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cUUID* self = (const cUUID*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Variant'", nullptr);
#endif
  {
   unsigned char tolua_ret = ( unsigned char)  self->Variant();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Variant'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GenerateVersion3 of class  cUUID */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cUUID_GenerateVersion300
static int tolua_AllToLua_cUUID_GenerateVersion300(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cUUID",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const AString a_Name = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  {
   cUUID tolua_ret = (cUUID)  cUUID::GenerateVersion3(a_Name);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cUUID)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cUUID");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cUUID));
     tolua_pushusertype(tolua_S,tolua_obj,"cUUID");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GenerateVersion3'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: DamageType of class  TakeDamageInfo */
#ifndef TOLUA_DISABLE_tolua_get_TakeDamageInfo_DamageType
static int tolua_get_TakeDamageInfo_DamageType(lua_State* tolua_S)
{
  TakeDamageInfo* self = (TakeDamageInfo*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DamageType'",nullptr);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->DamageType);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: DamageType of class  TakeDamageInfo */
#ifndef TOLUA_DISABLE_tolua_set_TakeDamageInfo_DamageType
static int tolua_set_TakeDamageInfo_DamageType(lua_State* tolua_S)
{
  TakeDamageInfo* self = (TakeDamageInfo*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'DamageType'",nullptr);
  if (!tolua_iseDamageType(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->DamageType = ((eDamageType) (int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Attacker of class  TakeDamageInfo */
#ifndef TOLUA_DISABLE_tolua_get_TakeDamageInfo_Attacker_ptr
static int tolua_get_TakeDamageInfo_Attacker_ptr(lua_State* tolua_S)
{
  TakeDamageInfo* self = (TakeDamageInfo*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Attacker'",nullptr);
#endif
   tolua_pushusertype(tolua_S,(void*)self->Attacker,"cEntity");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Attacker of class  TakeDamageInfo */
#ifndef TOLUA_DISABLE_tolua_set_TakeDamageInfo_Attacker_ptr
static int tolua_set_TakeDamageInfo_Attacker_ptr(lua_State* tolua_S)
{
  TakeDamageInfo* self = (TakeDamageInfo*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Attacker'",nullptr);
  if (!tolua_isusertype(tolua_S,2,"cEntity",0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Attacker = ((cEntity*)  tolua_tousertype(tolua_S,2,nullptr))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: RawDamage of class  TakeDamageInfo */
#ifndef TOLUA_DISABLE_tolua_get_TakeDamageInfo_RawDamage
static int tolua_get_TakeDamageInfo_RawDamage(lua_State* tolua_S)
{
  TakeDamageInfo* self = (TakeDamageInfo*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'RawDamage'",nullptr);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->RawDamage);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: RawDamage of class  TakeDamageInfo */
#ifndef TOLUA_DISABLE_tolua_set_TakeDamageInfo_RawDamage
static int tolua_set_TakeDamageInfo_RawDamage(lua_State* tolua_S)
{
  TakeDamageInfo* self = (TakeDamageInfo*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'RawDamage'",nullptr);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->RawDamage = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FinalDamage of class  TakeDamageInfo */
#ifndef TOLUA_DISABLE_tolua_get_TakeDamageInfo_FinalDamage
static int tolua_get_TakeDamageInfo_FinalDamage(lua_State* tolua_S)
{
  TakeDamageInfo* self = (TakeDamageInfo*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FinalDamage'",nullptr);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->FinalDamage);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FinalDamage of class  TakeDamageInfo */
#ifndef TOLUA_DISABLE_tolua_set_TakeDamageInfo_FinalDamage
static int tolua_set_TakeDamageInfo_FinalDamage(lua_State* tolua_S)
{
  TakeDamageInfo* self = (TakeDamageInfo*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'FinalDamage'",nullptr);
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->FinalDamage = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: Knockback of class  TakeDamageInfo */
#ifndef TOLUA_DISABLE_tolua_get_TakeDamageInfo_Knockback
static int tolua_get_TakeDamageInfo_Knockback(lua_State* tolua_S)
{
  TakeDamageInfo* self = (TakeDamageInfo*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Knockback'",nullptr);
#endif
   tolua_pushusertype(tolua_S,(void*)&self->Knockback,"Vector3<double>");
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: Knockback of class  TakeDamageInfo */
#ifndef TOLUA_DISABLE_tolua_set_TakeDamageInfo_Knockback
static int tolua_set_TakeDamageInfo_Knockback(lua_State* tolua_S)
{
  TakeDamageInfo* self = (TakeDamageInfo*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Knockback'",nullptr);
  if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<double>",0,&tolua_err)))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  self->Knockback = *((  Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseEntityType (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 15.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eEntityType";
	return 0;
}
/* method: GetEntityType of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetEntityType00
static int tolua_AllToLua_cEntity_GetEntityType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEntityType'", nullptr);
#endif
  {
   cEntity::eEntityType tolua_ret = (cEntity::eEntityType)  self->GetEntityType();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetEntityType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsArrow of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsArrow00
static int tolua_AllToLua_cEntity_IsArrow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsArrow'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsArrow();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsArrow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsEnderCrystal of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsEnderCrystal00
static int tolua_AllToLua_cEntity_IsEnderCrystal00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsEnderCrystal'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsEnderCrystal();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsEnderCrystal'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsPlayer of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsPlayer00
static int tolua_AllToLua_cEntity_IsPlayer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsPlayer'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsPlayer();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsPlayer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsPickup of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsPickup00
static int tolua_AllToLua_cEntity_IsPickup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsPickup'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsPickup();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsPickup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsMob of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsMob00
static int tolua_AllToLua_cEntity_IsMob00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsMob'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsMob();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsMob'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsPawn of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsPawn00
static int tolua_AllToLua_cEntity_IsPawn00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsPawn'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsPawn();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsPawn'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsFallingBlock of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsFallingBlock00
static int tolua_AllToLua_cEntity_IsFallingBlock00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsFallingBlock'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsFallingBlock();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsFallingBlock'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsMinecart of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsMinecart00
static int tolua_AllToLua_cEntity_IsMinecart00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsMinecart'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsMinecart();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsMinecart'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsBoat of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsBoat00
static int tolua_AllToLua_cEntity_IsBoat00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsBoat'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsBoat();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsBoat'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsTNT of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsTNT00
static int tolua_AllToLua_cEntity_IsTNT00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsTNT'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsTNT();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsTNT'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsProjectile of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsProjectile00
static int tolua_AllToLua_cEntity_IsProjectile00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsProjectile'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsProjectile();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsProjectile'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsExpOrb of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsExpOrb00
static int tolua_AllToLua_cEntity_IsExpOrb00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsExpOrb'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsExpOrb();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsExpOrb'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsFloater of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsFloater00
static int tolua_AllToLua_cEntity_IsFloater00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsFloater'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsFloater();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsFloater'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsItemFrame of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsItemFrame00
static int tolua_AllToLua_cEntity_IsItemFrame00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsItemFrame'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsItemFrame();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsItemFrame'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsLeashKnot of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsLeashKnot00
static int tolua_AllToLua_cEntity_IsLeashKnot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsLeashKnot'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsLeashKnot();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsLeashKnot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsPainting of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsPainting00
static int tolua_AllToLua_cEntity_IsPainting00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsPainting'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsPainting();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsPainting'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsA of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsA00
static int tolua_AllToLua_cEntity_IsA00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const char* a_ClassName = ((const char*)  tolua_tostring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsA'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsA(a_ClassName);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsA'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetClassStatic of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetClassStatic00
static int tolua_AllToLua_cEntity_GetClassStatic00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   const char* tolua_ret = (const char*)  cEntity::GetClassStatic();
   tolua_pushstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetClassStatic'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetClass of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetClass00
static int tolua_AllToLua_cEntity_GetClass00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetClass'", nullptr);
#endif
  {
   const char* tolua_ret = (const char*)  self->GetClass();
   tolua_pushstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetClass'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetParentClass of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetParentClass00
static int tolua_AllToLua_cEntity_GetParentClass00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetParentClass'", nullptr);
#endif
  {
   const char* tolua_ret = (const char*)  self->GetParentClass();
   tolua_pushstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetParentClass'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DoesPreventBlockPlacement of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_DoesPreventBlockPlacement00
static int tolua_AllToLua_cEntity_DoesPreventBlockPlacement00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DoesPreventBlockPlacement'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->DoesPreventBlockPlacement();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DoesPreventBlockPlacement'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetWorld of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetWorld00
static int tolua_AllToLua_cEntity_GetWorld00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetWorld'", nullptr);
#endif
  {
   cWorld* tolua_ret = (cWorld*)  self->GetWorld();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cWorld");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetWorld'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetHeadYaw of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetHeadYaw00
static int tolua_AllToLua_cEntity_GetHeadYaw00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetHeadYaw'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetHeadYaw();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetHeadYaw'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetHeight of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetHeight00
static int tolua_AllToLua_cEntity_GetHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetHeight'", nullptr);
#endif
  {
   float tolua_ret = (float)  self->GetHeight();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMass of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetMass00
static int tolua_AllToLua_cEntity_GetMass00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMass'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetMass();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMass'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPosX of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetPosX00
static int tolua_AllToLua_cEntity_GetPosX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPosX'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetPosX();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPosX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPosY of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetPosY00
static int tolua_AllToLua_cEntity_GetPosY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPosY'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetPosY();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPosY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPosZ of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetPosZ00
static int tolua_AllToLua_cEntity_GetPosZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPosZ'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetPosZ();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPosZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetYaw of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetYaw00
static int tolua_AllToLua_cEntity_GetYaw00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetYaw'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetYaw();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetYaw'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPitch of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetPitch00
static int tolua_AllToLua_cEntity_GetPitch00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPitch'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetPitch();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPitch'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetRoll of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetRoll00
static int tolua_AllToLua_cEntity_GetRoll00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetRoll'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetRoll();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetRoll'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetLookVector of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetLookVector00
static int tolua_AllToLua_cEntity_GetLookVector00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetLookVector'", nullptr);
#endif
  {
    Vector3<double> tolua_ret = (  Vector3<double>)  self->GetLookVector();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<double>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<double>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetLookVector'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSpeedX of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetSpeedX00
static int tolua_AllToLua_cEntity_GetSpeedX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSpeedX'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetSpeedX();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSpeedX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSpeedY of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetSpeedY00
static int tolua_AllToLua_cEntity_GetSpeedY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSpeedY'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetSpeedY();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSpeedY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSpeedZ of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetSpeedZ00
static int tolua_AllToLua_cEntity_GetSpeedZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSpeedZ'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetSpeedZ();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSpeedZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetWidth of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetWidth00
static int tolua_AllToLua_cEntity_GetWidth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetWidth'", nullptr);
#endif
  {
   float tolua_ret = (float)  self->GetWidth();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetWidth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetChunkX of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetChunkX00
static int tolua_AllToLua_cEntity_GetChunkX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetChunkX'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetChunkX();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetChunkX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetChunkZ of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetChunkZ00
static int tolua_AllToLua_cEntity_GetChunkZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetChunkZ'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetChunkZ();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetChunkZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetBoundingBox of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetBoundingBox00
static int tolua_AllToLua_cEntity_GetBoundingBox00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetBoundingBox'", nullptr);
#endif
  {
   cBoundingBox tolua_ret = (cBoundingBox)  self->GetBoundingBox();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cBoundingBox)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cBoundingBox");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cBoundingBox));
     tolua_pushusertype(tolua_S,tolua_obj,"cBoundingBox");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetBoundingBox'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetHeadYaw of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetHeadYaw00
static int tolua_AllToLua_cEntity_SetHeadYaw00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_HeadYaw = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetHeadYaw'", nullptr);
#endif
  {
   self->SetHeadYaw(a_HeadYaw);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetHeadYaw'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetMass of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetMass00
static int tolua_AllToLua_cEntity_SetMass00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_Mass = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetMass'", nullptr);
#endif
  {
   self->SetMass(a_Mass);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetMass'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetPosX of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetPosX00
static int tolua_AllToLua_cEntity_SetPosX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_PosX = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetPosX'", nullptr);
#endif
  {
   self->SetPosX(a_PosX);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetPosX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetPosY of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetPosY00
static int tolua_AllToLua_cEntity_SetPosY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_PosY = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetPosY'", nullptr);
#endif
  {
   self->SetPosY(a_PosY);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetPosY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetPosZ of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetPosZ00
static int tolua_AllToLua_cEntity_SetPosZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_PosZ = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetPosZ'", nullptr);
#endif
  {
   self->SetPosZ(a_PosZ);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetPosZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetPosition of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetPosition00
static int tolua_AllToLua_cEntity_SetPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_PosX = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_PosY = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_PosZ = ((double)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetPosition'", nullptr);
#endif
  {
   self->SetPosition(a_PosX,a_PosY,a_PosZ);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetPosition of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetPosition01
static int tolua_AllToLua_cEntity_SetPosition01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<double>* a_Position = ((const Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetPosition'", nullptr);
#endif
  {
   self->SetPosition(*a_Position);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cEntity_SetPosition00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetYaw of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetYaw00
static int tolua_AllToLua_cEntity_SetYaw00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_Yaw = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetYaw'", nullptr);
#endif
  {
   self->SetYaw(a_Yaw);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetYaw'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetPitch of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetPitch00
static int tolua_AllToLua_cEntity_SetPitch00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_Pitch = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetPitch'", nullptr);
#endif
  {
   self->SetPitch(a_Pitch);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetPitch'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetRoll of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetRoll00
static int tolua_AllToLua_cEntity_SetRoll00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_Roll = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetRoll'", nullptr);
#endif
  {
   self->SetRoll(a_Roll);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetRoll'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSpeed of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetSpeed00
static int tolua_AllToLua_cEntity_SetSpeed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_SpeedX = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_SpeedY = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_SpeedZ = ((double)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSpeed'", nullptr);
#endif
  {
   self->SetSpeed(a_SpeedX,a_SpeedY,a_SpeedZ);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetSpeed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSpeed of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetSpeed01
static int tolua_AllToLua_cEntity_SetSpeed01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<double> a_Speed = *((  Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSpeed'", nullptr);
#endif
  {
   self->SetSpeed(a_Speed);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cEntity_SetSpeed00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSpeedX of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetSpeedX00
static int tolua_AllToLua_cEntity_SetSpeedX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_SpeedX = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSpeedX'", nullptr);
#endif
  {
   self->SetSpeedX(a_SpeedX);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetSpeedX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSpeedY of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetSpeedY00
static int tolua_AllToLua_cEntity_SetSpeedY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_SpeedY = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSpeedY'", nullptr);
#endif
  {
   self->SetSpeedY(a_SpeedY);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetSpeedY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSpeedZ of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetSpeedZ00
static int tolua_AllToLua_cEntity_SetSpeedZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_SpeedZ = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSpeedZ'", nullptr);
#endif
  {
   self->SetSpeedZ(a_SpeedZ);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetSpeedZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddPosX of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_AddPosX00
static int tolua_AllToLua_cEntity_AddPosX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_AddPosX = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddPosX'", nullptr);
#endif
  {
   self->AddPosX(a_AddPosX);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddPosX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddPosY of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_AddPosY00
static int tolua_AllToLua_cEntity_AddPosY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_AddPosY = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddPosY'", nullptr);
#endif
  {
   self->AddPosY(a_AddPosY);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddPosY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddPosZ of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_AddPosZ00
static int tolua_AllToLua_cEntity_AddPosZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_AddPosZ = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddPosZ'", nullptr);
#endif
  {
   self->AddPosZ(a_AddPosZ);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddPosZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddPosition of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_AddPosition00
static int tolua_AllToLua_cEntity_AddPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_AddPosX = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_AddPosY = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_AddPosZ = ((double)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddPosition'", nullptr);
#endif
  {
   self->AddPosition(a_AddPosX,a_AddPosY,a_AddPosZ);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddPosition of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_AddPosition01
static int tolua_AllToLua_cEntity_AddPosition01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<double>* a_AddPos = ((const Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddPosition'", nullptr);
#endif
  {
   self->AddPosition(*a_AddPos);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cEntity_AddPosition00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddSpeed of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_AddSpeed00
static int tolua_AllToLua_cEntity_AddSpeed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_AddSpeedX = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_AddSpeedY = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_AddSpeedZ = ((double)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddSpeed'", nullptr);
#endif
  {
   self->AddSpeed(a_AddSpeedX,a_AddSpeedY,a_AddSpeedZ);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddSpeed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddSpeed of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_AddSpeed01
static int tolua_AllToLua_cEntity_AddSpeed01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<double>* a_AddSpeed = ((const Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddSpeed'", nullptr);
#endif
  {
   self->AddSpeed(*a_AddSpeed);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cEntity_AddSpeed00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddSpeedX of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_AddSpeedX00
static int tolua_AllToLua_cEntity_AddSpeedX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_AddSpeedX = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddSpeedX'", nullptr);
#endif
  {
   self->AddSpeedX(a_AddSpeedX);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddSpeedX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddSpeedY of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_AddSpeedY00
static int tolua_AllToLua_cEntity_AddSpeedY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_AddSpeedY = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddSpeedY'", nullptr);
#endif
  {
   self->AddSpeedY(a_AddSpeedY);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddSpeedY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddSpeedZ of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_AddSpeedZ00
static int tolua_AllToLua_cEntity_AddSpeedZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_AddSpeedZ = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddSpeedZ'", nullptr);
#endif
  {
   self->AddSpeedZ(a_AddSpeedZ);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddSpeedZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: HandleSpeedFromAttachee of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_HandleSpeedFromAttachee00
static int tolua_AllToLua_cEntity_HandleSpeedFromAttachee00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  float a_Forward = ((float)  tolua_tonumber(tolua_S,2,0));
  float a_Sideways = ((float)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HandleSpeedFromAttachee'", nullptr);
#endif
  {
   self->HandleSpeedFromAttachee(a_Forward,a_Sideways);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'HandleSpeedFromAttachee'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SteerVehicle of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SteerVehicle00
static int tolua_AllToLua_cEntity_SteerVehicle00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  float a_Forward = ((float)  tolua_tonumber(tolua_S,2,0));
  float a_Sideways = ((float)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SteerVehicle'", nullptr);
#endif
  {
   self->SteerVehicle(a_Forward,a_Sideways);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SteerVehicle'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetUniqueID of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetUniqueID00
static int tolua_AllToLua_cEntity_GetUniqueID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetUniqueID'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->GetUniqueID();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetUniqueID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsDestroyed of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsDestroyed00
static int tolua_AllToLua_cEntity_IsDestroyed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsDestroyed'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsDestroyed();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsDestroyed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsTicking of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsTicking00
static int tolua_AllToLua_cEntity_IsTicking00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsTicking'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsTicking();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsTicking'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: TakeDamage of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_TakeDamage00
static int tolua_AllToLua_cEntity_TakeDamage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cEntity",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  cEntity* a_Attacker = ((cEntity*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'TakeDamage'", nullptr);
#endif
  {
   self->TakeDamage(*a_Attacker);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'TakeDamage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseDamageType (lua_State* L, int lo, int def, tolua_Error* err);
/* method: TakeDamage of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_TakeDamage01
static int tolua_AllToLua_cEntity_TakeDamage01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_iseDamageType(tolua_S,2,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  eDamageType a_DamageType = ((eDamageType) (  int)  tolua_tonumber(tolua_S,2,0));
  cEntity* a_Attacker = ((cEntity*)  tolua_tousertype(tolua_S,3,nullptr));
  int a_RawDamage = ((int)  tolua_tonumber(tolua_S,4,0));
  double a_KnockbackAmount = ((double)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'TakeDamage'", nullptr);
#endif
  {
   self->TakeDamage(a_DamageType,a_Attacker,a_RawDamage,a_KnockbackAmount);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cEntity_TakeDamage00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseDamageType (lua_State* L, int lo, int def, tolua_Error* err);
/* method: TakeDamage of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_TakeDamage02
static int tolua_AllToLua_cEntity_TakeDamage02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_iseDamageType(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  eDamageType a_DamageType = ((eDamageType) (  int)  tolua_tonumber(tolua_S,2,0));
  unsigned int a_Attacker = (( unsigned int)  tolua_tonumber(tolua_S,3,0));
  int a_RawDamage = ((int)  tolua_tonumber(tolua_S,4,0));
  double a_KnockbackAmount = ((double)  tolua_tonumber(tolua_S,5,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'TakeDamage'", nullptr);
#endif
  {
   self->TakeDamage(a_DamageType,a_Attacker,a_RawDamage,a_KnockbackAmount);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cEntity_TakeDamage01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseDamageType (lua_State* L, int lo, int def, tolua_Error* err);
/* method: TakeDamage of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_TakeDamage03
static int tolua_AllToLua_cEntity_TakeDamage03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_iseDamageType(tolua_S,2,0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  eDamageType a_DamageType = ((eDamageType) (  int)  tolua_tonumber(tolua_S,2,0));
  cEntity* a_Attacker = ((cEntity*)  tolua_tousertype(tolua_S,3,nullptr));
  int a_RawDamage = ((int)  tolua_tonumber(tolua_S,4,0));
  float a_FinalDamage = ((float)  tolua_tonumber(tolua_S,5,0));
  double a_KnockbackAmount = ((double)  tolua_tonumber(tolua_S,6,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'TakeDamage'", nullptr);
#endif
  {
   self->TakeDamage(a_DamageType,a_Attacker,a_RawDamage,a_FinalDamage,a_KnockbackAmount);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cEntity_TakeDamage02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetGravity of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetGravity00
static int tolua_AllToLua_cEntity_GetGravity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetGravity'", nullptr);
#endif
  {
   float tolua_ret = (float)  self->GetGravity();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetGravity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetGravity of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetGravity00
static int tolua_AllToLua_cEntity_SetGravity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  float a_Gravity = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetGravity'", nullptr);
#endif
  {
   self->SetGravity(a_Gravity);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetGravity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetAirDrag of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetAirDrag00
static int tolua_AllToLua_cEntity_GetAirDrag00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetAirDrag'", nullptr);
#endif
  {
   float tolua_ret = (float)  self->GetAirDrag();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetAirDrag'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetAirDrag of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetAirDrag00
static int tolua_AllToLua_cEntity_SetAirDrag00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  float a_AirDrag = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetAirDrag'", nullptr);
#endif
  {
   self->SetAirDrag(a_AirDrag);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetAirDrag'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetYawFromSpeed of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetYawFromSpeed00
static int tolua_AllToLua_cEntity_SetYawFromSpeed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetYawFromSpeed'", nullptr);
#endif
  {
   self->SetYawFromSpeed();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetYawFromSpeed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetPitchFromSpeed of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetPitchFromSpeed00
static int tolua_AllToLua_cEntity_SetPitchFromSpeed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetPitchFromSpeed'", nullptr);
#endif
  {
   self->SetPitchFromSpeed();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetPitchFromSpeed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetRawDamageAgainst of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetRawDamageAgainst00
static int tolua_AllToLua_cEntity_GetRawDamageAgainst00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cEntity",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const cEntity* a_Receiver = ((const cEntity*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetRawDamageAgainst'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetRawDamageAgainst(*a_Receiver);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetRawDamageAgainst'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseDamageType (lua_State* L, int lo, int def, tolua_Error* err);
/* method: ArmorCoversAgainst of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_ArmorCoversAgainst00
static int tolua_AllToLua_cEntity_ArmorCoversAgainst00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_iseDamageType(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  eDamageType a_DamageType = ((eDamageType) (  int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ArmorCoversAgainst'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->ArmorCoversAgainst(a_DamageType);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ArmorCoversAgainst'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseDamageType (lua_State* L, int lo, int def, tolua_Error* err);
/* method: GetArmorCoverAgainst of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetArmorCoverAgainst00
static int tolua_AllToLua_cEntity_GetArmorCoverAgainst00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"const cEntity",0,&tolua_err) ||
     !tolua_iseDamageType(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const cEntity* a_Attacker = ((const cEntity*)  tolua_tousertype(tolua_S,2,nullptr));
  eDamageType a_DamageType = ((eDamageType) (  int)  tolua_tonumber(tolua_S,3,0));
  int a_RawDamage = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetArmorCoverAgainst'", nullptr);
#endif
  {
   float tolua_ret = (float)  self->GetArmorCoverAgainst(a_Attacker,a_DamageType,a_RawDamage);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetArmorCoverAgainst'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseDamageType (lua_State* L, int lo, int def, tolua_Error* err);
/* method: GetEnchantmentCoverAgainst of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetEnchantmentCoverAgainst00
static int tolua_AllToLua_cEntity_GetEnchantmentCoverAgainst00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"const cEntity",0,&tolua_err) ||
     !tolua_iseDamageType(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const cEntity* a_Attacker = ((const cEntity*)  tolua_tousertype(tolua_S,2,nullptr));
  eDamageType a_DamageType = ((eDamageType) (  int)  tolua_tonumber(tolua_S,3,0));
  int a_Damage = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEnchantmentCoverAgainst'", nullptr);
#endif
  {
   float tolua_ret = (float)  self->GetEnchantmentCoverAgainst(a_Attacker,a_DamageType,a_Damage);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetEnchantmentCoverAgainst'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetEnchantmentBlastKnockbackReduction of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetEnchantmentBlastKnockbackReduction00
static int tolua_AllToLua_cEntity_GetEnchantmentBlastKnockbackReduction00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEnchantmentBlastKnockbackReduction'", nullptr);
#endif
  {
   float tolua_ret = (float)  self->GetEnchantmentBlastKnockbackReduction();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetEnchantmentBlastKnockbackReduction'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetKnockbackAmountAgainst of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetKnockbackAmountAgainst00
static int tolua_AllToLua_cEntity_GetKnockbackAmountAgainst00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cEntity",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const cEntity* a_Receiver = ((const cEntity*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetKnockbackAmountAgainst'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetKnockbackAmountAgainst(*a_Receiver);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetKnockbackAmountAgainst'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetEquippedWeapon of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetEquippedWeapon00
static int tolua_AllToLua_cEntity_GetEquippedWeapon00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEquippedWeapon'", nullptr);
#endif
  {
   cItem tolua_ret = (cItem)  self->GetEquippedWeapon();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cItem)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cItem));
     tolua_pushusertype(tolua_S,tolua_obj,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetEquippedWeapon'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetEquippedHelmet of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetEquippedHelmet00
static int tolua_AllToLua_cEntity_GetEquippedHelmet00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEquippedHelmet'", nullptr);
#endif
  {
   cItem tolua_ret = (cItem)  self->GetEquippedHelmet();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cItem)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cItem));
     tolua_pushusertype(tolua_S,tolua_obj,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetEquippedHelmet'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetEquippedChestplate of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetEquippedChestplate00
static int tolua_AllToLua_cEntity_GetEquippedChestplate00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEquippedChestplate'", nullptr);
#endif
  {
   cItem tolua_ret = (cItem)  self->GetEquippedChestplate();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cItem)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cItem));
     tolua_pushusertype(tolua_S,tolua_obj,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetEquippedChestplate'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetEquippedLeggings of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetEquippedLeggings00
static int tolua_AllToLua_cEntity_GetEquippedLeggings00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEquippedLeggings'", nullptr);
#endif
  {
   cItem tolua_ret = (cItem)  self->GetEquippedLeggings();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cItem)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cItem));
     tolua_pushusertype(tolua_S,tolua_obj,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetEquippedLeggings'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetEquippedBoots of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetEquippedBoots00
static int tolua_AllToLua_cEntity_GetEquippedBoots00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEquippedBoots'", nullptr);
#endif
  {
   cItem tolua_ret = (cItem)  self->GetEquippedBoots();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cItem)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cItem));
     tolua_pushusertype(tolua_S,tolua_obj,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetEquippedBoots'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetOffHandEquipedItem of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetOffHandEquipedItem00
static int tolua_AllToLua_cEntity_GetOffHandEquipedItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetOffHandEquipedItem'", nullptr);
#endif
  {
   cItem tolua_ret = (cItem)  self->GetOffHandEquipedItem();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cItem)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cItem));
     tolua_pushusertype(tolua_S,tolua_obj,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetOffHandEquipedItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ApplyArmorDamage of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_ApplyArmorDamage00
static int tolua_AllToLua_cEntity_ApplyArmorDamage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  int DamageBlocked = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ApplyArmorDamage'", nullptr);
#endif
  {
   self->ApplyArmorDamage(DamageBlocked);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ApplyArmorDamage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseDamageType (lua_State* L, int lo, int def, tolua_Error* err);
/* method: Killed of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_Killed00
static int tolua_AllToLua_cEntity_Killed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cEntity",0,&tolua_err)) ||
     !tolua_iseDamageType(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const cEntity* a_Victim = ((const cEntity*)  tolua_tousertype(tolua_S,2,nullptr));
  eDamageType a_DamageType = ((eDamageType) (  int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Killed'", nullptr);
#endif
  {
   self->Killed(*a_Victim,a_DamageType);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Killed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Heal of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_Heal00
static int tolua_AllToLua_cEntity_Heal00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_HitPoints = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Heal'", nullptr);
#endif
  {
   self->Heal(a_HitPoints);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Heal'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetHealth of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetHealth00
static int tolua_AllToLua_cEntity_GetHealth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetHealth'", nullptr);
#endif
  {
   float tolua_ret = (float)  self->GetHealth();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetHealth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetHealth of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetHealth00
static int tolua_AllToLua_cEntity_SetHealth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  float a_Health = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetHealth'", nullptr);
#endif
  {
   self->SetHealth(a_Health);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetHealth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetMaxHealth of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetMaxHealth00
static int tolua_AllToLua_cEntity_SetMaxHealth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  float a_MaxHealth = ((float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetMaxHealth'", nullptr);
#endif
  {
   self->SetMaxHealth(a_MaxHealth);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetMaxHealth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMaxHealth of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetMaxHealth00
static int tolua_AllToLua_cEntity_GetMaxHealth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMaxHealth'", nullptr);
#endif
  {
   float tolua_ret = (float)  self->GetMaxHealth();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMaxHealth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetIsFireproof of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetIsFireproof00
static int tolua_AllToLua_cEntity_SetIsFireproof00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_IsFireproof = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetIsFireproof'", nullptr);
#endif
  {
   self->SetIsFireproof(a_IsFireproof);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetIsFireproof'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsFireproof of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsFireproof00
static int tolua_AllToLua_cEntity_IsFireproof00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsFireproof'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsFireproof();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsFireproof'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: StartBurning of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_StartBurning00
static int tolua_AllToLua_cEntity_StartBurning00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_TicksLeftBurning = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'StartBurning'", nullptr);
#endif
  {
   self->StartBurning(a_TicksLeftBurning);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'StartBurning'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: StopBurning of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_StopBurning00
static int tolua_AllToLua_cEntity_StopBurning00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'StopBurning'", nullptr);
#endif
  {
   self->StopBurning();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'StopBurning'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: TeleportToEntity of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_TeleportToEntity00
static int tolua_AllToLua_cEntity_TeleportToEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cEntity",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  cEntity* a_Entity = ((cEntity*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'TeleportToEntity'", nullptr);
#endif
  {
   self->TeleportToEntity(*a_Entity);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'TeleportToEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: TeleportToCoords of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_TeleportToCoords00
static int tolua_AllToLua_cEntity_TeleportToCoords00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_PosX = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_PosY = ((double)  tolua_tonumber(tolua_S,3,0));
  double a_PosZ = ((double)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'TeleportToCoords'", nullptr);
#endif
  {
   self->TeleportToCoords(a_PosX,a_PosY,a_PosZ);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'TeleportToCoords'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: MoveToWorld of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_MoveToWorld00
static int tolua_AllToLua_cEntity_MoveToWorld00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cWorld",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isboolean(tolua_S,4,1,&tolua_err) ||
     !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  cWorld* a_World = ((cWorld*)  tolua_tousertype(tolua_S,2,nullptr));
   Vector3<double> a_NewPosition = *((  Vector3<double>*)  tolua_tousertype(tolua_S,3,nullptr));
  bool a_ShouldSetPortalCooldown = ((bool)  tolua_toboolean(tolua_S,4,false));
  bool a_ShouldSendRespawn = ((bool)  tolua_toboolean(tolua_S,5,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'MoveToWorld'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->MoveToWorld(*a_World,a_NewPosition,a_ShouldSetPortalCooldown,a_ShouldSendRespawn);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'MoveToWorld'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: MoveToWorld of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_MoveToWorld01
static int tolua_AllToLua_cEntity_MoveToWorld01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cWorld",0,&tolua_err)) ||
     !tolua_isboolean(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  cWorld* a_World = ((cWorld*)  tolua_tousertype(tolua_S,2,nullptr));
  bool a_ShouldSendRespawn = ((bool)  tolua_toboolean(tolua_S,3,0));
   Vector3<double> a_NewPosition = *((  Vector3<double>*)  tolua_tousertype(tolua_S,4,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'MoveToWorld'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->MoveToWorld(*a_World,a_ShouldSendRespawn,a_NewPosition);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cEntity_MoveToWorld00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: MoveToWorld of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_MoveToWorld02
static int tolua_AllToLua_cEntity_MoveToWorld02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cWorld",0,&tolua_err)) ||
     !tolua_isboolean(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  cWorld* a_World = ((cWorld*)  tolua_tousertype(tolua_S,2,nullptr));
  bool a_ShouldSendRespawn = ((bool)  tolua_toboolean(tolua_S,3,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'MoveToWorld'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->MoveToWorld(*a_World,a_ShouldSendRespawn);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cEntity_MoveToWorld01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: MoveToWorld of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_MoveToWorld03
static int tolua_AllToLua_cEntity_MoveToWorld03(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_WorldName = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  bool a_ShouldSendRespawn = ((bool)  tolua_toboolean(tolua_S,3,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'MoveToWorld'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->MoveToWorld(a_WorldName,a_ShouldSendRespawn);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cEntity_MoveToWorld02(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsCrouched of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsCrouched00
static int tolua_AllToLua_cEntity_IsCrouched00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsCrouched'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsCrouched();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsCrouched'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsElytraFlying of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsElytraFlying00
static int tolua_AllToLua_cEntity_IsElytraFlying00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsElytraFlying'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsElytraFlying();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsElytraFlying'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsInvisible of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsInvisible00
static int tolua_AllToLua_cEntity_IsInvisible00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsInvisible'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsInvisible();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsInvisible'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsOnFire of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsOnFire00
static int tolua_AllToLua_cEntity_IsOnFire00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsOnFire'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsOnFire();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsOnFire'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsRclking of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsRclking00
static int tolua_AllToLua_cEntity_IsRclking00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsRclking'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsRclking();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsRclking'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsRiding of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsRiding00
static int tolua_AllToLua_cEntity_IsRiding00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsRiding'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsRiding();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsRiding'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsSprinting of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsSprinting00
static int tolua_AllToLua_cEntity_IsSprinting00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsSprinting'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsSprinting();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsSprinting'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsInFire of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsInFire00
static int tolua_AllToLua_cEntity_IsInFire00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsInFire'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsInFire();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsInFire'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsInLava of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsInLava00
static int tolua_AllToLua_cEntity_IsInLava00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsInLava'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsInLava();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsInLava'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsInWater of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsInWater00
static int tolua_AllToLua_cEntity_IsInWater00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsInWater'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsInWater();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsInWater'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsHeadInWater of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsHeadInWater00
static int tolua_AllToLua_cEntity_IsHeadInWater00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsHeadInWater'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsHeadInWater();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsHeadInWater'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetAirLevel of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetAirLevel00
static int tolua_AllToLua_cEntity_GetAirLevel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetAirLevel'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetAirLevel();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetAirLevel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetTicksAlive of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetTicksAlive00
static int tolua_AllToLua_cEntity_GetTicksAlive00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetTicksAlive'", nullptr);
#endif
  {
   long int tolua_ret = (long int)  self->GetTicksAlive();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetTicksAlive'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetInvulnerableTicks of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetInvulnerableTicks00
static int tolua_AllToLua_cEntity_GetInvulnerableTicks00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetInvulnerableTicks'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetInvulnerableTicks();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetInvulnerableTicks'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetInvulnerableTicks of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetInvulnerableTicks00
static int tolua_AllToLua_cEntity_SetInvulnerableTicks00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntity* self = (cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_InvulnerableTicks = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetInvulnerableTicks'", nullptr);
#endif
  {
   self->SetInvulnerableTicks(a_InvulnerableTicks);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetInvulnerableTicks'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsOnGround of class  cEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsOnGround00
static int tolua_AllToLua_cEntity_IsOnGround00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEntity* self = (const cEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsOnGround'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsOnGround();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsOnGround'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetBeamTarget of class  cEnderCrystal */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnderCrystal_GetBeamTarget00
static int tolua_AllToLua_cEnderCrystal_GetBeamTarget00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEnderCrystal",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEnderCrystal* self = (const cEnderCrystal*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetBeamTarget'", nullptr);
#endif
  {
    Vector3<int> tolua_ret = (  Vector3<int>)  self->GetBeamTarget();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetBeamTarget'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetBeamTarget of class  cEnderCrystal */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnderCrystal_SetBeamTarget00
static int tolua_AllToLua_cEnderCrystal_SetBeamTarget00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEnderCrystal",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEnderCrystal* self = (cEnderCrystal*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<int> a_BeamTarget = *((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetBeamTarget'", nullptr);
#endif
  {
   self->SetBeamTarget(a_BeamTarget);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetBeamTarget'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DisplaysBeam of class  cEnderCrystal */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnderCrystal_DisplaysBeam00
static int tolua_AllToLua_cEnderCrystal_DisplaysBeam00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEnderCrystal",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEnderCrystal* self = (const cEnderCrystal*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DisplaysBeam'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->DisplaysBeam();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DisplaysBeam'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetDisplayBeam of class  cEnderCrystal */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnderCrystal_SetDisplayBeam00
static int tolua_AllToLua_cEnderCrystal_SetDisplayBeam00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEnderCrystal",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEnderCrystal* self = (cEnderCrystal*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_DisplayBeam = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetDisplayBeam'", nullptr);
#endif
  {
   self->SetDisplayBeam(a_DisplayBeam);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetDisplayBeam'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ShowsBottom of class  cEnderCrystal */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnderCrystal_ShowsBottom00
static int tolua_AllToLua_cEnderCrystal_ShowsBottom00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cEnderCrystal",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cEnderCrystal* self = (const cEnderCrystal*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ShowsBottom'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->ShowsBottom();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ShowsBottom'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetShowBottom of class  cEnderCrystal */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnderCrystal_SetShowBottom00
static int tolua_AllToLua_cEnderCrystal_SetShowBottom00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cEnderCrystal",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEnderCrystal* self = (cEnderCrystal*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_ShowBottom = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetShowBottom'", nullptr);
#endif
  {
   self->SetShowBottom(a_ShowBottom);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetShowBottom'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseMaterial (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 5.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eMaterial";
	return 0;
}
/* method: GetMaterial of class  cBoat */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoat_GetMaterial00
static int tolua_AllToLua_cBoat_GetMaterial00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBoat",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBoat* self = (const cBoat*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMaterial'", nullptr);
#endif
  {
   cBoat::eMaterial tolua_ret = (cBoat::eMaterial)  self->GetMaterial();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMaterial'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetMaterial of class  cBoat */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoat_SetMaterial00
static int tolua_AllToLua_cBoat_SetMaterial00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBoat",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBoat* self = (cBoat*)  tolua_tousertype(tolua_S,1,nullptr);
  cBoat::eMaterial a_Material = ((cBoat::eMaterial) (  int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetMaterial'", nullptr);
#endif
  {
   self->SetMaterial(a_Material);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetMaterial'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ItemToMaterial of class  cBoat */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoat_ItemToMaterial00
static int tolua_AllToLua_cBoat_ItemToMaterial00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBoat",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
  {
   cBoat::eMaterial tolua_ret = (cBoat::eMaterial)  cBoat::ItemToMaterial(*a_Item);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ItemToMaterial'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: MaterialToItem of class  cBoat */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoat_MaterialToItem00
static int tolua_AllToLua_cBoat_MaterialToItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBoat",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBoat::eMaterial a_Material = ((cBoat::eMaterial) (  int)  tolua_tonumber(tolua_S,2,0));
  {
   cItem tolua_ret = (cItem)  cBoat::MaterialToItem(a_Material);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cItem)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cItem));
     tolua_pushusertype(tolua_S,tolua_obj,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'MaterialToItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: MaterialToString of class  cBoat */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoat_MaterialToString00
static int tolua_AllToLua_cBoat_MaterialToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBoat",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBoat::eMaterial a_Material = ((const cBoat::eMaterial) (  int)  tolua_tonumber(tolua_S,2,0));
  {
   AString tolua_ret = (AString)  cBoat::MaterialToString(a_Material);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'MaterialToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: StringToMaterial of class  cBoat */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBoat_StringToMaterial00
static int tolua_AllToLua_cBoat_StringToMaterial00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBoat",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const AString a_Material = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  {
   cBoat::eMaterial tolua_ret = (cBoat::eMaterial)  cBoat::StringToMaterial(a_Material);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'StringToMaterial'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddEntityEffect of class  cPawn */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPawn_AddEntityEffect00
static int tolua_AllToLua_cPawn_AddEntityEffect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPawn",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPawn* self = (cPawn*)  tolua_tousertype(tolua_S,1,nullptr);
  cEntityEffect::eType a_EffectType = ((cEntityEffect::eType) (  int)  tolua_tonumber(tolua_S,2,0));
  int a_EffectDurationTicks = ((int)  tolua_tonumber(tolua_S,3,0));
  short a_EffectIntensity = ((short)  tolua_tonumber(tolua_S,4,0));
  double a_DistanceModifier = ((double)  tolua_tonumber(tolua_S,5,1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddEntityEffect'", nullptr);
#endif
  {
   self->AddEntityEffect(a_EffectType,a_EffectDurationTicks,a_EffectIntensity,a_DistanceModifier);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddEntityEffect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: RemoveEntityEffect of class  cPawn */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPawn_RemoveEntityEffect00
static int tolua_AllToLua_cPawn_RemoveEntityEffect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPawn",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPawn* self = (cPawn*)  tolua_tousertype(tolua_S,1,nullptr);
  cEntityEffect::eType a_EffectType = ((cEntityEffect::eType) (  int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'RemoveEntityEffect'", nullptr);
#endif
  {
   self->RemoveEntityEffect(a_EffectType);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'RemoveEntityEffect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: HasEntityEffect of class  cPawn */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPawn_HasEntityEffect00
static int tolua_AllToLua_cPawn_HasEntityEffect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPawn",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPawn* self = (const cPawn*)  tolua_tousertype(tolua_S,1,nullptr);
  cEntityEffect::eType a_EffectType = ((cEntityEffect::eType) (  int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HasEntityEffect'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->HasEntityEffect(a_EffectType);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'HasEntityEffect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ClearEntityEffects of class  cPawn */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPawn_ClearEntityEffects00
static int tolua_AllToLua_cPawn_ClearEntityEffects00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPawn",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPawn* self = (cPawn*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ClearEntityEffects'", nullptr);
#endif
  {
   self->ClearEntityEffects();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ClearEntityEffects'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: FindTeleportDestination of class  cPawn */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPawn_FindTeleportDestination00
static int tolua_AllToLua_cPawn_FindTeleportDestination00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cPawn",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cWorld",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"Vector3<double>",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"const Vector3<int>",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,7,&tolua_err) || !tolua_isusertype(tolua_S,7,"const Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cWorld* a_World = ((cWorld*)  tolua_tousertype(tolua_S,2,nullptr));
  const int a_HeightRequired = ((const int)  tolua_tonumber(tolua_S,3,0));
  unsigned const int a_NumTries = ((unsigned const int)  tolua_tonumber(tolua_S,4,0));
   Vector3<double>* a_Destination = ((  Vector3<double>*)  tolua_tousertype(tolua_S,5,nullptr));
  const Vector3<int> a_MinBoxCorner = *((const Vector3<int>*)  tolua_tousertype(tolua_S,6,nullptr));
  const Vector3<int> a_MaxBoxCorner = *((const Vector3<int>*)  tolua_tousertype(tolua_S,7,nullptr));
  {
   bool tolua_ret = (bool)  cPawn::FindTeleportDestination(*a_World,a_HeightRequired,a_NumTries,*a_Destination,a_MinBoxCorner,a_MaxBoxCorner);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'FindTeleportDestination'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: FindTeleportDestination of class  cPawn */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPawn_FindTeleportDestination01
static int tolua_AllToLua_cPawn_FindTeleportDestination01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cPawn",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cWorld",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"Vector3<double>",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"const cBoundingBox",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,7,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cWorld* a_World = ((cWorld*)  tolua_tousertype(tolua_S,2,nullptr));
  const int a_HeightRequired = ((const int)  tolua_tonumber(tolua_S,3,0));
  unsigned const int a_NumTries = ((unsigned const int)  tolua_tonumber(tolua_S,4,0));
   Vector3<double>* a_Destination = ((  Vector3<double>*)  tolua_tousertype(tolua_S,5,nullptr));
  const cBoundingBox a_BoundingBox = *((const cBoundingBox*)  tolua_tousertype(tolua_S,6,nullptr));
  {
   bool tolua_ret = (bool)  cPawn::FindTeleportDestination(*a_World,a_HeightRequired,a_NumTries,*a_Destination,a_BoundingBox);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cPawn_FindTeleportDestination00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: FindTeleportDestination of class  cPawn */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPawn_FindTeleportDestination02
static int tolua_AllToLua_cPawn_FindTeleportDestination02(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cPawn",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cWorld",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"Vector3<double>",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"Vector3<int>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,7,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cWorld* a_World = ((cWorld*)  tolua_tousertype(tolua_S,2,nullptr));
  const int a_HeightRequired = ((const int)  tolua_tonumber(tolua_S,3,0));
  unsigned const int a_NumTries = ((unsigned const int)  tolua_tonumber(tolua_S,4,0));
   Vector3<double>* a_Destination = ((  Vector3<double>*)  tolua_tousertype(tolua_S,5,nullptr));
   Vector3<int> a_Centre = *((  Vector3<int>*)  tolua_tousertype(tolua_S,6,nullptr));
  const int a_HalfCubeWidth = ((const int)  tolua_tonumber(tolua_S,7,0));
  {
   bool tolua_ret = (bool)  cPawn::FindTeleportDestination(*a_World,a_HeightRequired,a_NumTries,*a_Destination,a_Centre,a_HalfCubeWidth);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cPawn_FindTeleportDestination01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseKind (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 9.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eKind";
	return 0;
}
/* method: GetProjectileKind of class  cProjectileEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cProjectileEntity_GetProjectileKind00
static int tolua_AllToLua_cProjectileEntity_GetProjectileKind00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cProjectileEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cProjectileEntity* self = (const cProjectileEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetProjectileKind'", nullptr);
#endif
  {
   cProjectileEntity::eKind tolua_ret = (cProjectileEntity::eKind)  self->GetProjectileKind();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetProjectileKind'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetCreatorUniqueID of class  cProjectileEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cProjectileEntity_GetCreatorUniqueID00
static int tolua_AllToLua_cProjectileEntity_GetCreatorUniqueID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cProjectileEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cProjectileEntity* self = (const cProjectileEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetCreatorUniqueID'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->GetCreatorUniqueID();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetCreatorUniqueID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetCreatorName of class  cProjectileEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cProjectileEntity_GetCreatorName00
static int tolua_AllToLua_cProjectileEntity_GetCreatorName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cProjectileEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cProjectileEntity* self = (const cProjectileEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetCreatorName'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetCreatorName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetCreatorName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMCAClassName of class  cProjectileEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cProjectileEntity_GetMCAClassName00
static int tolua_AllToLua_cProjectileEntity_GetMCAClassName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cProjectileEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cProjectileEntity* self = (const cProjectileEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMCAClassName'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetMCAClassName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMCAClassName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsInGround of class  cProjectileEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cProjectileEntity_IsInGround00
static int tolua_AllToLua_cProjectileEntity_IsInGround00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cProjectileEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cProjectileEntity* self = (const cProjectileEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsInGround'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsInGround();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsInGround'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_isePickupState (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 2.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "ePickupState";
	return 0;
}
/* method: GetPickupState of class  cArrowEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cArrowEntity_GetPickupState00
static int tolua_AllToLua_cArrowEntity_GetPickupState00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cArrowEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cArrowEntity* self = (const cArrowEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPickupState'", nullptr);
#endif
  {
   cArrowEntity::ePickupState tolua_ret = (cArrowEntity::ePickupState)  self->GetPickupState();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPickupState'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetPickupState of class  cArrowEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cArrowEntity_SetPickupState00
static int tolua_AllToLua_cArrowEntity_SetPickupState00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cArrowEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cArrowEntity* self = (cArrowEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  cArrowEntity::ePickupState a_PickupState = ((cArrowEntity::ePickupState) (  int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetPickupState'", nullptr);
#endif
  {
   self->SetPickupState(a_PickupState);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetPickupState'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetDamageCoeff of class  cArrowEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cArrowEntity_GetDamageCoeff00
static int tolua_AllToLua_cArrowEntity_GetDamageCoeff00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cArrowEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cArrowEntity* self = (const cArrowEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetDamageCoeff'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetDamageCoeff();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetDamageCoeff'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetDamageCoeff of class  cArrowEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cArrowEntity_SetDamageCoeff00
static int tolua_AllToLua_cArrowEntity_SetDamageCoeff00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cArrowEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cArrowEntity* self = (cArrowEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_DamageCoeff = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetDamageCoeff'", nullptr);
#endif
  {
   self->SetDamageCoeff(a_DamageCoeff);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetDamageCoeff'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CanPickup of class  cArrowEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cArrowEntity_CanPickup00
static int tolua_AllToLua_cArrowEntity_CanPickup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cArrowEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cPlayer",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cArrowEntity* self = (const cArrowEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const cPlayer* a_Player = ((const cPlayer*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CanPickup'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->CanPickup(*a_Player);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CanPickup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsCritical of class  cArrowEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cArrowEntity_IsCritical00
static int tolua_AllToLua_cArrowEntity_IsCritical00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cArrowEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cArrowEntity* self = (const cArrowEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsCritical'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsCritical();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsCritical'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetIsCritical of class  cArrowEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cArrowEntity_SetIsCritical00
static int tolua_AllToLua_cArrowEntity_SetIsCritical00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cArrowEntity",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cArrowEntity* self = (cArrowEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_IsCritical = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetIsCritical'", nullptr);
#endif
  {
   self->SetIsCritical(a_IsCritical);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetIsCritical'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetBlockHit of class  cArrowEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cArrowEntity_GetBlockHit00
static int tolua_AllToLua_cArrowEntity_GetBlockHit00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cArrowEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cArrowEntity* self = (const cArrowEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetBlockHit'", nullptr);
#endif
  {
    Vector3<int> tolua_ret = (  Vector3<int>)  self->GetBlockHit();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetBlockHit'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPotionColor of class  cEntityEffect */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntityEffect_GetPotionColor00
static int tolua_AllToLua_cEntityEffect_GetPotionColor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cEntityEffect",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  short a_ItemDamage = ((short)  tolua_tonumber(tolua_S,2,0));
  {
   int tolua_ret = (int)  cEntityEffect::GetPotionColor(a_ItemDamage);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPotionColor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPotionEffectType of class  cEntityEffect */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntityEffect_GetPotionEffectType00
static int tolua_AllToLua_cEntityEffect_GetPotionEffectType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cEntityEffect",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  short a_ItemDamage = ((short)  tolua_tonumber(tolua_S,2,0));
  {
   cEntityEffect::eType tolua_ret = (cEntityEffect::eType)  cEntityEffect::GetPotionEffectType(a_ItemDamage);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPotionEffectType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPotionEffectIntensity of class  cEntityEffect */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntityEffect_GetPotionEffectIntensity00
static int tolua_AllToLua_cEntityEffect_GetPotionEffectIntensity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cEntityEffect",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  short a_ItemDamage = ((short)  tolua_tonumber(tolua_S,2,0));
  {
   short tolua_ret = (short)  cEntityEffect::GetPotionEffectIntensity(a_ItemDamage);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPotionEffectIntensity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPotionEffectDuration of class  cEntityEffect */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntityEffect_GetPotionEffectDuration00
static int tolua_AllToLua_cEntityEffect_GetPotionEffectDuration00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cEntityEffect",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  short a_ItemDamage = ((short)  tolua_tonumber(tolua_S,2,0));
  {
   int tolua_ret = (int)  cEntityEffect::GetPotionEffectDuration(a_ItemDamage);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPotionEffectDuration'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsPotionDrinkable of class  cEntityEffect */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntityEffect_IsPotionDrinkable00
static int tolua_AllToLua_cEntityEffect_IsPotionDrinkable00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cEntityEffect",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  short a_ItemDamage = ((short)  tolua_tonumber(tolua_S,2,0));
  {
   bool tolua_ret = (bool)  cEntityEffect::IsPotionDrinkable(a_ItemDamage);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsPotionDrinkable'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetAge of class  cExpOrb */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cExpOrb_GetAge00
static int tolua_AllToLua_cExpOrb_GetAge00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cExpOrb",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cExpOrb* self = (const cExpOrb*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetAge'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetAge();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetAge'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetAge of class  cExpOrb */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cExpOrb_SetAge00
static int tolua_AllToLua_cExpOrb_SetAge00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cExpOrb",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cExpOrb* self = (cExpOrb*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_Age = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetAge'", nullptr);
#endif
  {
   self->SetAge(a_Age);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetAge'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetReward of class  cExpOrb */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cExpOrb_GetReward00
static int tolua_AllToLua_cExpOrb_GetReward00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cExpOrb",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cExpOrb* self = (const cExpOrb*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetReward'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetReward();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetReward'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetReward of class  cExpOrb */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cExpOrb_SetReward00
static int tolua_AllToLua_cExpOrb_SetReward00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cExpOrb",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cExpOrb* self = (cExpOrb*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_Reward = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetReward'", nullptr);
#endif
  {
   self->SetReward(a_Reward);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetReward'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetBlockType of class  cFallingBlock */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFallingBlock_GetBlockType00
static int tolua_AllToLua_cFallingBlock_GetBlockType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cFallingBlock",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cFallingBlock* self = (const cFallingBlock*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetBlockType'", nullptr);
#endif
  {
   unsigned char tolua_ret = ( unsigned char)  self->GetBlockType();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetBlockType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetBlockMeta of class  cFallingBlock */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFallingBlock_GetBlockMeta00
static int tolua_AllToLua_cFallingBlock_GetBlockMeta00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cFallingBlock",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cFallingBlock* self = (const cFallingBlock*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetBlockMeta'", nullptr);
#endif
  {
   unsigned char tolua_ret = ( unsigned char)  self->GetBlockMeta();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetBlockMeta'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetItem of class  cFireworkEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFireworkEntity_GetItem00
static int tolua_AllToLua_cFireworkEntity_GetItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cFireworkEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cFireworkEntity* self = (const cFireworkEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetItem'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetItem();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetItem of class  cFireworkEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFireworkEntity_SetItem00
static int tolua_AllToLua_cFireworkEntity_SetItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cFireworkEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cFireworkEntity* self = (cFireworkEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetItem'", nullptr);
#endif
  {
   self->SetItem(*a_Item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetTicksToExplosion of class  cFireworkEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFireworkEntity_GetTicksToExplosion00
static int tolua_AllToLua_cFireworkEntity_GetTicksToExplosion00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cFireworkEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cFireworkEntity* self = (const cFireworkEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetTicksToExplosion'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetTicksToExplosion();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetTicksToExplosion'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetTicksToExplosion of class  cFireworkEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFireworkEntity_SetTicksToExplosion00
static int tolua_AllToLua_cFireworkEntity_SetTicksToExplosion00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cFireworkEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cFireworkEntity* self = (cFireworkEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_TicksToExplosion = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetTicksToExplosion'", nullptr);
#endif
  {
   self->SetTicksToExplosion(a_TicksToExplosion);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetTicksToExplosion'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CanPickup of class  cFloater */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFloater_CanPickup00
static int tolua_AllToLua_cFloater_CanPickup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cFloater",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cFloater* self = (const cFloater*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CanPickup'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->CanPickup();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CanPickup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetOwnerID of class  cFloater */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFloater_GetOwnerID00
static int tolua_AllToLua_cFloater_GetOwnerID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cFloater",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cFloater* self = (const cFloater*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetOwnerID'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->GetOwnerID();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetOwnerID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetAttachedMobID of class  cFloater */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFloater_GetAttachedMobID00
static int tolua_AllToLua_cFloater_GetAttachedMobID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cFloater",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cFloater* self = (const cFloater*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetAttachedMobID'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->GetAttachedMobID();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetAttachedMobID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetBitePos of class  cFloater */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFloater_GetBitePos00
static int tolua_AllToLua_cFloater_GetBitePos00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cFloater",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cFloater* self = (const cFloater*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetBitePos'", nullptr);
#endif
  {
    Vector3<double> tolua_ret = (  Vector3<double>)  self->GetBitePos();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<double>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<double>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetBitePos'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetFacing of class  cHangingEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cHangingEntity_GetFacing00
static int tolua_AllToLua_cHangingEntity_GetFacing00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cHangingEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cHangingEntity* self = (const cHangingEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetFacing'", nullptr);
#endif
  {
   eBlockFace tolua_ret = (eBlockFace)  self->GetFacing();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetFacing'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsValidSupportBlock of class  cHangingEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cHangingEntity_IsValidSupportBlock00
static int tolua_AllToLua_cHangingEntity_IsValidSupportBlock00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cHangingEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  unsigned char a_BlockType = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
  {
   bool tolua_ret = (bool)  cHangingEntity::IsValidSupportBlock(a_BlockType);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsValidSupportBlock'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseBlockFace (lua_State* L, int lo, int def, tolua_Error* err);
/* method: SetFacing of class  cHangingEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cHangingEntity_SetFacing00
static int tolua_AllToLua_cHangingEntity_SetFacing00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cHangingEntity",0,&tolua_err) ||
     !tolua_iseBlockFace(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cHangingEntity* self = (cHangingEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  eBlockFace a_Facing = ((eBlockFace) (  int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetFacing'", nullptr);
#endif
  {
   self->SetFacing(a_Facing);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetFacing'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetItem of class  cItemFrame */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemFrame_GetItem00
static int tolua_AllToLua_cItemFrame_GetItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItemFrame",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItemFrame* self = (const cItemFrame*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetItem'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetItem();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetItem of class  cItemFrame */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemFrame_SetItem00
static int tolua_AllToLua_cItemFrame_SetItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItemFrame",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItemFrame* self = (cItemFrame*)  tolua_tousertype(tolua_S,1,nullptr);
  cItem* a_Item = ((cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetItem'", nullptr);
#endif
  {
   self->SetItem(*a_Item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetItemRotation of class  cItemFrame */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemFrame_GetItemRotation00
static int tolua_AllToLua_cItemFrame_GetItemRotation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cItemFrame",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cItemFrame* self = (const cItemFrame*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetItemRotation'", nullptr);
#endif
  {
   Byte tolua_ret = (Byte)  self->GetItemRotation();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetItemRotation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetItemRotation of class  cItemFrame */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItemFrame_SetItemRotation00
static int tolua_AllToLua_cItemFrame_SetItemRotation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cItemFrame",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cItemFrame* self = (cItemFrame*)  tolua_tousertype(tolua_S,1,nullptr);
  Byte a_ItemRotation = ((Byte)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetItemRotation'", nullptr);
#endif
  {
   self->SetItemRotation(a_ItemRotation);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetItemRotation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: MAX_HEALTH of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_get_cPlayer_MAX_HEALTH
static int tolua_get_cPlayer_MAX_HEALTH(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)cPlayer::MAX_HEALTH);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: MAX_FOOD_LEVEL of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_get_cPlayer_MAX_FOOD_LEVEL
static int tolua_get_cPlayer_MAX_FOOD_LEVEL(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)cPlayer::MAX_FOOD_LEVEL);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetCurrentExperience of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetCurrentExperience00
static int tolua_AllToLua_cPlayer_SetCurrentExperience00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_XpTotal = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetCurrentExperience'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->SetCurrentExperience(a_XpTotal);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetCurrentExperience'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DeltaExperience of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_DeltaExperience00
static int tolua_AllToLua_cPlayer_DeltaExperience00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_Xp_delta = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeltaExperience'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->DeltaExperience(a_Xp_delta);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DeltaExperience'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetXpLifetimeTotal of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetXpLifetimeTotal00
static int tolua_AllToLua_cPlayer_GetXpLifetimeTotal00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetXpLifetimeTotal'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetXpLifetimeTotal();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetXpLifetimeTotal'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetCurrentXp of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetCurrentXp00
static int tolua_AllToLua_cPlayer_GetCurrentXp00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetCurrentXp'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetCurrentXp();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetCurrentXp'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetXpLevel of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetXpLevel00
static int tolua_AllToLua_cPlayer_GetXpLevel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetXpLevel'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetXpLevel();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetXpLevel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetXpPercentage of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetXpPercentage00
static int tolua_AllToLua_cPlayer_GetXpPercentage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetXpPercentage'", nullptr);
#endif
  {
   float tolua_ret = (float)  self->GetXpPercentage();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetXpPercentage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: XpForLevel of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_XpForLevel00
static int tolua_AllToLua_cPlayer_XpForLevel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  int a_Level = ((int)  tolua_tonumber(tolua_S,2,0));
  {
   int tolua_ret = (int)  cPlayer::XpForLevel(a_Level);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'XpForLevel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CalcLevelFromXp of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_CalcLevelFromXp00
static int tolua_AllToLua_cPlayer_CalcLevelFromXp00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  int a_CurrentXp = ((int)  tolua_tonumber(tolua_S,2,0));
  {
   int tolua_ret = (int)  cPlayer::CalcLevelFromXp(a_CurrentXp);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CalcLevelFromXp'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetEyeHeight of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetEyeHeight00
static int tolua_AllToLua_cPlayer_GetEyeHeight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEyeHeight'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetEyeHeight();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetEyeHeight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetEyePosition of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetEyePosition00
static int tolua_AllToLua_cPlayer_GetEyePosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEyePosition'", nullptr);
#endif
  {
    Vector3<double> tolua_ret = (  Vector3<double>)  self->GetEyePosition();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<double>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<double>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetEyePosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetInventory of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetInventory00
static int tolua_AllToLua_cPlayer_GetInventory00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetInventory'", nullptr);
#endif
  {
   cInventory& tolua_ret = (cInventory&)  self->GetInventory();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"cInventory");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetInventory'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetEquippedItem of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetEquippedItem00
static int tolua_AllToLua_cPlayer_GetEquippedItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEquippedItem'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetEquippedItem();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetEquippedItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Freeze of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_Freeze00
static int tolua_AllToLua_cPlayer_Freeze00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<double>* a_Location = ((const Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Freeze'", nullptr);
#endif
  {
   self->Freeze(*a_Location);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Freeze'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsFrozen of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_IsFrozen00
static int tolua_AllToLua_cPlayer_IsFrozen00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsFrozen'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsFrozen();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsFrozen'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Unfreeze of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_Unfreeze00
static int tolua_AllToLua_cPlayer_Unfreeze00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Unfreeze'", nullptr);
#endif
  {
   self->Unfreeze();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Unfreeze'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendRotation of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SendRotation00
static int tolua_AllToLua_cPlayer_SendRotation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_YawDegrees = ((double)  tolua_tonumber(tolua_S,2,0));
  double a_PitchDegrees = ((double)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendRotation'", nullptr);
#endif
  {
   self->SendRotation(a_YawDegrees,a_PitchDegrees);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendRotation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpectateEntity of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SpectateEntity00
static int tolua_AllToLua_cPlayer_SpectateEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"cEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  cEntity* a_Target = ((cEntity*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpectateEntity'", nullptr);
#endif
  {
   self->SpectateEntity(a_Target);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SpectateEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetThrowStartPos of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetThrowStartPos00
static int tolua_AllToLua_cPlayer_GetThrowStartPos00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetThrowStartPos'", nullptr);
#endif
  {
    Vector3<double> tolua_ret = (  Vector3<double>)  self->GetThrowStartPos();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<double>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<double>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetThrowStartPos'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetThrowSpeed of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetThrowSpeed00
static int tolua_AllToLua_cPlayer_GetThrowSpeed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_SpeedCoeff = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetThrowSpeed'", nullptr);
#endif
  {
    Vector3<double> tolua_ret = (  Vector3<double>)  self->GetThrowSpeed(a_SpeedCoeff);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<double>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<double>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetThrowSpeed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetGameMode of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetGameMode00
static int tolua_AllToLua_cPlayer_GetGameMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetGameMode'", nullptr);
#endif
  {
   eGameMode tolua_ret = (eGameMode)  self->GetGameMode();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetGameMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetEffectiveGameMode of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetEffectiveGameMode00
static int tolua_AllToLua_cPlayer_GetEffectiveGameMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEffectiveGameMode'", nullptr);
#endif
  {
   eGameMode tolua_ret = (eGameMode)  self->GetEffectiveGameMode();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetEffectiveGameMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseGameMode (lua_State* L, int lo, int def, tolua_Error* err);
/* method: SetGameMode of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetGameMode00
static int tolua_AllToLua_cPlayer_SetGameMode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_iseGameMode(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  eGameMode a_GameMode = ((eGameMode) (  int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetGameMode'", nullptr);
#endif
  {
   self->SetGameMode(a_GameMode);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetGameMode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsGameModeCreative of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_IsGameModeCreative00
static int tolua_AllToLua_cPlayer_IsGameModeCreative00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsGameModeCreative'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsGameModeCreative();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsGameModeCreative'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsGameModeSurvival of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_IsGameModeSurvival00
static int tolua_AllToLua_cPlayer_IsGameModeSurvival00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsGameModeSurvival'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsGameModeSurvival();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsGameModeSurvival'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsGameModeAdventure of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_IsGameModeAdventure00
static int tolua_AllToLua_cPlayer_IsGameModeAdventure00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsGameModeAdventure'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsGameModeAdventure();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsGameModeAdventure'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsGameModeSpectator of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_IsGameModeSpectator00
static int tolua_AllToLua_cPlayer_IsGameModeSpectator00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsGameModeSpectator'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsGameModeSpectator();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsGameModeSpectator'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsFireproof of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_IsFireproof00
static int tolua_AllToLua_cPlayer_IsFireproof00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsFireproof'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsFireproof();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsFireproof'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CanMobsTarget of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_CanMobsTarget00
static int tolua_AllToLua_cPlayer_CanMobsTarget00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CanMobsTarget'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->CanMobsTarget();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CanMobsTarget'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetIP of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetIP00
static int tolua_AllToLua_cPlayer_GetIP00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetIP'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetIP();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetIP'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetStatistics of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetStatistics00
static int tolua_AllToLua_cPlayer_GetStatistics00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetStatistics'", nullptr);
#endif
  {
   StatisticsManager& tolua_ret = (StatisticsManager&)  self->GetStatistics();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"StatisticsManager");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetStatistics'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetTeam of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetTeam00
static int tolua_AllToLua_cPlayer_GetTeam00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetTeam'", nullptr);
#endif
  {
   cTeam* tolua_ret = (cTeam*)  self->GetTeam();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cTeam");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetTeam'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetTeam of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetTeam01
static int tolua_AllToLua_cPlayer_GetTeam01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetTeam'", nullptr);
#endif
  {
   const cTeam* tolua_ret = (const cTeam*)  self->GetTeam();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"const cTeam");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cPlayer_GetTeam00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetTeam of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetTeam00
static int tolua_AllToLua_cPlayer_SetTeam00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"cTeam",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  cTeam* a_Team = ((cTeam*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetTeam'", nullptr);
#endif
  {
   self->SetTeam(a_Team);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetTeam'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ForceSetSpeed of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_ForceSetSpeed00
static int tolua_AllToLua_cPlayer_ForceSetSpeed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<double>* a_Speed = ((const Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ForceSetSpeed'", nullptr);
#endif
  {
   self->ForceSetSpeed(*a_Speed);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ForceSetSpeed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetWindow of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetWindow00
static int tolua_AllToLua_cPlayer_GetWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetWindow'", nullptr);
#endif
  {
   cWindow* tolua_ret = (cWindow*)  self->GetWindow();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cWindow");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: OpenWindow of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_OpenWindow00
static int tolua_AllToLua_cPlayer_OpenWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cWindow",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  cWindow* a_Window = ((cWindow*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'OpenWindow'", nullptr);
#endif
  {
   self->OpenWindow(*a_Window);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'OpenWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CloseWindow of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_CloseWindow00
static int tolua_AllToLua_cPlayer_CloseWindow00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_CanRefuse = ((bool)  tolua_toboolean(tolua_S,2,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CloseWindow'", nullptr);
#endif
  {
   self->CloseWindow(a_CanRefuse);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CloseWindow'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CloseWindowIfID of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_CloseWindowIfID00
static int tolua_AllToLua_cPlayer_CloseWindowIfID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isboolean(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  char a_WindowID = ((char)  tolua_tonumber(tolua_S,2,0));
  bool a_CanRefuse = ((bool)  tolua_toboolean(tolua_S,3,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CloseWindowIfID'", nullptr);
#endif
  {
   self->CloseWindowIfID(a_WindowID,a_CanRefuse);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CloseWindowIfID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetClientHandle of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetClientHandle00
static int tolua_AllToLua_cPlayer_GetClientHandle00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetClientHandle'", nullptr);
#endif
  {
   cClientHandle* tolua_ret = (cClientHandle*)  self->GetClientHandle();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cClientHandle");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetClientHandle'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendMessage of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SendMessage00
static int tolua_AllToLua_cPlayer_SendMessage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendMessage'", nullptr);
#endif
  {
   self->SendMessage(a_Message);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendMessage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendMessageInfo of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SendMessageInfo00
static int tolua_AllToLua_cPlayer_SendMessageInfo00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendMessageInfo'", nullptr);
#endif
  {
   self->SendMessageInfo(a_Message);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendMessageInfo'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendMessageFailure of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SendMessageFailure00
static int tolua_AllToLua_cPlayer_SendMessageFailure00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendMessageFailure'", nullptr);
#endif
  {
   self->SendMessageFailure(a_Message);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendMessageFailure'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendMessageSuccess of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SendMessageSuccess00
static int tolua_AllToLua_cPlayer_SendMessageSuccess00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendMessageSuccess'", nullptr);
#endif
  {
   self->SendMessageSuccess(a_Message);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendMessageSuccess'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendMessageWarning of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SendMessageWarning00
static int tolua_AllToLua_cPlayer_SendMessageWarning00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendMessageWarning'", nullptr);
#endif
  {
   self->SendMessageWarning(a_Message);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendMessageWarning'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendMessageFatal of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SendMessageFatal00
static int tolua_AllToLua_cPlayer_SendMessageFatal00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendMessageFatal'", nullptr);
#endif
  {
   self->SendMessageFatal(a_Message);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendMessageFatal'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendMessagePrivateMsg of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SendMessagePrivateMsg00
static int tolua_AllToLua_cPlayer_SendMessagePrivateMsg00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString a_Sender = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendMessagePrivateMsg'", nullptr);
#endif
  {
   self->SendMessagePrivateMsg(a_Message,a_Sender);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendMessagePrivateMsg'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendMessage of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SendMessage01
static int tolua_AllToLua_cPlayer_SendMessage01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cCompositeChat",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  const cCompositeChat* a_Message = ((const cCompositeChat*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendMessage'", nullptr);
#endif
  {
   self->SendMessage(*a_Message);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cPlayer_SendMessage00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseChatType (lua_State* L, int lo, int def, tolua_Error* err);
/* method: SendMessageRaw of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SendMessageRaw00
static int tolua_AllToLua_cPlayer_SendMessageRaw00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iseChatType(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_MessageRaw = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  eChatType a_Type = ((eChatType) (  int)  tolua_tonumber(tolua_S,3,eChatType::ctChatBox));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendMessageRaw'", nullptr);
#endif
  {
   self->SendMessageRaw(a_MessageRaw,a_Type);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendMessageRaw'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendSystemMessage of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SendSystemMessage00
static int tolua_AllToLua_cPlayer_SendSystemMessage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendSystemMessage'", nullptr);
#endif
  {
   self->SendSystemMessage(a_Message);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendSystemMessage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendAboveActionBarMessage of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SendAboveActionBarMessage00
static int tolua_AllToLua_cPlayer_SendAboveActionBarMessage00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Message = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendAboveActionBarMessage'", nullptr);
#endif
  {
   self->SendAboveActionBarMessage(a_Message);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendAboveActionBarMessage'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendSystemMessage of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SendSystemMessage01
static int tolua_AllToLua_cPlayer_SendSystemMessage01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cCompositeChat",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  const cCompositeChat* a_Message = ((const cCompositeChat*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendSystemMessage'", nullptr);
#endif
  {
   self->SendSystemMessage(*a_Message);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cPlayer_SendSystemMessage00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendAboveActionBarMessage of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SendAboveActionBarMessage01
static int tolua_AllToLua_cPlayer_SendAboveActionBarMessage01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cCompositeChat",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  const cCompositeChat* a_Message = ((const cCompositeChat*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendAboveActionBarMessage'", nullptr);
#endif
  {
   self->SendAboveActionBarMessage(*a_Message);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cPlayer_SendAboveActionBarMessage00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetName of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetName00
static int tolua_AllToLua_cPlayer_GetName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetName'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: HasPermission of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_HasPermission00
static int tolua_AllToLua_cPlayer_HasPermission00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Permission = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HasPermission'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->HasPermission(a_Permission);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'HasPermission'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetColor of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetColor00
static int tolua_AllToLua_cPlayer_GetColor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetColor'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetColor();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetColor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPrefix of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetPrefix00
static int tolua_AllToLua_cPlayer_GetPrefix00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPrefix'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetPrefix();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPrefix'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSuffix of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetSuffix00
static int tolua_AllToLua_cPlayer_GetSuffix00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSuffix'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetSuffix();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSuffix'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPlayerListName of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetPlayerListName00
static int tolua_AllToLua_cPlayer_GetPlayerListName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPlayerListName'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetPlayerListName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPlayerListName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: TossEquippedItem of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_TossEquippedItem00
static int tolua_AllToLua_cPlayer_TossEquippedItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  char a_Amount = ((char)  tolua_tonumber(tolua_S,2,1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'TossEquippedItem'", nullptr);
#endif
  {
   self->TossEquippedItem(a_Amount);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'TossEquippedItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ReplaceOneEquippedItemTossRest of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_ReplaceOneEquippedItemTossRest00
static int tolua_AllToLua_cPlayer_ReplaceOneEquippedItemTossRest00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* tolua_var_1 = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ReplaceOneEquippedItemTossRest'", nullptr);
#endif
  {
   self->ReplaceOneEquippedItemTossRest(*tolua_var_1);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ReplaceOneEquippedItemTossRest'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: TossHeldItem of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_TossHeldItem00
static int tolua_AllToLua_cPlayer_TossHeldItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  char a_Amount = ((char)  tolua_tonumber(tolua_S,2,1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'TossHeldItem'", nullptr);
#endif
  {
   self->TossHeldItem(a_Amount);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'TossHeldItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: TossPickup of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_TossPickup00
static int tolua_AllToLua_cPlayer_TossPickup00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'TossPickup'", nullptr);
#endif
  {
   self->TossPickup(*a_Item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'TossPickup'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Heal of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_Heal00
static int tolua_AllToLua_cPlayer_Heal00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_Health = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Heal'", nullptr);
#endif
  {
   self->Heal(a_Health);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Heal'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetFoodLevel of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetFoodLevel00
static int tolua_AllToLua_cPlayer_GetFoodLevel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetFoodLevel'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetFoodLevel();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetFoodLevel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetFoodSaturationLevel of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetFoodSaturationLevel00
static int tolua_AllToLua_cPlayer_GetFoodSaturationLevel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetFoodSaturationLevel'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetFoodSaturationLevel();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetFoodSaturationLevel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetFoodTickTimer of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetFoodTickTimer00
static int tolua_AllToLua_cPlayer_GetFoodTickTimer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetFoodTickTimer'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetFoodTickTimer();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetFoodTickTimer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetFoodExhaustionLevel of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetFoodExhaustionLevel00
static int tolua_AllToLua_cPlayer_GetFoodExhaustionLevel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetFoodExhaustionLevel'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetFoodExhaustionLevel();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetFoodExhaustionLevel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsSatiated of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_IsSatiated00
static int tolua_AllToLua_cPlayer_IsSatiated00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsSatiated'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsSatiated();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsSatiated'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetFoodLevel of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetFoodLevel00
static int tolua_AllToLua_cPlayer_SetFoodLevel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_FoodLevel = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetFoodLevel'", nullptr);
#endif
  {
   self->SetFoodLevel(a_FoodLevel);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetFoodLevel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetFoodSaturationLevel of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetFoodSaturationLevel00
static int tolua_AllToLua_cPlayer_SetFoodSaturationLevel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_FoodSaturationLevel = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetFoodSaturationLevel'", nullptr);
#endif
  {
   self->SetFoodSaturationLevel(a_FoodSaturationLevel);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetFoodSaturationLevel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetFoodTickTimer of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetFoodTickTimer00
static int tolua_AllToLua_cPlayer_SetFoodTickTimer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_FoodTickTimer = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetFoodTickTimer'", nullptr);
#endif
  {
   self->SetFoodTickTimer(a_FoodTickTimer);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetFoodTickTimer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetFoodExhaustionLevel of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetFoodExhaustionLevel00
static int tolua_AllToLua_cPlayer_SetFoodExhaustionLevel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_FoodExhaustionLevel = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetFoodExhaustionLevel'", nullptr);
#endif
  {
   self->SetFoodExhaustionLevel(a_FoodExhaustionLevel);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetFoodExhaustionLevel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Feed of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_Feed00
static int tolua_AllToLua_cPlayer_Feed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_Food = ((int)  tolua_tonumber(tolua_S,2,0));
  double a_Saturation = ((double)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Feed'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->Feed(a_Food,a_Saturation);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Feed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddFoodExhaustion of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_AddFoodExhaustion00
static int tolua_AllToLua_cPlayer_AddFoodExhaustion00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_Exhaustion = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddFoodExhaustion'", nullptr);
#endif
  {
   self->AddFoodExhaustion(a_Exhaustion);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddFoodExhaustion'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsEating of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_IsEating00
static int tolua_AllToLua_cPlayer_IsEating00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsEating'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsEating();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsEating'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsFlying of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_IsFlying00
static int tolua_AllToLua_cPlayer_IsFlying00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsFlying'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsFlying();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsFlying'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsInBed of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_IsInBed00
static int tolua_AllToLua_cPlayer_IsInBed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsInBed'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsInBed();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsInBed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsLeftHanded of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_IsLeftHanded00
static int tolua_AllToLua_cPlayer_IsLeftHanded00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsLeftHanded'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsLeftHanded();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsLeftHanded'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsFishing of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_IsFishing00
static int tolua_AllToLua_cPlayer_IsFishing00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsFishing'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsFishing();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsFishing'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetIsFishing of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetIsFishing00
static int tolua_AllToLua_cPlayer_SetIsFishing00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_IsFishing = ((bool)  tolua_toboolean(tolua_S,2,0));
  unsigned int a_FloaterID = (( unsigned int)  tolua_tonumber(tolua_S,3,cEntity::INVALID_ID));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetIsFishing'", nullptr);
#endif
  {
   self->SetIsFishing(a_IsFishing,a_FloaterID);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetIsFishing'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetFloaterID of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetFloaterID00
static int tolua_AllToLua_cPlayer_GetFloaterID00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetFloaterID'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->GetFloaterID();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetFloaterID'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Respawn of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_Respawn00
static int tolua_AllToLua_cPlayer_Respawn00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Respawn'", nullptr);
#endif
  {
   self->Respawn();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Respawn'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetVisible of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetVisible00
static int tolua_AllToLua_cPlayer_SetVisible00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_bVisible = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetVisible'", nullptr);
#endif
  {
   self->SetVisible(a_bVisible);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetVisible'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetDraggingItem of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetDraggingItem00
static int tolua_AllToLua_cPlayer_GetDraggingItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetDraggingItem'", nullptr);
#endif
  {
   cItem& tolua_ret = (cItem&)  self->GetDraggingItem();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetDraggingItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetDraggingItem of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetDraggingItem00
static int tolua_AllToLua_cPlayer_SetDraggingItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetDraggingItem'", nullptr);
#endif
  {
   self->SetDraggingItem(*a_Item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetDraggingItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMaxSpeed of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetMaxSpeed00
static int tolua_AllToLua_cPlayer_GetMaxSpeed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMaxSpeed'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetMaxSpeed();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMaxSpeed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNormalMaxSpeed of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetNormalMaxSpeed00
static int tolua_AllToLua_cPlayer_GetNormalMaxSpeed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNormalMaxSpeed'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetNormalMaxSpeed();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetNormalMaxSpeed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSprintingMaxSpeed of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetSprintingMaxSpeed00
static int tolua_AllToLua_cPlayer_GetSprintingMaxSpeed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSprintingMaxSpeed'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetSprintingMaxSpeed();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSprintingMaxSpeed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetFlyingMaxSpeed of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetFlyingMaxSpeed00
static int tolua_AllToLua_cPlayer_GetFlyingMaxSpeed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetFlyingMaxSpeed'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetFlyingMaxSpeed();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetFlyingMaxSpeed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetNormalMaxSpeed of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetNormalMaxSpeed00
static int tolua_AllToLua_cPlayer_SetNormalMaxSpeed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_Speed = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetNormalMaxSpeed'", nullptr);
#endif
  {
   self->SetNormalMaxSpeed(a_Speed);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetNormalMaxSpeed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSprintingMaxSpeed of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetSprintingMaxSpeed00
static int tolua_AllToLua_cPlayer_SetSprintingMaxSpeed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_Speed = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSprintingMaxSpeed'", nullptr);
#endif
  {
   self->SetSprintingMaxSpeed(a_Speed);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetSprintingMaxSpeed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetFlyingMaxSpeed of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetFlyingMaxSpeed00
static int tolua_AllToLua_cPlayer_SetFlyingMaxSpeed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_Speed = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetFlyingMaxSpeed'", nullptr);
#endif
  {
   self->SetFlyingMaxSpeed(a_Speed);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetFlyingMaxSpeed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetCrouch of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetCrouch00
static int tolua_AllToLua_cPlayer_SetCrouch00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_ShouldCrouch = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetCrouch'", nullptr);
#endif
  {
   self->SetCrouch(a_ShouldCrouch);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetCrouch'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetElytraFlight of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetElytraFlight00
static int tolua_AllToLua_cPlayer_SetElytraFlight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_ShouldElytraFly = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetElytraFlight'", nullptr);
#endif
  {
   self->SetElytraFlight(a_ShouldElytraFly);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetElytraFlight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetFlying of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetFlying00
static int tolua_AllToLua_cPlayer_SetFlying00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_ShouldFly = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetFlying'", nullptr);
#endif
  {
   self->SetFlying(a_ShouldFly);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetFlying'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetLeftHanded of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetLeftHanded00
static int tolua_AllToLua_cPlayer_SetLeftHanded00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_IsLeftHanded = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetLeftHanded'", nullptr);
#endif
  {
   self->SetLeftHanded(a_IsLeftHanded);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetLeftHanded'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSprint of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetSprint00
static int tolua_AllToLua_cPlayer_SetSprint00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_ShouldSprint = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSprint'", nullptr);
#endif
  {
   self->SetSprint(a_ShouldSprint);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetSprint'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetCanFly of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetCanFly00
static int tolua_AllToLua_cPlayer_SetCanFly00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_CanFly = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetCanFly'", nullptr);
#endif
  {
   self->SetCanFly(a_CanFly);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetCanFly'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: HasCustomName of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_HasCustomName00
static int tolua_AllToLua_cPlayer_HasCustomName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HasCustomName'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->HasCustomName();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'HasCustomName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetCustomName of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetCustomName00
static int tolua_AllToLua_cPlayer_GetCustomName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetCustomName'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetCustomName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetCustomName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetCustomName of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetCustomName00
static int tolua_AllToLua_cPlayer_SetCustomName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_CustomName = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetCustomName'", nullptr);
#endif
  {
   self->SetCustomName(a_CustomName);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetCustomName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetLastBedPos of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetLastBedPos00
static int tolua_AllToLua_cPlayer_GetLastBedPos00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetLastBedPos'", nullptr);
#endif
  {
    Vector3<int> tolua_ret = (  Vector3<int>)  self->GetLastBedPos();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetLastBedPos'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsRespawnPointForced of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_IsRespawnPointForced00
static int tolua_AllToLua_cPlayer_IsRespawnPointForced00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsRespawnPointForced'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsRespawnPointForced();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsRespawnPointForced'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetBedPos of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetBedPos00
static int tolua_AllToLua_cPlayer_SetBedPos00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<int> a_Position = *((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetBedPos'", nullptr);
#endif
  {
   self->SetBedPos(a_Position);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetBedPos'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetBedPos of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetBedPos01
static int tolua_AllToLua_cPlayer_SetBedPos01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cWorld",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<int> a_Position = *((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
  const cWorld* a_World = ((const cWorld*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetBedPos'", nullptr);
#endif
  {
   self->SetBedPos(a_Position,*a_World);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cPlayer_SetBedPos00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetRespawnPosition of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetRespawnPosition00
static int tolua_AllToLua_cPlayer_SetRespawnPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cWorld",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<int> a_Position = *((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
  const cWorld* a_World = ((const cWorld*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetRespawnPosition'", nullptr);
#endif
  {
   self->SetRespawnPosition(a_Position,*a_World);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetRespawnPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CanFly of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_CanFly00
static int tolua_AllToLua_cPlayer_CanFly00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CanFly'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->CanFly();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CanFly'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: LoadRank of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_LoadRank00
static int tolua_AllToLua_cPlayer_LoadRank00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'LoadRank'", nullptr);
#endif
  {
   self->LoadRank();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'LoadRank'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SendBlocksAround of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SendBlocksAround00
static int tolua_AllToLua_cPlayer_SendBlocksAround00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<int> a_BlockPos = *((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
  int a_Range = ((int)  tolua_tonumber(tolua_S,3,1));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendBlocksAround'", nullptr);
#endif
  {
   self->SendBlocksAround(a_BlockPos,a_Range);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SendBlocksAround'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseSkinPart (lua_State* L, int lo, int def, tolua_Error* err);
/* method: HasSkinPart of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_HasSkinPart00
static int tolua_AllToLua_cPlayer_HasSkinPart00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_iseSkinPart(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  eSkinPart a_Part = ((eSkinPart) (  int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HasSkinPart'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->HasSkinPart(a_Part);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'HasSkinPart'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSkinParts of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetSkinParts00
static int tolua_AllToLua_cPlayer_GetSkinParts00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPlayer",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPlayer* self = (const cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSkinParts'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetSkinParts();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSkinParts'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSkinParts of class  cPlayer */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetSkinParts00
static int tolua_AllToLua_cPlayer_SetSkinParts00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPlayer* self = (cPlayer*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_Parts = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSkinParts'", nullptr);
#endif
  {
   self->SetSkinParts(a_Parts);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetSkinParts'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetName of class  cPainting */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPainting_GetName00
static int tolua_AllToLua_cPainting_GetName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPainting",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPainting* self = (const cPainting*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetName'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetItem of class  cPickup */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPickup_GetItem00
static int tolua_AllToLua_cPickup_GetItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPickup",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPickup* self = (cPickup*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetItem'", nullptr);
#endif
  {
   cItem& tolua_ret = (cItem&)  self->GetItem();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CollectedBy of class  cPickup */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPickup_CollectedBy00
static int tolua_AllToLua_cPickup_CollectedBy00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPickup",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cEntity",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPickup* self = (cPickup*)  tolua_tousertype(tolua_S,1,nullptr);
  cEntity* a_Dest = ((cEntity*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CollectedBy'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->CollectedBy(*a_Dest);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CollectedBy'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CanCombine of class  cPickup */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPickup_CanCombine00
static int tolua_AllToLua_cPickup_CanCombine00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPickup",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPickup* self = (const cPickup*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CanCombine'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->CanCombine();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CanCombine'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetCanCombine of class  cPickup */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPickup_SetCanCombine00
static int tolua_AllToLua_cPickup_SetCanCombine00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPickup",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPickup* self = (cPickup*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_CanCombine = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetCanCombine'", nullptr);
#endif
  {
   self->SetCanCombine(a_CanCombine);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetCanCombine'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetAge of class  cPickup */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPickup_GetAge00
static int tolua_AllToLua_cPickup_GetAge00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPickup",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPickup* self = (const cPickup*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetAge'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetAge();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetAge'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetAge of class  cPickup */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPickup_SetAge00
static int tolua_AllToLua_cPickup_SetAge00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPickup",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPickup* self = (cPickup*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_Age = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetAge'", nullptr);
#endif
  {
   self->SetAge(a_Age);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetAge'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetLifetime of class  cPickup */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPickup_GetLifetime00
static int tolua_AllToLua_cPickup_GetLifetime00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPickup",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPickup* self = (const cPickup*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetLifetime'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetLifetime();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetLifetime'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetLifetime of class  cPickup */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPickup_SetLifetime00
static int tolua_AllToLua_cPickup_SetLifetime00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cPickup",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cPickup* self = (cPickup*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_Lifetime = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetLifetime'", nullptr);
#endif
  {
   self->SetLifetime(a_Lifetime);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetLifetime'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsCollected of class  cPickup */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPickup_IsCollected00
static int tolua_AllToLua_cPickup_IsCollected00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPickup",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPickup* self = (const cPickup*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsCollected'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsCollected();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsCollected'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsPlayerCreated of class  cPickup */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cPickup_IsPlayerCreated00
static int tolua_AllToLua_cPickup_IsPlayerCreated00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cPickup",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cPickup* self = (const cPickup*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsPlayerCreated'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsPlayerCreated();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsPlayerCreated'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetEntityEffectType of class  cSplashPotionEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cSplashPotionEntity_GetEntityEffectType00
static int tolua_AllToLua_cSplashPotionEntity_GetEntityEffectType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cSplashPotionEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cSplashPotionEntity* self = (const cSplashPotionEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEntityEffectType'", nullptr);
#endif
  {
   cEntityEffect::eType tolua_ret = (cEntityEffect::eType)  self->GetEntityEffectType();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetEntityEffectType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPotionColor of class  cSplashPotionEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cSplashPotionEntity_GetPotionColor00
static int tolua_AllToLua_cSplashPotionEntity_GetPotionColor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cSplashPotionEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cSplashPotionEntity* self = (const cSplashPotionEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPotionColor'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetPotionColor();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPotionColor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetItem of class  cSplashPotionEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cSplashPotionEntity_GetItem00
static int tolua_AllToLua_cSplashPotionEntity_GetItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cSplashPotionEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cSplashPotionEntity* self = (const cSplashPotionEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetItem'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetItem();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetEntityEffectType of class  cSplashPotionEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cSplashPotionEntity_SetEntityEffectType00
static int tolua_AllToLua_cSplashPotionEntity_SetEntityEffectType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cSplashPotionEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cSplashPotionEntity* self = (cSplashPotionEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  cEntityEffect::eType a_EntityEffectType = ((cEntityEffect::eType) (  int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetEntityEffectType'", nullptr);
#endif
  {
   self->SetEntityEffectType(a_EntityEffectType);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetEntityEffectType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetPotionColor of class  cSplashPotionEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cSplashPotionEntity_SetPotionColor00
static int tolua_AllToLua_cSplashPotionEntity_SetPotionColor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cSplashPotionEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cSplashPotionEntity* self = (cSplashPotionEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_PotionColor = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetPotionColor'", nullptr);
#endif
  {
   self->SetPotionColor(a_PotionColor);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetPotionColor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Explode of class  cTNTEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cTNTEntity_Explode00
static int tolua_AllToLua_cTNTEntity_Explode00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cTNTEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cTNTEntity* self = (cTNTEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Explode'", nullptr);
#endif
  {
   self->Explode();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Explode'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetFuseTicks of class  cTNTEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cTNTEntity_GetFuseTicks00
static int tolua_AllToLua_cTNTEntity_GetFuseTicks00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cTNTEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cTNTEntity* self = (const cTNTEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetFuseTicks'", nullptr);
#endif
  {
   unsigned tolua_ret = (unsigned)  self->GetFuseTicks();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetFuseTicks'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetFuseTicks of class  cTNTEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cTNTEntity_SetFuseTicks00
static int tolua_AllToLua_cTNTEntity_SetFuseTicks00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cTNTEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cTNTEntity* self = (cTNTEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  unsigned a_FuseTicks = ((unsigned)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetFuseTicks'", nullptr);
#endif
  {
   self->SetFuseTicks(a_FuseTicks);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetFuseTicks'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseMonsterType (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= -1.0 && val <= 69.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eMonsterType";
	return 0;
}
int tolua_iseFamily (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 4.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "eFamily";
	return 0;
}
/* method: MoveToPosition of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_MoveToPosition00
static int tolua_AllToLua_cMonster_MoveToPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMonster",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMonster* self = (cMonster*)  tolua_tousertype(tolua_S,1,nullptr);
  const Vector3<double>* a_Position = ((const Vector3<double>*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'MoveToPosition'", nullptr);
#endif
  {
   self->MoveToPosition(*a_Position);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'MoveToPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMobType of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_GetMobType00
static int tolua_AllToLua_cMonster_GetMobType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMonster",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMonster* self = (const cMonster*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMobType'", nullptr);
#endif
  {
   eMonsterType tolua_ret = (eMonsterType)  self->GetMobType();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMobType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMobFamily of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_GetMobFamily00
static int tolua_AllToLua_cMonster_GetMobFamily00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMonster",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMonster* self = (const cMonster*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMobFamily'", nullptr);
#endif
  {
   cMonster::eFamily tolua_ret = (cMonster::eFamily)  self->GetMobFamily();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMobFamily'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CanBeLeashed of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_CanBeLeashed00
static int tolua_AllToLua_cMonster_CanBeLeashed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMonster",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMonster* self = (const cMonster*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CanBeLeashed'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->CanBeLeashed();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CanBeLeashed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetCanBeLeashed of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_SetCanBeLeashed00
static int tolua_AllToLua_cMonster_SetCanBeLeashed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMonster",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMonster* self = (cMonster*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_CanBeLeashed = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetCanBeLeashed'", nullptr);
#endif
  {
   self->SetCanBeLeashed(a_CanBeLeashed);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetCanBeLeashed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsLeashed of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_IsLeashed00
static int tolua_AllToLua_cMonster_IsLeashed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMonster",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMonster* self = (const cMonster*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsLeashed'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsLeashed();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsLeashed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: LeashTo of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_LeashTo00
static int tolua_AllToLua_cMonster_LeashTo00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMonster",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cEntity",0,&tolua_err)) ||
     !tolua_isboolean(tolua_S,3,1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMonster* self = (cMonster*)  tolua_tousertype(tolua_S,1,nullptr);
  cEntity* a_Entity = ((cEntity*)  tolua_tousertype(tolua_S,2,nullptr));
  bool a_ShouldBroadcast = ((bool)  tolua_toboolean(tolua_S,3,true));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'LeashTo'", nullptr);
#endif
  {
   self->LeashTo(*a_Entity,a_ShouldBroadcast);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'LeashTo'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Unleash of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_Unleash00
static int tolua_AllToLua_cMonster_Unleash00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMonster",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMonster* self = (cMonster*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_ShouldDropLeashPickup = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Unleash'", nullptr);
#endif
  {
   self->Unleash(a_ShouldDropLeashPickup);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Unleash'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetLeashedTo of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_GetLeashedTo00
static int tolua_AllToLua_cMonster_GetLeashedTo00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMonster",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMonster* self = (const cMonster*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetLeashedTo'", nullptr);
#endif
  {
   cEntity* tolua_ret = (cEntity*)  self->GetLeashedTo();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cEntity");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetLeashedTo'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetBurnsInDaylight of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_SetBurnsInDaylight00
static int tolua_AllToLua_cMonster_SetBurnsInDaylight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMonster",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMonster* self = (cMonster*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_BurnsInDaylight = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetBurnsInDaylight'", nullptr);
#endif
  {
   self->SetBurnsInDaylight(a_BurnsInDaylight);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetBurnsInDaylight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: BurnsInDaylight of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_BurnsInDaylight00
static int tolua_AllToLua_cMonster_BurnsInDaylight00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMonster",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMonster* self = (const cMonster*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'BurnsInDaylight'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->BurnsInDaylight();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'BurnsInDaylight'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetRelativeWalkSpeed of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_GetRelativeWalkSpeed00
static int tolua_AllToLua_cMonster_GetRelativeWalkSpeed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMonster",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMonster* self = (const cMonster*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetRelativeWalkSpeed'", nullptr);
#endif
  {
   double tolua_ret = (double)  self->GetRelativeWalkSpeed();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetRelativeWalkSpeed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetRelativeWalkSpeed of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_SetRelativeWalkSpeed00
static int tolua_AllToLua_cMonster_SetRelativeWalkSpeed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMonster",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMonster* self = (cMonster*)  tolua_tousertype(tolua_S,1,nullptr);
  double a_WalkSpeed = ((double)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetRelativeWalkSpeed'", nullptr);
#endif
  {
   self->SetRelativeWalkSpeed(a_WalkSpeed);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetRelativeWalkSpeed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsBaby of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_IsBaby00
static int tolua_AllToLua_cMonster_IsBaby00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMonster",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMonster* self = (const cMonster*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsBaby'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsBaby();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsBaby'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetAge of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_GetAge00
static int tolua_AllToLua_cMonster_GetAge00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMonster",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMonster* self = (const cMonster*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetAge'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetAge();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetAge'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetAge of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_SetAge00
static int tolua_AllToLua_cMonster_SetAge00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMonster",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMonster* self = (cMonster*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_Age = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetAge'", nullptr);
#endif
  {
   self->SetAge(a_Age);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetAge'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: HasCustomName of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_HasCustomName00
static int tolua_AllToLua_cMonster_HasCustomName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMonster",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMonster* self = (const cMonster*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HasCustomName'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->HasCustomName();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'HasCustomName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetCustomName of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_GetCustomName00
static int tolua_AllToLua_cMonster_GetCustomName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMonster",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMonster* self = (const cMonster*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetCustomName'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetCustomName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetCustomName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetCustomName of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_SetCustomName00
static int tolua_AllToLua_cMonster_SetCustomName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMonster",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMonster* self = (cMonster*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_CustomName = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetCustomName'", nullptr);
#endif
  {
   self->SetCustomName(a_CustomName);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetCustomName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsCustomNameAlwaysVisible of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_IsCustomNameAlwaysVisible00
static int tolua_AllToLua_cMonster_IsCustomNameAlwaysVisible00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMonster",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMonster* self = (const cMonster*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsCustomNameAlwaysVisible'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsCustomNameAlwaysVisible();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsCustomNameAlwaysVisible'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetCustomNameAlwaysVisible of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_SetCustomNameAlwaysVisible00
static int tolua_AllToLua_cMonster_SetCustomNameAlwaysVisible00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMonster",0,&tolua_err) ||
     !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMonster* self = (cMonster*)  tolua_tousertype(tolua_S,1,nullptr);
  bool a_CustomNameAlwaysVisible = ((bool)  tolua_toboolean(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetCustomNameAlwaysVisible'", nullptr);
#endif
  {
   self->SetCustomNameAlwaysVisible(a_CustomNameAlwaysVisible);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetCustomNameAlwaysVisible'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseMonsterType (lua_State* L, int lo, int def, tolua_Error* err);
/* method: MobTypeToString of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_MobTypeToString00
static int tolua_AllToLua_cMonster_MobTypeToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cMonster",0,&tolua_err) ||
     !tolua_iseMonsterType(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  eMonsterType a_MobType = ((eMonsterType) (  int)  tolua_tonumber(tolua_S,2,0));
  {
   AString tolua_ret = (AString)  cMonster::MobTypeToString(a_MobType);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'MobTypeToString'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseMonsterType (lua_State* L, int lo, int def, tolua_Error* err);
/* method: MobTypeToVanillaName of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_MobTypeToVanillaName00
static int tolua_AllToLua_cMonster_MobTypeToVanillaName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cMonster",0,&tolua_err) ||
     !tolua_iseMonsterType(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  eMonsterType a_MobType = ((eMonsterType) (  int)  tolua_tonumber(tolua_S,2,0));
  {
   AString tolua_ret = (AString)  cMonster::MobTypeToVanillaName(a_MobType);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'MobTypeToVanillaName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: StringToMobType of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_StringToMobType00
static int tolua_AllToLua_cMonster_StringToMobType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cMonster",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const AString a_MobTypeName = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  {
   eMonsterType tolua_ret = (eMonsterType)  cMonster::StringToMobType(a_MobTypeName);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'StringToMobType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseMonsterType (lua_State* L, int lo, int def, tolua_Error* err);
/* method: FamilyFromType of class  cMonster */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMonster_FamilyFromType00
static int tolua_AllToLua_cMonster_FamilyFromType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cMonster",0,&tolua_err) ||
     !tolua_iseMonsterType(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  eMonsterType a_MobType = ((eMonsterType) (  int)  tolua_tonumber(tolua_S,2,0));
  {
   cMonster::eFamily tolua_ret = (cMonster::eFamily)  cMonster::FamilyFromType(a_MobType);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'FamilyFromType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPos of class  cBlockEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockEntity_GetPos00
static int tolua_AllToLua_cBlockEntity_GetPos00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockEntity* self = (const cBlockEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPos'", nullptr);
#endif
  {
    Vector3<int> tolua_ret = (  Vector3<int>)  self->GetPos();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPos'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPosX of class  cBlockEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockEntity_GetPosX00
static int tolua_AllToLua_cBlockEntity_GetPosX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockEntity* self = (const cBlockEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPosX'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetPosX();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPosX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPosY of class  cBlockEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockEntity_GetPosY00
static int tolua_AllToLua_cBlockEntity_GetPosY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockEntity* self = (const cBlockEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPosY'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetPosY();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPosY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPosZ of class  cBlockEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockEntity_GetPosZ00
static int tolua_AllToLua_cBlockEntity_GetPosZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockEntity* self = (const cBlockEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPosZ'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetPosZ();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPosZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetRelPos of class  cBlockEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockEntity_GetRelPos00
static int tolua_AllToLua_cBlockEntity_GetRelPos00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockEntity* self = (const cBlockEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetRelPos'", nullptr);
#endif
  {
    Vector3<int> tolua_ret = (  Vector3<int>)  self->GetRelPos();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<int>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<int>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<int>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetRelPos'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetBlockType of class  cBlockEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockEntity_GetBlockType00
static int tolua_AllToLua_cBlockEntity_GetBlockType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockEntity* self = (const cBlockEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetBlockType'", nullptr);
#endif
  {
   unsigned char tolua_ret = ( unsigned char)  self->GetBlockType();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetBlockType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetWorld of class  cBlockEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockEntity_GetWorld00
static int tolua_AllToLua_cBlockEntity_GetWorld00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockEntity* self = (const cBlockEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetWorld'", nullptr);
#endif
  {
   cWorld* tolua_ret = (cWorld*)  self->GetWorld();
    tolua_pushusertype(tolua_S,(void*)tolua_ret,"cWorld");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetWorld'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetChunkX of class  cBlockEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockEntity_GetChunkX00
static int tolua_AllToLua_cBlockEntity_GetChunkX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockEntity* self = (const cBlockEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetChunkX'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetChunkX();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetChunkX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetChunkZ of class  cBlockEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockEntity_GetChunkZ00
static int tolua_AllToLua_cBlockEntity_GetChunkZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockEntity* self = (const cBlockEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetChunkZ'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetChunkZ();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetChunkZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetRelX of class  cBlockEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockEntity_GetRelX00
static int tolua_AllToLua_cBlockEntity_GetRelX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockEntity* self = (const cBlockEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetRelX'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetRelX();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetRelX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetRelZ of class  cBlockEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockEntity_GetRelZ00
static int tolua_AllToLua_cBlockEntity_GetRelZ00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockEntity* self = (const cBlockEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetRelZ'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetRelZ();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetRelZ'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsActive of class  cBeaconEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBeaconEntity_IsActive00
static int tolua_AllToLua_cBeaconEntity_IsActive00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBeaconEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBeaconEntity* self = (const cBeaconEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsActive'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsActive();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsActive'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetBeaconLevel of class  cBeaconEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBeaconEntity_GetBeaconLevel00
static int tolua_AllToLua_cBeaconEntity_GetBeaconLevel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBeaconEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBeaconEntity* self = (const cBeaconEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetBeaconLevel'", nullptr);
#endif
  {
   char tolua_ret = (char)  self->GetBeaconLevel();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetBeaconLevel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPrimaryEffect of class  cBeaconEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBeaconEntity_GetPrimaryEffect00
static int tolua_AllToLua_cBeaconEntity_GetPrimaryEffect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBeaconEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBeaconEntity* self = (const cBeaconEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPrimaryEffect'", nullptr);
#endif
  {
   cEntityEffect::eType tolua_ret = (cEntityEffect::eType)  self->GetPrimaryEffect();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPrimaryEffect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSecondaryEffect of class  cBeaconEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBeaconEntity_GetSecondaryEffect00
static int tolua_AllToLua_cBeaconEntity_GetSecondaryEffect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBeaconEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBeaconEntity* self = (const cBeaconEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSecondaryEffect'", nullptr);
#endif
  {
   cEntityEffect::eType tolua_ret = (cEntityEffect::eType)  self->GetSecondaryEffect();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSecondaryEffect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetPrimaryEffect of class  cBeaconEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBeaconEntity_SetPrimaryEffect00
static int tolua_AllToLua_cBeaconEntity_SetPrimaryEffect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBeaconEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBeaconEntity* self = (cBeaconEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  cEntityEffect::eType a_Effect = ((cEntityEffect::eType) (  int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetPrimaryEffect'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->SetPrimaryEffect(a_Effect);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetPrimaryEffect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSecondaryEffect of class  cBeaconEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBeaconEntity_SetSecondaryEffect00
static int tolua_AllToLua_cBeaconEntity_SetSecondaryEffect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBeaconEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBeaconEntity* self = (cBeaconEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  cEntityEffect::eType a_Effect = ((cEntityEffect::eType) (  int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSecondaryEffect'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->SetSecondaryEffect(a_Effect);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetSecondaryEffect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: CalculatePyramidLevel of class  cBeaconEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBeaconEntity_CalculatePyramidLevel00
static int tolua_AllToLua_cBeaconEntity_CalculatePyramidLevel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBeaconEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBeaconEntity* self = (cBeaconEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CalculatePyramidLevel'", nullptr);
#endif
  {
   char tolua_ret = (char)  self->CalculatePyramidLevel();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'CalculatePyramidLevel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsBeaconBlocked of class  cBeaconEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBeaconEntity_IsBeaconBlocked00
static int tolua_AllToLua_cBeaconEntity_IsBeaconBlocked00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBeaconEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBeaconEntity* self = (cBeaconEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsBeaconBlocked'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsBeaconBlocked();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsBeaconBlocked'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: UpdateBeacon of class  cBeaconEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBeaconEntity_UpdateBeacon00
static int tolua_AllToLua_cBeaconEntity_UpdateBeacon00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBeaconEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBeaconEntity* self = (cBeaconEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'UpdateBeacon'", nullptr);
#endif
  {
   self->UpdateBeacon();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'UpdateBeacon'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GiveEffects of class  cBeaconEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBeaconEntity_GiveEffects00
static int tolua_AllToLua_cBeaconEntity_GiveEffects00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBeaconEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBeaconEntity* self = (cBeaconEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GiveEffects'", nullptr);
#endif
  {
   self->GiveEffects();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GiveEffects'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsMineralBlock of class  cBeaconEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBeaconEntity_IsMineralBlock00
static int tolua_AllToLua_cBeaconEntity_IsMineralBlock00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBeaconEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  unsigned char a_BlockType = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
  {
   bool tolua_ret = (bool)  cBeaconEntity::IsMineralBlock(a_BlockType);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsMineralBlock'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsValidEffect of class  cBeaconEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBeaconEntity_IsValidEffect00
static int tolua_AllToLua_cBeaconEntity_IsValidEffect00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cBeaconEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cEntityEffect::eType a_Effect = ((cEntityEffect::eType) (  int)  tolua_tonumber(tolua_S,2,0));
  char a_BeaconLevel = ((char)  tolua_tonumber(tolua_S,3,0));
  {
   bool tolua_ret = (bool)  cBeaconEntity::IsValidEffect(a_Effect,a_BeaconLevel);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsValidEffect'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetColor of class  cBedEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBedEntity_GetColor00
static int tolua_AllToLua_cBedEntity_GetColor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBedEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBedEntity* self = (const cBedEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetColor'", nullptr);
#endif
  {
   short tolua_ret = (short)  self->GetColor();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetColor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetColor of class  cBedEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBedEntity_SetColor00
static int tolua_AllToLua_cBedEntity_SetColor00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBedEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBedEntity* self = (cBedEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  short a_Color = ((short)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetColor'", nullptr);
#endif
  {
   self->SetColor(a_Color);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetColor'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsPillowBlock of class  cBedEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBedEntity_IsPillowBlock00
static int tolua_AllToLua_cBedEntity_IsPillowBlock00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBedEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBedEntity* self = (cBedEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsPillowBlock'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsPillowBlock();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsPillowBlock'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSlot of class  cBlockEntityWithItems */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockEntityWithItems_GetSlot00
static int tolua_AllToLua_cBlockEntityWithItems_GetSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockEntityWithItems",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBlockEntityWithItems* self = (const cBlockEntityWithItems*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_SlotNum = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSlot'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetSlot(a_SlotNum);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSlot of class  cBlockEntityWithItems */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockEntityWithItems_GetSlot01
static int tolua_AllToLua_cBlockEntityWithItems_GetSlot01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBlockEntityWithItems",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  const cBlockEntityWithItems* self = (const cBlockEntityWithItems*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_X = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_Y = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSlot'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetSlot(a_X,a_Y);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cBlockEntityWithItems_GetSlot00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSlot of class  cBlockEntityWithItems */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockEntityWithItems_SetSlot00
static int tolua_AllToLua_cBlockEntityWithItems_SetSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockEntityWithItems",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBlockEntityWithItems* self = (cBlockEntityWithItems*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_SlotNum = ((int)  tolua_tonumber(tolua_S,2,0));
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSlot'", nullptr);
#endif
  {
   self->SetSlot(a_SlotNum,*a_Item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSlot of class  cBlockEntityWithItems */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockEntityWithItems_SetSlot01
static int tolua_AllToLua_cBlockEntityWithItems_SetSlot01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockEntityWithItems",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cBlockEntityWithItems* self = (cBlockEntityWithItems*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_X = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_Y = ((int)  tolua_tonumber(tolua_S,3,0));
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,4,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSlot'", nullptr);
#endif
  {
   self->SetSlot(a_X,a_Y,*a_Item);
  }
 }
 return 0;
tolua_lerror:
 return tolua_AllToLua_cBlockEntityWithItems_SetSlot00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetContents of class  cBlockEntityWithItems */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockEntityWithItems_GetContents00
static int tolua_AllToLua_cBlockEntityWithItems_GetContents00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBlockEntityWithItems",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBlockEntityWithItems* self = (cBlockEntityWithItems*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetContents'", nullptr);
#endif
  {
   cItemGrid& tolua_ret = (cItemGrid&)  self->GetContents();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"cItemGrid");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetContents'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: __cBlockEntityWindowOwner__ of class  cBlockEntityWithItems */
#ifndef TOLUA_DISABLE_tolua_get_cBlockEntityWithItems___cBlockEntityWindowOwner__
static int tolua_get_cBlockEntityWithItems___cBlockEntityWindowOwner__(lua_State* tolua_S)
{
  cBlockEntityWithItems* self = (cBlockEntityWithItems*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable '__cBlockEntityWindowOwner__'",nullptr);
#endif
#ifdef __cplusplus
   tolua_pushusertype(tolua_S,(void*)static_cast<cBlockEntityWindowOwner*>(self), "cBlockEntityWindowOwner");
#else
   tolua_pushusertype(tolua_S,(void*)((cBlockEntityWindowOwner*)self), "cBlockEntityWindowOwner");
#endif
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetBrewingTimeLeft of class  cBrewingstandEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBrewingstandEntity_GetBrewingTimeLeft00
static int tolua_AllToLua_cBrewingstandEntity_GetBrewingTimeLeft00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBrewingstandEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBrewingstandEntity* self = (const cBrewingstandEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetBrewingTimeLeft'", nullptr);
#endif
  {
   short tolua_ret = (short)  self->GetBrewingTimeLeft();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetBrewingTimeLeft'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetTimeBrewed of class  cBrewingstandEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBrewingstandEntity_GetTimeBrewed00
static int tolua_AllToLua_cBrewingstandEntity_GetTimeBrewed00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBrewingstandEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBrewingstandEntity* self = (cBrewingstandEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetTimeBrewed'", nullptr);
#endif
  {
   short tolua_ret = (short)  self->GetTimeBrewed();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetTimeBrewed'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetRemainingFuel of class  cBrewingstandEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBrewingstandEntity_GetRemainingFuel00
static int tolua_AllToLua_cBrewingstandEntity_GetRemainingFuel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBrewingstandEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBrewingstandEntity* self = (cBrewingstandEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetRemainingFuel'", nullptr);
#endif
  {
   short tolua_ret = (short)  self->GetRemainingFuel();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetRemainingFuel'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetLeftBottleSlot of class  cBrewingstandEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBrewingstandEntity_GetLeftBottleSlot00
static int tolua_AllToLua_cBrewingstandEntity_GetLeftBottleSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBrewingstandEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBrewingstandEntity* self = (const cBrewingstandEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetLeftBottleSlot'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetLeftBottleSlot();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetLeftBottleSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMiddleBottleSlot of class  cBrewingstandEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBrewingstandEntity_GetMiddleBottleSlot00
static int tolua_AllToLua_cBrewingstandEntity_GetMiddleBottleSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBrewingstandEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBrewingstandEntity* self = (const cBrewingstandEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMiddleBottleSlot'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetMiddleBottleSlot();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMiddleBottleSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetRightBottleSlot of class  cBrewingstandEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBrewingstandEntity_GetRightBottleSlot00
static int tolua_AllToLua_cBrewingstandEntity_GetRightBottleSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBrewingstandEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBrewingstandEntity* self = (const cBrewingstandEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetRightBottleSlot'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetRightBottleSlot();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetRightBottleSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetIndgredientSlot of class  cBrewingstandEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBrewingstandEntity_GetIndgredientSlot00
static int tolua_AllToLua_cBrewingstandEntity_GetIndgredientSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBrewingstandEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBrewingstandEntity* self = (const cBrewingstandEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetIndgredientSlot'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetIndgredientSlot();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetIndgredientSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetFuelSlot of class  cBrewingstandEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBrewingstandEntity_GetFuelSlot00
static int tolua_AllToLua_cBrewingstandEntity_GetFuelSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cBrewingstandEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cBrewingstandEntity* self = (const cBrewingstandEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetFuelSlot'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetFuelSlot();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetFuelSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetResultItem of class  cBrewingstandEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBrewingstandEntity_GetResultItem00
static int tolua_AllToLua_cBrewingstandEntity_GetResultItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBrewingstandEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBrewingstandEntity* self = (cBrewingstandEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  size_t a_SlotNumber = ((size_t)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetResultItem'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetResultItem(a_SlotNumber);
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetResultItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetLeftBottleSlot of class  cBrewingstandEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBrewingstandEntity_SetLeftBottleSlot00
static int tolua_AllToLua_cBrewingstandEntity_SetLeftBottleSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBrewingstandEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBrewingstandEntity* self = (cBrewingstandEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetLeftBottleSlot'", nullptr);
#endif
  {
   self->SetLeftBottleSlot(*a_Item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetLeftBottleSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetMiddleBottleSlot of class  cBrewingstandEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBrewingstandEntity_SetMiddleBottleSlot00
static int tolua_AllToLua_cBrewingstandEntity_SetMiddleBottleSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBrewingstandEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBrewingstandEntity* self = (cBrewingstandEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetMiddleBottleSlot'", nullptr);
#endif
  {
   self->SetMiddleBottleSlot(*a_Item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetMiddleBottleSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetRightBottleSlot of class  cBrewingstandEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBrewingstandEntity_SetRightBottleSlot00
static int tolua_AllToLua_cBrewingstandEntity_SetRightBottleSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBrewingstandEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBrewingstandEntity* self = (cBrewingstandEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetRightBottleSlot'", nullptr);
#endif
  {
   self->SetRightBottleSlot(*a_Item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetRightBottleSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetIngredientSlot of class  cBrewingstandEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBrewingstandEntity_SetIngredientSlot00
static int tolua_AllToLua_cBrewingstandEntity_SetIngredientSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBrewingstandEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBrewingstandEntity* self = (cBrewingstandEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetIngredientSlot'", nullptr);
#endif
  {
   self->SetIngredientSlot(*a_Item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetIngredientSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetFuelSlot of class  cBrewingstandEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBrewingstandEntity_SetFuelSlot00
static int tolua_AllToLua_cBrewingstandEntity_SetFuelSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cBrewingstandEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cBrewingstandEntity* self = (cBrewingstandEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetFuelSlot'", nullptr);
#endif
  {
   self->SetFuelSlot(*a_Item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetFuelSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Activate of class  cCommandBlockEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCommandBlockEntity_Activate00
static int tolua_AllToLua_cCommandBlockEntity_Activate00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cCommandBlockEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cCommandBlockEntity* self = (cCommandBlockEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Activate'", nullptr);
#endif
  {
   self->Activate();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Activate'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetCommand of class  cCommandBlockEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCommandBlockEntity_SetCommand00
static int tolua_AllToLua_cCommandBlockEntity_SetCommand00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cCommandBlockEntity",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cCommandBlockEntity* self = (cCommandBlockEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Cmd = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetCommand'", nullptr);
#endif
  {
   self->SetCommand(a_Cmd);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetCommand'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetCommand of class  cCommandBlockEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCommandBlockEntity_GetCommand00
static int tolua_AllToLua_cCommandBlockEntity_GetCommand00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cCommandBlockEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cCommandBlockEntity* self = (const cCommandBlockEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetCommand'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetCommand();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetCommand'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetLastOutput of class  cCommandBlockEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCommandBlockEntity_GetLastOutput00
static int tolua_AllToLua_cCommandBlockEntity_GetLastOutput00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cCommandBlockEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cCommandBlockEntity* self = (const cCommandBlockEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetLastOutput'", nullptr);
#endif
  {
   const AString tolua_ret = (const AString)  self->GetLastOutput();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetLastOutput'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetResult of class  cCommandBlockEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCommandBlockEntity_GetResult00
static int tolua_AllToLua_cCommandBlockEntity_GetResult00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cCommandBlockEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cCommandBlockEntity* self = (const cCommandBlockEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetResult'", nullptr);
#endif
  {
   unsigned char tolua_ret = ( unsigned char)  self->GetResult();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetResult'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: AddDropSpenserDir of class  cDropSpenserEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cDropSpenserEntity_AddDropSpenserDir00
static int tolua_AllToLua_cDropSpenserEntity_AddDropSpenserDir00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cDropSpenserEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cDropSpenserEntity* self = (cDropSpenserEntity*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<int>* a_RelCoord = ((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
  unsigned char a_Direction = (( unsigned char)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddDropSpenserDir'", nullptr);
#endif
  {
   self->AddDropSpenserDir(*a_RelCoord,a_Direction);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'AddDropSpenserDir'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Activate of class  cDropSpenserEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cDropSpenserEntity_Activate00
static int tolua_AllToLua_cDropSpenserEntity_Activate00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cDropSpenserEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cDropSpenserEntity* self = (cDropSpenserEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Activate'", nullptr);
#endif
  {
   self->Activate();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Activate'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpawnProjectileFromDispenser of class  cDispenserEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cDispenserEntity_SpawnProjectileFromDispenser00
static int tolua_AllToLua_cDispenserEntity_SpawnProjectileFromDispenser00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cDispenserEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3<int>",0,&tolua_err)) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,4,&tolua_err) || !tolua_isusertype(tolua_S,4,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,5,"const cItem",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cDispenserEntity* self = (cDispenserEntity*)  tolua_tousertype(tolua_S,1,nullptr);
   Vector3<int> a_BlockPos = *((  Vector3<int>*)  tolua_tousertype(tolua_S,2,nullptr));
  cProjectileEntity::eKind a_Kind = ((cProjectileEntity::eKind) (  int)  tolua_tonumber(tolua_S,3,0));
  const Vector3<double>* a_Speed = ((const Vector3<double>*)  tolua_tousertype(tolua_S,4,nullptr));
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,5,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnProjectileFromDispenser'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->SpawnProjectileFromDispenser(a_BlockPos,a_Kind,*a_Speed,a_Item);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SpawnProjectileFromDispenser'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpawnProjectileFromDispenser of class  cDispenserEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cDispenserEntity_SpawnProjectileFromDispenser01
static int tolua_AllToLua_cDispenserEntity_SpawnProjectileFromDispenser01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cDispenserEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
     !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,6,&tolua_err) || !tolua_isusertype(tolua_S,6,"const Vector3<double>",0,&tolua_err)) ||
     !tolua_isusertype(tolua_S,7,"const cItem",1,&tolua_err) ||
     !tolua_isnoobj(tolua_S,8,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  cDispenserEntity* self = (cDispenserEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_BlockX = ((int)  tolua_tonumber(tolua_S,2,0));
  int a_BlockY = ((int)  tolua_tonumber(tolua_S,3,0));
  int a_BlockZ = ((int)  tolua_tonumber(tolua_S,4,0));
  cProjectileEntity::eKind a_Kind = ((cProjectileEntity::eKind) (  int)  tolua_tonumber(tolua_S,5,0));
  const Vector3<double>* a_Speed = ((const Vector3<double>*)  tolua_tousertype(tolua_S,6,nullptr));
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,7,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnProjectileFromDispenser'", nullptr);
#endif
  {
   unsigned int tolua_ret = ( unsigned int)  self->SpawnProjectileFromDispenser(a_BlockX,a_BlockY,a_BlockZ,a_Kind,*a_Speed,a_Item);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_AllToLua_cDispenserEntity_SpawnProjectileFromDispenser00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetShootVector of class  cDispenserEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cDispenserEntity_GetShootVector00
static int tolua_AllToLua_cDispenserEntity_GetShootVector00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cDispenserEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  unsigned char a_BlockMeta = (( unsigned char)  tolua_tonumber(tolua_S,2,0));
  {
   Vector3<double> tolua_ret = (Vector3<double>)  cDispenserEntity::GetShootVector(a_BlockMeta);
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((Vector3<double>)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3<double>));
     tolua_pushusertype(tolua_S,tolua_obj,"Vector3<double>");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetShootVector'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetInputSlot of class  cFurnaceEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFurnaceEntity_GetInputSlot00
static int tolua_AllToLua_cFurnaceEntity_GetInputSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cFurnaceEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cFurnaceEntity* self = (const cFurnaceEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetInputSlot'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetInputSlot();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetInputSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetFuelSlot of class  cFurnaceEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFurnaceEntity_GetFuelSlot00
static int tolua_AllToLua_cFurnaceEntity_GetFuelSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cFurnaceEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cFurnaceEntity* self = (const cFurnaceEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetFuelSlot'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetFuelSlot();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetFuelSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetOutputSlot of class  cFurnaceEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFurnaceEntity_GetOutputSlot00
static int tolua_AllToLua_cFurnaceEntity_GetOutputSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cFurnaceEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cFurnaceEntity* self = (const cFurnaceEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetOutputSlot'", nullptr);
#endif
  {
   const cItem& tolua_ret = (const cItem&)  self->GetOutputSlot();
    tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const cItem");
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetOutputSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetInputSlot of class  cFurnaceEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFurnaceEntity_SetInputSlot00
static int tolua_AllToLua_cFurnaceEntity_SetInputSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cFurnaceEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cFurnaceEntity* self = (cFurnaceEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetInputSlot'", nullptr);
#endif
  {
   self->SetInputSlot(*a_Item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetInputSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetFuelSlot of class  cFurnaceEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFurnaceEntity_SetFuelSlot00
static int tolua_AllToLua_cFurnaceEntity_SetFuelSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cFurnaceEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cFurnaceEntity* self = (cFurnaceEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetFuelSlot'", nullptr);
#endif
  {
   self->SetFuelSlot(*a_Item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetFuelSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetOutputSlot of class  cFurnaceEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFurnaceEntity_SetOutputSlot00
static int tolua_AllToLua_cFurnaceEntity_SetOutputSlot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cFurnaceEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cFurnaceEntity* self = (cFurnaceEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetOutputSlot'", nullptr);
#endif
  {
   self->SetOutputSlot(*a_Item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetOutputSlot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetTimeCooked of class  cFurnaceEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFurnaceEntity_GetTimeCooked00
static int tolua_AllToLua_cFurnaceEntity_GetTimeCooked00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cFurnaceEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cFurnaceEntity* self = (const cFurnaceEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetTimeCooked'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetTimeCooked();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetTimeCooked'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetCookTimeLeft of class  cFurnaceEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFurnaceEntity_GetCookTimeLeft00
static int tolua_AllToLua_cFurnaceEntity_GetCookTimeLeft00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cFurnaceEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cFurnaceEntity* self = (const cFurnaceEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetCookTimeLeft'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetCookTimeLeft();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetCookTimeLeft'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetFuelBurnTimeLeft of class  cFurnaceEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFurnaceEntity_GetFuelBurnTimeLeft00
static int tolua_AllToLua_cFurnaceEntity_GetFuelBurnTimeLeft00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cFurnaceEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cFurnaceEntity* self = (const cFurnaceEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetFuelBurnTimeLeft'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetFuelBurnTimeLeft();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetFuelBurnTimeLeft'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: HasFuelTimeLeft of class  cFurnaceEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFurnaceEntity_HasFuelTimeLeft00
static int tolua_AllToLua_cFurnaceEntity_HasFuelTimeLeft00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cFurnaceEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cFurnaceEntity* self = (const cFurnaceEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HasFuelTimeLeft'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->HasFuelTimeLeft();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'HasFuelTimeLeft'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetAndResetReward of class  cFurnaceEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFurnaceEntity_GetAndResetReward00
static int tolua_AllToLua_cFurnaceEntity_GetAndResetReward00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cFurnaceEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cFurnaceEntity* self = (cFurnaceEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetAndResetReward'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetAndResetReward();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetAndResetReward'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetRecord of class  cJukeboxEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cJukeboxEntity_GetRecord00
static int tolua_AllToLua_cJukeboxEntity_GetRecord00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cJukeboxEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cJukeboxEntity* self = (cJukeboxEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetRecord'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetRecord();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetRecord'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetRecord of class  cJukeboxEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cJukeboxEntity_SetRecord00
static int tolua_AllToLua_cJukeboxEntity_SetRecord00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cJukeboxEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cJukeboxEntity* self = (cJukeboxEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_Record = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetRecord'", nullptr);
#endif
  {
   self->SetRecord(a_Record);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetRecord'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: PlayRecord of class  cJukeboxEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cJukeboxEntity_PlayRecord00
static int tolua_AllToLua_cJukeboxEntity_PlayRecord00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cJukeboxEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cJukeboxEntity* self = (cJukeboxEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  int a_Record = ((int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'PlayRecord'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->PlayRecord(a_Record);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'PlayRecord'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: EjectRecord of class  cJukeboxEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cJukeboxEntity_EjectRecord00
static int tolua_AllToLua_cJukeboxEntity_EjectRecord00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cJukeboxEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cJukeboxEntity* self = (cJukeboxEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'EjectRecord'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->EjectRecord();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'EjectRecord'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsPlayingRecord of class  cJukeboxEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cJukeboxEntity_IsPlayingRecord00
static int tolua_AllToLua_cJukeboxEntity_IsPlayingRecord00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cJukeboxEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cJukeboxEntity* self = (const cJukeboxEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsPlayingRecord'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsPlayingRecord();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsPlayingRecord'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsRecordItem of class  cJukeboxEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cJukeboxEntity_IsRecordItem00
static int tolua_AllToLua_cJukeboxEntity_IsRecordItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"cJukeboxEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  int a_Item = ((int)  tolua_tonumber(tolua_S,2,0));
  {
   bool tolua_ret = (bool)  cJukeboxEntity::IsRecordItem(a_Item);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsRecordItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNote of class  cNoteEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cNoteEntity_GetNote00
static int tolua_AllToLua_cNoteEntity_GetNote00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cNoteEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cNoteEntity* self = (cNoteEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNote'", nullptr);
#endif
  {
   unsigned char tolua_ret = (unsigned char)  self->GetNote();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetNote'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetNote of class  cNoteEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cNoteEntity_SetNote00
static int tolua_AllToLua_cNoteEntity_SetNote00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cNoteEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cNoteEntity* self = (cNoteEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  unsigned char a_Note = ((unsigned char)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetNote'", nullptr);
#endif
  {
   self->SetNote(a_Note);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetNote'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IncrementNote of class  cNoteEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cNoteEntity_IncrementNote00
static int tolua_AllToLua_cNoteEntity_IncrementNote00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cNoteEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cNoteEntity* self = (cNoteEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IncrementNote'", nullptr);
#endif
  {
   self->IncrementNote();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IncrementNote'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: MakeSound of class  cNoteEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cNoteEntity_MakeSound00
static int tolua_AllToLua_cNoteEntity_MakeSound00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cNoteEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cNoteEntity* self = (cNoteEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'MakeSound'", nullptr);
#endif
  {
   self->MakeSound();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'MakeSound'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetLines of class  cSignEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cSignEntity_SetLines00
static int tolua_AllToLua_cSignEntity_SetLines00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cSignEntity",0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,5,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cSignEntity* self = (cSignEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const AString a_Line1 = ((const AString)  tolua_tocppstring(tolua_S,2,nullptr));
  const AString a_Line2 = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
  const AString a_Line3 = ((const AString)  tolua_tocppstring(tolua_S,4,nullptr));
  const AString a_Line4 = ((const AString)  tolua_tocppstring(tolua_S,5,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetLines'", nullptr);
#endif
  {
   self->SetLines(a_Line1,a_Line2,a_Line3,a_Line4);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetLines'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetLine of class  cSignEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cSignEntity_SetLine00
static int tolua_AllToLua_cSignEntity_SetLine00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cSignEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cSignEntity* self = (cSignEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  size_t a_Index = ((size_t)  tolua_tonumber(tolua_S,2,0));
  const AString a_Line = ((const AString)  tolua_tocppstring(tolua_S,3,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetLine'", nullptr);
#endif
  {
   self->SetLine(a_Index,a_Line);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetLine'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetLine of class  cSignEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cSignEntity_GetLine00
static int tolua_AllToLua_cSignEntity_GetLine00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cSignEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cSignEntity* self = (const cSignEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  size_t a_Index = ((size_t)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetLine'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetLine(a_Index);
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetLine'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetType of class  cMobHeadEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobHeadEntity_SetType00
static int tolua_AllToLua_cMobHeadEntity_SetType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMobHeadEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMobHeadEntity* self = (cMobHeadEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const eMobHeadType a_SkullType = ((const eMobHeadType) (  int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetType'", nullptr);
#endif
  {
   self->SetType(a_SkullType);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseMobHeadRotation (lua_State* L, int lo, int def, tolua_Error* err);
/* method: SetRotation of class  cMobHeadEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobHeadEntity_SetRotation00
static int tolua_AllToLua_cMobHeadEntity_SetRotation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMobHeadEntity",0,&tolua_err) ||
     !tolua_iseMobHeadRotation(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMobHeadEntity* self = (cMobHeadEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  eMobHeadRotation a_Rotation = ((eMobHeadRotation) (  int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetRotation'", nullptr);
#endif
  {
   self->SetRotation(a_Rotation);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetRotation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetOwner of class  cMobHeadEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobHeadEntity_SetOwner00
static int tolua_AllToLua_cMobHeadEntity_SetOwner00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMobHeadEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cPlayer",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMobHeadEntity* self = (cMobHeadEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const cPlayer* a_Owner = ((const cPlayer*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetOwner'", nullptr);
#endif
  {
   self->SetOwner(*a_Owner);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetOwner'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetType of class  cMobHeadEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobHeadEntity_GetType00
static int tolua_AllToLua_cMobHeadEntity_GetType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMobHeadEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMobHeadEntity* self = (const cMobHeadEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetType'", nullptr);
#endif
  {
   eMobHeadType tolua_ret = (eMobHeadType)  self->GetType();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetType'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetRotation of class  cMobHeadEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobHeadEntity_GetRotation00
static int tolua_AllToLua_cMobHeadEntity_GetRotation00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMobHeadEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMobHeadEntity* self = (const cMobHeadEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetRotation'", nullptr);
#endif
  {
   eMobHeadRotation tolua_ret = (eMobHeadRotation)  self->GetRotation();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetRotation'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetOwnerName of class  cMobHeadEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobHeadEntity_GetOwnerName00
static int tolua_AllToLua_cMobHeadEntity_GetOwnerName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMobHeadEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMobHeadEntity* self = (const cMobHeadEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetOwnerName'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetOwnerName();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetOwnerName'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetOwnerTexture of class  cMobHeadEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobHeadEntity_GetOwnerTexture00
static int tolua_AllToLua_cMobHeadEntity_GetOwnerTexture00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMobHeadEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMobHeadEntity* self = (const cMobHeadEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetOwnerTexture'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetOwnerTexture();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetOwnerTexture'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetOwnerTextureSignature of class  cMobHeadEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobHeadEntity_GetOwnerTextureSignature00
static int tolua_AllToLua_cMobHeadEntity_GetOwnerTextureSignature00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMobHeadEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMobHeadEntity* self = (const cMobHeadEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetOwnerTextureSignature'", nullptr);
#endif
  {
   AString tolua_ret = (AString)  self->GetOwnerTextureSignature();
   tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetOwnerTextureSignature'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: UpdateActiveState of class  cMobSpawnerEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobSpawnerEntity_UpdateActiveState00
static int tolua_AllToLua_cMobSpawnerEntity_UpdateActiveState00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMobSpawnerEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMobSpawnerEntity* self = (cMobSpawnerEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'UpdateActiveState'", nullptr);
#endif
  {
   self->UpdateActiveState();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'UpdateActiveState'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: ResetTimer of class  cMobSpawnerEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobSpawnerEntity_ResetTimer00
static int tolua_AllToLua_cMobSpawnerEntity_ResetTimer00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMobSpawnerEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMobSpawnerEntity* self = (cMobSpawnerEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ResetTimer'", nullptr);
#endif
  {
   self->ResetTimer();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'ResetTimer'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SpawnEntity of class  cMobSpawnerEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobSpawnerEntity_SpawnEntity00
static int tolua_AllToLua_cMobSpawnerEntity_SpawnEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMobSpawnerEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMobSpawnerEntity* self = (cMobSpawnerEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnEntity'", nullptr);
#endif
  {
   self->SpawnEntity();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SpawnEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseMonsterType (lua_State* L, int lo, int def, tolua_Error* err);
/* method: GetNearbyMonsterNum of class  cMobSpawnerEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobSpawnerEntity_GetNearbyMonsterNum00
static int tolua_AllToLua_cMobSpawnerEntity_GetNearbyMonsterNum00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMobSpawnerEntity",0,&tolua_err) ||
     !tolua_iseMonsterType(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMobSpawnerEntity* self = (cMobSpawnerEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  eMonsterType a_EntityType = ((eMonsterType) (  int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNearbyMonsterNum'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetNearbyMonsterNum(a_EntityType);
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetNearbyMonsterNum'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetNearbyPlayersNum of class  cMobSpawnerEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobSpawnerEntity_GetNearbyPlayersNum00
static int tolua_AllToLua_cMobSpawnerEntity_GetNearbyPlayersNum00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMobSpawnerEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMobSpawnerEntity* self = (cMobSpawnerEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNearbyPlayersNum'", nullptr);
#endif
  {
   int tolua_ret = (int)  self->GetNearbyPlayersNum();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetNearbyPlayersNum'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetEntity of class  cMobSpawnerEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobSpawnerEntity_GetEntity00
static int tolua_AllToLua_cMobSpawnerEntity_GetEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMobSpawnerEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMobSpawnerEntity* self = (const cMobSpawnerEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEntity'", nullptr);
#endif
  {
   eMonsterType tolua_ret = (eMonsterType)  self->GetEntity();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSpawnCount of class  cMobSpawnerEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobSpawnerEntity_GetSpawnCount00
static int tolua_AllToLua_cMobSpawnerEntity_GetSpawnCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMobSpawnerEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMobSpawnerEntity* self = (const cMobSpawnerEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSpawnCount'", nullptr);
#endif
  {
   short tolua_ret = (short)  self->GetSpawnCount();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSpawnCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSpawnRange of class  cMobSpawnerEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobSpawnerEntity_GetSpawnRange00
static int tolua_AllToLua_cMobSpawnerEntity_GetSpawnRange00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMobSpawnerEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMobSpawnerEntity* self = (const cMobSpawnerEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSpawnRange'", nullptr);
#endif
  {
   short tolua_ret = (short)  self->GetSpawnRange();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSpawnRange'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetSpawnDelay of class  cMobSpawnerEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobSpawnerEntity_GetSpawnDelay00
static int tolua_AllToLua_cMobSpawnerEntity_GetSpawnDelay00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMobSpawnerEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMobSpawnerEntity* self = (const cMobSpawnerEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSpawnDelay'", nullptr);
#endif
  {
   short tolua_ret = (short)  self->GetSpawnDelay();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetSpawnDelay'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMinSpawnDelay of class  cMobSpawnerEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobSpawnerEntity_GetMinSpawnDelay00
static int tolua_AllToLua_cMobSpawnerEntity_GetMinSpawnDelay00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMobSpawnerEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMobSpawnerEntity* self = (const cMobSpawnerEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMinSpawnDelay'", nullptr);
#endif
  {
   short tolua_ret = (short)  self->GetMinSpawnDelay();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMinSpawnDelay'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMaxSpawnDelay of class  cMobSpawnerEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobSpawnerEntity_GetMaxSpawnDelay00
static int tolua_AllToLua_cMobSpawnerEntity_GetMaxSpawnDelay00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMobSpawnerEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMobSpawnerEntity* self = (const cMobSpawnerEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMaxSpawnDelay'", nullptr);
#endif
  {
   short tolua_ret = (short)  self->GetMaxSpawnDelay();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMaxSpawnDelay'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMaxNearbyEntities of class  cMobSpawnerEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobSpawnerEntity_GetMaxNearbyEntities00
static int tolua_AllToLua_cMobSpawnerEntity_GetMaxNearbyEntities00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMobSpawnerEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMobSpawnerEntity* self = (const cMobSpawnerEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMaxNearbyEntities'", nullptr);
#endif
  {
   short tolua_ret = (short)  self->GetMaxNearbyEntities();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMaxNearbyEntities'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetRequiredPlayerRange of class  cMobSpawnerEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobSpawnerEntity_GetRequiredPlayerRange00
static int tolua_AllToLua_cMobSpawnerEntity_GetRequiredPlayerRange00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cMobSpawnerEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cMobSpawnerEntity* self = (const cMobSpawnerEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetRequiredPlayerRange'", nullptr);
#endif
  {
   short tolua_ret = (short)  self->GetRequiredPlayerRange();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetRequiredPlayerRange'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_iseMonsterType (lua_State* L, int lo, int def, tolua_Error* err);
/* method: SetEntity of class  cMobSpawnerEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobSpawnerEntity_SetEntity00
static int tolua_AllToLua_cMobSpawnerEntity_SetEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMobSpawnerEntity",0,&tolua_err) ||
     !tolua_iseMonsterType(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMobSpawnerEntity* self = (cMobSpawnerEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  eMonsterType a_EntityType = ((eMonsterType) (  int)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetEntity'", nullptr);
#endif
  {
   self->SetEntity(a_EntityType);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetEntity'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSpawnDelay of class  cMobSpawnerEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobSpawnerEntity_SetSpawnDelay00
static int tolua_AllToLua_cMobSpawnerEntity_SetSpawnDelay00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMobSpawnerEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMobSpawnerEntity* self = (cMobSpawnerEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  short a_Delay = ((short)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSpawnDelay'", nullptr);
#endif
  {
   self->SetSpawnDelay(a_Delay);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetSpawnDelay'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSpawnCount of class  cMobSpawnerEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobSpawnerEntity_SetSpawnCount00
static int tolua_AllToLua_cMobSpawnerEntity_SetSpawnCount00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMobSpawnerEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMobSpawnerEntity* self = (cMobSpawnerEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  short a_SpawnCount = ((short)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSpawnCount'", nullptr);
#endif
  {
   self->SetSpawnCount(a_SpawnCount);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetSpawnCount'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetSpawnRange of class  cMobSpawnerEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobSpawnerEntity_SetSpawnRange00
static int tolua_AllToLua_cMobSpawnerEntity_SetSpawnRange00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMobSpawnerEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMobSpawnerEntity* self = (cMobSpawnerEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  short a_SpawnRange = ((short)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetSpawnRange'", nullptr);
#endif
  {
   self->SetSpawnRange(a_SpawnRange);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetSpawnRange'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetMinSpawnDelay of class  cMobSpawnerEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobSpawnerEntity_SetMinSpawnDelay00
static int tolua_AllToLua_cMobSpawnerEntity_SetMinSpawnDelay00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMobSpawnerEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMobSpawnerEntity* self = (cMobSpawnerEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  short a_Min = ((short)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetMinSpawnDelay'", nullptr);
#endif
  {
   self->SetMinSpawnDelay(a_Min);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetMinSpawnDelay'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetMaxSpawnDelay of class  cMobSpawnerEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobSpawnerEntity_SetMaxSpawnDelay00
static int tolua_AllToLua_cMobSpawnerEntity_SetMaxSpawnDelay00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMobSpawnerEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMobSpawnerEntity* self = (cMobSpawnerEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  short a_Max = ((short)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetMaxSpawnDelay'", nullptr);
#endif
  {
   self->SetMaxSpawnDelay(a_Max);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetMaxSpawnDelay'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetMaxNearbyEntities of class  cMobSpawnerEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobSpawnerEntity_SetMaxNearbyEntities00
static int tolua_AllToLua_cMobSpawnerEntity_SetMaxNearbyEntities00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMobSpawnerEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMobSpawnerEntity* self = (cMobSpawnerEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  short a_MaxNearbyEntities = ((short)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetMaxNearbyEntities'", nullptr);
#endif
  {
   self->SetMaxNearbyEntities(a_MaxNearbyEntities);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetMaxNearbyEntities'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetRequiredPlayerRange of class  cMobSpawnerEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cMobSpawnerEntity_SetRequiredPlayerRange00
static int tolua_AllToLua_cMobSpawnerEntity_SetRequiredPlayerRange00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cMobSpawnerEntity",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cMobSpawnerEntity* self = (cMobSpawnerEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  short a_RequiredPlayerRange = ((short)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetRequiredPlayerRange'", nullptr);
#endif
  {
   self->SetRequiredPlayerRange(a_RequiredPlayerRange);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetRequiredPlayerRange'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsItemInPot of class  cFlowerPotEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFlowerPotEntity_IsItemInPot00
static int tolua_AllToLua_cFlowerPotEntity_IsItemInPot00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cFlowerPotEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cFlowerPotEntity* self = (cFlowerPotEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsItemInPot'", nullptr);
#endif
  {
   bool tolua_ret = (bool)  self->IsItemInPot();
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsItemInPot'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetItem of class  cFlowerPotEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFlowerPotEntity_GetItem00
static int tolua_AllToLua_cFlowerPotEntity_GetItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const cFlowerPotEntity",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const cFlowerPotEntity* self = (const cFlowerPotEntity*)  tolua_tousertype(tolua_S,1,nullptr);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetItem'", nullptr);
#endif
  {
   cItem tolua_ret = (cItem)  self->GetItem();
   {
#ifdef __cplusplus
    void* tolua_obj = Mtolua_new((cItem)(tolua_ret));
     tolua_pushusertype(tolua_S,tolua_obj,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(cItem));
     tolua_pushusertype(tolua_S,tolua_obj,"cItem");
    tolua_register_gc(tolua_S,lua_gettop(tolua_S));
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetItem of class  cFlowerPotEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cFlowerPotEntity_SetItem00
static int tolua_AllToLua_cFlowerPotEntity_SetItem00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"cFlowerPotEntity",0,&tolua_err) ||
     (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cItem",0,&tolua_err)) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  cFlowerPotEntity* self = (cFlowerPotEntity*)  tolua_tousertype(tolua_S,1,nullptr);
  const cItem* a_Item = ((const cItem*)  tolua_tousertype(tolua_S,2,nullptr));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetItem'", nullptr);
#endif
  {
   self->SetItem(*a_Item);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetItem'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

 int tolua_isCustomStatistic (lua_State* L, int lo, int def, tolua_Error* err)
{
	if (!tolua_isnumber(L,lo,def,err)) return 0;
	lua_Number val = tolua_tonumber(L,lo,def);
	if (val >= 0.0 && val <= 75.0) return 1;
	err->index = lo;
	err->array = 0;
	err->type = "CustomStatistic";
	return 0;
}
/* Open function */
TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S)
{
 tolua_open(tolua_S);
 tolua_reg_types(tolua_S);
 tolua_module(tolua_S,nullptr,0);
 tolua_beginmodule(tolua_S,nullptr);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"Vector3i","Vector3<int>","",tolua_collect_Vector3_int_);
  #else
  tolua_cclass(tolua_S,"Vector3i","Vector3<int>","",nullptr);
  #endif
  tolua_beginmodule(tolua_S,"Vector3i");
   tolua_variable(tolua_S,"x",tolua_get_Vector3_int__x,tolua_set_Vector3_int__x);
   tolua_variable(tolua_S,"y",tolua_get_Vector3_int__y,tolua_set_Vector3_int__y);
   tolua_variable(tolua_S,"z",tolua_get_Vector3_int__z,tolua_set_Vector3_int__z);
   tolua_function(tolua_S,"new",tolua_AllToLua_Vector3i_new00);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3i_new00_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_Vector3i_new00_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_Vector3i_new01);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3i_new01_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_Vector3i_new01_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_Vector3i_new02);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3i_new02_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_Vector3i_new02_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_Vector3i_new03);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3i_new03_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_Vector3i_new03_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_Vector3i_new04);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3i_new04_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_Vector3i_new04_local);
   tolua_function(tolua_S,"Set",tolua_AllToLua_Vector3i_Set00);
   tolua_function(tolua_S,"Normalize",tolua_AllToLua_Vector3i_Normalize00);
   tolua_function(tolua_S,"NormalizeCopy",tolua_AllToLua_Vector3i_NormalizeCopy00);
   tolua_function(tolua_S,"HasNonZeroLength",tolua_AllToLua_Vector3i_HasNonZeroLength00);
   tolua_function(tolua_S,"Length",tolua_AllToLua_Vector3i_Length00);
   tolua_function(tolua_S,"SqrLength",tolua_AllToLua_Vector3i_SqrLength00);
   tolua_function(tolua_S,"Dot",tolua_AllToLua_Vector3i_Dot00);
   tolua_function(tolua_S,"Abs",tolua_AllToLua_Vector3i_Abs00);
   tolua_function(tolua_S,"Clamp",tolua_AllToLua_Vector3i_Clamp00);
   tolua_function(tolua_S,"Cross",tolua_AllToLua_Vector3i_Cross00);
   tolua_function(tolua_S,"Equals",tolua_AllToLua_Vector3i_Equals00);
   tolua_function(tolua_S,"EqualsEps",tolua_AllToLua_Vector3i_EqualsEps00);
   tolua_function(tolua_S,"Move",tolua_AllToLua_Vector3i_Move00);
   tolua_function(tolua_S,"Move",tolua_AllToLua_Vector3i_Move01);
   tolua_function(tolua_S,"Floor",tolua_AllToLua_Vector3i_Floor00);
   tolua_function(tolua_S,"Ceil",tolua_AllToLua_Vector3i_Ceil00);
   tolua_function(tolua_S,".add",tolua_AllToLua_Vector3i__add00);
   tolua_function(tolua_S,".sub",tolua_AllToLua_Vector3i__sub00);
   tolua_function(tolua_S,".sub",tolua_AllToLua_Vector3i__sub01);
   tolua_function(tolua_S,".mul",tolua_AllToLua_Vector3i__mul00);
   tolua_function(tolua_S,".div",tolua_AllToLua_Vector3i__div00);
   tolua_function(tolua_S,".mul",tolua_AllToLua_Vector3i__mul01);
   tolua_function(tolua_S,".div",tolua_AllToLua_Vector3i__div01);
   tolua_function(tolua_S,"addedX",tolua_AllToLua_Vector3i_addedX00);
   tolua_function(tolua_S,"addedY",tolua_AllToLua_Vector3i_addedY00);
   tolua_function(tolua_S,"addedZ",tolua_AllToLua_Vector3i_addedZ00);
   tolua_function(tolua_S,"addedXZ",tolua_AllToLua_Vector3i_addedXZ00);
   tolua_function(tolua_S,"LineCoeffToXYPlane",tolua_AllToLua_Vector3i_LineCoeffToXYPlane00);
   tolua_function(tolua_S,"LineCoeffToXZPlane",tolua_AllToLua_Vector3i_LineCoeffToXZPlane00);
   tolua_function(tolua_S,"LineCoeffToYZPlane",tolua_AllToLua_Vector3i_LineCoeffToYZPlane00);
   tolua_function(tolua_S,"TurnCW",tolua_AllToLua_Vector3i_TurnCW00);
   tolua_function(tolua_S,"TurnCCW",tolua_AllToLua_Vector3i_TurnCCW00);
   tolua_variable(tolua_S,"EPS",tolua_get_Vector3_int__EPS,nullptr);
   tolua_variable(tolua_S,"NO_INTERSECTION",tolua_get_Vector3_int__NO_INTERSECTION,nullptr);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"Vector3f","Vector3<float>","",tolua_collect_Vector3_float_);
  #else
  tolua_cclass(tolua_S,"Vector3f","Vector3<float>","",nullptr);
  #endif
  tolua_beginmodule(tolua_S,"Vector3f");
   tolua_variable(tolua_S,"x",tolua_get_Vector3_float__x,tolua_set_Vector3_float__x);
   tolua_variable(tolua_S,"y",tolua_get_Vector3_float__y,tolua_set_Vector3_float__y);
   tolua_variable(tolua_S,"z",tolua_get_Vector3_float__z,tolua_set_Vector3_float__z);
   tolua_function(tolua_S,"new",tolua_AllToLua_Vector3f_new00);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3f_new00_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_Vector3f_new00_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_Vector3f_new01);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3f_new01_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_Vector3f_new01_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_Vector3f_new02);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3f_new02_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_Vector3f_new02_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_Vector3f_new03);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3f_new03_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_Vector3f_new03_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_Vector3f_new04);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3f_new04_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_Vector3f_new04_local);
   tolua_function(tolua_S,"Set",tolua_AllToLua_Vector3f_Set00);
   tolua_function(tolua_S,"Normalize",tolua_AllToLua_Vector3f_Normalize00);
   tolua_function(tolua_S,"NormalizeCopy",tolua_AllToLua_Vector3f_NormalizeCopy00);
   tolua_function(tolua_S,"HasNonZeroLength",tolua_AllToLua_Vector3f_HasNonZeroLength00);
   tolua_function(tolua_S,"Length",tolua_AllToLua_Vector3f_Length00);
   tolua_function(tolua_S,"SqrLength",tolua_AllToLua_Vector3f_SqrLength00);
   tolua_function(tolua_S,"Dot",tolua_AllToLua_Vector3f_Dot00);
   tolua_function(tolua_S,"Abs",tolua_AllToLua_Vector3f_Abs00);
   tolua_function(tolua_S,"Clamp",tolua_AllToLua_Vector3f_Clamp00);
   tolua_function(tolua_S,"Cross",tolua_AllToLua_Vector3f_Cross00);
   tolua_function(tolua_S,"Equals",tolua_AllToLua_Vector3f_Equals00);
   tolua_function(tolua_S,"EqualsEps",tolua_AllToLua_Vector3f_EqualsEps00);
   tolua_function(tolua_S,"Move",tolua_AllToLua_Vector3f_Move00);
   tolua_function(tolua_S,"Move",tolua_AllToLua_Vector3f_Move01);
   tolua_function(tolua_S,"Floor",tolua_AllToLua_Vector3f_Floor00);
   tolua_function(tolua_S,"Ceil",tolua_AllToLua_Vector3f_Ceil00);
   tolua_function(tolua_S,".add",tolua_AllToLua_Vector3f__add00);
   tolua_function(tolua_S,".sub",tolua_AllToLua_Vector3f__sub00);
   tolua_function(tolua_S,".sub",tolua_AllToLua_Vector3f__sub01);
   tolua_function(tolua_S,".mul",tolua_AllToLua_Vector3f__mul00);
   tolua_function(tolua_S,".div",tolua_AllToLua_Vector3f__div00);
   tolua_function(tolua_S,".mul",tolua_AllToLua_Vector3f__mul01);
   tolua_function(tolua_S,".div",tolua_AllToLua_Vector3f__div01);
   tolua_function(tolua_S,"addedX",tolua_AllToLua_Vector3f_addedX00);
   tolua_function(tolua_S,"addedY",tolua_AllToLua_Vector3f_addedY00);
   tolua_function(tolua_S,"addedZ",tolua_AllToLua_Vector3f_addedZ00);
   tolua_function(tolua_S,"addedXZ",tolua_AllToLua_Vector3f_addedXZ00);
   tolua_function(tolua_S,"LineCoeffToXYPlane",tolua_AllToLua_Vector3f_LineCoeffToXYPlane00);
   tolua_function(tolua_S,"LineCoeffToXZPlane",tolua_AllToLua_Vector3f_LineCoeffToXZPlane00);
   tolua_function(tolua_S,"LineCoeffToYZPlane",tolua_AllToLua_Vector3f_LineCoeffToYZPlane00);
   tolua_function(tolua_S,"TurnCW",tolua_AllToLua_Vector3f_TurnCW00);
   tolua_function(tolua_S,"TurnCCW",tolua_AllToLua_Vector3f_TurnCCW00);
   tolua_variable(tolua_S,"EPS",tolua_get_Vector3_float__EPS,nullptr);
   tolua_variable(tolua_S,"NO_INTERSECTION",tolua_get_Vector3_float__NO_INTERSECTION,nullptr);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"Vector3d","Vector3<double>","",tolua_collect_Vector3_double_);
  #else
  tolua_cclass(tolua_S,"Vector3d","Vector3<double>","",nullptr);
  #endif
  tolua_beginmodule(tolua_S,"Vector3d");
   tolua_variable(tolua_S,"x",tolua_get_Vector3_double__x,tolua_set_Vector3_double__x);
   tolua_variable(tolua_S,"y",tolua_get_Vector3_double__y,tolua_set_Vector3_double__y);
   tolua_variable(tolua_S,"z",tolua_get_Vector3_double__z,tolua_set_Vector3_double__z);
   tolua_function(tolua_S,"new",tolua_AllToLua_Vector3d_new00);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3d_new00_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_Vector3d_new00_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_Vector3d_new01);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3d_new01_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_Vector3d_new01_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_Vector3d_new02);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3d_new02_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_Vector3d_new02_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_Vector3d_new03);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3d_new03_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_Vector3d_new03_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_Vector3d_new04);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3d_new04_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_Vector3d_new04_local);
   tolua_function(tolua_S,"Set",tolua_AllToLua_Vector3d_Set00);
   tolua_function(tolua_S,"Normalize",tolua_AllToLua_Vector3d_Normalize00);
   tolua_function(tolua_S,"NormalizeCopy",tolua_AllToLua_Vector3d_NormalizeCopy00);
   tolua_function(tolua_S,"HasNonZeroLength",tolua_AllToLua_Vector3d_HasNonZeroLength00);
   tolua_function(tolua_S,"Length",tolua_AllToLua_Vector3d_Length00);
   tolua_function(tolua_S,"SqrLength",tolua_AllToLua_Vector3d_SqrLength00);
   tolua_function(tolua_S,"Dot",tolua_AllToLua_Vector3d_Dot00);
   tolua_function(tolua_S,"Abs",tolua_AllToLua_Vector3d_Abs00);
   tolua_function(tolua_S,"Clamp",tolua_AllToLua_Vector3d_Clamp00);
   tolua_function(tolua_S,"Cross",tolua_AllToLua_Vector3d_Cross00);
   tolua_function(tolua_S,"Equals",tolua_AllToLua_Vector3d_Equals00);
   tolua_function(tolua_S,"EqualsEps",tolua_AllToLua_Vector3d_EqualsEps00);
   tolua_function(tolua_S,"Move",tolua_AllToLua_Vector3d_Move00);
   tolua_function(tolua_S,"Move",tolua_AllToLua_Vector3d_Move01);
   tolua_function(tolua_S,"Floor",tolua_AllToLua_Vector3d_Floor00);
   tolua_function(tolua_S,"Ceil",tolua_AllToLua_Vector3d_Ceil00);
   tolua_function(tolua_S,".add",tolua_AllToLua_Vector3d__add00);
   tolua_function(tolua_S,".sub",tolua_AllToLua_Vector3d__sub00);
   tolua_function(tolua_S,".sub",tolua_AllToLua_Vector3d__sub01);
   tolua_function(tolua_S,".mul",tolua_AllToLua_Vector3d__mul00);
   tolua_function(tolua_S,".div",tolua_AllToLua_Vector3d__div00);
   tolua_function(tolua_S,".mul",tolua_AllToLua_Vector3d__mul01);
   tolua_function(tolua_S,".div",tolua_AllToLua_Vector3d__div01);
   tolua_function(tolua_S,"addedX",tolua_AllToLua_Vector3d_addedX00);
   tolua_function(tolua_S,"addedY",tolua_AllToLua_Vector3d_addedY00);
   tolua_function(tolua_S,"addedZ",tolua_AllToLua_Vector3d_addedZ00);
   tolua_function(tolua_S,"addedXZ",tolua_AllToLua_Vector3d_addedXZ00);
   tolua_function(tolua_S,"LineCoeffToXYPlane",tolua_AllToLua_Vector3d_LineCoeffToXYPlane00);
   tolua_function(tolua_S,"LineCoeffToXZPlane",tolua_AllToLua_Vector3d_LineCoeffToXZPlane00);
   tolua_function(tolua_S,"LineCoeffToYZPlane",tolua_AllToLua_Vector3d_LineCoeffToYZPlane00);
   tolua_function(tolua_S,"TurnCW",tolua_AllToLua_Vector3d_TurnCW00);
   tolua_function(tolua_S,"TurnCCW",tolua_AllToLua_Vector3d_TurnCCW00);
   tolua_variable(tolua_S,"EPS",tolua_get_Vector3_double__EPS,nullptr);
   tolua_variable(tolua_S,"NO_INTERSECTION",tolua_get_Vector3_double__NO_INTERSECTION,nullptr);
  tolua_endmodule(tolua_S);
  tolua_constant(tolua_S,"biInvalidBiome",biInvalidBiome);
  tolua_constant(tolua_S,"biFirstBiome",biFirstBiome);
  tolua_constant(tolua_S,"biOcean",biOcean);
  tolua_constant(tolua_S,"biPlains",biPlains);
  tolua_constant(tolua_S,"biDesert",biDesert);
  tolua_constant(tolua_S,"biExtremeHills",biExtremeHills);
  tolua_constant(tolua_S,"biForest",biForest);
  tolua_constant(tolua_S,"biTaiga",biTaiga);
  tolua_constant(tolua_S,"biSwampland",biSwampland);
  tolua_constant(tolua_S,"biRiver",biRiver);
  tolua_constant(tolua_S,"biHell",biHell);
  tolua_constant(tolua_S,"biNether",biNether);
  tolua_constant(tolua_S,"biSky",biSky);
  tolua_constant(tolua_S,"biEnd",biEnd);
  tolua_constant(tolua_S,"biFrozenOcean",biFrozenOcean);
  tolua_constant(tolua_S,"biFrozenRiver",biFrozenRiver);
  tolua_constant(tolua_S,"biIcePlains",biIcePlains);
  tolua_constant(tolua_S,"biTundra",biTundra);
  tolua_constant(tolua_S,"biIceMountains",biIceMountains);
  tolua_constant(tolua_S,"biMushroomIsland",biMushroomIsland);
  tolua_constant(tolua_S,"biMushroomShore",biMushroomShore);
  tolua_constant(tolua_S,"biBeach",biBeach);
  tolua_constant(tolua_S,"biDesertHills",biDesertHills);
  tolua_constant(tolua_S,"biForestHills",biForestHills);
  tolua_constant(tolua_S,"biTaigaHills",biTaigaHills);
  tolua_constant(tolua_S,"biExtremeHillsEdge",biExtremeHillsEdge);
  tolua_constant(tolua_S,"biJungle",biJungle);
  tolua_constant(tolua_S,"biJungleHills",biJungleHills);
  tolua_constant(tolua_S,"biJungleEdge",biJungleEdge);
  tolua_constant(tolua_S,"biDeepOcean",biDeepOcean);
  tolua_constant(tolua_S,"biStoneBeach",biStoneBeach);
  tolua_constant(tolua_S,"biColdBeach",biColdBeach);
  tolua_constant(tolua_S,"biBirchForest",biBirchForest);
  tolua_constant(tolua_S,"biBirchForestHills",biBirchForestHills);
  tolua_constant(tolua_S,"biRoofedForest",biRoofedForest);
  tolua_constant(tolua_S,"biColdTaiga",biColdTaiga);
  tolua_constant(tolua_S,"biColdTaigaHills",biColdTaigaHills);
  tolua_constant(tolua_S,"biMegaTaiga",biMegaTaiga);
  tolua_constant(tolua_S,"biMegaTaigaHills",biMegaTaigaHills);
  tolua_constant(tolua_S,"biExtremeHillsPlus",biExtremeHillsPlus);
  tolua_constant(tolua_S,"biSavanna",biSavanna);
  tolua_constant(tolua_S,"biSavannaPlateau",biSavannaPlateau);
  tolua_constant(tolua_S,"biMesa",biMesa);
  tolua_constant(tolua_S,"biMesaPlateauF",biMesaPlateauF);
  tolua_constant(tolua_S,"biMesaPlateau",biMesaPlateau);
  tolua_constant(tolua_S,"biNumBiomes",biNumBiomes);
  tolua_constant(tolua_S,"biMaxBiome",biMaxBiome);
  tolua_constant(tolua_S,"biVariant",biVariant);
  tolua_constant(tolua_S,"biFirstVariantBiome",biFirstVariantBiome);
  tolua_constant(tolua_S,"biSunflowerPlains",biSunflowerPlains);
  tolua_constant(tolua_S,"biDesertM",biDesertM);
  tolua_constant(tolua_S,"biExtremeHillsM",biExtremeHillsM);
  tolua_constant(tolua_S,"biFlowerForest",biFlowerForest);
  tolua_constant(tolua_S,"biTaigaM",biTaigaM);
  tolua_constant(tolua_S,"biSwamplandM",biSwamplandM);
  tolua_constant(tolua_S,"biIcePlainsSpikes",biIcePlainsSpikes);
  tolua_constant(tolua_S,"biJungleM",biJungleM);
  tolua_constant(tolua_S,"biJungleEdgeM",biJungleEdgeM);
  tolua_constant(tolua_S,"biBirchForestM",biBirchForestM);
  tolua_constant(tolua_S,"biBirchForestHillsM",biBirchForestHillsM);
  tolua_constant(tolua_S,"biRoofedForestM",biRoofedForestM);
  tolua_constant(tolua_S,"biColdTaigaM",biColdTaigaM);
  tolua_constant(tolua_S,"biMegaSpruceTaiga",biMegaSpruceTaiga);
  tolua_constant(tolua_S,"biMegaSpruceTaigaHills",biMegaSpruceTaigaHills);
  tolua_constant(tolua_S,"biExtremeHillsPlusM",biExtremeHillsPlusM);
  tolua_constant(tolua_S,"biSavannaM",biSavannaM);
  tolua_constant(tolua_S,"biSavannaPlateauM",biSavannaPlateauM);
  tolua_constant(tolua_S,"biMesaBryce",biMesaBryce);
  tolua_constant(tolua_S,"biMesaPlateauFM",biMesaPlateauFM);
  tolua_constant(tolua_S,"biMesaPlateauM",biMesaPlateauM);
  tolua_constant(tolua_S,"biNumVariantBiomes",biNumVariantBiomes);
  tolua_constant(tolua_S,"biMaxVariantBiome",biMaxVariantBiome);
  tolua_function(tolua_S,"StringToBiome",tolua_AllToLua_StringToBiome00);
  tolua_function(tolua_S,"BiomeToString",tolua_AllToLua_BiomeToString00);
  tolua_function(tolua_S,"IsBiomeNoDownfall",tolua_AllToLua_IsBiomeNoDownfall00);
  tolua_function(tolua_S,"IsBiomeOcean",tolua_AllToLua_IsBiomeOcean00);
  tolua_function(tolua_S,"IsBiomeVeryCold",tolua_AllToLua_IsBiomeVeryCold00);
  tolua_function(tolua_S,"IsBiomeCold",tolua_AllToLua_IsBiomeCold00);
  tolua_function(tolua_S,"IsBiomeMountain",tolua_AllToLua_IsBiomeMountain00);
  tolua_function(tolua_S,"IsBiomeMesa",tolua_AllToLua_IsBiomeMesa00);
  tolua_function(tolua_S,"GetSnowStartHeight",tolua_AllToLua_GetSnowStartHeight00);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"cIniFile","cIniFile","cSettingsRepositoryInterface",tolua_collect_cIniFile);
  #else
  tolua_cclass(tolua_S,"cIniFile","cIniFile","cSettingsRepositoryInterface",nullptr);
  #endif
  tolua_beginmodule(tolua_S,"cIniFile");
   tolua_constant(tolua_S,"noID",cIniFile::noID);
   tolua_function(tolua_S,"new",tolua_AllToLua_cIniFile_new00);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cIniFile_new00_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cIniFile_new00_local);
   tolua_function(tolua_S,"CaseSensitive",tolua_AllToLua_cIniFile_CaseSensitive00);
   tolua_function(tolua_S,"CaseInsensitive",tolua_AllToLua_cIniFile_CaseInsensitive00);
   tolua_function(tolua_S,"ReadFile",tolua_AllToLua_cIniFile_ReadFile00);
   tolua_function(tolua_S,"WriteFile",tolua_AllToLua_cIniFile_WriteFile00);
   tolua_function(tolua_S,"Flush",tolua_AllToLua_cIniFile_Flush00);
   tolua_function(tolua_S,"Clear",tolua_AllToLua_cIniFile_Clear00);
   tolua_function(tolua_S,"HasValue",tolua_AllToLua_cIniFile_HasValue00);
   tolua_function(tolua_S,"FindKey",tolua_AllToLua_cIniFile_FindKey00);
   tolua_function(tolua_S,"FindValue",tolua_AllToLua_cIniFile_FindValue00);
   tolua_function(tolua_S,"GetNumKeys",tolua_AllToLua_cIniFile_GetNumKeys00);
   tolua_function(tolua_S,"AddKeyName",tolua_AllToLua_cIniFile_AddKeyName00);
   tolua_function(tolua_S,"GetKeyName",tolua_AllToLua_cIniFile_GetKeyName00);
   tolua_function(tolua_S,"GetNumValues",tolua_AllToLua_cIniFile_GetNumValues00);
   tolua_function(tolua_S,"GetNumValues",tolua_AllToLua_cIniFile_GetNumValues01);
   tolua_function(tolua_S,"GetValueName",tolua_AllToLua_cIniFile_GetValueName00);
   tolua_function(tolua_S,"GetValueName",tolua_AllToLua_cIniFile_GetValueName01);
   tolua_function(tolua_S,"GetValue",tolua_AllToLua_cIniFile_GetValue00);
   tolua_function(tolua_S,"GetValue",tolua_AllToLua_cIniFile_GetValue01);
   tolua_function(tolua_S,"GetValue",tolua_AllToLua_cIniFile_GetValue02);
   tolua_function(tolua_S,"GetValue",tolua_AllToLua_cIniFile_GetValue03);
   tolua_function(tolua_S,"GetValueF",tolua_AllToLua_cIniFile_GetValueF00);
   tolua_function(tolua_S,"GetValueI",tolua_AllToLua_cIniFile_GetValueI00);
   tolua_function(tolua_S,"GetValueB",tolua_AllToLua_cIniFile_GetValueB00);
   tolua_function(tolua_S,"GetValueSet",tolua_AllToLua_cIniFile_GetValueSet00);
   tolua_function(tolua_S,"GetValueSet",tolua_AllToLua_cIniFile_GetValueSet01);
   tolua_function(tolua_S,"GetValueSetF",tolua_AllToLua_cIniFile_GetValueSetF00);
   tolua_function(tolua_S,"GetValueSetI",tolua_AllToLua_cIniFile_GetValueSetI00);
   tolua_function(tolua_S,"GetValueSetI",tolua_AllToLua_cIniFile_GetValueSetI01);
   tolua_function(tolua_S,"GetValueSetB",tolua_AllToLua_cIniFile_GetValueSetB00);
   tolua_function(tolua_S,"AddValue",tolua_AllToLua_cIniFile_AddValue00);
   tolua_function(tolua_S,"AddValueI",tolua_AllToLua_cIniFile_AddValueI00);
   tolua_function(tolua_S,"AddValueB",tolua_AllToLua_cIniFile_AddValueB00);
   tolua_function(tolua_S,"AddValueF",tolua_AllToLua_cIniFile_AddValueF00);
   tolua_function(tolua_S,"SetValue",tolua_AllToLua_cIniFile_SetValue00);
   tolua_function(tolua_S,"SetValue",tolua_AllToLua_cIniFile_SetValue01);
   tolua_function(tolua_S,"SetValueI",tolua_AllToLua_cIniFile_SetValueI00);
   tolua_function(tolua_S,"SetValueI",tolua_AllToLua_cIniFile_SetValueI01);
   tolua_function(tolua_S,"SetValueB",tolua_AllToLua_cIniFile_SetValueB00);
   tolua_function(tolua_S,"SetValueF",tolua_AllToLua_cIniFile_SetValueF00);
   tolua_function(tolua_S,"DeleteValueByID",tolua_AllToLua_cIniFile_DeleteValueByID00);
   tolua_function(tolua_S,"DeleteValue",tolua_AllToLua_cIniFile_DeleteValue00);
   tolua_function(tolua_S,"DeleteKey",tolua_AllToLua_cIniFile_DeleteKey00);
   tolua_function(tolua_S,"GetNumHeaderComments",tolua_AllToLua_cIniFile_GetNumHeaderComments00);
   tolua_function(tolua_S,"AddHeaderComment",tolua_AllToLua_cIniFile_AddHeaderComment00);
   tolua_function(tolua_S,"GetHeaderComment",tolua_AllToLua_cIniFile_GetHeaderComment00);
   tolua_function(tolua_S,"DeleteHeaderComment",tolua_AllToLua_cIniFile_DeleteHeaderComment00);
   tolua_function(tolua_S,"DeleteHeaderComments",tolua_AllToLua_cIniFile_DeleteHeaderComments00);
   tolua_function(tolua_S,"GetNumKeyComments",tolua_AllToLua_cIniFile_GetNumKeyComments00);
   tolua_function(tolua_S,"GetNumKeyComments",tolua_AllToLua_cIniFile_GetNumKeyComments01);
   tolua_function(tolua_S,"AddKeyComment",tolua_AllToLua_cIniFile_AddKeyComment00);
   tolua_function(tolua_S,"AddKeyComment",tolua_AllToLua_cIniFile_AddKeyComment01);
   tolua_function(tolua_S,"GetKeyComment",tolua_AllToLua_cIniFile_GetKeyComment00);
   tolua_function(tolua_S,"GetKeyComment",tolua_AllToLua_cIniFile_GetKeyComment01);
   tolua_function(tolua_S,"DeleteKeyComment",tolua_AllToLua_cIniFile_DeleteKeyComment00);
   tolua_function(tolua_S,"DeleteKeyComment",tolua_AllToLua_cIniFile_DeleteKeyComment01);
   tolua_function(tolua_S,"DeleteKeyComments",tolua_AllToLua_cIniFile_DeleteKeyComments00);
   tolua_function(tolua_S,"DeleteKeyComments",tolua_AllToLua_cIniFile_DeleteKeyComments01);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cFile","cFile","",nullptr);
  tolua_beginmodule(tolua_S,"cFile");
   tolua_function(tolua_S,"GetPathSeparator",tolua_AllToLua_cFile_GetPathSeparator00);
   tolua_function(tolua_S,"GetExecutableExt",tolua_AllToLua_cFile_GetExecutableExt00);
  tolua_endmodule(tolua_S);
  tolua_function(tolua_S,"GetTime",tolua_AllToLua_GetTime00);
  tolua_cclass(tolua_S,"cPluginManager","cPluginManager","",nullptr);
  tolua_beginmodule(tolua_S,"cPluginManager");
   tolua_constant(tolua_S,"crExecuted",cPluginManager::crExecuted);
   tolua_constant(tolua_S,"crUnknownCommand",cPluginManager::crUnknownCommand);
   tolua_constant(tolua_S,"crError",cPluginManager::crError);
   tolua_constant(tolua_S,"crBlocked",cPluginManager::crBlocked);
   tolua_constant(tolua_S,"crNoPermission",cPluginManager::crNoPermission);
   tolua_constant(tolua_S,"psLoaded",cPluginManager::psLoaded);
   tolua_constant(tolua_S,"psDisabled",cPluginManager::psDisabled);
   tolua_constant(tolua_S,"psUnloaded",cPluginManager::psUnloaded);
   tolua_constant(tolua_S,"psError",cPluginManager::psError);
   tolua_constant(tolua_S,"psNotFound",cPluginManager::psNotFound);
   tolua_constant(tolua_S,"HOOK_BLOCK_SPREAD",cPluginManager::HOOK_BLOCK_SPREAD);
   tolua_constant(tolua_S,"HOOK_BLOCK_TO_PICKUPS",cPluginManager::HOOK_BLOCK_TO_PICKUPS);
   tolua_constant(tolua_S,"HOOK_BREWING_COMPLETING",cPluginManager::HOOK_BREWING_COMPLETING);
   tolua_constant(tolua_S,"HOOK_BREWING_COMPLETED",cPluginManager::HOOK_BREWING_COMPLETED);
   tolua_constant(tolua_S,"HOOK_CHAT",cPluginManager::HOOK_CHAT);
   tolua_constant(tolua_S,"HOOK_CHUNK_AVAILABLE",cPluginManager::HOOK_CHUNK_AVAILABLE);
   tolua_constant(tolua_S,"HOOK_CHUNK_GENERATED",cPluginManager::HOOK_CHUNK_GENERATED);
   tolua_constant(tolua_S,"HOOK_CHUNK_GENERATING",cPluginManager::HOOK_CHUNK_GENERATING);
   tolua_constant(tolua_S,"HOOK_CHUNK_UNLOADED",cPluginManager::HOOK_CHUNK_UNLOADED);
   tolua_constant(tolua_S,"HOOK_CHUNK_UNLOADING",cPluginManager::HOOK_CHUNK_UNLOADING);
   tolua_constant(tolua_S,"HOOK_COLLECTING_PICKUP",cPluginManager::HOOK_COLLECTING_PICKUP);
   tolua_constant(tolua_S,"HOOK_CRAFTING_NO_RECIPE",cPluginManager::HOOK_CRAFTING_NO_RECIPE);
   tolua_constant(tolua_S,"HOOK_DISCONNECT",cPluginManager::HOOK_DISCONNECT);
   tolua_constant(tolua_S,"HOOK_PLAYER_ANIMATION",cPluginManager::HOOK_PLAYER_ANIMATION);
   tolua_constant(tolua_S,"HOOK_ENTITY_ADD_EFFECT",cPluginManager::HOOK_ENTITY_ADD_EFFECT);
   tolua_constant(tolua_S,"HOOK_ENTITY_CHANGING_WORLD",cPluginManager::HOOK_ENTITY_CHANGING_WORLD);
   tolua_constant(tolua_S,"HOOK_ENTITY_CHANGED_WORLD",cPluginManager::HOOK_ENTITY_CHANGED_WORLD);
   tolua_constant(tolua_S,"HOOK_EXECUTE_COMMAND",cPluginManager::HOOK_EXECUTE_COMMAND);
   tolua_constant(tolua_S,"HOOK_EXPLODED",cPluginManager::HOOK_EXPLODED);
   tolua_constant(tolua_S,"HOOK_EXPLODING",cPluginManager::HOOK_EXPLODING);
   tolua_constant(tolua_S,"HOOK_HANDSHAKE",cPluginManager::HOOK_HANDSHAKE);
   tolua_constant(tolua_S,"HOOK_HOPPER_PULLING_ITEM",cPluginManager::HOOK_HOPPER_PULLING_ITEM);
   tolua_constant(tolua_S,"HOOK_HOPPER_PUSHING_ITEM",cPluginManager::HOOK_HOPPER_PUSHING_ITEM);
   tolua_constant(tolua_S,"HOOK_DROPSPENSE",cPluginManager::HOOK_DROPSPENSE);
   tolua_constant(tolua_S,"HOOK_KILLED",cPluginManager::HOOK_KILLED);
   tolua_constant(tolua_S,"HOOK_KILLING",cPluginManager::HOOK_KILLING);
   tolua_constant(tolua_S,"HOOK_LOGIN",cPluginManager::HOOK_LOGIN);
   tolua_constant(tolua_S,"HOOK_LOGIN_FORGE",cPluginManager::HOOK_LOGIN_FORGE);
   tolua_constant(tolua_S,"HOOK_PLAYER_BREAKING_BLOCK",cPluginManager::HOOK_PLAYER_BREAKING_BLOCK);
   tolua_constant(tolua_S,"HOOK_PLAYER_BROKEN_BLOCK",cPluginManager::HOOK_PLAYER_BROKEN_BLOCK);
   tolua_constant(tolua_S,"HOOK_PLAYER_DESTROYED",cPluginManager::HOOK_PLAYER_DESTROYED);
   tolua_constant(tolua_S,"HOOK_PLAYER_EATING",cPluginManager::HOOK_PLAYER_EATING);
   tolua_constant(tolua_S,"HOOK_PLAYER_FISHED",cPluginManager::HOOK_PLAYER_FISHED);
   tolua_constant(tolua_S,"HOOK_PLAYER_FISHING",cPluginManager::HOOK_PLAYER_FISHING);
   tolua_constant(tolua_S,"HOOK_PLAYER_FOOD_LEVEL_CHANGE",cPluginManager::HOOK_PLAYER_FOOD_LEVEL_CHANGE);
   tolua_constant(tolua_S,"HOOK_PLAYER_JOINED",cPluginManager::HOOK_PLAYER_JOINED);
   tolua_constant(tolua_S,"HOOK_PLAYER_LEFT_CLICK",cPluginManager::HOOK_PLAYER_LEFT_CLICK);
   tolua_constant(tolua_S,"HOOK_PLAYER_MOVING",cPluginManager::HOOK_PLAYER_MOVING);
   tolua_constant(tolua_S,"HOOK_PLAYER_OPENING_WINDOW",cPluginManager::HOOK_PLAYER_OPENING_WINDOW);
   tolua_constant(tolua_S,"HOOK_PLAYER_PLACED_BLOCK",cPluginManager::HOOK_PLAYER_PLACED_BLOCK);
   tolua_constant(tolua_S,"HOOK_PLAYER_PLACING_BLOCK",cPluginManager::HOOK_PLAYER_PLACING_BLOCK);
   tolua_constant(tolua_S,"HOOK_PLAYER_CROUCHED",cPluginManager::HOOK_PLAYER_CROUCHED);
   tolua_constant(tolua_S,"HOOK_PLAYER_RIGHT_CLICK",cPluginManager::HOOK_PLAYER_RIGHT_CLICK);
   tolua_constant(tolua_S,"HOOK_PLAYER_RIGHT_CLICKING_ENTITY",cPluginManager::HOOK_PLAYER_RIGHT_CLICKING_ENTITY);
   tolua_constant(tolua_S,"HOOK_PLAYER_SHOOTING",cPluginManager::HOOK_PLAYER_SHOOTING);
   tolua_constant(tolua_S,"HOOK_PLAYER_SPAWNED",cPluginManager::HOOK_PLAYER_SPAWNED);
   tolua_constant(tolua_S,"HOOK_ENTITY_TELEPORT",cPluginManager::HOOK_ENTITY_TELEPORT);
   tolua_constant(tolua_S,"HOOK_PLAYER_TOSSING_ITEM",cPluginManager::HOOK_PLAYER_TOSSING_ITEM);
   tolua_constant(tolua_S,"HOOK_PLAYER_USED_BLOCK",cPluginManager::HOOK_PLAYER_USED_BLOCK);
   tolua_constant(tolua_S,"HOOK_PLAYER_USED_ITEM",cPluginManager::HOOK_PLAYER_USED_ITEM);
   tolua_constant(tolua_S,"HOOK_PLAYER_USING_BLOCK",cPluginManager::HOOK_PLAYER_USING_BLOCK);
   tolua_constant(tolua_S,"HOOK_PLAYER_USING_ITEM",cPluginManager::HOOK_PLAYER_USING_ITEM);
   tolua_constant(tolua_S,"HOOK_PLUGIN_MESSAGE",cPluginManager::HOOK_PLUGIN_MESSAGE);
   tolua_constant(tolua_S,"HOOK_PLUGINS_LOADED",cPluginManager::HOOK_PLUGINS_LOADED);
   tolua_constant(tolua_S,"HOOK_POST_CRAFTING",cPluginManager::HOOK_POST_CRAFTING);
   tolua_constant(tolua_S,"HOOK_PRE_CRAFTING",cPluginManager::HOOK_PRE_CRAFTING);
   tolua_constant(tolua_S,"HOOK_PROJECTILE_HIT_BLOCK",cPluginManager::HOOK_PROJECTILE_HIT_BLOCK);
   tolua_constant(tolua_S,"HOOK_PROJECTILE_HIT_ENTITY",cPluginManager::HOOK_PROJECTILE_HIT_ENTITY);
   tolua_constant(tolua_S,"HOOK_SERVER_PING",cPluginManager::HOOK_SERVER_PING);
   tolua_constant(tolua_S,"HOOK_SPAWNED_ENTITY",cPluginManager::HOOK_SPAWNED_ENTITY);
   tolua_constant(tolua_S,"HOOK_SPAWNED_MONSTER",cPluginManager::HOOK_SPAWNED_MONSTER);
   tolua_constant(tolua_S,"HOOK_SPAWNING_ENTITY",cPluginManager::HOOK_SPAWNING_ENTITY);
   tolua_constant(tolua_S,"HOOK_SPAWNING_MONSTER",cPluginManager::HOOK_SPAWNING_MONSTER);
   tolua_constant(tolua_S,"HOOK_TAKE_DAMAGE",cPluginManager::HOOK_TAKE_DAMAGE);
   tolua_constant(tolua_S,"HOOK_TICK",cPluginManager::HOOK_TICK);
   tolua_constant(tolua_S,"HOOK_UPDATED_SIGN",cPluginManager::HOOK_UPDATED_SIGN);
   tolua_constant(tolua_S,"HOOK_UPDATING_SIGN",cPluginManager::HOOK_UPDATING_SIGN);
   tolua_constant(tolua_S,"HOOK_WEATHER_CHANGED",cPluginManager::HOOK_WEATHER_CHANGED);
   tolua_constant(tolua_S,"HOOK_WEATHER_CHANGING",cPluginManager::HOOK_WEATHER_CHANGING);
   tolua_constant(tolua_S,"HOOK_WORLD_STARTED",cPluginManager::HOOK_WORLD_STARTED);
   tolua_constant(tolua_S,"HOOK_WORLD_TICK",cPluginManager::HOOK_WORLD_TICK);
   tolua_function(tolua_S,"Get",tolua_AllToLua_cPluginManager_Get00);
   tolua_function(tolua_S,"RefreshPluginList",tolua_AllToLua_cPluginManager_RefreshPluginList00);
   tolua_function(tolua_S,"ReloadPlugins",tolua_AllToLua_cPluginManager_ReloadPlugins00);
   tolua_function(tolua_S,"GetNumPlugins",tolua_AllToLua_cPluginManager_GetNumPlugins00);
   tolua_function(tolua_S,"GetNumLoadedPlugins",tolua_AllToLua_cPluginManager_GetNumLoadedPlugins00);
   tolua_function(tolua_S,"UnloadPlugin",tolua_AllToLua_cPluginManager_UnloadPlugin00);
   tolua_function(tolua_S,"ReloadPlugin",tolua_AllToLua_cPluginManager_ReloadPlugin00);
   tolua_function(tolua_S,"LoadPlugin",tolua_AllToLua_cPluginManager_LoadPlugin00);
   tolua_function(tolua_S,"IsPluginLoaded",tolua_AllToLua_cPluginManager_IsPluginLoaded00);
   tolua_function(tolua_S,"IsCommandBound",tolua_AllToLua_cPluginManager_IsCommandBound00);
   tolua_function(tolua_S,"GetCommandPermission",tolua_AllToLua_cPluginManager_GetCommandPermission00);
   tolua_function(tolua_S,"ExecuteCommand",tolua_AllToLua_cPluginManager_ExecuteCommand00);
   tolua_function(tolua_S,"ForceExecuteCommand",tolua_AllToLua_cPluginManager_ForceExecuteCommand00);
   tolua_function(tolua_S,"IsConsoleCommandBound",tolua_AllToLua_cPluginManager_IsConsoleCommandBound00);
   tolua_function(tolua_S,"GetPluginFolderName",tolua_AllToLua_cPluginManager_GetPluginFolderName00);
   tolua_function(tolua_S,"GetPluginsPath",tolua_AllToLua_cPluginManager_GetPluginsPath00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cPlugin","cPlugin","",nullptr);
  tolua_beginmodule(tolua_S,"cPlugin");
   tolua_function(tolua_S,"GetName",tolua_AllToLua_cPlugin_GetName00);
   tolua_function(tolua_S,"SetName",tolua_AllToLua_cPlugin_SetName00);
   tolua_function(tolua_S,"GetVersion",tolua_AllToLua_cPlugin_GetVersion00);
   tolua_function(tolua_S,"SetVersion",tolua_AllToLua_cPlugin_SetVersion00);
   tolua_function(tolua_S,"GetFolderName",tolua_AllToLua_cPlugin_GetFolderName00);
   tolua_function(tolua_S,"GetLocalFolder",tolua_AllToLua_cPlugin_GetLocalFolder00);
   tolua_function(tolua_S,"GetLoadError",tolua_AllToLua_cPlugin_GetLoadError00);
   tolua_function(tolua_S,"GetStatus",tolua_AllToLua_cPlugin_GetStatus00);
   tolua_function(tolua_S,"IsLoaded",tolua_AllToLua_cPlugin_IsLoaded00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cPluginLua","cPluginLua","cPlugin",nullptr);
  tolua_beginmodule(tolua_S,"cPluginLua");
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"cLuaWindow","cLuaWindow","cWindow",tolua_collect_cLuaWindow);
  #else
  tolua_cclass(tolua_S,"cLuaWindow","cLuaWindow","cWindow",nullptr);
  #endif
  tolua_beginmodule(tolua_S,"cLuaWindow");
   tolua_function(tolua_S,"delete",tolua_AllToLua_cLuaWindow_delete00);
   tolua_function(tolua_S,"GetContents",tolua_AllToLua_cLuaWindow_GetContents00);
  tolua_endmodule(tolua_S);
  tolua_constant(tolua_S,"E_BLOCK_AIR",E_BLOCK_AIR);
  tolua_constant(tolua_S,"E_BLOCK_STONE",E_BLOCK_STONE);
  tolua_constant(tolua_S,"E_BLOCK_GRASS",E_BLOCK_GRASS);
  tolua_constant(tolua_S,"E_BLOCK_DIRT",E_BLOCK_DIRT);
  tolua_constant(tolua_S,"E_BLOCK_COBBLESTONE",E_BLOCK_COBBLESTONE);
  tolua_constant(tolua_S,"E_BLOCK_PLANKS",E_BLOCK_PLANKS);
  tolua_constant(tolua_S,"E_BLOCK_SAPLING",E_BLOCK_SAPLING);
  tolua_constant(tolua_S,"E_BLOCK_BEDROCK",E_BLOCK_BEDROCK);
  tolua_constant(tolua_S,"E_BLOCK_WATER",E_BLOCK_WATER);
  tolua_constant(tolua_S,"E_BLOCK_STATIONARY_WATER",E_BLOCK_STATIONARY_WATER);
  tolua_constant(tolua_S,"E_BLOCK_LAVA",E_BLOCK_LAVA);
  tolua_constant(tolua_S,"E_BLOCK_STATIONARY_LAVA",E_BLOCK_STATIONARY_LAVA);
  tolua_constant(tolua_S,"E_BLOCK_SAND",E_BLOCK_SAND);
  tolua_constant(tolua_S,"E_BLOCK_GRAVEL",E_BLOCK_GRAVEL);
  tolua_constant(tolua_S,"E_BLOCK_GOLD_ORE",E_BLOCK_GOLD_ORE);
  tolua_constant(tolua_S,"E_BLOCK_IRON_ORE",E_BLOCK_IRON_ORE);
  tolua_constant(tolua_S,"E_BLOCK_COAL_ORE",E_BLOCK_COAL_ORE);
  tolua_constant(tolua_S,"E_BLOCK_LOG",E_BLOCK_LOG);
  tolua_constant(tolua_S,"E_BLOCK_LEAVES",E_BLOCK_LEAVES);
  tolua_constant(tolua_S,"E_BLOCK_SPONGE",E_BLOCK_SPONGE);
  tolua_constant(tolua_S,"E_BLOCK_GLASS",E_BLOCK_GLASS);
  tolua_constant(tolua_S,"E_BLOCK_LAPIS_ORE",E_BLOCK_LAPIS_ORE);
  tolua_constant(tolua_S,"E_BLOCK_LAPIS_BLOCK",E_BLOCK_LAPIS_BLOCK);
  tolua_constant(tolua_S,"E_BLOCK_DISPENSER",E_BLOCK_DISPENSER);
  tolua_constant(tolua_S,"E_BLOCK_SANDSTONE",E_BLOCK_SANDSTONE);
  tolua_constant(tolua_S,"E_BLOCK_NOTE_BLOCK",E_BLOCK_NOTE_BLOCK);
  tolua_constant(tolua_S,"E_BLOCK_BED",E_BLOCK_BED);
  tolua_constant(tolua_S,"E_BLOCK_POWERED_RAIL",E_BLOCK_POWERED_RAIL);
  tolua_constant(tolua_S,"E_BLOCK_DETECTOR_RAIL",E_BLOCK_DETECTOR_RAIL);
  tolua_constant(tolua_S,"E_BLOCK_STICKY_PISTON",E_BLOCK_STICKY_PISTON);
  tolua_constant(tolua_S,"E_BLOCK_COBWEB",E_BLOCK_COBWEB);
  tolua_constant(tolua_S,"E_BLOCK_TALL_GRASS",E_BLOCK_TALL_GRASS);
  tolua_constant(tolua_S,"E_BLOCK_DEAD_BUSH",E_BLOCK_DEAD_BUSH);
  tolua_constant(tolua_S,"E_BLOCK_PISTON",E_BLOCK_PISTON);
  tolua_constant(tolua_S,"E_BLOCK_PISTON_EXTENSION",E_BLOCK_PISTON_EXTENSION);
  tolua_constant(tolua_S,"E_BLOCK_WOOL",E_BLOCK_WOOL);
  tolua_constant(tolua_S,"E_BLOCK_PISTON_MOVED_BLOCK",E_BLOCK_PISTON_MOVED_BLOCK);
  tolua_constant(tolua_S,"E_BLOCK_DANDELION",E_BLOCK_DANDELION);
  tolua_constant(tolua_S,"E_BLOCK_FLOWER",E_BLOCK_FLOWER);
  tolua_constant(tolua_S,"E_BLOCK_BROWN_MUSHROOM",E_BLOCK_BROWN_MUSHROOM);
  tolua_constant(tolua_S,"E_BLOCK_RED_MUSHROOM",E_BLOCK_RED_MUSHROOM);
  tolua_constant(tolua_S,"E_BLOCK_GOLD_BLOCK",E_BLOCK_GOLD_BLOCK);
  tolua_constant(tolua_S,"E_BLOCK_IRON_BLOCK",E_BLOCK_IRON_BLOCK);
  tolua_constant(tolua_S,"E_BLOCK_DOUBLE_STONE_SLAB",E_BLOCK_DOUBLE_STONE_SLAB);
  tolua_constant(tolua_S,"E_BLOCK_STONE_SLAB",E_BLOCK_STONE_SLAB);
  tolua_constant(tolua_S,"E_BLOCK_BRICK",E_BLOCK_BRICK);
  tolua_constant(tolua_S,"E_BLOCK_TNT",E_BLOCK_TNT);
  tolua_constant(tolua_S,"E_BLOCK_BOOKCASE",E_BLOCK_BOOKCASE);
  tolua_constant(tolua_S,"E_BLOCK_MOSSY_COBBLESTONE",E_BLOCK_MOSSY_COBBLESTONE);
  tolua_constant(tolua_S,"E_BLOCK_OBSIDIAN",E_BLOCK_OBSIDIAN);
  tolua_constant(tolua_S,"E_BLOCK_TORCH",E_BLOCK_TORCH);
  tolua_constant(tolua_S,"E_BLOCK_FIRE",E_BLOCK_FIRE);
  tolua_constant(tolua_S,"E_BLOCK_MOB_SPAWNER",E_BLOCK_MOB_SPAWNER);
  tolua_constant(tolua_S,"E_BLOCK_OAK_WOOD_STAIRS",E_BLOCK_OAK_WOOD_STAIRS);
  tolua_constant(tolua_S,"E_BLOCK_CHEST",E_BLOCK_CHEST);
  tolua_constant(tolua_S,"E_BLOCK_REDSTONE_WIRE",E_BLOCK_REDSTONE_WIRE);
  tolua_constant(tolua_S,"E_BLOCK_DIAMOND_ORE",E_BLOCK_DIAMOND_ORE);
  tolua_constant(tolua_S,"E_BLOCK_DIAMOND_BLOCK",E_BLOCK_DIAMOND_BLOCK);
  tolua_constant(tolua_S,"E_BLOCK_CRAFTING_TABLE",E_BLOCK_CRAFTING_TABLE);
  tolua_constant(tolua_S,"E_BLOCK_WORKBENCH",E_BLOCK_WORKBENCH);
  tolua_constant(tolua_S,"E_BLOCK_WHEAT",E_BLOCK_WHEAT);
  tolua_constant(tolua_S,"E_BLOCK_CROPS",E_BLOCK_CROPS);
  tolua_constant(tolua_S,"E_BLOCK_FARMLAND",E_BLOCK_FARMLAND);
  tolua_constant(tolua_S,"E_BLOCK_FURNACE",E_BLOCK_FURNACE);
  tolua_constant(tolua_S,"E_BLOCK_LIT_FURNACE",E_BLOCK_LIT_FURNACE);
  tolua_constant(tolua_S,"E_BLOCK_BURNING_FURNACE",E_BLOCK_BURNING_FURNACE);
  tolua_constant(tolua_S,"E_BLOCK_SIGN_POST",E_BLOCK_SIGN_POST);
  tolua_constant(tolua_S,"E_BLOCK_OAK_DOOR",E_BLOCK_OAK_DOOR);
  tolua_constant(tolua_S,"E_BLOCK_LADDER",E_BLOCK_LADDER);
  tolua_constant(tolua_S,"E_BLOCK_RAIL",E_BLOCK_RAIL);
  tolua_constant(tolua_S,"E_BLOCK_MINECART_TRACKS",E_BLOCK_MINECART_TRACKS);
  tolua_constant(tolua_S,"E_BLOCK_COBBLESTONE_STAIRS",E_BLOCK_COBBLESTONE_STAIRS);
  tolua_constant(tolua_S,"E_BLOCK_WALLSIGN",E_BLOCK_WALLSIGN);
  tolua_constant(tolua_S,"E_BLOCK_LEVER",E_BLOCK_LEVER);
  tolua_constant(tolua_S,"E_BLOCK_STONE_PRESSURE_PLATE",E_BLOCK_STONE_PRESSURE_PLATE);
  tolua_constant(tolua_S,"E_BLOCK_IRON_DOOR",E_BLOCK_IRON_DOOR);
  tolua_constant(tolua_S,"E_BLOCK_WOODEN_PRESSURE_PLATE",E_BLOCK_WOODEN_PRESSURE_PLATE);
  tolua_constant(tolua_S,"E_BLOCK_REDSTONE_ORE",E_BLOCK_REDSTONE_ORE);
  tolua_constant(tolua_S,"E_BLOCK_REDSTONE_ORE_GLOWING",E_BLOCK_REDSTONE_ORE_GLOWING);
  tolua_constant(tolua_S,"E_BLOCK_REDSTONE_TORCH_OFF",E_BLOCK_REDSTONE_TORCH_OFF);
  tolua_constant(tolua_S,"E_BLOCK_REDSTONE_TORCH_ON",E_BLOCK_REDSTONE_TORCH_ON);
  tolua_constant(tolua_S,"E_BLOCK_STONE_BUTTON",E_BLOCK_STONE_BUTTON);
  tolua_constant(tolua_S,"E_BLOCK_SNOW",E_BLOCK_SNOW);
  tolua_constant(tolua_S,"E_BLOCK_ICE",E_BLOCK_ICE);
  tolua_constant(tolua_S,"E_BLOCK_SNOW_BLOCK",E_BLOCK_SNOW_BLOCK);
  tolua_constant(tolua_S,"E_BLOCK_CACTUS",E_BLOCK_CACTUS);
  tolua_constant(tolua_S,"E_BLOCK_CLAY",E_BLOCK_CLAY);
  tolua_constant(tolua_S,"E_BLOCK_SUGARCANE",E_BLOCK_SUGARCANE);
  tolua_constant(tolua_S,"E_BLOCK_REEDS",E_BLOCK_REEDS);
  tolua_constant(tolua_S,"E_BLOCK_JUKEBOX",E_BLOCK_JUKEBOX);
  tolua_constant(tolua_S,"E_BLOCK_FENCE",E_BLOCK_FENCE);
  tolua_constant(tolua_S,"E_BLOCK_PUMPKIN",E_BLOCK_PUMPKIN);
  tolua_constant(tolua_S,"E_BLOCK_NETHERRACK",E_BLOCK_NETHERRACK);
  tolua_constant(tolua_S,"E_BLOCK_SOULSAND",E_BLOCK_SOULSAND);
  tolua_constant(tolua_S,"E_BLOCK_GLOWSTONE",E_BLOCK_GLOWSTONE);
  tolua_constant(tolua_S,"E_BLOCK_NETHER_PORTAL",E_BLOCK_NETHER_PORTAL);
  tolua_constant(tolua_S,"E_BLOCK_JACK_O_LANTERN",E_BLOCK_JACK_O_LANTERN);
  tolua_constant(tolua_S,"E_BLOCK_CAKE",E_BLOCK_CAKE);
  tolua_constant(tolua_S,"E_BLOCK_REDSTONE_REPEATER_OFF",E_BLOCK_REDSTONE_REPEATER_OFF);
  tolua_constant(tolua_S,"E_BLOCK_REDSTONE_REPEATER_ON",E_BLOCK_REDSTONE_REPEATER_ON);
  tolua_constant(tolua_S,"E_BLOCK_STAINED_GLASS",E_BLOCK_STAINED_GLASS);
  tolua_constant(tolua_S,"E_BLOCK_TRAPDOOR",E_BLOCK_TRAPDOOR);
  tolua_constant(tolua_S,"E_BLOCK_SILVERFISH_EGG",E_BLOCK_SILVERFISH_EGG);
  tolua_constant(tolua_S,"E_BLOCK_STONE_BRICKS",E_BLOCK_STONE_BRICKS);
  tolua_constant(tolua_S,"E_BLOCK_HUGE_BROWN_MUSHROOM",E_BLOCK_HUGE_BROWN_MUSHROOM);
  tolua_constant(tolua_S,"E_BLOCK_HUGE_RED_MUSHROOM",E_BLOCK_HUGE_RED_MUSHROOM);
  tolua_constant(tolua_S,"E_BLOCK_IRON_BARS",E_BLOCK_IRON_BARS);
  tolua_constant(tolua_S,"E_BLOCK_GLASS_PANE",E_BLOCK_GLASS_PANE);
  tolua_constant(tolua_S,"E_BLOCK_MELON",E_BLOCK_MELON);
  tolua_constant(tolua_S,"E_BLOCK_PUMPKIN_STEM",E_BLOCK_PUMPKIN_STEM);
  tolua_constant(tolua_S,"E_BLOCK_MELON_STEM",E_BLOCK_MELON_STEM);
  tolua_constant(tolua_S,"E_BLOCK_VINES",E_BLOCK_VINES);
  tolua_constant(tolua_S,"E_BLOCK_OAK_FENCE_GATE",E_BLOCK_OAK_FENCE_GATE);
  tolua_constant(tolua_S,"E_BLOCK_BRICK_STAIRS",E_BLOCK_BRICK_STAIRS);
  tolua_constant(tolua_S,"E_BLOCK_STONE_BRICK_STAIRS",E_BLOCK_STONE_BRICK_STAIRS);
  tolua_constant(tolua_S,"E_BLOCK_MYCELIUM",E_BLOCK_MYCELIUM);
  tolua_constant(tolua_S,"E_BLOCK_LILY_PAD",E_BLOCK_LILY_PAD);
  tolua_constant(tolua_S,"E_BLOCK_NETHER_BRICK",E_BLOCK_NETHER_BRICK);
  tolua_constant(tolua_S,"E_BLOCK_NETHER_BRICK_FENCE",E_BLOCK_NETHER_BRICK_FENCE);
  tolua_constant(tolua_S,"E_BLOCK_NETHER_BRICK_STAIRS",E_BLOCK_NETHER_BRICK_STAIRS);
  tolua_constant(tolua_S,"E_BLOCK_NETHER_WART",E_BLOCK_NETHER_WART);
  tolua_constant(tolua_S,"E_BLOCK_ENCHANTMENT_TABLE",E_BLOCK_ENCHANTMENT_TABLE);
  tolua_constant(tolua_S,"E_BLOCK_BREWING_STAND",E_BLOCK_BREWING_STAND);
  tolua_constant(tolua_S,"E_BLOCK_CAULDRON",E_BLOCK_CAULDRON);
  tolua_constant(tolua_S,"E_BLOCK_END_PORTAL",E_BLOCK_END_PORTAL);
  tolua_constant(tolua_S,"E_BLOCK_END_PORTAL_FRAME",E_BLOCK_END_PORTAL_FRAME);
  tolua_constant(tolua_S,"E_BLOCK_END_STONE",E_BLOCK_END_STONE);
  tolua_constant(tolua_S,"E_BLOCK_DRAGON_EGG",E_BLOCK_DRAGON_EGG);
  tolua_constant(tolua_S,"E_BLOCK_REDSTONE_LAMP_OFF",E_BLOCK_REDSTONE_LAMP_OFF);
  tolua_constant(tolua_S,"E_BLOCK_REDSTONE_LAMP_ON",E_BLOCK_REDSTONE_LAMP_ON);
  tolua_constant(tolua_S,"E_BLOCK_DOUBLE_WOODEN_SLAB",E_BLOCK_DOUBLE_WOODEN_SLAB);
  tolua_constant(tolua_S,"E_BLOCK_WOODEN_SLAB",E_BLOCK_WOODEN_SLAB);
  tolua_constant(tolua_S,"E_BLOCK_COCOA_POD",E_BLOCK_COCOA_POD);
  tolua_constant(tolua_S,"E_BLOCK_SANDSTONE_STAIRS",E_BLOCK_SANDSTONE_STAIRS);
  tolua_constant(tolua_S,"E_BLOCK_EMERALD_ORE",E_BLOCK_EMERALD_ORE);
  tolua_constant(tolua_S,"E_BLOCK_ENDER_CHEST",E_BLOCK_ENDER_CHEST);
  tolua_constant(tolua_S,"E_BLOCK_TRIPWIRE_HOOK",E_BLOCK_TRIPWIRE_HOOK);
  tolua_constant(tolua_S,"E_BLOCK_TRIPWIRE",E_BLOCK_TRIPWIRE);
  tolua_constant(tolua_S,"E_BLOCK_EMERALD_BLOCK",E_BLOCK_EMERALD_BLOCK);
  tolua_constant(tolua_S,"E_BLOCK_SPRUCE_WOOD_STAIRS",E_BLOCK_SPRUCE_WOOD_STAIRS);
  tolua_constant(tolua_S,"E_BLOCK_BIRCH_WOOD_STAIRS",E_BLOCK_BIRCH_WOOD_STAIRS);
  tolua_constant(tolua_S,"E_BLOCK_JUNGLE_WOOD_STAIRS",E_BLOCK_JUNGLE_WOOD_STAIRS);
  tolua_constant(tolua_S,"E_BLOCK_COMMAND_BLOCK",E_BLOCK_COMMAND_BLOCK);
  tolua_constant(tolua_S,"E_BLOCK_BEACON",E_BLOCK_BEACON);
  tolua_constant(tolua_S,"E_BLOCK_COBBLESTONE_WALL",E_BLOCK_COBBLESTONE_WALL);
  tolua_constant(tolua_S,"E_BLOCK_FLOWER_POT",E_BLOCK_FLOWER_POT);
  tolua_constant(tolua_S,"E_BLOCK_CARROTS",E_BLOCK_CARROTS);
  tolua_constant(tolua_S,"E_BLOCK_POTATOES",E_BLOCK_POTATOES);
  tolua_constant(tolua_S,"E_BLOCK_WOODEN_BUTTON",E_BLOCK_WOODEN_BUTTON);
  tolua_constant(tolua_S,"E_BLOCK_HEAD",E_BLOCK_HEAD);
  tolua_constant(tolua_S,"E_BLOCK_ANVIL",E_BLOCK_ANVIL);
  tolua_constant(tolua_S,"E_BLOCK_TRAPPED_CHEST",E_BLOCK_TRAPPED_CHEST);
  tolua_constant(tolua_S,"E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE",E_BLOCK_LIGHT_WEIGHTED_PRESSURE_PLATE);
  tolua_constant(tolua_S,"E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE",E_BLOCK_HEAVY_WEIGHTED_PRESSURE_PLATE);
  tolua_constant(tolua_S,"E_BLOCK_INACTIVE_COMPARATOR",E_BLOCK_INACTIVE_COMPARATOR);
  tolua_constant(tolua_S,"E_BLOCK_ACTIVE_COMPARATOR",E_BLOCK_ACTIVE_COMPARATOR);
  tolua_constant(tolua_S,"E_BLOCK_DAYLIGHT_SENSOR",E_BLOCK_DAYLIGHT_SENSOR);
  tolua_constant(tolua_S,"E_BLOCK_BLOCK_OF_REDSTONE",E_BLOCK_BLOCK_OF_REDSTONE);
  tolua_constant(tolua_S,"E_BLOCK_NETHER_QUARTZ_ORE",E_BLOCK_NETHER_QUARTZ_ORE);
  tolua_constant(tolua_S,"E_BLOCK_HOPPER",E_BLOCK_HOPPER);
  tolua_constant(tolua_S,"E_BLOCK_QUARTZ_BLOCK",E_BLOCK_QUARTZ_BLOCK);
  tolua_constant(tolua_S,"E_BLOCK_QUARTZ_STAIRS",E_BLOCK_QUARTZ_STAIRS);
  tolua_constant(tolua_S,"E_BLOCK_ACTIVATOR_RAIL",E_BLOCK_ACTIVATOR_RAIL);
  tolua_constant(tolua_S,"E_BLOCK_DROPPER",E_BLOCK_DROPPER);
  tolua_constant(tolua_S,"E_BLOCK_STAINED_CLAY",E_BLOCK_STAINED_CLAY);
  tolua_constant(tolua_S,"E_BLOCK_TERRACOTTA",E_BLOCK_TERRACOTTA);
  tolua_constant(tolua_S,"E_BLOCK_STAINED_GLASS_PANE",E_BLOCK_STAINED_GLASS_PANE);
  tolua_constant(tolua_S,"E_BLOCK_NEW_LEAVES",E_BLOCK_NEW_LEAVES);
  tolua_constant(tolua_S,"E_BLOCK_NEW_LOG",E_BLOCK_NEW_LOG);
  tolua_constant(tolua_S,"E_BLOCK_ACACIA_WOOD_STAIRS",E_BLOCK_ACACIA_WOOD_STAIRS);
  tolua_constant(tolua_S,"E_BLOCK_DARK_OAK_WOOD_STAIRS",E_BLOCK_DARK_OAK_WOOD_STAIRS);
  tolua_constant(tolua_S,"E_BLOCK_SLIME_BLOCK",E_BLOCK_SLIME_BLOCK);
  tolua_constant(tolua_S,"E_BLOCK_BARRIER",E_BLOCK_BARRIER);
  tolua_constant(tolua_S,"E_BLOCK_IRON_TRAPDOOR",E_BLOCK_IRON_TRAPDOOR);
  tolua_constant(tolua_S,"E_BLOCK_PRISMARINE_BLOCK",E_BLOCK_PRISMARINE_BLOCK);
  tolua_constant(tolua_S,"E_BLOCK_SEA_LANTERN",E_BLOCK_SEA_LANTERN);
  tolua_constant(tolua_S,"E_BLOCK_HAY_BALE",E_BLOCK_HAY_BALE);
  tolua_constant(tolua_S,"E_BLOCK_CARPET",E_BLOCK_CARPET);
  tolua_constant(tolua_S,"E_BLOCK_HARDENED_CLAY",E_BLOCK_HARDENED_CLAY);
  tolua_constant(tolua_S,"E_BLOCK_BLOCK_OF_COAL",E_BLOCK_BLOCK_OF_COAL);
  tolua_constant(tolua_S,"E_BLOCK_PACKED_ICE",E_BLOCK_PACKED_ICE);
  tolua_constant(tolua_S,"E_BLOCK_BIG_FLOWER",E_BLOCK_BIG_FLOWER);
  tolua_constant(tolua_S,"E_BLOCK_STANDING_BANNER",E_BLOCK_STANDING_BANNER);
  tolua_constant(tolua_S,"E_BLOCK_WALL_BANNER",E_BLOCK_WALL_BANNER);
  tolua_constant(tolua_S,"E_BLOCK_INVERTED_DAYLIGHT_SENSOR",E_BLOCK_INVERTED_DAYLIGHT_SENSOR);
  tolua_constant(tolua_S,"E_BLOCK_RED_SANDSTONE",E_BLOCK_RED_SANDSTONE);
  tolua_constant(tolua_S,"E_BLOCK_RED_SANDSTONE_STAIRS",E_BLOCK_RED_SANDSTONE_STAIRS);
  tolua_constant(tolua_S,"E_BLOCK_DOUBLE_RED_SANDSTONE_SLAB",E_BLOCK_DOUBLE_RED_SANDSTONE_SLAB);
  tolua_constant(tolua_S,"E_BLOCK_RED_SANDSTONE_SLAB",E_BLOCK_RED_SANDSTONE_SLAB);
  tolua_constant(tolua_S,"E_BLOCK_SPRUCE_FENCE_GATE",E_BLOCK_SPRUCE_FENCE_GATE);
  tolua_constant(tolua_S,"E_BLOCK_BIRCH_FENCE_GATE",E_BLOCK_BIRCH_FENCE_GATE);
  tolua_constant(tolua_S,"E_BLOCK_JUNGLE_FENCE_GATE",E_BLOCK_JUNGLE_FENCE_GATE);
  tolua_constant(tolua_S,"E_BLOCK_DARK_OAK_FENCE_GATE",E_BLOCK_DARK_OAK_FENCE_GATE);
  tolua_constant(tolua_S,"E_BLOCK_ACACIA_FENCE_GATE",E_BLOCK_ACACIA_FENCE_GATE);
  tolua_constant(tolua_S,"E_BLOCK_SPRUCE_FENCE",E_BLOCK_SPRUCE_FENCE);
  tolua_constant(tolua_S,"E_BLOCK_BIRCH_FENCE",E_BLOCK_BIRCH_FENCE);
  tolua_constant(tolua_S,"E_BLOCK_JUNGLE_FENCE",E_BLOCK_JUNGLE_FENCE);
  tolua_constant(tolua_S,"E_BLOCK_DARK_OAK_FENCE",E_BLOCK_DARK_OAK_FENCE);
  tolua_constant(tolua_S,"E_BLOCK_ACACIA_FENCE",E_BLOCK_ACACIA_FENCE);
  tolua_constant(tolua_S,"E_BLOCK_SPRUCE_DOOR",E_BLOCK_SPRUCE_DOOR);
  tolua_constant(tolua_S,"E_BLOCK_BIRCH_DOOR",E_BLOCK_BIRCH_DOOR);
  tolua_constant(tolua_S,"E_BLOCK_JUNGLE_DOOR",E_BLOCK_JUNGLE_DOOR);
  tolua_constant(tolua_S,"E_BLOCK_ACACIA_DOOR",E_BLOCK_ACACIA_DOOR);
  tolua_constant(tolua_S,"E_BLOCK_DARK_OAK_DOOR",E_BLOCK_DARK_OAK_DOOR);
  tolua_constant(tolua_S,"E_BLOCK_END_ROD",E_BLOCK_END_ROD);
  tolua_constant(tolua_S,"E_BLOCK_CHORUS_PLANT",E_BLOCK_CHORUS_PLANT);
  tolua_constant(tolua_S,"E_BLOCK_CHORUS_FLOWER",E_BLOCK_CHORUS_FLOWER);
  tolua_constant(tolua_S,"E_BLOCK_PURPUR_BLOCK",E_BLOCK_PURPUR_BLOCK);
  tolua_constant(tolua_S,"E_BLOCK_PURPUR_PILLAR",E_BLOCK_PURPUR_PILLAR);
  tolua_constant(tolua_S,"E_BLOCK_PURPUR_STAIRS",E_BLOCK_PURPUR_STAIRS);
  tolua_constant(tolua_S,"E_BLOCK_PURPUR_DOUBLE_SLAB",E_BLOCK_PURPUR_DOUBLE_SLAB);
  tolua_constant(tolua_S,"E_BLOCK_PURPUR_SLAB",E_BLOCK_PURPUR_SLAB);
  tolua_constant(tolua_S,"E_BLOCK_END_BRICKS",E_BLOCK_END_BRICKS);
  tolua_constant(tolua_S,"E_BLOCK_BEETROOTS",E_BLOCK_BEETROOTS);
  tolua_constant(tolua_S,"E_BLOCK_GRASS_PATH",E_BLOCK_GRASS_PATH);
  tolua_constant(tolua_S,"E_BLOCK_END_GATEWAY",E_BLOCK_END_GATEWAY);
  tolua_constant(tolua_S,"E_BLOCK_REPEATING_COMMAND_BLOCK",E_BLOCK_REPEATING_COMMAND_BLOCK);
  tolua_constant(tolua_S,"E_BLOCK_CHAIN_COMMAND_BLOCK",E_BLOCK_CHAIN_COMMAND_BLOCK);
  tolua_constant(tolua_S,"E_BLOCK_FROSTED_ICE",E_BLOCK_FROSTED_ICE);
  tolua_constant(tolua_S,"E_BLOCK_MAGMA",E_BLOCK_MAGMA);
  tolua_constant(tolua_S,"E_BLOCK_NETHER_WART_BLOCK",E_BLOCK_NETHER_WART_BLOCK);
  tolua_constant(tolua_S,"E_BLOCK_RED_NETHER_BRICK",E_BLOCK_RED_NETHER_BRICK);
  tolua_constant(tolua_S,"E_BLOCK_BONE_BLOCK",E_BLOCK_BONE_BLOCK);
  tolua_constant(tolua_S,"E_BLOCK_STRUCTURE_VOID",E_BLOCK_STRUCTURE_VOID);
  tolua_constant(tolua_S,"E_BLOCK_OBSERVER",E_BLOCK_OBSERVER);
  tolua_constant(tolua_S,"E_BLOCK_WHITE_SHULKER_BOX",E_BLOCK_WHITE_SHULKER_BOX);
  tolua_constant(tolua_S,"E_BLOCK_ORANGE_SHULKER_BOX",E_BLOCK_ORANGE_SHULKER_BOX);
  tolua_constant(tolua_S,"E_BLOCK_MAGENTA_SHULKER_BOX",E_BLOCK_MAGENTA_SHULKER_BOX);
  tolua_constant(tolua_S,"E_BLOCK_LIGHT_BLUE_SHULKER_BOX",E_BLOCK_LIGHT_BLUE_SHULKER_BOX);
  tolua_constant(tolua_S,"E_BLOCK_YELLOW_SHULKER_BOX",E_BLOCK_YELLOW_SHULKER_BOX);
  tolua_constant(tolua_S,"E_BLOCK_LIME_SHULKER_BOX",E_BLOCK_LIME_SHULKER_BOX);
  tolua_constant(tolua_S,"E_BLOCK_PINK_SHULKER_BOX",E_BLOCK_PINK_SHULKER_BOX);
  tolua_constant(tolua_S,"E_BLOCK_GRAY_SHULKER_BOX",E_BLOCK_GRAY_SHULKER_BOX);
  tolua_constant(tolua_S,"E_BLOCK_LIGHT_GRAY_SHULKER_BOX",E_BLOCK_LIGHT_GRAY_SHULKER_BOX);
  tolua_constant(tolua_S,"E_BLOCK_CYAN_SHULKER_BOX",E_BLOCK_CYAN_SHULKER_BOX);
  tolua_constant(tolua_S,"E_BLOCK_PURPLE_SHULKER_BOX",E_BLOCK_PURPLE_SHULKER_BOX);
  tolua_constant(tolua_S,"E_BLOCK_BLUE_SHULKER_BOX",E_BLOCK_BLUE_SHULKER_BOX);
  tolua_constant(tolua_S,"E_BLOCK_BROWN_SHULKER_BOX",E_BLOCK_BROWN_SHULKER_BOX);
  tolua_constant(tolua_S,"E_BLOCK_GREEN_SHULKER_BOX",E_BLOCK_GREEN_SHULKER_BOX);
  tolua_constant(tolua_S,"E_BLOCK_RED_SHULKER_BOX",E_BLOCK_RED_SHULKER_BOX);
  tolua_constant(tolua_S,"E_BLOCK_BLACK_SHULKER_BOX",E_BLOCK_BLACK_SHULKER_BOX);
  tolua_constant(tolua_S,"E_BLOCK_WHITE_GLAZED_TERRACOTTA",E_BLOCK_WHITE_GLAZED_TERRACOTTA);
  tolua_constant(tolua_S,"E_BLOCK_ORANGE_GLAZED_TERRACOTTA",E_BLOCK_ORANGE_GLAZED_TERRACOTTA);
  tolua_constant(tolua_S,"E_BLOCK_MAGENTA_GLAZED_TERRACOTTA",E_BLOCK_MAGENTA_GLAZED_TERRACOTTA);
  tolua_constant(tolua_S,"E_BLOCK_LIGHT_BLUE_GLAZED_TERRACOTTA",E_BLOCK_LIGHT_BLUE_GLAZED_TERRACOTTA);
  tolua_constant(tolua_S,"E_BLOCK_YELLOW_GLAZED_TERRACOTTA",E_BLOCK_YELLOW_GLAZED_TERRACOTTA);
  tolua_constant(tolua_S,"E_BLOCK_LIME_GLAZED_TERRACOTTA",E_BLOCK_LIME_GLAZED_TERRACOTTA);
  tolua_constant(tolua_S,"E_BLOCK_PINK_GLAZED_TERRACOTTA",E_BLOCK_PINK_GLAZED_TERRACOTTA);
  tolua_constant(tolua_S,"E_BLOCK_GRAY_GLAZED_TERRACOTTA",E_BLOCK_GRAY_GLAZED_TERRACOTTA);
  tolua_constant(tolua_S,"E_BLOCK_LIGHT_GRAY_GLAZED_TERRACOTTA",E_BLOCK_LIGHT_GRAY_GLAZED_TERRACOTTA);
  tolua_constant(tolua_S,"E_BLOCK_CYAN_GLAZED_TERRACOTTA",E_BLOCK_CYAN_GLAZED_TERRACOTTA);
  tolua_constant(tolua_S,"E_BLOCK_PURPLE_GLAZED_TERRACOTTA",E_BLOCK_PURPLE_GLAZED_TERRACOTTA);
  tolua_constant(tolua_S,"E_BLOCK_BLUE_GLAZED_TERRACOTTA",E_BLOCK_BLUE_GLAZED_TERRACOTTA);
  tolua_constant(tolua_S,"E_BLOCK_BROWN_GLAZED_TERRACOTTA",E_BLOCK_BROWN_GLAZED_TERRACOTTA);
  tolua_constant(tolua_S,"E_BLOCK_GREEN_GLAZED_TERRACOTTA",E_BLOCK_GREEN_GLAZED_TERRACOTTA);
  tolua_constant(tolua_S,"E_BLOCK_RED_GLAZED_TERRACOTTA",E_BLOCK_RED_GLAZED_TERRACOTTA);
  tolua_constant(tolua_S,"E_BLOCK_BLACK_GLAZED_TERRACOTTA",E_BLOCK_BLACK_GLAZED_TERRACOTTA);
  tolua_constant(tolua_S,"E_BLOCK_CONCRETE",E_BLOCK_CONCRETE);
  tolua_constant(tolua_S,"E_BLOCK_CONCRETE_POWDER",E_BLOCK_CONCRETE_POWDER);
  tolua_constant(tolua_S,"E_BLOCK_STRUCTURE_BLOCK",E_BLOCK_STRUCTURE_BLOCK);
  tolua_constant(tolua_S,"E_BLOCK_NUMBER_OF_TYPES",E_BLOCK_NUMBER_OF_TYPES);
  tolua_constant(tolua_S,"E_BLOCK_MAX_TYPE_ID",E_BLOCK_MAX_TYPE_ID);
  tolua_constant(tolua_S,"E_BLOCK_UNFINISHED",E_BLOCK_UNFINISHED);
  tolua_constant(tolua_S,"E_BLOCK_YELLOW_FLOWER",E_BLOCK_YELLOW_FLOWER);
  tolua_constant(tolua_S,"E_BLOCK_RED_ROSE",E_BLOCK_RED_ROSE);
  tolua_constant(tolua_S,"E_BLOCK_WOODEN_DOOR",E_BLOCK_WOODEN_DOOR);
  tolua_constant(tolua_S,"E_BLOCK_FENCE_GATE",E_BLOCK_FENCE_GATE);
  tolua_constant(tolua_S,"E_BLOCK_WOODEN_STAIRS",E_BLOCK_WOODEN_STAIRS);
  tolua_constant(tolua_S,"E_ITEM_EMPTY",E_ITEM_EMPTY);
  tolua_constant(tolua_S,"E_ITEM_FIRST",E_ITEM_FIRST);
  tolua_constant(tolua_S,"E_ITEM_IRON_SHOVEL",E_ITEM_IRON_SHOVEL);
  tolua_constant(tolua_S,"E_ITEM_IRON_PICKAXE",E_ITEM_IRON_PICKAXE);
  tolua_constant(tolua_S,"E_ITEM_IRON_AXE",E_ITEM_IRON_AXE);
  tolua_constant(tolua_S,"E_ITEM_FLINT_AND_STEEL",E_ITEM_FLINT_AND_STEEL);
  tolua_constant(tolua_S,"E_ITEM_RED_APPLE",E_ITEM_RED_APPLE);
  tolua_constant(tolua_S,"E_ITEM_BOW",E_ITEM_BOW);
  tolua_constant(tolua_S,"E_ITEM_ARROW",E_ITEM_ARROW);
  tolua_constant(tolua_S,"E_ITEM_COAL",E_ITEM_COAL);
  tolua_constant(tolua_S,"E_ITEM_DIAMOND",E_ITEM_DIAMOND);
  tolua_constant(tolua_S,"E_ITEM_IRON",E_ITEM_IRON);
  tolua_constant(tolua_S,"E_ITEM_GOLD",E_ITEM_GOLD);
  tolua_constant(tolua_S,"E_ITEM_IRON_SWORD",E_ITEM_IRON_SWORD);
  tolua_constant(tolua_S,"E_ITEM_WOODEN_SWORD",E_ITEM_WOODEN_SWORD);
  tolua_constant(tolua_S,"E_ITEM_WOODEN_SHOVEL",E_ITEM_WOODEN_SHOVEL);
  tolua_constant(tolua_S,"E_ITEM_WOODEN_PICKAXE",E_ITEM_WOODEN_PICKAXE);
  tolua_constant(tolua_S,"E_ITEM_WOODEN_AXE",E_ITEM_WOODEN_AXE);
  tolua_constant(tolua_S,"E_ITEM_STONE_SWORD",E_ITEM_STONE_SWORD);
  tolua_constant(tolua_S,"E_ITEM_STONE_SHOVEL",E_ITEM_STONE_SHOVEL);
  tolua_constant(tolua_S,"E_ITEM_STONE_PICKAXE",E_ITEM_STONE_PICKAXE);
  tolua_constant(tolua_S,"E_ITEM_STONE_AXE",E_ITEM_STONE_AXE);
  tolua_constant(tolua_S,"E_ITEM_DIAMOND_SWORD",E_ITEM_DIAMOND_SWORD);
  tolua_constant(tolua_S,"E_ITEM_DIAMOND_SHOVEL",E_ITEM_DIAMOND_SHOVEL);
  tolua_constant(tolua_S,"E_ITEM_DIAMOND_PICKAXE",E_ITEM_DIAMOND_PICKAXE);
  tolua_constant(tolua_S,"E_ITEM_DIAMOND_AXE",E_ITEM_DIAMOND_AXE);
  tolua_constant(tolua_S,"E_ITEM_STICK",E_ITEM_STICK);
  tolua_constant(tolua_S,"E_ITEM_BOWL",E_ITEM_BOWL);
  tolua_constant(tolua_S,"E_ITEM_MUSHROOM_SOUP",E_ITEM_MUSHROOM_SOUP);
  tolua_constant(tolua_S,"E_ITEM_GOLD_SWORD",E_ITEM_GOLD_SWORD);
  tolua_constant(tolua_S,"E_ITEM_GOLD_SHOVEL",E_ITEM_GOLD_SHOVEL);
  tolua_constant(tolua_S,"E_ITEM_GOLD_PICKAXE",E_ITEM_GOLD_PICKAXE);
  tolua_constant(tolua_S,"E_ITEM_GOLD_AXE",E_ITEM_GOLD_AXE);
  tolua_constant(tolua_S,"E_ITEM_STRING",E_ITEM_STRING);
  tolua_constant(tolua_S,"E_ITEM_FEATHER",E_ITEM_FEATHER);
  tolua_constant(tolua_S,"E_ITEM_GUNPOWDER",E_ITEM_GUNPOWDER);
  tolua_constant(tolua_S,"E_ITEM_WOODEN_HOE",E_ITEM_WOODEN_HOE);
  tolua_constant(tolua_S,"E_ITEM_STONE_HOE",E_ITEM_STONE_HOE);
  tolua_constant(tolua_S,"E_ITEM_IRON_HOE",E_ITEM_IRON_HOE);
  tolua_constant(tolua_S,"E_ITEM_DIAMOND_HOE",E_ITEM_DIAMOND_HOE);
  tolua_constant(tolua_S,"E_ITEM_GOLD_HOE",E_ITEM_GOLD_HOE);
  tolua_constant(tolua_S,"E_ITEM_SEEDS",E_ITEM_SEEDS);
  tolua_constant(tolua_S,"E_ITEM_WHEAT",E_ITEM_WHEAT);
  tolua_constant(tolua_S,"E_ITEM_BREAD",E_ITEM_BREAD);
  tolua_constant(tolua_S,"E_ITEM_LEATHER_CAP",E_ITEM_LEATHER_CAP);
  tolua_constant(tolua_S,"E_ITEM_LEATHER_TUNIC",E_ITEM_LEATHER_TUNIC);
  tolua_constant(tolua_S,"E_ITEM_LEATHER_PANTS",E_ITEM_LEATHER_PANTS);
  tolua_constant(tolua_S,"E_ITEM_LEATHER_BOOTS",E_ITEM_LEATHER_BOOTS);
  tolua_constant(tolua_S,"E_ITEM_CHAIN_HELMET",E_ITEM_CHAIN_HELMET);
  tolua_constant(tolua_S,"E_ITEM_CHAIN_CHESTPLATE",E_ITEM_CHAIN_CHESTPLATE);
  tolua_constant(tolua_S,"E_ITEM_CHAIN_LEGGINGS",E_ITEM_CHAIN_LEGGINGS);
  tolua_constant(tolua_S,"E_ITEM_CHAIN_BOOTS",E_ITEM_CHAIN_BOOTS);
  tolua_constant(tolua_S,"E_ITEM_IRON_HELMET",E_ITEM_IRON_HELMET);
  tolua_constant(tolua_S,"E_ITEM_IRON_CHESTPLATE",E_ITEM_IRON_CHESTPLATE);
  tolua_constant(tolua_S,"E_ITEM_IRON_LEGGINGS",E_ITEM_IRON_LEGGINGS);
  tolua_constant(tolua_S,"E_ITEM_IRON_BOOTS",E_ITEM_IRON_BOOTS);
  tolua_constant(tolua_S,"E_ITEM_DIAMOND_HELMET",E_ITEM_DIAMOND_HELMET);
  tolua_constant(tolua_S,"E_ITEM_DIAMOND_CHESTPLATE",E_ITEM_DIAMOND_CHESTPLATE);
  tolua_constant(tolua_S,"E_ITEM_DIAMOND_LEGGINGS",E_ITEM_DIAMOND_LEGGINGS);
  tolua_constant(tolua_S,"E_ITEM_DIAMOND_BOOTS",E_ITEM_DIAMOND_BOOTS);
  tolua_constant(tolua_S,"E_ITEM_GOLD_HELMET",E_ITEM_GOLD_HELMET);
  tolua_constant(tolua_S,"E_ITEM_GOLD_CHESTPLATE",E_ITEM_GOLD_CHESTPLATE);
  tolua_constant(tolua_S,"E_ITEM_GOLD_LEGGINGS",E_ITEM_GOLD_LEGGINGS);
  tolua_constant(tolua_S,"E_ITEM_GOLD_BOOTS",E_ITEM_GOLD_BOOTS);
  tolua_constant(tolua_S,"E_ITEM_FLINT",E_ITEM_FLINT);
  tolua_constant(tolua_S,"E_ITEM_RAW_PORKCHOP",E_ITEM_RAW_PORKCHOP);
  tolua_constant(tolua_S,"E_ITEM_COOKED_PORKCHOP",E_ITEM_COOKED_PORKCHOP);
  tolua_constant(tolua_S,"E_ITEM_PAINTING",E_ITEM_PAINTING);
  tolua_constant(tolua_S,"E_ITEM_GOLDEN_APPLE",E_ITEM_GOLDEN_APPLE);
  tolua_constant(tolua_S,"E_ITEM_SIGN",E_ITEM_SIGN);
  tolua_constant(tolua_S,"E_ITEM_WOODEN_DOOR",E_ITEM_WOODEN_DOOR);
  tolua_constant(tolua_S,"E_ITEM_BUCKET",E_ITEM_BUCKET);
  tolua_constant(tolua_S,"E_ITEM_WATER_BUCKET",E_ITEM_WATER_BUCKET);
  tolua_constant(tolua_S,"E_ITEM_LAVA_BUCKET",E_ITEM_LAVA_BUCKET);
  tolua_constant(tolua_S,"E_ITEM_MINECART",E_ITEM_MINECART);
  tolua_constant(tolua_S,"E_ITEM_SADDLE",E_ITEM_SADDLE);
  tolua_constant(tolua_S,"E_ITEM_IRON_DOOR",E_ITEM_IRON_DOOR);
  tolua_constant(tolua_S,"E_ITEM_REDSTONE_DUST",E_ITEM_REDSTONE_DUST);
  tolua_constant(tolua_S,"E_ITEM_SNOWBALL",E_ITEM_SNOWBALL);
  tolua_constant(tolua_S,"E_ITEM_BOAT",E_ITEM_BOAT);
  tolua_constant(tolua_S,"E_ITEM_LEATHER",E_ITEM_LEATHER);
  tolua_constant(tolua_S,"E_ITEM_MILK",E_ITEM_MILK);
  tolua_constant(tolua_S,"E_ITEM_CLAY_BRICK",E_ITEM_CLAY_BRICK);
  tolua_constant(tolua_S,"E_ITEM_CLAY",E_ITEM_CLAY);
  tolua_constant(tolua_S,"E_ITEM_SUGARCANE",E_ITEM_SUGARCANE);
  tolua_constant(tolua_S,"E_ITEM_SUGAR_CANE",E_ITEM_SUGAR_CANE);
  tolua_constant(tolua_S,"E_ITEM_PAPER",E_ITEM_PAPER);
  tolua_constant(tolua_S,"E_ITEM_BOOK",E_ITEM_BOOK);
  tolua_constant(tolua_S,"E_ITEM_SLIMEBALL",E_ITEM_SLIMEBALL);
  tolua_constant(tolua_S,"E_ITEM_CHEST_MINECART",E_ITEM_CHEST_MINECART);
  tolua_constant(tolua_S,"E_ITEM_FURNACE_MINECART",E_ITEM_FURNACE_MINECART);
  tolua_constant(tolua_S,"E_ITEM_EGG",E_ITEM_EGG);
  tolua_constant(tolua_S,"E_ITEM_COMPASS",E_ITEM_COMPASS);
  tolua_constant(tolua_S,"E_ITEM_FISHING_ROD",E_ITEM_FISHING_ROD);
  tolua_constant(tolua_S,"E_ITEM_CLOCK",E_ITEM_CLOCK);
  tolua_constant(tolua_S,"E_ITEM_GLOWSTONE_DUST",E_ITEM_GLOWSTONE_DUST);
  tolua_constant(tolua_S,"E_ITEM_RAW_FISH",E_ITEM_RAW_FISH);
  tolua_constant(tolua_S,"E_ITEM_COOKED_FISH",E_ITEM_COOKED_FISH);
  tolua_constant(tolua_S,"E_ITEM_DYE",E_ITEM_DYE);
  tolua_constant(tolua_S,"E_ITEM_BONE",E_ITEM_BONE);
  tolua_constant(tolua_S,"E_ITEM_SUGAR",E_ITEM_SUGAR);
  tolua_constant(tolua_S,"E_ITEM_CAKE",E_ITEM_CAKE);
  tolua_constant(tolua_S,"E_ITEM_BED",E_ITEM_BED);
  tolua_constant(tolua_S,"E_ITEM_REDSTONE_REPEATER",E_ITEM_REDSTONE_REPEATER);
  tolua_constant(tolua_S,"E_ITEM_COOKIE",E_ITEM_COOKIE);
  tolua_constant(tolua_S,"E_ITEM_MAP",E_ITEM_MAP);
  tolua_constant(tolua_S,"E_ITEM_SHEARS",E_ITEM_SHEARS);
  tolua_constant(tolua_S,"E_ITEM_MELON_SLICE",E_ITEM_MELON_SLICE);
  tolua_constant(tolua_S,"E_ITEM_PUMPKIN_SEEDS",E_ITEM_PUMPKIN_SEEDS);
  tolua_constant(tolua_S,"E_ITEM_MELON_SEEDS",E_ITEM_MELON_SEEDS);
  tolua_constant(tolua_S,"E_ITEM_RAW_BEEF",E_ITEM_RAW_BEEF);
  tolua_constant(tolua_S,"E_ITEM_STEAK",E_ITEM_STEAK);
  tolua_constant(tolua_S,"E_ITEM_RAW_CHICKEN",E_ITEM_RAW_CHICKEN);
  tolua_constant(tolua_S,"E_ITEM_COOKED_CHICKEN",E_ITEM_COOKED_CHICKEN);
  tolua_constant(tolua_S,"E_ITEM_ROTTEN_FLESH",E_ITEM_ROTTEN_FLESH);
  tolua_constant(tolua_S,"E_ITEM_ENDER_PEARL",E_ITEM_ENDER_PEARL);
  tolua_constant(tolua_S,"E_ITEM_BLAZE_ROD",E_ITEM_BLAZE_ROD);
  tolua_constant(tolua_S,"E_ITEM_GHAST_TEAR",E_ITEM_GHAST_TEAR);
  tolua_constant(tolua_S,"E_ITEM_GOLD_NUGGET",E_ITEM_GOLD_NUGGET);
  tolua_constant(tolua_S,"E_ITEM_NETHER_WART",E_ITEM_NETHER_WART);
  tolua_constant(tolua_S,"E_ITEM_POTION",E_ITEM_POTION);
  tolua_constant(tolua_S,"E_ITEM_POTIONS",E_ITEM_POTIONS);
  tolua_constant(tolua_S,"E_ITEM_GLASS_BOTTLE",E_ITEM_GLASS_BOTTLE);
  tolua_constant(tolua_S,"E_ITEM_SPIDER_EYE",E_ITEM_SPIDER_EYE);
  tolua_constant(tolua_S,"E_ITEM_FERMENTED_SPIDER_EYE",E_ITEM_FERMENTED_SPIDER_EYE);
  tolua_constant(tolua_S,"E_ITEM_BLAZE_POWDER",E_ITEM_BLAZE_POWDER);
  tolua_constant(tolua_S,"E_ITEM_MAGMA_CREAM",E_ITEM_MAGMA_CREAM);
  tolua_constant(tolua_S,"E_ITEM_BREWING_STAND",E_ITEM_BREWING_STAND);
  tolua_constant(tolua_S,"E_ITEM_CAULDRON",E_ITEM_CAULDRON);
  tolua_constant(tolua_S,"E_ITEM_EYE_OF_ENDER",E_ITEM_EYE_OF_ENDER);
  tolua_constant(tolua_S,"E_ITEM_GLISTERING_MELON",E_ITEM_GLISTERING_MELON);
  tolua_constant(tolua_S,"E_ITEM_SPAWN_EGG",E_ITEM_SPAWN_EGG);
  tolua_constant(tolua_S,"E_ITEM_BOTTLE_O_ENCHANTING",E_ITEM_BOTTLE_O_ENCHANTING);
  tolua_constant(tolua_S,"E_ITEM_FIRE_CHARGE",E_ITEM_FIRE_CHARGE);
  tolua_constant(tolua_S,"E_ITEM_BOOK_AND_QUILL",E_ITEM_BOOK_AND_QUILL);
  tolua_constant(tolua_S,"E_ITEM_WRITTEN_BOOK",E_ITEM_WRITTEN_BOOK);
  tolua_constant(tolua_S,"E_ITEM_EMERALD",E_ITEM_EMERALD);
  tolua_constant(tolua_S,"E_ITEM_ITEM_FRAME",E_ITEM_ITEM_FRAME);
  tolua_constant(tolua_S,"E_ITEM_FLOWER_POT",E_ITEM_FLOWER_POT);
  tolua_constant(tolua_S,"E_ITEM_CARROT",E_ITEM_CARROT);
  tolua_constant(tolua_S,"E_ITEM_POTATO",E_ITEM_POTATO);
  tolua_constant(tolua_S,"E_ITEM_BAKED_POTATO",E_ITEM_BAKED_POTATO);
  tolua_constant(tolua_S,"E_ITEM_POISONOUS_POTATO",E_ITEM_POISONOUS_POTATO);
  tolua_constant(tolua_S,"E_ITEM_EMPTY_MAP",E_ITEM_EMPTY_MAP);
  tolua_constant(tolua_S,"E_ITEM_GOLDEN_CARROT",E_ITEM_GOLDEN_CARROT);
  tolua_constant(tolua_S,"E_ITEM_HEAD",E_ITEM_HEAD);
  tolua_constant(tolua_S,"E_ITEM_CARROT_ON_STICK",E_ITEM_CARROT_ON_STICK);
  tolua_constant(tolua_S,"E_ITEM_NETHER_STAR",E_ITEM_NETHER_STAR);
  tolua_constant(tolua_S,"E_ITEM_PUMPKIN_PIE",E_ITEM_PUMPKIN_PIE);
  tolua_constant(tolua_S,"E_ITEM_FIREWORK_ROCKET",E_ITEM_FIREWORK_ROCKET);
  tolua_constant(tolua_S,"E_ITEM_FIREWORK_STAR",E_ITEM_FIREWORK_STAR);
  tolua_constant(tolua_S,"E_ITEM_ENCHANTED_BOOK",E_ITEM_ENCHANTED_BOOK);
  tolua_constant(tolua_S,"E_ITEM_COMPARATOR",E_ITEM_COMPARATOR);
  tolua_constant(tolua_S,"E_ITEM_NETHER_BRICK",E_ITEM_NETHER_BRICK);
  tolua_constant(tolua_S,"E_ITEM_NETHER_QUARTZ",E_ITEM_NETHER_QUARTZ);
  tolua_constant(tolua_S,"E_ITEM_MINECART_WITH_TNT",E_ITEM_MINECART_WITH_TNT);
  tolua_constant(tolua_S,"E_ITEM_MINECART_WITH_HOPPER",E_ITEM_MINECART_WITH_HOPPER);
  tolua_constant(tolua_S,"E_ITEM_PRISMARINE_SHARD",E_ITEM_PRISMARINE_SHARD);
  tolua_constant(tolua_S,"E_ITEM_PRISMARINE_CRYSTALS",E_ITEM_PRISMARINE_CRYSTALS);
  tolua_constant(tolua_S,"E_ITEM_RAW_RABBIT",E_ITEM_RAW_RABBIT);
  tolua_constant(tolua_S,"E_ITEM_COOKED_RABBIT",E_ITEM_COOKED_RABBIT);
  tolua_constant(tolua_S,"E_ITEM_RABBIT_STEW",E_ITEM_RABBIT_STEW);
  tolua_constant(tolua_S,"E_ITEM_RABBITS_FOOT",E_ITEM_RABBITS_FOOT);
  tolua_constant(tolua_S,"E_ITEM_RABBIT_HIDE",E_ITEM_RABBIT_HIDE);
  tolua_constant(tolua_S,"E_ITEM_ARMOR_STAND",E_ITEM_ARMOR_STAND);
  tolua_constant(tolua_S,"E_ITEM_IRON_HORSE_ARMOR",E_ITEM_IRON_HORSE_ARMOR);
  tolua_constant(tolua_S,"E_ITEM_GOLD_HORSE_ARMOR",E_ITEM_GOLD_HORSE_ARMOR);
  tolua_constant(tolua_S,"E_ITEM_DIAMOND_HORSE_ARMOR",E_ITEM_DIAMOND_HORSE_ARMOR);
  tolua_constant(tolua_S,"E_ITEM_LEAD",E_ITEM_LEAD);
  tolua_constant(tolua_S,"E_ITEM_LEASH",E_ITEM_LEASH);
  tolua_constant(tolua_S,"E_ITEM_NAME_TAG",E_ITEM_NAME_TAG);
  tolua_constant(tolua_S,"E_ITEM_MINECART_WITH_COMMAND_BLOCK",E_ITEM_MINECART_WITH_COMMAND_BLOCK);
  tolua_constant(tolua_S,"E_ITEM_RAW_MUTTON",E_ITEM_RAW_MUTTON);
  tolua_constant(tolua_S,"E_ITEM_COOKED_MUTTON",E_ITEM_COOKED_MUTTON);
  tolua_constant(tolua_S,"E_ITEM_BANNER",E_ITEM_BANNER);
  tolua_constant(tolua_S,"E_ITEM_END_CRYSTAL",E_ITEM_END_CRYSTAL);
  tolua_constant(tolua_S,"E_ITEM_SPRUCE_DOOR",E_ITEM_SPRUCE_DOOR);
  tolua_constant(tolua_S,"E_ITEM_BIRCH_DOOR",E_ITEM_BIRCH_DOOR);
  tolua_constant(tolua_S,"E_ITEM_JUNGLE_DOOR",E_ITEM_JUNGLE_DOOR);
  tolua_constant(tolua_S,"E_ITEM_ACACIA_DOOR",E_ITEM_ACACIA_DOOR);
  tolua_constant(tolua_S,"E_ITEM_DARK_OAK_DOOR",E_ITEM_DARK_OAK_DOOR);
  tolua_constant(tolua_S,"E_ITEM_CHORUS_FRUIT",E_ITEM_CHORUS_FRUIT);
  tolua_constant(tolua_S,"E_ITEM_POPPED_CHORUS_FRUIT",E_ITEM_POPPED_CHORUS_FRUIT);
  tolua_constant(tolua_S,"E_ITEM_BEETROOT",E_ITEM_BEETROOT);
  tolua_constant(tolua_S,"E_ITEM_BEETROOT_SEEDS",E_ITEM_BEETROOT_SEEDS);
  tolua_constant(tolua_S,"E_ITEM_BEETROOT_SOUP",E_ITEM_BEETROOT_SOUP);
  tolua_constant(tolua_S,"E_ITEM_DRAGON_BREATH",E_ITEM_DRAGON_BREATH);
  tolua_constant(tolua_S,"E_ITEM_SPLASH_POTION",E_ITEM_SPLASH_POTION);
  tolua_constant(tolua_S,"E_ITEM_SPECTRAL_ARROW",E_ITEM_SPECTRAL_ARROW);
  tolua_constant(tolua_S,"E_ITEM_TIPPED_ARROW",E_ITEM_TIPPED_ARROW);
  tolua_constant(tolua_S,"E_ITEM_LINGERING_POTION",E_ITEM_LINGERING_POTION);
  tolua_constant(tolua_S,"E_ITEM_SHIELD",E_ITEM_SHIELD);
  tolua_constant(tolua_S,"E_ITEM_ELYTRA",E_ITEM_ELYTRA);
  tolua_constant(tolua_S,"E_ITEM_SPRUCE_BOAT",E_ITEM_SPRUCE_BOAT);
  tolua_constant(tolua_S,"E_ITEM_BIRCH_BOAT",E_ITEM_BIRCH_BOAT);
  tolua_constant(tolua_S,"E_ITEM_JUNGLE_BOAT",E_ITEM_JUNGLE_BOAT);
  tolua_constant(tolua_S,"E_ITEM_ACACIA_BOAT",E_ITEM_ACACIA_BOAT);
  tolua_constant(tolua_S,"E_ITEM_DARK_OAK_BOAT",E_ITEM_DARK_OAK_BOAT);
  tolua_constant(tolua_S,"E_ITEM_TOTEM_OF_UNDYING",E_ITEM_TOTEM_OF_UNDYING);
  tolua_constant(tolua_S,"E_ITEM_SHULKER_SHELL",E_ITEM_SHULKER_SHELL);
  tolua_constant(tolua_S,"E_ITEM_IRON_NUGGET",E_ITEM_IRON_NUGGET);
  tolua_constant(tolua_S,"E_ITEM_NUMBER_OF_CONSECUTIVE_TYPES",E_ITEM_NUMBER_OF_CONSECUTIVE_TYPES);
  tolua_constant(tolua_S,"E_ITEM_MAX_CONSECUTIVE_TYPE_ID",E_ITEM_MAX_CONSECUTIVE_TYPE_ID);
  tolua_constant(tolua_S,"E_ITEM_FIRST_DISC",E_ITEM_FIRST_DISC);
  tolua_constant(tolua_S,"E_ITEM_13_DISC",E_ITEM_13_DISC);
  tolua_constant(tolua_S,"E_ITEM_CAT_DISC",E_ITEM_CAT_DISC);
  tolua_constant(tolua_S,"E_ITEM_BLOCKS_DISC",E_ITEM_BLOCKS_DISC);
  tolua_constant(tolua_S,"E_ITEM_CHIRP_DISC",E_ITEM_CHIRP_DISC);
  tolua_constant(tolua_S,"E_ITEM_FAR_DISC",E_ITEM_FAR_DISC);
  tolua_constant(tolua_S,"E_ITEM_MALL_DISC",E_ITEM_MALL_DISC);
  tolua_constant(tolua_S,"E_ITEM_MELLOHI_DISC",E_ITEM_MELLOHI_DISC);
  tolua_constant(tolua_S,"E_ITEM_STAL_DISC",E_ITEM_STAL_DISC);
  tolua_constant(tolua_S,"E_ITEM_STRAD_DISC",E_ITEM_STRAD_DISC);
  tolua_constant(tolua_S,"E_ITEM_WARD_DISC",E_ITEM_WARD_DISC);
  tolua_constant(tolua_S,"E_ITEM_11_DISC",E_ITEM_11_DISC);
  tolua_constant(tolua_S,"E_ITEM_WAIT_DISC",E_ITEM_WAIT_DISC);
  tolua_constant(tolua_S,"E_ITEM_LAST_DISC_PLUS_ONE",E_ITEM_LAST_DISC_PLUS_ONE);
  tolua_constant(tolua_S,"E_ITEM_LAST_DISC",E_ITEM_LAST_DISC);
  tolua_constant(tolua_S,"E_ITEM_LAST",E_ITEM_LAST);
  tolua_constant(tolua_S,"E_BLOCK_ANVIL_Z",E_BLOCK_ANVIL_Z);
  tolua_constant(tolua_S,"E_BLOCK_ANVIL_X",E_BLOCK_ANVIL_X);
  tolua_constant(tolua_S,"E_BLOCK_ANVIL_NO_DAMAGE",E_BLOCK_ANVIL_NO_DAMAGE);
  tolua_constant(tolua_S,"E_BLOCK_ANVIL_LOW_DAMAGE",E_BLOCK_ANVIL_LOW_DAMAGE);
  tolua_constant(tolua_S,"E_BLOCK_ANVIL_HIGH_DAMAGE",E_BLOCK_ANVIL_HIGH_DAMAGE);
  tolua_constant(tolua_S,"E_BLOCK_BED_ZP",E_BLOCK_BED_ZP);
  tolua_constant(tolua_S,"E_BLOCK_BED_XM",E_BLOCK_BED_XM);
  tolua_constant(tolua_S,"E_BLOCK_BED_ZM",E_BLOCK_BED_ZM);
  tolua_constant(tolua_S,"E_BLOCK_BED_XP",E_BLOCK_BED_XP);
  tolua_constant(tolua_S,"E_BLOCK_BED_OCCUPIED",E_BLOCK_BED_OCCUPIED);
  tolua_constant(tolua_S,"E_BLOCK_BED_BED_HEAD",E_BLOCK_BED_BED_HEAD);
  tolua_constant(tolua_S,"E_META_BIG_FLOWER_SUNFLOWER",E_META_BIG_FLOWER_SUNFLOWER);
  tolua_constant(tolua_S,"E_META_BIG_FLOWER_LILAC",E_META_BIG_FLOWER_LILAC);
  tolua_constant(tolua_S,"E_META_BIG_FLOWER_DOUBLE_TALL_GRASS",E_META_BIG_FLOWER_DOUBLE_TALL_GRASS);
  tolua_constant(tolua_S,"E_META_BIG_FLOWER_LARGE_FERN",E_META_BIG_FLOWER_LARGE_FERN);
  tolua_constant(tolua_S,"E_META_BIG_FLOWER_ROSE_BUSH",E_META_BIG_FLOWER_ROSE_BUSH);
  tolua_constant(tolua_S,"E_META_BIG_FLOWER_PEONY",E_META_BIG_FLOWER_PEONY);
  tolua_constant(tolua_S,"E_META_BIG_FLOWER_TOP",E_META_BIG_FLOWER_TOP);
  tolua_constant(tolua_S,"E_META_BREWING_STAND_FILLED_SLOT_XP",E_META_BREWING_STAND_FILLED_SLOT_XP);
  tolua_constant(tolua_S,"E_META_BREWING_STAND_FILLED_SLOT_XM_ZP",E_META_BREWING_STAND_FILLED_SLOT_XM_ZP);
  tolua_constant(tolua_S,"E_META_BREWING_STAND_FILLED_SLOT_XM_ZM",E_META_BREWING_STAND_FILLED_SLOT_XM_ZM);
  tolua_constant(tolua_S,"E_BLOCK_BUTTON_YM",E_BLOCK_BUTTON_YM);
  tolua_constant(tolua_S,"E_BLOCK_BUTTON_XP",E_BLOCK_BUTTON_XP);
  tolua_constant(tolua_S,"E_BLOCK_BUTTON_XM",E_BLOCK_BUTTON_XM);
  tolua_constant(tolua_S,"E_BLOCK_BUTTON_ZP",E_BLOCK_BUTTON_ZP);
  tolua_constant(tolua_S,"E_BLOCK_BUTTON_ZM",E_BLOCK_BUTTON_ZM);
  tolua_constant(tolua_S,"E_BLOCK_BUTTON_YP",E_BLOCK_BUTTON_YP);
  tolua_constant(tolua_S,"E_BLOCK_BUTTON_PRESSED",E_BLOCK_BUTTON_PRESSED);
  tolua_constant(tolua_S,"E_META_CARPET_WHITE",E_META_CARPET_WHITE);
  tolua_constant(tolua_S,"E_META_CARPET_ORANGE",E_META_CARPET_ORANGE);
  tolua_constant(tolua_S,"E_META_CARPET_MAGENTA",E_META_CARPET_MAGENTA);
  tolua_constant(tolua_S,"E_META_CARPET_LIGHTBLUE",E_META_CARPET_LIGHTBLUE);
  tolua_constant(tolua_S,"E_META_CARPET_YELLOW",E_META_CARPET_YELLOW);
  tolua_constant(tolua_S,"E_META_CARPET_LIGHTGREEN",E_META_CARPET_LIGHTGREEN);
  tolua_constant(tolua_S,"E_META_CARPET_PINK",E_META_CARPET_PINK);
  tolua_constant(tolua_S,"E_META_CARPET_GRAY",E_META_CARPET_GRAY);
  tolua_constant(tolua_S,"E_META_CARPET_LIGHTGRAY",E_META_CARPET_LIGHTGRAY);
  tolua_constant(tolua_S,"E_META_CARPET_CYAN",E_META_CARPET_CYAN);
  tolua_constant(tolua_S,"E_META_CARPET_PURPLE",E_META_CARPET_PURPLE);
  tolua_constant(tolua_S,"E_META_CARPET_BLUE",E_META_CARPET_BLUE);
  tolua_constant(tolua_S,"E_META_CARPET_BROWN",E_META_CARPET_BROWN);
  tolua_constant(tolua_S,"E_META_CARPET_GREEN",E_META_CARPET_GREEN);
  tolua_constant(tolua_S,"E_META_CARPET_RED",E_META_CARPET_RED);
  tolua_constant(tolua_S,"E_META_CARPET_BLACK",E_META_CARPET_BLACK);
  tolua_constant(tolua_S,"E_META_CHEST_FACING_ZM",E_META_CHEST_FACING_ZM);
  tolua_constant(tolua_S,"E_META_CHEST_FACING_ZP",E_META_CHEST_FACING_ZP);
  tolua_constant(tolua_S,"E_META_CHEST_FACING_XM",E_META_CHEST_FACING_XM);
  tolua_constant(tolua_S,"E_META_CHEST_FACING_XP",E_META_CHEST_FACING_XP);
  tolua_constant(tolua_S,"E_META_CONCRETE_WHITE",E_META_CONCRETE_WHITE);
  tolua_constant(tolua_S,"E_META_CONCRETE_ORANGE",E_META_CONCRETE_ORANGE);
  tolua_constant(tolua_S,"E_META_CONCRETE_MAGENTA",E_META_CONCRETE_MAGENTA);
  tolua_constant(tolua_S,"E_META_CONCRETE_LIGHTBLUE",E_META_CONCRETE_LIGHTBLUE);
  tolua_constant(tolua_S,"E_META_CONCRETE_YELLOW",E_META_CONCRETE_YELLOW);
  tolua_constant(tolua_S,"E_META_CONCRETE_LIGHTGREEN",E_META_CONCRETE_LIGHTGREEN);
  tolua_constant(tolua_S,"E_META_CONCRETE_PINK",E_META_CONCRETE_PINK);
  tolua_constant(tolua_S,"E_META_CONCRETE_GRAY",E_META_CONCRETE_GRAY);
  tolua_constant(tolua_S,"E_META_CONCRETE_LIGHTGRAY",E_META_CONCRETE_LIGHTGRAY);
  tolua_constant(tolua_S,"E_META_CONCRETE_CYAN",E_META_CONCRETE_CYAN);
  tolua_constant(tolua_S,"E_META_CONCRETE_PURPLE",E_META_CONCRETE_PURPLE);
  tolua_constant(tolua_S,"E_META_CONCRETE_BLUE",E_META_CONCRETE_BLUE);
  tolua_constant(tolua_S,"E_META_CONCRETE_BROWN",E_META_CONCRETE_BROWN);
  tolua_constant(tolua_S,"E_META_CONCRETE_GREEN",E_META_CONCRETE_GREEN);
  tolua_constant(tolua_S,"E_META_CONCRETE_RED",E_META_CONCRETE_RED);
  tolua_constant(tolua_S,"E_META_CONCRETE_BLACK",E_META_CONCRETE_BLACK);
  tolua_constant(tolua_S,"E_META_CONCRETE_POWDER_WHITE",E_META_CONCRETE_POWDER_WHITE);
  tolua_constant(tolua_S,"E_META_CONCRETE_POWDER_ORANGE",E_META_CONCRETE_POWDER_ORANGE);
  tolua_constant(tolua_S,"E_META_CONCRETE_POWDER_MAGENTA",E_META_CONCRETE_POWDER_MAGENTA);
  tolua_constant(tolua_S,"E_META_CONCRETE_POWDER_LIGHTBLUE",E_META_CONCRETE_POWDER_LIGHTBLUE);
  tolua_constant(tolua_S,"E_META_CONCRETE_POWDER_YELLOW",E_META_CONCRETE_POWDER_YELLOW);
  tolua_constant(tolua_S,"E_META_CONCRETE_POWDER_LIGHTGREEN",E_META_CONCRETE_POWDER_LIGHTGREEN);
  tolua_constant(tolua_S,"E_META_CONCRETE_POWDER_PINK",E_META_CONCRETE_POWDER_PINK);
  tolua_constant(tolua_S,"E_META_CONCRETE_POWDER_GRAY",E_META_CONCRETE_POWDER_GRAY);
  tolua_constant(tolua_S,"E_META_CONCRETE_POWDER_LIGHTGRAY",E_META_CONCRETE_POWDER_LIGHTGRAY);
  tolua_constant(tolua_S,"E_META_CONCRETE_POWDER_CYAN",E_META_CONCRETE_POWDER_CYAN);
  tolua_constant(tolua_S,"E_META_CONCRETE_POWDER_PURPLE",E_META_CONCRETE_POWDER_PURPLE);
  tolua_constant(tolua_S,"E_META_CONCRETE_POWDER_BLUE",E_META_CONCRETE_POWDER_BLUE);
  tolua_constant(tolua_S,"E_META_CONCRETE_POWDER_BROWN",E_META_CONCRETE_POWDER_BROWN);
  tolua_constant(tolua_S,"E_META_CONCRETE_POWDER_GREEN",E_META_CONCRETE_POWDER_GREEN);
  tolua_constant(tolua_S,"E_META_CONCRETE_POWDER_RED",E_META_CONCRETE_POWDER_RED);
  tolua_constant(tolua_S,"E_META_CONCRETE_POWDER_BLACK",E_META_CONCRETE_POWDER_BLACK);
  tolua_constant(tolua_S,"E_META_DIRT_NORMAL",E_META_DIRT_NORMAL);
  tolua_constant(tolua_S,"E_META_DIRT_GRASSLESS",E_META_DIRT_GRASSLESS);
  tolua_constant(tolua_S,"E_META_DIRT_COARSE",E_META_DIRT_COARSE);
  tolua_constant(tolua_S,"E_META_DIRT_PODZOL",E_META_DIRT_PODZOL);
  tolua_constant(tolua_S,"E_META_DROPSPENSER_FACING_YM",E_META_DROPSPENSER_FACING_YM);
  tolua_constant(tolua_S,"E_META_DROPSPENSER_FACING_YP",E_META_DROPSPENSER_FACING_YP);
  tolua_constant(tolua_S,"E_META_DROPSPENSER_FACING_ZM",E_META_DROPSPENSER_FACING_ZM);
  tolua_constant(tolua_S,"E_META_DROPSPENSER_FACING_ZP",E_META_DROPSPENSER_FACING_ZP);
  tolua_constant(tolua_S,"E_META_DROPSPENSER_FACING_XM",E_META_DROPSPENSER_FACING_XM);
  tolua_constant(tolua_S,"E_META_DROPSPENSER_FACING_XP",E_META_DROPSPENSER_FACING_XP);
  tolua_constant(tolua_S,"E_META_DROPSPENSER_FACING_MASK",E_META_DROPSPENSER_FACING_MASK);
  tolua_constant(tolua_S,"E_META_DROPSPENSER_ACTIVATED",E_META_DROPSPENSER_ACTIVATED);
  tolua_constant(tolua_S,"E_META_DOUBLE_STONE_SLAB_STONE",E_META_DOUBLE_STONE_SLAB_STONE);
  tolua_constant(tolua_S,"E_META_DOUBLE_STONE_SLAB_SANDSTON",E_META_DOUBLE_STONE_SLAB_SANDSTON);
  tolua_constant(tolua_S,"E_META_DOUBLE_STONE_SLAB_WOODEN",E_META_DOUBLE_STONE_SLAB_WOODEN);
  tolua_constant(tolua_S,"E_META_DOUBLE_STONE_SLAB_COBBLESTONE",E_META_DOUBLE_STONE_SLAB_COBBLESTONE);
  tolua_constant(tolua_S,"E_META_DOUBLE_STONE_SLAB_BRICK",E_META_DOUBLE_STONE_SLAB_BRICK);
  tolua_constant(tolua_S,"E_META_DOUBLE_STONE_SLAB_STONE_BRICK",E_META_DOUBLE_STONE_SLAB_STONE_BRICK);
  tolua_constant(tolua_S,"E_META_DOUBLE_STONE_SLAB_NETHER_BRICK",E_META_DOUBLE_STONE_SLAB_NETHER_BRICK);
  tolua_constant(tolua_S,"E_META_DOUBLE_STONE_SLAB_QUARTZ",E_META_DOUBLE_STONE_SLAB_QUARTZ);
  tolua_constant(tolua_S,"E_META_DOUBLE_STONE_SLAB_SMOOTH_STONE",E_META_DOUBLE_STONE_SLAB_SMOOTH_STONE);
  tolua_constant(tolua_S,"E_META_DOUBLE_STONE_SLAB_SMOOTH_SANDSTONE",E_META_DOUBLE_STONE_SLAB_SMOOTH_SANDSTONE);
  tolua_constant(tolua_S,"E_META_DOUBLE_STONE_SLAB_TILE_QUARTZ",E_META_DOUBLE_STONE_SLAB_TILE_QUARTZ);
  tolua_constant(tolua_S,"E_META_END_PORTAL_FRAME_ZP",E_META_END_PORTAL_FRAME_ZP);
  tolua_constant(tolua_S,"E_META_END_PORTAL_FRAME_XM",E_META_END_PORTAL_FRAME_XM);
  tolua_constant(tolua_S,"E_META_END_PORTAL_FRAME_ZM",E_META_END_PORTAL_FRAME_ZM);
  tolua_constant(tolua_S,"E_META_END_PORTAL_FRAME_XP",E_META_END_PORTAL_FRAME_XP);
  tolua_constant(tolua_S,"E_META_END_PORTAL_FRAME_ZP_EYE",E_META_END_PORTAL_FRAME_ZP_EYE);
  tolua_constant(tolua_S,"E_META_END_PORTAL_FRAME_XM_EYE",E_META_END_PORTAL_FRAME_XM_EYE);
  tolua_constant(tolua_S,"E_META_END_PORTAL_FRAME_ZM_EYE",E_META_END_PORTAL_FRAME_ZM_EYE);
  tolua_constant(tolua_S,"E_META_END_PORTAL_FRAME_XP_EYE",E_META_END_PORTAL_FRAME_XP_EYE);
  tolua_constant(tolua_S,"E_META_END_PORTAL_FRAME_NO_EYE",E_META_END_PORTAL_FRAME_NO_EYE);
  tolua_constant(tolua_S,"E_META_END_PORTAL_FRAME_EYE",E_META_END_PORTAL_FRAME_EYE);
  tolua_constant(tolua_S,"E_META_FLOWER_POPPY",E_META_FLOWER_POPPY);
  tolua_constant(tolua_S,"E_META_FLOWER_BLUE_ORCHID",E_META_FLOWER_BLUE_ORCHID);
  tolua_constant(tolua_S,"E_META_FLOWER_ALLIUM",E_META_FLOWER_ALLIUM);
  tolua_constant(tolua_S,"E_META_FLOWER_RED_TULIP",E_META_FLOWER_RED_TULIP);
  tolua_constant(tolua_S,"E_META_FLOWER_ORANGE_TULIP",E_META_FLOWER_ORANGE_TULIP);
  tolua_constant(tolua_S,"E_META_FLOWER_WHITE_TULIP",E_META_FLOWER_WHITE_TULIP);
  tolua_constant(tolua_S,"E_META_FLOWER_PINK_TULIP",E_META_FLOWER_PINK_TULIP);
  tolua_constant(tolua_S,"E_META_FLOWER_OXEYE_DAISY",E_META_FLOWER_OXEYE_DAISY);
  tolua_constant(tolua_S,"E_META_JUKEBOX_OFF",E_META_JUKEBOX_OFF);
  tolua_constant(tolua_S,"E_META_JUKEBOX_ON",E_META_JUKEBOX_ON);
  tolua_constant(tolua_S,"E_META_HOPPER_FACING_YM",E_META_HOPPER_FACING_YM);
  tolua_constant(tolua_S,"E_META_HOPPER_UNATTACHED",E_META_HOPPER_UNATTACHED);
  tolua_constant(tolua_S,"E_META_HOPPER_FACING_ZM",E_META_HOPPER_FACING_ZM);
  tolua_constant(tolua_S,"E_META_HOPPER_FACING_ZP",E_META_HOPPER_FACING_ZP);
  tolua_constant(tolua_S,"E_META_HOPPER_FACING_XM",E_META_HOPPER_FACING_XM);
  tolua_constant(tolua_S,"E_META_HOPPER_FACING_XP",E_META_HOPPER_FACING_XP);
  tolua_constant(tolua_S,"E_META_LEAVES_APPLE",E_META_LEAVES_APPLE);
  tolua_constant(tolua_S,"E_META_LEAVES_CONIFER",E_META_LEAVES_CONIFER);
  tolua_constant(tolua_S,"E_META_LEAVES_BIRCH",E_META_LEAVES_BIRCH);
  tolua_constant(tolua_S,"E_META_LEAVES_JUNGLE",E_META_LEAVES_JUNGLE);
  tolua_constant(tolua_S,"E_META_LEAVES_APPLE_NO_DECAY",E_META_LEAVES_APPLE_NO_DECAY);
  tolua_constant(tolua_S,"E_META_LEAVES_CONIFER_NO_DECAY",E_META_LEAVES_CONIFER_NO_DECAY);
  tolua_constant(tolua_S,"E_META_LEAVES_BIRCH_NO_DECAY",E_META_LEAVES_BIRCH_NO_DECAY);
  tolua_constant(tolua_S,"E_META_LEAVES_JUNGLE_NO_DECAY",E_META_LEAVES_JUNGLE_NO_DECAY);
  tolua_constant(tolua_S,"E_META_LEAVES_APPLE_CHECK_DECAY",E_META_LEAVES_APPLE_CHECK_DECAY);
  tolua_constant(tolua_S,"E_META_LEAVES_CONIFER_CHECK_DECAY",E_META_LEAVES_CONIFER_CHECK_DECAY);
  tolua_constant(tolua_S,"E_META_LEAVES_BIRCH_CHECK_DECAY",E_META_LEAVES_BIRCH_CHECK_DECAY);
  tolua_constant(tolua_S,"E_META_LEAVES_JUNGLE_CHECK_DECAY",E_META_LEAVES_JUNGLE_CHECK_DECAY);
  tolua_constant(tolua_S,"E_META_MUSHROOM_ALL_SIDES",E_META_MUSHROOM_ALL_SIDES);
  tolua_constant(tolua_S,"E_META_MUSHROOM_NORTH_WEST",E_META_MUSHROOM_NORTH_WEST);
  tolua_constant(tolua_S,"E_META_MUSHROOM_NORTH",E_META_MUSHROOM_NORTH);
  tolua_constant(tolua_S,"E_META_MUSHROOM_NORTH_EAST",E_META_MUSHROOM_NORTH_EAST);
  tolua_constant(tolua_S,"E_META_MUSHROOM_WEST",E_META_MUSHROOM_WEST);
  tolua_constant(tolua_S,"E_META_MUSHROOM_CENTER",E_META_MUSHROOM_CENTER);
  tolua_constant(tolua_S,"E_META_MUSHROOM_EAST",E_META_MUSHROOM_EAST);
  tolua_constant(tolua_S,"E_META_MUSHROOM_SOUTH_WEST",E_META_MUSHROOM_SOUTH_WEST);
  tolua_constant(tolua_S,"E_META_MUSHROOM_SOUTH",E_META_MUSHROOM_SOUTH);
  tolua_constant(tolua_S,"E_META_MUSHROOM_SOUTH_EAST",E_META_MUSHROOM_SOUTH_EAST);
  tolua_constant(tolua_S,"E_META_MUSHROOM_STEM",E_META_MUSHROOM_STEM);
  tolua_constant(tolua_S,"E_META_MUSHROOM_CAP",E_META_MUSHROOM_CAP);
  tolua_constant(tolua_S,"E_META_MUSHROOM_FULL_STEM",E_META_MUSHROOM_FULL_STEM);
  tolua_constant(tolua_S,"E_META_NEWLEAVES_ACACIA",E_META_NEWLEAVES_ACACIA);
  tolua_constant(tolua_S,"E_META_NEWLEAVES_DARK_OAK",E_META_NEWLEAVES_DARK_OAK);
  tolua_constant(tolua_S,"E_META_NEWLEAVES_ACACIA_NO_DECAY",E_META_NEWLEAVES_ACACIA_NO_DECAY);
  tolua_constant(tolua_S,"E_META_NEWLEAVES_DARK_OAK_NO_DECAY",E_META_NEWLEAVES_DARK_OAK_NO_DECAY);
  tolua_constant(tolua_S,"E_META_NEWLEAVES_ACACIA_CHECK_DECAY",E_META_NEWLEAVES_ACACIA_CHECK_DECAY);
  tolua_constant(tolua_S,"E_META_NEWLEAVES_DARK_OAK_CHECK_DECAY",E_META_NEWLEAVES_DARK_OAK_CHECK_DECAY);
  tolua_constant(tolua_S,"E_META_LOG_APPLE",E_META_LOG_APPLE);
  tolua_constant(tolua_S,"E_META_LOG_CONIFER",E_META_LOG_CONIFER);
  tolua_constant(tolua_S,"E_META_LOG_BIRCH",E_META_LOG_BIRCH);
  tolua_constant(tolua_S,"E_META_LOG_JUNGLE",E_META_LOG_JUNGLE);
  tolua_constant(tolua_S,"E_META_NEW_LOG_ACACIA_WOOD",E_META_NEW_LOG_ACACIA_WOOD);
  tolua_constant(tolua_S,"E_META_NEW_LOG_DARK_OAK_WOOD",E_META_NEW_LOG_DARK_OAK_WOOD);
  tolua_constant(tolua_S,"E_META_PISTON_DOWN",E_META_PISTON_DOWN);
  tolua_constant(tolua_S,"E_META_PISTON_U",E_META_PISTON_U);
  tolua_constant(tolua_S,"E_META_PISTON_ZM",E_META_PISTON_ZM);
  tolua_constant(tolua_S,"E_META_PISTON_ZP",E_META_PISTON_ZP);
  tolua_constant(tolua_S,"E_META_PISTON_XM",E_META_PISTON_XM);
  tolua_constant(tolua_S,"E_META_PISTON_XP",E_META_PISTON_XP);
  tolua_constant(tolua_S,"E_META_PISTON_HEAD_STICKY",E_META_PISTON_HEAD_STICKY);
  tolua_constant(tolua_S,"E_META_PISTON_EXTENDED",E_META_PISTON_EXTENDED);
  tolua_constant(tolua_S,"E_META_PLANKS_OAK",E_META_PLANKS_OAK);
  tolua_constant(tolua_S,"E_META_PLANKS_SPRUCE",E_META_PLANKS_SPRUCE);
  tolua_constant(tolua_S,"E_META_PLANKS_BIRCH",E_META_PLANKS_BIRCH);
  tolua_constant(tolua_S,"E_META_PLANKS_JUNGLE",E_META_PLANKS_JUNGLE);
  tolua_constant(tolua_S,"E_META_PLANKS_ACACIA",E_META_PLANKS_ACACIA);
  tolua_constant(tolua_S,"E_META_PLANKS_DARK_OAK",E_META_PLANKS_DARK_OAK);
  tolua_constant(tolua_S,"E_META_PRESSURE_PLATE_RAISED",E_META_PRESSURE_PLATE_RAISED);
  tolua_constant(tolua_S,"E_META_PRESSURE_PLATE_DEPRESSED",E_META_PRESSURE_PLATE_DEPRESSED);
  tolua_constant(tolua_S,"E_META_PRISMARINE_BLOCK_ROUGH",E_META_PRISMARINE_BLOCK_ROUGH);
  tolua_constant(tolua_S,"E_META_PRISMARINE_BLOCK_BRICKS",E_META_PRISMARINE_BLOCK_BRICKS);
  tolua_constant(tolua_S,"E_META_PRISMARINE_BLOCK_DARK",E_META_PRISMARINE_BLOCK_DARK);
  tolua_constant(tolua_S,"E_META_QUARTZ_NORMAL",E_META_QUARTZ_NORMAL);
  tolua_constant(tolua_S,"E_META_QUARTZ_CHISELLED",E_META_QUARTZ_CHISELLED);
  tolua_constant(tolua_S,"E_META_QUARTZ_PILLAR",E_META_QUARTZ_PILLAR);
  tolua_constant(tolua_S,"E_META_RAIL_ZM_ZP",E_META_RAIL_ZM_ZP);
  tolua_constant(tolua_S,"E_META_RAIL_XM_XP",E_META_RAIL_XM_XP);
  tolua_constant(tolua_S,"E_META_RAIL_ASCEND_XP",E_META_RAIL_ASCEND_XP);
  tolua_constant(tolua_S,"E_META_RAIL_ASCEND_XM",E_META_RAIL_ASCEND_XM);
  tolua_constant(tolua_S,"E_META_RAIL_ASCEND_ZM",E_META_RAIL_ASCEND_ZM);
  tolua_constant(tolua_S,"E_META_RAIL_ASCEND_ZP",E_META_RAIL_ASCEND_ZP);
  tolua_constant(tolua_S,"E_META_RAIL_CURVED_ZP_XP",E_META_RAIL_CURVED_ZP_XP);
  tolua_constant(tolua_S,"E_META_RAIL_CURVED_ZP_XM",E_META_RAIL_CURVED_ZP_XM);
  tolua_constant(tolua_S,"E_META_RAIL_CURVED_ZM_XM",E_META_RAIL_CURVED_ZM_XM);
  tolua_constant(tolua_S,"E_META_RAIL_CURVED_ZM_XP",E_META_RAIL_CURVED_ZM_XP);
  tolua_constant(tolua_S,"E_META_RED_SANDSTONE_NORMAL",E_META_RED_SANDSTONE_NORMAL);
  tolua_constant(tolua_S,"E_META_RED_SANDSTONE_ORNAMENT",E_META_RED_SANDSTONE_ORNAMENT);
  tolua_constant(tolua_S,"E_META_RED_SANDSTONE_SMOOTH",E_META_RED_SANDSTONE_SMOOTH);
  tolua_constant(tolua_S,"E_META_REDSTONE_REPEATER_FACING_ZM",E_META_REDSTONE_REPEATER_FACING_ZM);
  tolua_constant(tolua_S,"E_META_REDSTONE_REPEATER_FACING_XP",E_META_REDSTONE_REPEATER_FACING_XP);
  tolua_constant(tolua_S,"E_META_REDSTONE_REPEATER_FACING_ZP",E_META_REDSTONE_REPEATER_FACING_ZP);
  tolua_constant(tolua_S,"E_META_REDSTONE_REPEATER_FACING_XM",E_META_REDSTONE_REPEATER_FACING_XM);
  tolua_constant(tolua_S,"E_META_REDSTONE_REPEATER_FACING_MASK",E_META_REDSTONE_REPEATER_FACING_MASK);
  tolua_constant(tolua_S,"E_META_SAND_NORMAL",E_META_SAND_NORMAL);
  tolua_constant(tolua_S,"E_META_SAND_RED",E_META_SAND_RED);
  tolua_constant(tolua_S,"E_META_SANDSTONE_NORMAL",E_META_SANDSTONE_NORMAL);
  tolua_constant(tolua_S,"E_META_SANDSTONE_ORNAMENT",E_META_SANDSTONE_ORNAMENT);
  tolua_constant(tolua_S,"E_META_SANDSTONE_SMOOTH",E_META_SANDSTONE_SMOOTH);
  tolua_constant(tolua_S,"E_META_SAPLING_APPLE",E_META_SAPLING_APPLE);
  tolua_constant(tolua_S,"E_META_SAPLING_CONIFER",E_META_SAPLING_CONIFER);
  tolua_constant(tolua_S,"E_META_SAPLING_BIRCH",E_META_SAPLING_BIRCH);
  tolua_constant(tolua_S,"E_META_SAPLING_JUNGLE",E_META_SAPLING_JUNGLE);
  tolua_constant(tolua_S,"E_META_SAPLING_ACACIA",E_META_SAPLING_ACACIA);
  tolua_constant(tolua_S,"E_META_SAPLING_DARK_OAK",E_META_SAPLING_DARK_OAK);
  tolua_constant(tolua_S,"E_META_SILVERFISH_EGG_STONE",E_META_SILVERFISH_EGG_STONE);
  tolua_constant(tolua_S,"E_META_SILVERFISH_EGG_COBBLESTONE",E_META_SILVERFISH_EGG_COBBLESTONE);
  tolua_constant(tolua_S,"E_META_SILVERFISH_EGG_STONE_BRICK",E_META_SILVERFISH_EGG_STONE_BRICK);
  tolua_constant(tolua_S,"E_META_SILVERFISH_EGG_MOSSY_STONE_BRICK",E_META_SILVERFISH_EGG_MOSSY_STONE_BRICK);
  tolua_constant(tolua_S,"E_META_SILVERFISH_EGG_CRACKED_STONE_BRICK",E_META_SILVERFISH_EGG_CRACKED_STONE_BRICK);
  tolua_constant(tolua_S,"E_META_SILVERFISH_EGG_CHISELED_STONE_BRICK",E_META_SILVERFISH_EGG_CHISELED_STONE_BRICK);
  tolua_constant(tolua_S,"E_META_SNOW_LAYER_ONE",E_META_SNOW_LAYER_ONE);
  tolua_constant(tolua_S,"E_META_SNOW_LAYER_TWO",E_META_SNOW_LAYER_TWO);
  tolua_constant(tolua_S,"E_META_SNOW_LAYER_THREE",E_META_SNOW_LAYER_THREE);
  tolua_constant(tolua_S,"E_META_SNOW_LAYER_FOUR",E_META_SNOW_LAYER_FOUR);
  tolua_constant(tolua_S,"E_META_SNOW_LAYER_FIVE",E_META_SNOW_LAYER_FIVE);
  tolua_constant(tolua_S,"E_META_SNOW_LAYER_SIX",E_META_SNOW_LAYER_SIX);
  tolua_constant(tolua_S,"E_META_SNOW_LAYER_SEVEN",E_META_SNOW_LAYER_SEVEN);
  tolua_constant(tolua_S,"E_META_SNOW_LAYER_EIGHT",E_META_SNOW_LAYER_EIGHT);
  tolua_constant(tolua_S,"E_META_SPONGE_DRY",E_META_SPONGE_DRY);
  tolua_constant(tolua_S,"E_META_SPONGE_WET",E_META_SPONGE_WET);
  tolua_constant(tolua_S,"E_META_STAINED_CLAY_WHITE",E_META_STAINED_CLAY_WHITE);
  tolua_constant(tolua_S,"E_META_STAINED_CLAY_ORANGE",E_META_STAINED_CLAY_ORANGE);
  tolua_constant(tolua_S,"E_META_STAINED_CLAY_MAGENTA",E_META_STAINED_CLAY_MAGENTA);
  tolua_constant(tolua_S,"E_META_STAINED_CLAY_LIGHTBLUE",E_META_STAINED_CLAY_LIGHTBLUE);
  tolua_constant(tolua_S,"E_META_STAINED_CLAY_YELLOW",E_META_STAINED_CLAY_YELLOW);
  tolua_constant(tolua_S,"E_META_STAINED_CLAY_LIGHTGREEN",E_META_STAINED_CLAY_LIGHTGREEN);
  tolua_constant(tolua_S,"E_META_STAINED_CLAY_PINK",E_META_STAINED_CLAY_PINK);
  tolua_constant(tolua_S,"E_META_STAINED_CLAY_GRAY",E_META_STAINED_CLAY_GRAY);
  tolua_constant(tolua_S,"E_META_STAINED_CLAY_LIGHTGRAY",E_META_STAINED_CLAY_LIGHTGRAY);
  tolua_constant(tolua_S,"E_META_STAINED_CLAY_CYAN",E_META_STAINED_CLAY_CYAN);
  tolua_constant(tolua_S,"E_META_STAINED_CLAY_PURPLE",E_META_STAINED_CLAY_PURPLE);
  tolua_constant(tolua_S,"E_META_STAINED_CLAY_BLUE",E_META_STAINED_CLAY_BLUE);
  tolua_constant(tolua_S,"E_META_STAINED_CLAY_BROWN",E_META_STAINED_CLAY_BROWN);
  tolua_constant(tolua_S,"E_META_STAINED_CLAY_GREEN",E_META_STAINED_CLAY_GREEN);
  tolua_constant(tolua_S,"E_META_STAINED_CLAY_RED",E_META_STAINED_CLAY_RED);
  tolua_constant(tolua_S,"E_META_STAINED_CLAY_BLACK",E_META_STAINED_CLAY_BLACK);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_WHITE",E_META_STAINED_GLASS_WHITE);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_ORANGE",E_META_STAINED_GLASS_ORANGE);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_MAGENTA",E_META_STAINED_GLASS_MAGENTA);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_LIGHTBLUE",E_META_STAINED_GLASS_LIGHTBLUE);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_YELLOW",E_META_STAINED_GLASS_YELLOW);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_LIGHTGREEN",E_META_STAINED_GLASS_LIGHTGREEN);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_PINK",E_META_STAINED_GLASS_PINK);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_GRAY",E_META_STAINED_GLASS_GRAY);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_LIGHTGRAY",E_META_STAINED_GLASS_LIGHTGRAY);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_CYAN",E_META_STAINED_GLASS_CYAN);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_PURPLE",E_META_STAINED_GLASS_PURPLE);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_BLUE",E_META_STAINED_GLASS_BLUE);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_BROWN",E_META_STAINED_GLASS_BROWN);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_GREEN",E_META_STAINED_GLASS_GREEN);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_RED",E_META_STAINED_GLASS_RED);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_BLACK",E_META_STAINED_GLASS_BLACK);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_PANE_WHITE",E_META_STAINED_GLASS_PANE_WHITE);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_PANE_ORANGE",E_META_STAINED_GLASS_PANE_ORANGE);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_PANE_MAGENTA",E_META_STAINED_GLASS_PANE_MAGENTA);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_PANE_LIGHTBLUE",E_META_STAINED_GLASS_PANE_LIGHTBLUE);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_PANE_YELLOW",E_META_STAINED_GLASS_PANE_YELLOW);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_PANE_LIGHTGREEN",E_META_STAINED_GLASS_PANE_LIGHTGREEN);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_PANE_PINK",E_META_STAINED_GLASS_PANE_PINK);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_PANE_GRAY",E_META_STAINED_GLASS_PANE_GRAY);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_PANE_LIGHTGRAY",E_META_STAINED_GLASS_PANE_LIGHTGRAY);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_PANE_CYAN",E_META_STAINED_GLASS_PANE_CYAN);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_PANE_PURPLE",E_META_STAINED_GLASS_PANE_PURPLE);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_PANE_BLUE",E_META_STAINED_GLASS_PANE_BLUE);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_PANE_BROWN",E_META_STAINED_GLASS_PANE_BROWN);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_PANE_GREEN",E_META_STAINED_GLASS_PANE_GREEN);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_PANE_RED",E_META_STAINED_GLASS_PANE_RED);
  tolua_constant(tolua_S,"E_META_STAINED_GLASS_PANE_BLACK",E_META_STAINED_GLASS_PANE_BLACK);
  tolua_constant(tolua_S,"E_BLOCK_STAIRS_XP",E_BLOCK_STAIRS_XP);
  tolua_constant(tolua_S,"E_BLOCK_STAIRS_XM",E_BLOCK_STAIRS_XM);
  tolua_constant(tolua_S,"E_BLOCK_STAIRS_ZP",E_BLOCK_STAIRS_ZP);
  tolua_constant(tolua_S,"E_BLOCK_STAIRS_ZM",E_BLOCK_STAIRS_ZM);
  tolua_constant(tolua_S,"E_BLOCK_STAIRS_UPSIDE_DOWN",E_BLOCK_STAIRS_UPSIDE_DOWN);
  tolua_constant(tolua_S,"E_META_STONE_STONE",E_META_STONE_STONE);
  tolua_constant(tolua_S,"E_META_STONE_GRANITE",E_META_STONE_GRANITE);
  tolua_constant(tolua_S,"E_META_STONE_POLISHED_GRANITE",E_META_STONE_POLISHED_GRANITE);
  tolua_constant(tolua_S,"E_META_STONE_DIORITE",E_META_STONE_DIORITE);
  tolua_constant(tolua_S,"E_META_STONE_POLISHED_DIORITE",E_META_STONE_POLISHED_DIORITE);
  tolua_constant(tolua_S,"E_META_STONE_ANDESITE",E_META_STONE_ANDESITE);
  tolua_constant(tolua_S,"E_META_STONE_POLISHED_ANDESITE",E_META_STONE_POLISHED_ANDESITE);
  tolua_constant(tolua_S,"E_META_STONE_SLAB_STONE",E_META_STONE_SLAB_STONE);
  tolua_constant(tolua_S,"E_META_STONE_SLAB_SANDSTONE",E_META_STONE_SLAB_SANDSTONE);
  tolua_constant(tolua_S,"E_META_STONE_SLAB_PLANKS",E_META_STONE_SLAB_PLANKS);
  tolua_constant(tolua_S,"E_META_STONE_SLAB_COBBLESTONE",E_META_STONE_SLAB_COBBLESTONE);
  tolua_constant(tolua_S,"E_META_STONE_SLAB_BRICK",E_META_STONE_SLAB_BRICK);
  tolua_constant(tolua_S,"E_META_STONE_SLAB_STONE_BRICK",E_META_STONE_SLAB_STONE_BRICK);
  tolua_constant(tolua_S,"E_META_STONE_SLAB_NETHER_BRICK",E_META_STONE_SLAB_NETHER_BRICK);
  tolua_constant(tolua_S,"E_META_STONE_SLAB_QUARTZ",E_META_STONE_SLAB_QUARTZ);
  tolua_constant(tolua_S,"E_META_STONE_BRICK_NORMAL",E_META_STONE_BRICK_NORMAL);
  tolua_constant(tolua_S,"E_META_STONE_BRICK_MOSSY",E_META_STONE_BRICK_MOSSY);
  tolua_constant(tolua_S,"E_META_STONE_BRICK_CRACKED",E_META_STONE_BRICK_CRACKED);
  tolua_constant(tolua_S,"E_META_STONE_BRICK_ORNAMENT",E_META_STONE_BRICK_ORNAMENT);
  tolua_constant(tolua_S,"E_META_TALL_GRASS_DEAD_SHRUB",E_META_TALL_GRASS_DEAD_SHRUB);
  tolua_constant(tolua_S,"E_META_TALL_GRASS_GRASS",E_META_TALL_GRASS_GRASS);
  tolua_constant(tolua_S,"E_META_TALL_GRASS_FERN",E_META_TALL_GRASS_FERN);
  tolua_constant(tolua_S,"E_META_TALL_GRASS_BIOME",E_META_TALL_GRASS_BIOME);
  tolua_constant(tolua_S,"E_META_TORCH_EAST",E_META_TORCH_EAST);
  tolua_constant(tolua_S,"E_META_TORCH_WEST",E_META_TORCH_WEST);
  tolua_constant(tolua_S,"E_META_TORCH_SOUTH",E_META_TORCH_SOUTH);
  tolua_constant(tolua_S,"E_META_TORCH_NORTH",E_META_TORCH_NORTH);
  tolua_constant(tolua_S,"E_META_TORCH_FLOOR",E_META_TORCH_FLOOR);
  tolua_constant(tolua_S,"E_META_TORCH_XM",E_META_TORCH_XM);
  tolua_constant(tolua_S,"E_META_TORCH_XP",E_META_TORCH_XP);
  tolua_constant(tolua_S,"E_META_TORCH_ZM",E_META_TORCH_ZM);
  tolua_constant(tolua_S,"E_META_TORCH_ZP",E_META_TORCH_ZP);
  tolua_constant(tolua_S,"E_META_LOG_OAK_UP_DOWN",E_META_LOG_OAK_UP_DOWN);
  tolua_constant(tolua_S,"E_META_LOG_SPRUCE_UP_DOWN",E_META_LOG_SPRUCE_UP_DOWN);
  tolua_constant(tolua_S,"E_META_LOG_BIRCH_UP_DOWN",E_META_LOG_BIRCH_UP_DOWN);
  tolua_constant(tolua_S,"E_META_LOG_JUNGLE_UP_DOWN",E_META_LOG_JUNGLE_UP_DOWN);
  tolua_constant(tolua_S,"E_META_LOG_OAK_X",E_META_LOG_OAK_X);
  tolua_constant(tolua_S,"E_META_LOG_SPRUCE_X",E_META_LOG_SPRUCE_X);
  tolua_constant(tolua_S,"E_META_LOG_BIRCH_X",E_META_LOG_BIRCH_X);
  tolua_constant(tolua_S,"E_META_LOG_JUNGLE_X",E_META_LOG_JUNGLE_X);
  tolua_constant(tolua_S,"E_META_LOG_OAK_Z",E_META_LOG_OAK_Z);
  tolua_constant(tolua_S,"E_META_LOG_SPRUCE_Z",E_META_LOG_SPRUCE_Z);
  tolua_constant(tolua_S,"E_META_LOG_BIRCH_Z",E_META_LOG_BIRCH_Z);
  tolua_constant(tolua_S,"E_META_LOG_JUNGLE_Z",E_META_LOG_JUNGLE_Z);
  tolua_constant(tolua_S,"E_META_LOG_OAK_BARK_ONLY",E_META_LOG_OAK_BARK_ONLY);
  tolua_constant(tolua_S,"E_META_LOG_SPRUCE_BARK_ONLY",E_META_LOG_SPRUCE_BARK_ONLY);
  tolua_constant(tolua_S,"E_META_LOG_BIRCH_BARK_ONLY",E_META_LOG_BIRCH_BARK_ONLY);
  tolua_constant(tolua_S,"E_META_LOG_JUNGLE_BARK_ONLY",E_META_LOG_JUNGLE_BARK_ONLY);
  tolua_constant(tolua_S,"E_META_NEWLOG_ACACIA_UP_DOWN",E_META_NEWLOG_ACACIA_UP_DOWN);
  tolua_constant(tolua_S,"E_META_NEWLOG_DARK_OAK_UP_DOWN",E_META_NEWLOG_DARK_OAK_UP_DOWN);
  tolua_constant(tolua_S,"E_META_NEWLOG_ACACIA_X",E_META_NEWLOG_ACACIA_X);
  tolua_constant(tolua_S,"E_META_NEWLOG_DARK_OAK_X",E_META_NEWLOG_DARK_OAK_X);
  tolua_constant(tolua_S,"E_META_NEWLOG_ACACIA_Z",E_META_NEWLOG_ACACIA_Z);
  tolua_constant(tolua_S,"E_META_NEWLOG_DARK_OAK_Z",E_META_NEWLOG_DARK_OAK_Z);
  tolua_constant(tolua_S,"E_META_NEWLOG_ACACIA_BARK_ONLY",E_META_NEWLOG_ACACIA_BARK_ONLY);
  tolua_constant(tolua_S,"E_META_NEWLOG_DARK_OAK_BARK_ONLY",E_META_NEWLOG_DARK_OAK_BARK_ONLY);
  tolua_constant(tolua_S,"E_META_WOODEN_DOUBLE_SLAB_OAK",E_META_WOODEN_DOUBLE_SLAB_OAK);
  tolua_constant(tolua_S,"E_META_WOODEN_DOUBLE_SLAB_SPRUCE",E_META_WOODEN_DOUBLE_SLAB_SPRUCE);
  tolua_constant(tolua_S,"E_META_WOODEN_DOUBLE_SLAB_BIRCH",E_META_WOODEN_DOUBLE_SLAB_BIRCH);
  tolua_constant(tolua_S,"E_META_WOODEN_DOUBLE_SLAB_JUNGLE",E_META_WOODEN_DOUBLE_SLAB_JUNGLE);
  tolua_constant(tolua_S,"E_META_WOODEN_DOUBLE_SLAB_ACACIA",E_META_WOODEN_DOUBLE_SLAB_ACACIA);
  tolua_constant(tolua_S,"E_META_WOODEN_DOUBLE_SLAB_DARK_OAK",E_META_WOODEN_DOUBLE_SLAB_DARK_OAK);
  tolua_constant(tolua_S,"E_META_WOODEN_SLAB_OAK",E_META_WOODEN_SLAB_OAK);
  tolua_constant(tolua_S,"E_META_WOODEN_SLAB_SPRUCE",E_META_WOODEN_SLAB_SPRUCE);
  tolua_constant(tolua_S,"E_META_WOODEN_SLAB_BIRCH",E_META_WOODEN_SLAB_BIRCH);
  tolua_constant(tolua_S,"E_META_WOODEN_SLAB_JUNGLE",E_META_WOODEN_SLAB_JUNGLE);
  tolua_constant(tolua_S,"E_META_WOODEN_SLAB_ACACIA",E_META_WOODEN_SLAB_ACACIA);
  tolua_constant(tolua_S,"E_META_WOODEN_SLAB_DARK_OAK",E_META_WOODEN_SLAB_DARK_OAK);
  tolua_constant(tolua_S,"E_META_WOODEN_SLAB_UPSIDE_DOWN",E_META_WOODEN_SLAB_UPSIDE_DOWN);
  tolua_constant(tolua_S,"E_META_WOOL_WHITE",E_META_WOOL_WHITE);
  tolua_constant(tolua_S,"E_META_WOOL_ORANGE",E_META_WOOL_ORANGE);
  tolua_constant(tolua_S,"E_META_WOOL_MAGENTA",E_META_WOOL_MAGENTA);
  tolua_constant(tolua_S,"E_META_WOOL_LIGHTBLUE",E_META_WOOL_LIGHTBLUE);
  tolua_constant(tolua_S,"E_META_WOOL_YELLOW",E_META_WOOL_YELLOW);
  tolua_constant(tolua_S,"E_META_WOOL_LIGHTGREEN",E_META_WOOL_LIGHTGREEN);
  tolua_constant(tolua_S,"E_META_WOOL_PINK",E_META_WOOL_PINK);
  tolua_constant(tolua_S,"E_META_WOOL_GRAY",E_META_WOOL_GRAY);
  tolua_constant(tolua_S,"E_META_WOOL_LIGHTGRAY",E_META_WOOL_LIGHTGRAY);
  tolua_constant(tolua_S,"E_META_WOOL_CYAN",E_META_WOOL_CYAN);
  tolua_constant(tolua_S,"E_META_WOOL_PURPLE",E_META_WOOL_PURPLE);
  tolua_constant(tolua_S,"E_META_WOOL_BLUE",E_META_WOOL_BLUE);
  tolua_constant(tolua_S,"E_META_WOOL_BROWN",E_META_WOOL_BROWN);
  tolua_constant(tolua_S,"E_META_WOOL_GREEN",E_META_WOOL_GREEN);
  tolua_constant(tolua_S,"E_META_WOOL_RED",E_META_WOOL_RED);
  tolua_constant(tolua_S,"E_META_WOOL_BLACK",E_META_WOOL_BLACK);
  tolua_constant(tolua_S,"E_META_BANNER_BLACK",E_META_BANNER_BLACK);
  tolua_constant(tolua_S,"E_META_BANNER_RED",E_META_BANNER_RED);
  tolua_constant(tolua_S,"E_META_BANNER_GREEN",E_META_BANNER_GREEN);
  tolua_constant(tolua_S,"E_META_BANNER_BROWN",E_META_BANNER_BROWN);
  tolua_constant(tolua_S,"E_META_BANNER_BLUE",E_META_BANNER_BLUE);
  tolua_constant(tolua_S,"E_META_BANNER_PURPLE",E_META_BANNER_PURPLE);
  tolua_constant(tolua_S,"E_META_BANNER_CYAN",E_META_BANNER_CYAN);
  tolua_constant(tolua_S,"E_META_BANNER_LIGHTGRAY",E_META_BANNER_LIGHTGRAY);
  tolua_constant(tolua_S,"E_META_BANNER_GRAY",E_META_BANNER_GRAY);
  tolua_constant(tolua_S,"E_META_BANNER_PINK",E_META_BANNER_PINK);
  tolua_constant(tolua_S,"E_META_BANNER_LIGHTGREEN",E_META_BANNER_LIGHTGREEN);
  tolua_constant(tolua_S,"E_META_BANNER_YELLOW",E_META_BANNER_YELLOW);
  tolua_constant(tolua_S,"E_META_BANNER_LIGHTBLUE",E_META_BANNER_LIGHTBLUE);
  tolua_constant(tolua_S,"E_META_BANNER_MAGENTA",E_META_BANNER_MAGENTA);
  tolua_constant(tolua_S,"E_META_BANNER_ORANGE",E_META_BANNER_ORANGE);
  tolua_constant(tolua_S,"E_META_BANNER_WHITE",E_META_BANNER_WHITE);
  tolua_constant(tolua_S,"E_META_COAL_NORMAL",E_META_COAL_NORMAL);
  tolua_constant(tolua_S,"E_META_COAL_CHARCOAL",E_META_COAL_CHARCOAL);
  tolua_constant(tolua_S,"E_META_DYE_BLACK",E_META_DYE_BLACK);
  tolua_constant(tolua_S,"E_META_DYE_RED",E_META_DYE_RED);
  tolua_constant(tolua_S,"E_META_DYE_GREEN",E_META_DYE_GREEN);
  tolua_constant(tolua_S,"E_META_DYE_BROWN",E_META_DYE_BROWN);
  tolua_constant(tolua_S,"E_META_DYE_BLUE",E_META_DYE_BLUE);
  tolua_constant(tolua_S,"E_META_DYE_PURPLE",E_META_DYE_PURPLE);
  tolua_constant(tolua_S,"E_META_DYE_CYAN",E_META_DYE_CYAN);
  tolua_constant(tolua_S,"E_META_DYE_LIGHTGRAY",E_META_DYE_LIGHTGRAY);
  tolua_constant(tolua_S,"E_META_DYE_GRAY",E_META_DYE_GRAY);
  tolua_constant(tolua_S,"E_META_DYE_PINK",E_META_DYE_PINK);
  tolua_constant(tolua_S,"E_META_DYE_LIGHTGREEN",E_META_DYE_LIGHTGREEN);
  tolua_constant(tolua_S,"E_META_DYE_YELLOW",E_META_DYE_YELLOW);
  tolua_constant(tolua_S,"E_META_DYE_LIGHTBLUE",E_META_DYE_LIGHTBLUE);
  tolua_constant(tolua_S,"E_META_DYE_MAGENTA",E_META_DYE_MAGENTA);
  tolua_constant(tolua_S,"E_META_DYE_ORANGE",E_META_DYE_ORANGE);
  tolua_constant(tolua_S,"E_META_DYE_WHITE",E_META_DYE_WHITE);
  tolua_constant(tolua_S,"E_META_GOLDEN_APPLE_NORMAL",E_META_GOLDEN_APPLE_NORMAL);
  tolua_constant(tolua_S,"E_META_GOLDEN_APPLE_ENCHANTED",E_META_GOLDEN_APPLE_ENCHANTED);
  tolua_constant(tolua_S,"E_META_HEAD_SKELETON",E_META_HEAD_SKELETON);
  tolua_constant(tolua_S,"E_META_HEAD_WITHER",E_META_HEAD_WITHER);
  tolua_constant(tolua_S,"E_META_HEAD_ZOMBIE",E_META_HEAD_ZOMBIE);
  tolua_constant(tolua_S,"E_META_HEAD_PLAYER",E_META_HEAD_PLAYER);
  tolua_constant(tolua_S,"E_META_HEAD_CREEPER",E_META_HEAD_CREEPER);
  tolua_constant(tolua_S,"E_META_HEAD_DRAGON",E_META_HEAD_DRAGON);
  tolua_constant(tolua_S,"E_META_RAW_FISH_FISH",E_META_RAW_FISH_FISH);
  tolua_constant(tolua_S,"E_META_RAW_FISH_SALMON",E_META_RAW_FISH_SALMON);
  tolua_constant(tolua_S,"E_META_RAW_FISH_CLOWNFISH",E_META_RAW_FISH_CLOWNFISH);
  tolua_constant(tolua_S,"E_META_RAW_FISH_PUFFERFISH",E_META_RAW_FISH_PUFFERFISH);
  tolua_constant(tolua_S,"E_META_COOKED_FISH_FISH",E_META_COOKED_FISH_FISH);
  tolua_constant(tolua_S,"E_META_COOKED_FISH_SALMON",E_META_COOKED_FISH_SALMON);
  tolua_constant(tolua_S,"E_META_TRACKS_X",E_META_TRACKS_X);
  tolua_constant(tolua_S,"E_META_TRACKS_Z",E_META_TRACKS_Z);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_PICKUP",E_META_SPAWN_EGG_PICKUP);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_EXPERIENCE_ORB",E_META_SPAWN_EGG_EXPERIENCE_ORB);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_WITHER_SKELETON",E_META_SPAWN_EGG_WITHER_SKELETON);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_LEASH_KNOT",E_META_SPAWN_EGG_LEASH_KNOT);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_PAINTING",E_META_SPAWN_EGG_PAINTING);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_ARROW",E_META_SPAWN_EGG_ARROW);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_SNOWBALL",E_META_SPAWN_EGG_SNOWBALL);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_FIREBALL",E_META_SPAWN_EGG_FIREBALL);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_SMALL_FIREBALL",E_META_SPAWN_EGG_SMALL_FIREBALL);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_ENDER_PEARL",E_META_SPAWN_EGG_ENDER_PEARL);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_EYE_OF_ENDER",E_META_SPAWN_EGG_EYE_OF_ENDER);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_SPLASH_POTION",E_META_SPAWN_EGG_SPLASH_POTION);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_EXP_BOTTLE",E_META_SPAWN_EGG_EXP_BOTTLE);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_ITEM_FRAME",E_META_SPAWN_EGG_ITEM_FRAME);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_WITHER_SKULL",E_META_SPAWN_EGG_WITHER_SKULL);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_PRIMED_TNT",E_META_SPAWN_EGG_PRIMED_TNT);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_FALLING_BLOCK",E_META_SPAWN_EGG_FALLING_BLOCK);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_FIREWORK",E_META_SPAWN_EGG_FIREWORK);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_ZOMBIE_VILLAGER",E_META_SPAWN_EGG_ZOMBIE_VILLAGER);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_BOAT",E_META_SPAWN_EGG_BOAT);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_MINECART",E_META_SPAWN_EGG_MINECART);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_MINECART_CHEST",E_META_SPAWN_EGG_MINECART_CHEST);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_MINECART_FURNACE",E_META_SPAWN_EGG_MINECART_FURNACE);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_MINECART_TNT",E_META_SPAWN_EGG_MINECART_TNT);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_MINECART_HOPPER",E_META_SPAWN_EGG_MINECART_HOPPER);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_MINECART_SPAWNER",E_META_SPAWN_EGG_MINECART_SPAWNER);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_CREEPER",E_META_SPAWN_EGG_CREEPER);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_SKELETON",E_META_SPAWN_EGG_SKELETON);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_SPIDER",E_META_SPAWN_EGG_SPIDER);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_GIANT",E_META_SPAWN_EGG_GIANT);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_ZOMBIE",E_META_SPAWN_EGG_ZOMBIE);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_SLIME",E_META_SPAWN_EGG_SLIME);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_GHAST",E_META_SPAWN_EGG_GHAST);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_ZOMBIE_PIGMAN",E_META_SPAWN_EGG_ZOMBIE_PIGMAN);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_ENDERMAN",E_META_SPAWN_EGG_ENDERMAN);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_CAVE_SPIDER",E_META_SPAWN_EGG_CAVE_SPIDER);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_SILVERFISH",E_META_SPAWN_EGG_SILVERFISH);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_BLAZE",E_META_SPAWN_EGG_BLAZE);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_MAGMA_CUBE",E_META_SPAWN_EGG_MAGMA_CUBE);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_ENDER_DRAGON",E_META_SPAWN_EGG_ENDER_DRAGON);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_WITHER",E_META_SPAWN_EGG_WITHER);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_BAT",E_META_SPAWN_EGG_BAT);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_WITCH",E_META_SPAWN_EGG_WITCH);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_ENDERMITE",E_META_SPAWN_EGG_ENDERMITE);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_GUARDIAN",E_META_SPAWN_EGG_GUARDIAN);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_PIG",E_META_SPAWN_EGG_PIG);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_SHEEP",E_META_SPAWN_EGG_SHEEP);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_COW",E_META_SPAWN_EGG_COW);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_CHICKEN",E_META_SPAWN_EGG_CHICKEN);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_SQUID",E_META_SPAWN_EGG_SQUID);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_WOLF",E_META_SPAWN_EGG_WOLF);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_MOOSHROOM",E_META_SPAWN_EGG_MOOSHROOM);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_SNOW_GOLEM",E_META_SPAWN_EGG_SNOW_GOLEM);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_OCELOT",E_META_SPAWN_EGG_OCELOT);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_IRON_GOLEM",E_META_SPAWN_EGG_IRON_GOLEM);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_HORSE",E_META_SPAWN_EGG_HORSE);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_RABBIT",E_META_SPAWN_EGG_RABBIT);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_VILLAGER",E_META_SPAWN_EGG_VILLAGER);
  tolua_constant(tolua_S,"E_META_SPAWN_EGG_ENDER_CRYSTAL",E_META_SPAWN_EGG_ENDER_CRYSTAL);
  tolua_function(tolua_S,"BlockStringToType",tolua_AllToLua_BlockStringToType00);
  tolua_function(tolua_S,"StringToItem",tolua_AllToLua_StringToItem00);
  tolua_function(tolua_S,"ItemToString",tolua_AllToLua_ItemToString00);
  tolua_function(tolua_S,"ItemTypeToString",tolua_AllToLua_ItemTypeToString00);
  tolua_function(tolua_S,"ItemToFullString",tolua_AllToLua_ItemToFullString00);
  tolua_function(tolua_S,"GetIniItemSet",tolua_AllToLua_GetIniItemSet00);
  tolua_cclass(tolua_S,"cBlockInfo","cBlockInfo","",nullptr);
  tolua_beginmodule(tolua_S,"cBlockInfo");
   tolua_function(tolua_S,"GetLightValue",tolua_AllToLua_cBlockInfo_GetLightValue00);
   tolua_function(tolua_S,"GetSpreadLightFalloff",tolua_AllToLua_cBlockInfo_GetSpreadLightFalloff00);
   tolua_function(tolua_S,"CanBeTerraformed",tolua_AllToLua_cBlockInfo_CanBeTerraformed00);
   tolua_function(tolua_S,"FullyOccupiesVoxel",tolua_AllToLua_cBlockInfo_FullyOccupiesVoxel00);
   tolua_function(tolua_S,"IsClickedThrough",tolua_AllToLua_cBlockInfo_IsClickedThrough00);
   tolua_function(tolua_S,"IsOneHitDig",tolua_AllToLua_cBlockInfo_IsOneHitDig00);
   tolua_function(tolua_S,"IsPistonBreakable",tolua_AllToLua_cBlockInfo_IsPistonBreakable00);
   tolua_function(tolua_S,"IsRainBlocker",tolua_AllToLua_cBlockInfo_IsRainBlocker00);
   tolua_function(tolua_S,"IsSkylightDispersant",tolua_AllToLua_cBlockInfo_IsSkylightDispersant00);
   tolua_function(tolua_S,"IsSnowable",tolua_AllToLua_cBlockInfo_IsSnowable00);
   tolua_function(tolua_S,"IsSolid",tolua_AllToLua_cBlockInfo_IsSolid00);
   tolua_function(tolua_S,"IsTransparent",tolua_AllToLua_cBlockInfo_IsTransparent00);
   tolua_function(tolua_S,"IsUseableBySpectator",tolua_AllToLua_cBlockInfo_IsUseableBySpectator00);
   tolua_function(tolua_S,"GetBlockHeight",tolua_AllToLua_cBlockInfo_GetBlockHeight00);
   tolua_function(tolua_S,"GetHardness",tolua_AllToLua_cBlockInfo_GetHardness00);
  tolua_endmodule(tolua_S);
  tolua_function(tolua_S,"TrimString",tolua_AllToLua_TrimString00);
  tolua_function(tolua_S,"NoCaseCompare",tolua_AllToLua_NoCaseCompare00);
  tolua_function(tolua_S,"ReplaceString",tolua_AllToLua_ReplaceString00);
  tolua_function(tolua_S,"EscapeString",tolua_AllToLua_EscapeString00);
  tolua_function(tolua_S,"StripColorCodes",tolua_AllToLua_StripColorCodes00);
  tolua_constant(tolua_S,"MAX_EXPERIENCE_ORB_SIZE",MAX_EXPERIENCE_ORB_SIZE);
  tolua_constant(tolua_S,"BLOCK_FACE_NONE",BLOCK_FACE_NONE);
  tolua_constant(tolua_S,"BLOCK_FACE_XM",BLOCK_FACE_XM);
  tolua_constant(tolua_S,"BLOCK_FACE_XP",BLOCK_FACE_XP);
  tolua_constant(tolua_S,"BLOCK_FACE_YM",BLOCK_FACE_YM);
  tolua_constant(tolua_S,"BLOCK_FACE_YP",BLOCK_FACE_YP);
  tolua_constant(tolua_S,"BLOCK_FACE_ZM",BLOCK_FACE_ZM);
  tolua_constant(tolua_S,"BLOCK_FACE_ZP",BLOCK_FACE_ZP);
  tolua_constant(tolua_S,"BLOCK_FACE_BOTTOM",BLOCK_FACE_BOTTOM);
  tolua_constant(tolua_S,"BLOCK_FACE_TOP",BLOCK_FACE_TOP);
  tolua_constant(tolua_S,"BLOCK_FACE_NORTH",BLOCK_FACE_NORTH);
  tolua_constant(tolua_S,"BLOCK_FACE_SOUTH",BLOCK_FACE_SOUTH);
  tolua_constant(tolua_S,"BLOCK_FACE_WEST",BLOCK_FACE_WEST);
  tolua_constant(tolua_S,"BLOCK_FACE_EAST",BLOCK_FACE_EAST);
  tolua_constant(tolua_S,"BLOCK_FACE_MIN",BLOCK_FACE_MIN);
  tolua_constant(tolua_S,"BLOCK_FACE_MAX",BLOCK_FACE_MAX);
  tolua_constant(tolua_S,"DIG_STATUS_STARTED",DIG_STATUS_STARTED);
  tolua_constant(tolua_S,"DIG_STATUS_CANCELLED",DIG_STATUS_CANCELLED);
  tolua_constant(tolua_S,"DIG_STATUS_FINISHED",DIG_STATUS_FINISHED);
  tolua_constant(tolua_S,"DIG_STATUS_DROP_STACK",DIG_STATUS_DROP_STACK);
  tolua_constant(tolua_S,"DIG_STATUS_DROP_HELD",DIG_STATUS_DROP_HELD);
  tolua_constant(tolua_S,"DIG_STATUS_SHOOT_EAT",DIG_STATUS_SHOOT_EAT);
  tolua_constant(tolua_S,"DIG_STATUS_SWAP_ITEM_IN_HAND",DIG_STATUS_SWAP_ITEM_IN_HAND);
  tolua_constant(tolua_S,"caLeftClick",caLeftClick);
  tolua_constant(tolua_S,"caRightClick",caRightClick);
  tolua_constant(tolua_S,"caShiftLeftClick",caShiftLeftClick);
  tolua_constant(tolua_S,"caShiftRightClick",caShiftRightClick);
  tolua_constant(tolua_S,"caNumber1",caNumber1);
  tolua_constant(tolua_S,"caNumber2",caNumber2);
  tolua_constant(tolua_S,"caNumber3",caNumber3);
  tolua_constant(tolua_S,"caNumber4",caNumber4);
  tolua_constant(tolua_S,"caNumber5",caNumber5);
  tolua_constant(tolua_S,"caNumber6",caNumber6);
  tolua_constant(tolua_S,"caNumber7",caNumber7);
  tolua_constant(tolua_S,"caNumber8",caNumber8);
  tolua_constant(tolua_S,"caNumber9",caNumber9);
  tolua_constant(tolua_S,"caMiddleClick",caMiddleClick);
  tolua_constant(tolua_S,"caDropKey",caDropKey);
  tolua_constant(tolua_S,"caCtrlDropKey",caCtrlDropKey);
  tolua_constant(tolua_S,"caLeftClickOutside",caLeftClickOutside);
  tolua_constant(tolua_S,"caRightClickOutside",caRightClickOutside);
  tolua_constant(tolua_S,"caLeftClickOutsideHoldNothing",caLeftClickOutsideHoldNothing);
  tolua_constant(tolua_S,"caRightClickOutsideHoldNothing",caRightClickOutsideHoldNothing);
  tolua_constant(tolua_S,"caLeftPaintBegin",caLeftPaintBegin);
  tolua_constant(tolua_S,"caRightPaintBegin",caRightPaintBegin);
  tolua_constant(tolua_S,"caMiddlePaintBegin",caMiddlePaintBegin);
  tolua_constant(tolua_S,"caLeftPaintProgress",caLeftPaintProgress);
  tolua_constant(tolua_S,"caRightPaintProgress",caRightPaintProgress);
  tolua_constant(tolua_S,"caMiddlePaintProgress",caMiddlePaintProgress);
  tolua_constant(tolua_S,"caLeftPaintEnd",caLeftPaintEnd);
  tolua_constant(tolua_S,"caRightPaintEnd",caRightPaintEnd);
  tolua_constant(tolua_S,"caMiddlePaintEnd",caMiddlePaintEnd);
  tolua_constant(tolua_S,"caDblClick",caDblClick);
  tolua_constant(tolua_S,"caUnknown",caUnknown);
  tolua_constant(tolua_S,"eGameMode_NotSet",eGameMode_NotSet);
  tolua_constant(tolua_S,"eGameMode_Survival",eGameMode_Survival);
  tolua_constant(tolua_S,"eGameMode_Creative",eGameMode_Creative);
  tolua_constant(tolua_S,"eGameMode_Adventure",eGameMode_Adventure);
  tolua_constant(tolua_S,"eGameMode_Spectator",eGameMode_Spectator);
  tolua_constant(tolua_S,"gmNotSet",gmNotSet);
  tolua_constant(tolua_S,"gmSurvival",gmSurvival);
  tolua_constant(tolua_S,"gmCreative",gmCreative);
  tolua_constant(tolua_S,"gmAdventure",gmAdventure);
  tolua_constant(tolua_S,"gmSpectator",gmSpectator);
  tolua_constant(tolua_S,"gmMax",gmMax);
  tolua_constant(tolua_S,"gmMin",gmMin);
  tolua_constant(tolua_S,"ctChatBox",ctChatBox);
  tolua_constant(tolua_S,"ctSystem",ctSystem);
  tolua_constant(tolua_S,"ctAboveActionBar",ctAboveActionBar);
  tolua_constant(tolua_S,"eWeather_Sunny",eWeather_Sunny);
  tolua_constant(tolua_S,"eWeather_Rain",eWeather_Rain);
  tolua_constant(tolua_S,"eWeather_ThunderStorm",eWeather_ThunderStorm);
  tolua_constant(tolua_S,"wSunny",wSunny);
  tolua_constant(tolua_S,"wRain",wRain);
  tolua_constant(tolua_S,"wThunderstorm",wThunderstorm);
  tolua_constant(tolua_S,"wStorm",wStorm);
  tolua_constant(tolua_S,"SKULL_TYPE_SKELETON",SKULL_TYPE_SKELETON);
  tolua_constant(tolua_S,"SKULL_TYPE_WITHER",SKULL_TYPE_WITHER);
  tolua_constant(tolua_S,"SKULL_TYPE_ZOMBIE",SKULL_TYPE_ZOMBIE);
  tolua_constant(tolua_S,"SKULL_TYPE_PLAYER",SKULL_TYPE_PLAYER);
  tolua_constant(tolua_S,"SKULL_TYPE_CREEPER",SKULL_TYPE_CREEPER);
  tolua_constant(tolua_S,"SKULL_TYPE_DRAGON",SKULL_TYPE_DRAGON);
  tolua_constant(tolua_S,"SKULL_ROTATION_NORTH",SKULL_ROTATION_NORTH);
  tolua_constant(tolua_S,"SKULL_ROTATION_NORTH_NORTH_EAST",SKULL_ROTATION_NORTH_NORTH_EAST);
  tolua_constant(tolua_S,"SKULL_ROTATION_NORTH_EAST",SKULL_ROTATION_NORTH_EAST);
  tolua_constant(tolua_S,"SKULL_ROTATION_EAST_NORTH_EAST",SKULL_ROTATION_EAST_NORTH_EAST);
  tolua_constant(tolua_S,"SKULL_ROTATION_EAST",SKULL_ROTATION_EAST);
  tolua_constant(tolua_S,"SKULL_ROTATION_EAST_SOUTH_EAST",SKULL_ROTATION_EAST_SOUTH_EAST);
  tolua_constant(tolua_S,"SKULL_ROTATION_SOUTH_EAST",SKULL_ROTATION_SOUTH_EAST);
  tolua_constant(tolua_S,"SKULL_ROTATION_SOUTH_SOUTH_EAST",SKULL_ROTATION_SOUTH_SOUTH_EAST);
  tolua_constant(tolua_S,"SKULL_ROTATION_SOUTH",SKULL_ROTATION_SOUTH);
  tolua_constant(tolua_S,"SKULL_ROTATION_SOUTH_SOUTH_WEST",SKULL_ROTATION_SOUTH_SOUTH_WEST);
  tolua_constant(tolua_S,"SKULL_ROTATION_SOUTH_WEST",SKULL_ROTATION_SOUTH_WEST);
  tolua_constant(tolua_S,"SKULL_ROTATION_WEST_SOUTH_WEST",SKULL_ROTATION_WEST_SOUTH_WEST);
  tolua_constant(tolua_S,"SKULL_ROTATION_WEST",SKULL_ROTATION_WEST);
  tolua_constant(tolua_S,"SKULL_ROTATION_WEST_NORTH_WEST",SKULL_ROTATION_WEST_NORTH_WEST);
  tolua_constant(tolua_S,"SKULL_ROTATION_NORTH_WEST",SKULL_ROTATION_NORTH_WEST);
  tolua_constant(tolua_S,"SKULL_ROTATION_NORTH_NORTH_WEST",SKULL_ROTATION_NORTH_NORTH_WEST);
  tolua_constant(tolua_S,"spCape",spCape);
  tolua_constant(tolua_S,"spJacket",spJacket);
  tolua_constant(tolua_S,"spLeftSleeve",spLeftSleeve);
  tolua_constant(tolua_S,"spRightSleeve",spRightSleeve);
  tolua_constant(tolua_S,"spLeftPants",spLeftPants);
  tolua_constant(tolua_S,"spRightPants",spRightPants);
  tolua_constant(tolua_S,"spHat",spHat);
  tolua_constant(tolua_S,"spMask",spMask);
  tolua_constant(tolua_S,"dimNether",dimNether);
  tolua_constant(tolua_S,"dimOverworld",dimOverworld);
  tolua_constant(tolua_S,"dimEnd",dimEnd);
  tolua_constant(tolua_S,"dimNotSet",dimNotSet);
  tolua_constant(tolua_S,"dtAttack",dtAttack);
  tolua_constant(tolua_S,"dtRangedAttack",dtRangedAttack);
  tolua_constant(tolua_S,"dtLightning",dtLightning);
  tolua_constant(tolua_S,"dtFalling",dtFalling);
  tolua_constant(tolua_S,"dtDrowning",dtDrowning);
  tolua_constant(tolua_S,"dtSuffocating",dtSuffocating);
  tolua_constant(tolua_S,"dtStarving",dtStarving);
  tolua_constant(tolua_S,"dtCactusContact",dtCactusContact);
  tolua_constant(tolua_S,"dtMagmaContact",dtMagmaContact);
  tolua_constant(tolua_S,"dtLavaContact",dtLavaContact);
  tolua_constant(tolua_S,"dtPoisoning",dtPoisoning);
  tolua_constant(tolua_S,"dtWithering",dtWithering);
  tolua_constant(tolua_S,"dtOnFire",dtOnFire);
  tolua_constant(tolua_S,"dtFireContact",dtFireContact);
  tolua_constant(tolua_S,"dtInVoid",dtInVoid);
  tolua_constant(tolua_S,"dtPotionOfHarming",dtPotionOfHarming);
  tolua_constant(tolua_S,"dtEnderPearl",dtEnderPearl);
  tolua_constant(tolua_S,"dtAdmin",dtAdmin);
  tolua_constant(tolua_S,"dtExplosion",dtExplosion);
  tolua_constant(tolua_S,"dtEnvironment",dtEnvironment);
  tolua_constant(tolua_S,"dtPawnAttack",dtPawnAttack);
  tolua_constant(tolua_S,"dtEntityAttack",dtEntityAttack);
  tolua_constant(tolua_S,"dtMob",dtMob);
  tolua_constant(tolua_S,"dtMobAttack",dtMobAttack);
  tolua_constant(tolua_S,"dtArrowAttack",dtArrowAttack);
  tolua_constant(tolua_S,"dtArrow",dtArrow);
  tolua_constant(tolua_S,"dtProjectile",dtProjectile);
  tolua_constant(tolua_S,"dtFall",dtFall);
  tolua_constant(tolua_S,"dtDrown",dtDrown);
  tolua_constant(tolua_S,"dtSuffocation",dtSuffocation);
  tolua_constant(tolua_S,"dtStarvation",dtStarvation);
  tolua_constant(tolua_S,"dtHunger",dtHunger);
  tolua_constant(tolua_S,"dtCactus",dtCactus);
  tolua_constant(tolua_S,"dtCactuses",dtCactuses);
  tolua_constant(tolua_S,"dtCacti",dtCacti);
  tolua_constant(tolua_S,"dtMagma",dtMagma);
  tolua_constant(tolua_S,"dtLava",dtLava);
  tolua_constant(tolua_S,"dtPoison",dtPoison);
  tolua_constant(tolua_S,"dtWither",dtWither);
  tolua_constant(tolua_S,"dtBurning",dtBurning);
  tolua_constant(tolua_S,"dtInFire",dtInFire);
  tolua_constant(tolua_S,"dtPlugin",dtPlugin);
  tolua_constant(tolua_S,"esBed",esBed);
  tolua_constant(tolua_S,"esEnderCrystal",esEnderCrystal);
  tolua_constant(tolua_S,"esGhastFireball",esGhastFireball);
  tolua_constant(tolua_S,"esMonster",esMonster);
  tolua_constant(tolua_S,"esOther",esOther);
  tolua_constant(tolua_S,"esPlugin",esPlugin);
  tolua_constant(tolua_S,"esPrimedTNT",esPrimedTNT);
  tolua_constant(tolua_S,"esTNTMinecart",esTNTMinecart);
  tolua_constant(tolua_S,"esWitherBirth",esWitherBirth);
  tolua_constant(tolua_S,"esWitherSkull",esWitherSkull);
  tolua_constant(tolua_S,"esMax",esMax);
  tolua_constant(tolua_S,"slNone",slNone);
  tolua_constant(tolua_S,"slGravityAffectedOnly",slGravityAffectedOnly);
  tolua_constant(tolua_S,"slAll",slAll);
  tolua_constant(tolua_S,"ssFireSpread",ssFireSpread);
  tolua_constant(tolua_S,"ssGrassSpread",ssGrassSpread);
  tolua_constant(tolua_S,"ssMushroomSpread",ssMushroomSpread);
  tolua_constant(tolua_S,"ssMycelSpread",ssMycelSpread);
  tolua_constant(tolua_S,"ssVineSpread",ssVineSpread);
  tolua_constant(tolua_S,"mtCustom",mtCustom);
  tolua_constant(tolua_S,"mtFailure",mtFailure);
  tolua_constant(tolua_S,"mtInformation",mtInformation);
  tolua_constant(tolua_S,"mtSuccess",mtSuccess);
  tolua_constant(tolua_S,"mtWarning",mtWarning);
  tolua_constant(tolua_S,"mtFatal",mtFatal);
  tolua_constant(tolua_S,"mtDeath",mtDeath);
  tolua_constant(tolua_S,"mtPrivateMessage",mtPrivateMessage);
  tolua_constant(tolua_S,"mtJoin",mtJoin);
  tolua_constant(tolua_S,"mtLeave",mtLeave);
  tolua_constant(tolua_S,"mtMaxPlusOne",mtMaxPlusOne);
  tolua_constant(tolua_S,"mtFail",mtFail);
  tolua_constant(tolua_S,"mtError",mtError);
  tolua_constant(tolua_S,"mtInfo",mtInfo);
  tolua_constant(tolua_S,"mtPM",mtPM);
  tolua_module(tolua_S,"BannerPattern",0);
  tolua_beginmodule(tolua_S,"BannerPattern");
   tolua_constant(tolua_S,"BottomStripe",static_cast<lua_Number>(BannerPattern::BottomStripe));
   tolua_constant(tolua_S,"TopStripe",static_cast<lua_Number>(BannerPattern::TopStripe));
   tolua_constant(tolua_S,"LeftStripe",static_cast<lua_Number>(BannerPattern::LeftStripe));
   tolua_constant(tolua_S,"RightStripe",static_cast<lua_Number>(BannerPattern::RightStripe));
   tolua_constant(tolua_S,"CenterStripeVertical",static_cast<lua_Number>(BannerPattern::CenterStripeVertical));
   tolua_constant(tolua_S,"MiddleStripeHorizontal",static_cast<lua_Number>(BannerPattern::MiddleStripeHorizontal));
   tolua_constant(tolua_S,"DownRightStripe",static_cast<lua_Number>(BannerPattern::DownRightStripe));
   tolua_constant(tolua_S,"DownLeftStripe",static_cast<lua_Number>(BannerPattern::DownLeftStripe));
   tolua_constant(tolua_S,"SmallVerticalStripes",static_cast<lua_Number>(BannerPattern::SmallVerticalStripes));
   tolua_constant(tolua_S,"DiagonalCross",static_cast<lua_Number>(BannerPattern::DiagonalCross));
   tolua_constant(tolua_S,"SquareCross",static_cast<lua_Number>(BannerPattern::SquareCross));
   tolua_constant(tolua_S,"LeftOfDiagonal",static_cast<lua_Number>(BannerPattern::LeftOfDiagonal));
   tolua_constant(tolua_S,"RightOfUpsideDownDiagonal",static_cast<lua_Number>(BannerPattern::RightOfUpsideDownDiagonal));
   tolua_constant(tolua_S,"LeftOfUpsideDownDiagonal",static_cast<lua_Number>(BannerPattern::LeftOfUpsideDownDiagonal));
   tolua_constant(tolua_S,"RightOfDiagonal",static_cast<lua_Number>(BannerPattern::RightOfDiagonal));
   tolua_constant(tolua_S,"VerticalHalfLeft",static_cast<lua_Number>(BannerPattern::VerticalHalfLeft));
   tolua_constant(tolua_S,"VerticalHalfRight",static_cast<lua_Number>(BannerPattern::VerticalHalfRight));
   tolua_constant(tolua_S,"HorizontalHalfTop",static_cast<lua_Number>(BannerPattern::HorizontalHalfTop));
   tolua_constant(tolua_S,"HorizontalHalfBottom",static_cast<lua_Number>(BannerPattern::HorizontalHalfBottom));
   tolua_constant(tolua_S,"BottomLeftCorner",static_cast<lua_Number>(BannerPattern::BottomLeftCorner));
   tolua_constant(tolua_S,"BottomRightCorner",static_cast<lua_Number>(BannerPattern::BottomRightCorner));
   tolua_constant(tolua_S,"TopLeftCorner",static_cast<lua_Number>(BannerPattern::TopLeftCorner));
   tolua_constant(tolua_S,"TopRightCorner",static_cast<lua_Number>(BannerPattern::TopRightCorner));
   tolua_constant(tolua_S,"BottomTriangle",static_cast<lua_Number>(BannerPattern::BottomTriangle));
   tolua_constant(tolua_S,"TopTriangle",static_cast<lua_Number>(BannerPattern::TopTriangle));
   tolua_constant(tolua_S,"BottomTriangleSawtooth",static_cast<lua_Number>(BannerPattern::BottomTriangleSawtooth));
   tolua_constant(tolua_S,"TopTriangleSawtooth",static_cast<lua_Number>(BannerPattern::TopTriangleSawtooth));
   tolua_constant(tolua_S,"MiddleCircle",static_cast<lua_Number>(BannerPattern::MiddleCircle));
   tolua_constant(tolua_S,"MiddleRhombus",static_cast<lua_Number>(BannerPattern::MiddleRhombus));
   tolua_constant(tolua_S,"Border",static_cast<lua_Number>(BannerPattern::Border));
   tolua_constant(tolua_S,"CurlyBorder",static_cast<lua_Number>(BannerPattern::CurlyBorder));
   tolua_constant(tolua_S,"Brick",static_cast<lua_Number>(BannerPattern::Brick));
   tolua_constant(tolua_S,"Gradient",static_cast<lua_Number>(BannerPattern::Gradient));
   tolua_constant(tolua_S,"GradientUpsideDown",static_cast<lua_Number>(BannerPattern::GradientUpsideDown));
   tolua_constant(tolua_S,"Creeper",static_cast<lua_Number>(BannerPattern::Creeper));
   tolua_constant(tolua_S,"Skull",static_cast<lua_Number>(BannerPattern::Skull));
   tolua_constant(tolua_S,"Flower",static_cast<lua_Number>(BannerPattern::Flower));
   tolua_constant(tolua_S,"Mojang",static_cast<lua_Number>(BannerPattern::Mojang));
   tolua_constant(tolua_S,"Globe",static_cast<lua_Number>(BannerPattern::Globe));
   tolua_constant(tolua_S,"Piglin",static_cast<lua_Number>(BannerPattern::Piglin));
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"BossBarColor",0);
  tolua_beginmodule(tolua_S,"BossBarColor");
   tolua_constant(tolua_S,"Pink",static_cast<lua_Number>(BossBarColor::Pink));
   tolua_constant(tolua_S,"Blue",static_cast<lua_Number>(BossBarColor::Blue));
   tolua_constant(tolua_S,"Red",static_cast<lua_Number>(BossBarColor::Red));
   tolua_constant(tolua_S,"Green",static_cast<lua_Number>(BossBarColor::Green));
   tolua_constant(tolua_S,"Yellow",static_cast<lua_Number>(BossBarColor::Yellow));
   tolua_constant(tolua_S,"Purple",static_cast<lua_Number>(BossBarColor::Purple));
   tolua_constant(tolua_S,"White",static_cast<lua_Number>(BossBarColor::White));
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"BossBarDivisionType",0);
  tolua_beginmodule(tolua_S,"BossBarDivisionType");
   tolua_constant(tolua_S,"None",static_cast<lua_Number>(BossBarDivisionType::None));
   tolua_constant(tolua_S,"SixNotches",static_cast<lua_Number>(BossBarDivisionType::SixNotches));
   tolua_constant(tolua_S,"TenNotches",static_cast<lua_Number>(BossBarDivisionType::TenNotches));
   tolua_constant(tolua_S,"TwelveNotches",static_cast<lua_Number>(BossBarDivisionType::TwelveNotches));
   tolua_constant(tolua_S,"TwentyNotches",static_cast<lua_Number>(BossBarDivisionType::TwentyNotches));
  tolua_endmodule(tolua_S);
  tolua_function(tolua_S,"ClickActionToString",tolua_AllToLua_ClickActionToString00);
  tolua_function(tolua_S,"MirrorBlockFaceY",tolua_AllToLua_MirrorBlockFaceY00);
  tolua_function(tolua_S,"RotateBlockFaceCCW",tolua_AllToLua_RotateBlockFaceCCW00);
  tolua_function(tolua_S,"RotateBlockFaceCW",tolua_AllToLua_RotateBlockFaceCW00);
  tolua_function(tolua_S,"ReverseBlockFace",tolua_AllToLua_ReverseBlockFace00);
  tolua_function(tolua_S,"BlockFaceToString",tolua_AllToLua_BlockFaceToString00);
  tolua_function(tolua_S,"IsValidBlock",tolua_AllToLua_IsValidBlock00);
  tolua_function(tolua_S,"IsValidItem",tolua_AllToLua_IsValidItem00);
  tolua_function(tolua_S,"StringToDimension",tolua_AllToLua_StringToDimension00);
  tolua_function(tolua_S,"DimensionToString",tolua_AllToLua_DimensionToString00);
  tolua_function(tolua_S,"DamageTypeToString",tolua_AllToLua_DamageTypeToString00);
  tolua_function(tolua_S,"StringToDamageType",tolua_AllToLua_StringToDamageType00);
  tolua_function(tolua_S,"AddFaceDirection",tolua_AllToLua_AddFaceDirection00);
  tolua_function(tolua_S,"AddFaceDirection",tolua_AllToLua_AddFaceDirection01);
  tolua_function(tolua_S,"NormalizeAngleDegrees",tolua_AllToLua_NormalizeAngleDegrees00);
  tolua_module(tolua_S,"ItemCategory",0);
  tolua_beginmodule(tolua_S,"ItemCategory");
   tolua_function(tolua_S,"IsPickaxe",tolua_AllToLua_ItemCategory_IsPickaxe00);
   tolua_function(tolua_S,"IsAxe",tolua_AllToLua_ItemCategory_IsAxe00);
   tolua_function(tolua_S,"IsSword",tolua_AllToLua_ItemCategory_IsSword00);
   tolua_function(tolua_S,"IsHoe",tolua_AllToLua_ItemCategory_IsHoe00);
   tolua_function(tolua_S,"IsShovel",tolua_AllToLua_ItemCategory_IsShovel00);
   tolua_function(tolua_S,"IsTool",tolua_AllToLua_ItemCategory_IsTool00);
   tolua_function(tolua_S,"IsHelmet",tolua_AllToLua_ItemCategory_IsHelmet00);
   tolua_function(tolua_S,"IsChestPlate",tolua_AllToLua_ItemCategory_IsChestPlate00);
   tolua_function(tolua_S,"IsLeggings",tolua_AllToLua_ItemCategory_IsLeggings00);
   tolua_function(tolua_S,"IsBoots",tolua_AllToLua_ItemCategory_IsBoots00);
   tolua_function(tolua_S,"IsMinecart",tolua_AllToLua_ItemCategory_IsMinecart00);
   tolua_function(tolua_S,"IsArmor",tolua_AllToLua_ItemCategory_IsArmor00);
   tolua_function(tolua_S,"IsHorseArmor",tolua_AllToLua_ItemCategory_IsHorseArmor00);
   tolua_function(tolua_S,"IsVillagerFood",tolua_AllToLua_ItemCategory_IsVillagerFood00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cChatColor","cChatColor","",nullptr);
  tolua_beginmodule(tolua_S,"cChatColor");
   tolua_variable(tolua_S,"Delimiter",tolua_get_cChatColor_Delimiter,nullptr);
   tolua_variable(tolua_S,"Color",tolua_get_cChatColor_Color,nullptr);
   tolua_variable(tolua_S,"Black",tolua_get_cChatColor_Black,nullptr);
   tolua_variable(tolua_S,"Navy",tolua_get_cChatColor_Navy,nullptr);
   tolua_variable(tolua_S,"Green",tolua_get_cChatColor_Green,nullptr);
   tolua_variable(tolua_S,"Blue",tolua_get_cChatColor_Blue,nullptr);
   tolua_variable(tolua_S,"Red",tolua_get_cChatColor_Red,nullptr);
   tolua_variable(tolua_S,"Purple",tolua_get_cChatColor_Purple,nullptr);
   tolua_variable(tolua_S,"Gold",tolua_get_cChatColor_Gold,nullptr);
   tolua_variable(tolua_S,"LightGray",tolua_get_cChatColor_LightGray,nullptr);
   tolua_variable(tolua_S,"Gray",tolua_get_cChatColor_Gray,nullptr);
   tolua_variable(tolua_S,"DarkPurple",tolua_get_cChatColor_DarkPurple,nullptr);
   tolua_variable(tolua_S,"LightGreen",tolua_get_cChatColor_LightGreen,nullptr);
   tolua_variable(tolua_S,"LightBlue",tolua_get_cChatColor_LightBlue,nullptr);
   tolua_variable(tolua_S,"Rose",tolua_get_cChatColor_Rose,nullptr);
   tolua_variable(tolua_S,"LightPurple",tolua_get_cChatColor_LightPurple,nullptr);
   tolua_variable(tolua_S,"Yellow",tolua_get_cChatColor_Yellow,nullptr);
   tolua_variable(tolua_S,"White",tolua_get_cChatColor_White,nullptr);
   tolua_variable(tolua_S,"Random",tolua_get_cChatColor_Random,nullptr);
   tolua_variable(tolua_S,"Bold",tolua_get_cChatColor_Bold,nullptr);
   tolua_variable(tolua_S,"Strikethrough",tolua_get_cChatColor_Strikethrough,nullptr);
   tolua_variable(tolua_S,"Underlined",tolua_get_cChatColor_Underlined,nullptr);
   tolua_variable(tolua_S,"Italic",tolua_get_cChatColor_Italic,nullptr);
   tolua_variable(tolua_S,"Plain",tolua_get_cChatColor_Plain,nullptr);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cClientHandle","cClientHandle","",nullptr);
  tolua_beginmodule(tolua_S,"cClientHandle");
   tolua_function(tolua_S,"GetIPString",tolua_AllToLua_cClientHandle_GetIPString00);
   tolua_function(tolua_S,"GetPlayer",tolua_AllToLua_cClientHandle_GetPlayer00);
   tolua_function(tolua_S,"Kick",tolua_AllToLua_cClientHandle_Kick00);
   tolua_function(tolua_S,"SendBlockBreakAnim",tolua_AllToLua_cClientHandle_SendBlockBreakAnim00);
   tolua_function(tolua_S,"SendBlockChange",tolua_AllToLua_cClientHandle_SendBlockChange00);
   tolua_function(tolua_S,"SendBossBarAdd",tolua_AllToLua_cClientHandle_SendBossBarAdd00);
   tolua_function(tolua_S,"SendBossBarUpdateFlags",tolua_AllToLua_cClientHandle_SendBossBarUpdateFlags00);
   tolua_function(tolua_S,"SendBossBarUpdateStyle",tolua_AllToLua_cClientHandle_SendBossBarUpdateStyle00);
   tolua_function(tolua_S,"SendBossBarUpdateTitle",tolua_AllToLua_cClientHandle_SendBossBarUpdateTitle00);
   tolua_function(tolua_S,"SendBossBarRemove",tolua_AllToLua_cClientHandle_SendBossBarRemove00);
   tolua_function(tolua_S,"SendBossBarUpdateHealth",tolua_AllToLua_cClientHandle_SendBossBarUpdateHealth00);
   tolua_function(tolua_S,"SendCollectEntity",tolua_AllToLua_cClientHandle_SendCollectEntity00);
   tolua_function(tolua_S,"SendDestroyEntity",tolua_AllToLua_cClientHandle_SendDestroyEntity00);
   tolua_function(tolua_S,"SendDetachEntity",tolua_AllToLua_cClientHandle_SendDetachEntity00);
   tolua_function(tolua_S,"SendEditSign",tolua_AllToLua_cClientHandle_SendEditSign00);
   tolua_function(tolua_S,"SendEntityAnimation",tolua_AllToLua_cClientHandle_SendEntityAnimation00);
   tolua_function(tolua_S,"SendHideTitle",tolua_AllToLua_cClientHandle_SendHideTitle00);
   tolua_function(tolua_S,"SendLeashEntity",tolua_AllToLua_cClientHandle_SendLeashEntity00);
   tolua_function(tolua_S,"SendPlayerListHeaderFooter",tolua_AllToLua_cClientHandle_SendPlayerListHeaderFooter00);
   tolua_function(tolua_S,"SendResourcePack",tolua_AllToLua_cClientHandle_SendResourcePack00);
   tolua_function(tolua_S,"SendResetTitle",tolua_AllToLua_cClientHandle_SendResetTitle00);
   tolua_function(tolua_S,"SendSetSubTitle",tolua_AllToLua_cClientHandle_SendSetSubTitle00);
   tolua_function(tolua_S,"SendSetRawSubTitle",tolua_AllToLua_cClientHandle_SendSetRawSubTitle00);
   tolua_function(tolua_S,"SendSetTitle",tolua_AllToLua_cClientHandle_SendSetTitle00);
   tolua_function(tolua_S,"SendSetRawTitle",tolua_AllToLua_cClientHandle_SendSetRawTitle00);
   tolua_function(tolua_S,"SendSoundEffect",tolua_AllToLua_cClientHandle_SendSoundEffect00);
   tolua_function(tolua_S,"SendSoundEffect",tolua_AllToLua_cClientHandle_SendSoundEffect01);
   tolua_function(tolua_S,"SendThunderbolt",tolua_AllToLua_cClientHandle_SendThunderbolt00);
   tolua_function(tolua_S,"SendTitleTimes",tolua_AllToLua_cClientHandle_SendTitleTimes00);
   tolua_function(tolua_S,"SendUnleashEntity",tolua_AllToLua_cClientHandle_SendUnleashEntity00);
   tolua_function(tolua_S,"GetUsername",tolua_AllToLua_cClientHandle_GetUsername00);
   tolua_function(tolua_S,"GetPing",tolua_AllToLua_cClientHandle_GetPing00);
   tolua_function(tolua_S,"SetViewDistance",tolua_AllToLua_cClientHandle_SetViewDistance00);
   tolua_function(tolua_S,"GetViewDistance",tolua_AllToLua_cClientHandle_GetViewDistance00);
   tolua_function(tolua_S,"GetRequestedViewDistance",tolua_AllToLua_cClientHandle_GetRequestedViewDistance00);
   tolua_function(tolua_S,"SetLocale",tolua_AllToLua_cClientHandle_SetLocale00);
   tolua_function(tolua_S,"GetLocale",tolua_AllToLua_cClientHandle_GetLocale00);
   tolua_function(tolua_S,"GetUniqueID",tolua_AllToLua_cClientHandle_GetUniqueID00);
   tolua_function(tolua_S,"HasPluginChannel",tolua_AllToLua_cClientHandle_HasPluginChannel00);
   tolua_function(tolua_S,"SetClientBrand",tolua_AllToLua_cClientHandle_SetClientBrand00);
   tolua_function(tolua_S,"GetClientBrand",tolua_AllToLua_cClientHandle_GetClientBrand00);
   tolua_function(tolua_S,"GetForgeMods",tolua_AllToLua_cClientHandle_GetForgeMods00);
   tolua_function(tolua_S,"IsForgeClient",tolua_AllToLua_cClientHandle_IsForgeClient00);
   tolua_function(tolua_S,"GetProtocolVersion",tolua_AllToLua_cClientHandle_GetProtocolVersion00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"cColor","cColor","",tolua_collect_cColor);
  #else
  tolua_cclass(tolua_S,"cColor","cColor","",nullptr);
  #endif
  tolua_beginmodule(tolua_S,"cColor");
   tolua_constant(tolua_S,"COLOR_MIN",cColor::COLOR_MIN);
   tolua_constant(tolua_S,"COLOR_MAX",cColor::COLOR_MAX);
   tolua_constant(tolua_S,"COLOR_LIMIT",cColor::COLOR_LIMIT);
   tolua_constant(tolua_S,"COLOR_NONE",cColor::COLOR_NONE);
   tolua_function(tolua_S,"new",tolua_AllToLua_cColor_new00);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cColor_new00_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cColor_new00_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_cColor_new01);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cColor_new01_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cColor_new01_local);
   tolua_function(tolua_S,"IsValid",tolua_AllToLua_cColor_IsValid00);
   tolua_function(tolua_S,"SetColor",tolua_AllToLua_cColor_SetColor00);
   tolua_function(tolua_S,"SetRed",tolua_AllToLua_cColor_SetRed00);
   tolua_function(tolua_S,"SetGreen",tolua_AllToLua_cColor_SetGreen00);
   tolua_function(tolua_S,"SetBlue",tolua_AllToLua_cColor_SetBlue00);
   tolua_function(tolua_S,"GetRed",tolua_AllToLua_cColor_GetRed00);
   tolua_function(tolua_S,"GetGreen",tolua_AllToLua_cColor_GetGreen00);
   tolua_function(tolua_S,"GetBlue",tolua_AllToLua_cColor_GetBlue00);
   tolua_function(tolua_S,"Clear",tolua_AllToLua_cColor_Clear00);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"EffectID",0);
  tolua_beginmodule(tolua_S,"EffectID");
   tolua_constant(tolua_S,"SFX_RANDOM_DISPENSER_DISPENSE",static_cast<lua_Number>(EffectID::SFX_RANDOM_DISPENSER_DISPENSE));
   tolua_constant(tolua_S,"SFX_RANDOM_DISPENSER_DISPENSE_FAIL",static_cast<lua_Number>(EffectID::SFX_RANDOM_DISPENSER_DISPENSE_FAIL));
   tolua_constant(tolua_S,"SFX_RANDOM_DISPENSER_SHOOT",static_cast<lua_Number>(EffectID::SFX_RANDOM_DISPENSER_SHOOT));
   tolua_constant(tolua_S,"SFX_RANDOM_ENDER_EYE_LAUNCH",static_cast<lua_Number>(EffectID::SFX_RANDOM_ENDER_EYE_LAUNCH));
   tolua_constant(tolua_S,"SFX_RANDOM_FIREWORK_SHOT",static_cast<lua_Number>(EffectID::SFX_RANDOM_FIREWORK_SHOT));
   tolua_constant(tolua_S,"SFX_RANDOM_IRON_DOOR_OPEN",static_cast<lua_Number>(EffectID::SFX_RANDOM_IRON_DOOR_OPEN));
   tolua_constant(tolua_S,"SFX_RANDOM_WOODEN_DOOR_OPEN",static_cast<lua_Number>(EffectID::SFX_RANDOM_WOODEN_DOOR_OPEN));
   tolua_constant(tolua_S,"SFX_RANDOM_WOODEN_TRAPDOOR_OPEN",static_cast<lua_Number>(EffectID::SFX_RANDOM_WOODEN_TRAPDOOR_OPEN));
   tolua_constant(tolua_S,"SFX_RANDOM_FENCE_GATE_OPEN",static_cast<lua_Number>(EffectID::SFX_RANDOM_FENCE_GATE_OPEN));
   tolua_constant(tolua_S,"SFX_RANDOM_FIRE_EXTINGUISH",static_cast<lua_Number>(EffectID::SFX_RANDOM_FIRE_EXTINGUISH));
   tolua_constant(tolua_S,"SFX_RANDOM_PLAY_MUSIC_DISC",static_cast<lua_Number>(EffectID::SFX_RANDOM_PLAY_MUSIC_DISC));
   tolua_constant(tolua_S,"SFX_RANDOM_IRON_DOOR_CLOSE",static_cast<lua_Number>(EffectID::SFX_RANDOM_IRON_DOOR_CLOSE));
   tolua_constant(tolua_S,"SFX_RANDOM_WOODEN_DOOR_CLOSE",static_cast<lua_Number>(EffectID::SFX_RANDOM_WOODEN_DOOR_CLOSE));
   tolua_constant(tolua_S,"SFX_RANDOM_WOODEN_TRAPDOOR_CLOSE",static_cast<lua_Number>(EffectID::SFX_RANDOM_WOODEN_TRAPDOOR_CLOSE));
   tolua_constant(tolua_S,"SFX_RANDOM_FENCE_GATE_CLOSE",static_cast<lua_Number>(EffectID::SFX_RANDOM_FENCE_GATE_CLOSE));
   tolua_constant(tolua_S,"SFX_MOB_GHAST_WARN",static_cast<lua_Number>(EffectID::SFX_MOB_GHAST_WARN));
   tolua_constant(tolua_S,"SFX_MOB_GHAST_SHOOT",static_cast<lua_Number>(EffectID::SFX_MOB_GHAST_SHOOT));
   tolua_constant(tolua_S,"SFX_MOB_ENDERDRAGON_SHOOT",static_cast<lua_Number>(EffectID::SFX_MOB_ENDERDRAGON_SHOOT));
   tolua_constant(tolua_S,"SFX_MOB_BLAZE_SHOOT",static_cast<lua_Number>(EffectID::SFX_MOB_BLAZE_SHOOT));
   tolua_constant(tolua_S,"SFX_MOB_ZOMBIE_WOOD",static_cast<lua_Number>(EffectID::SFX_MOB_ZOMBIE_WOOD));
   tolua_constant(tolua_S,"SFX_MOB_ZOMBIE_METAL",static_cast<lua_Number>(EffectID::SFX_MOB_ZOMBIE_METAL));
   tolua_constant(tolua_S,"SFX_MOB_ZOMBIE_WOOD_BREAK",static_cast<lua_Number>(EffectID::SFX_MOB_ZOMBIE_WOOD_BREAK));
   tolua_constant(tolua_S,"SFX_MOB_WITHER_BREAK_BLOCK",static_cast<lua_Number>(EffectID::SFX_MOB_WITHER_BREAK_BLOCK));
   tolua_constant(tolua_S,"SFX_MOB_WITHER_SPAWN",static_cast<lua_Number>(EffectID::SFX_MOB_WITHER_SPAWN));
   tolua_constant(tolua_S,"SFX_MOB_WITHER_SHOOT",static_cast<lua_Number>(EffectID::SFX_MOB_WITHER_SHOOT));
   tolua_constant(tolua_S,"SFX_MOB_BAT_TAKEOFF",static_cast<lua_Number>(EffectID::SFX_MOB_BAT_TAKEOFF));
   tolua_constant(tolua_S,"SFX_MOB_ZOMBIE_INFECT",static_cast<lua_Number>(EffectID::SFX_MOB_ZOMBIE_INFECT));
   tolua_constant(tolua_S,"SFX_MOB_ZOMBIE_UNFECT",static_cast<lua_Number>(EffectID::SFX_MOB_ZOMBIE_UNFECT));
   tolua_constant(tolua_S,"SFX_MOB_ENDERDRAGON_DEATH",static_cast<lua_Number>(EffectID::SFX_MOB_ENDERDRAGON_DEATH));
   tolua_constant(tolua_S,"SFX_RANDOM_ANVIL_BREAK",static_cast<lua_Number>(EffectID::SFX_RANDOM_ANVIL_BREAK));
   tolua_constant(tolua_S,"SFX_RANDOM_ANVIL_USE",static_cast<lua_Number>(EffectID::SFX_RANDOM_ANVIL_USE));
   tolua_constant(tolua_S,"SFX_RANDOM_ANVIL_LAND",static_cast<lua_Number>(EffectID::SFX_RANDOM_ANVIL_LAND));
   tolua_constant(tolua_S,"SFX_RANDOM_PORTAL_TRAVEL",static_cast<lua_Number>(EffectID::SFX_RANDOM_PORTAL_TRAVEL));
   tolua_constant(tolua_S,"SFX_RANDOM_CHORUS_FLOWER_GROW",static_cast<lua_Number>(EffectID::SFX_RANDOM_CHORUS_FLOWER_GROW));
   tolua_constant(tolua_S,"SFX_RANDOM_CHORUS_FLOWER_DEATH",static_cast<lua_Number>(EffectID::SFX_RANDOM_CHORUS_FLOWER_DEATH));
   tolua_constant(tolua_S,"SFX_RANDOM_BREWING_STAND_BREW",static_cast<lua_Number>(EffectID::SFX_RANDOM_BREWING_STAND_BREW));
   tolua_constant(tolua_S,"SFX_RANDOM_IRON_TRAPDOOR_OPEN",static_cast<lua_Number>(EffectID::SFX_RANDOM_IRON_TRAPDOOR_OPEN));
   tolua_constant(tolua_S,"SFX_RANDOM_IRON_TRAPDOOR_CLOSE",static_cast<lua_Number>(EffectID::SFX_RANDOM_IRON_TRAPDOOR_CLOSE));
   tolua_constant(tolua_S,"PARTICLE_SMOKE",static_cast<lua_Number>(EffectID::PARTICLE_SMOKE));
   tolua_constant(tolua_S,"PARTICLE_BLOCK_BREAK",static_cast<lua_Number>(EffectID::PARTICLE_BLOCK_BREAK));
   tolua_constant(tolua_S,"PARTICLE_SPLASH_POTION",static_cast<lua_Number>(EffectID::PARTICLE_SPLASH_POTION));
   tolua_constant(tolua_S,"PARTICLE_EYE_OF_ENDER",static_cast<lua_Number>(EffectID::PARTICLE_EYE_OF_ENDER));
   tolua_constant(tolua_S,"PARTICLE_MOBSPAWN",static_cast<lua_Number>(EffectID::PARTICLE_MOBSPAWN));
   tolua_constant(tolua_S,"PARTICLE_HAPPY_VILLAGER",static_cast<lua_Number>(EffectID::PARTICLE_HAPPY_VILLAGER));
   tolua_constant(tolua_S,"PARTICLE_DRAGON_BREATH",static_cast<lua_Number>(EffectID::PARTICLE_DRAGON_BREATH));
   tolua_constant(tolua_S,"PARTICLE_END_GATEWAY_SPAWN",static_cast<lua_Number>(EffectID::PARTICLE_END_GATEWAY_SPAWN));
   tolua_constant(tolua_S,"PARTICLE_ENDERDRAGON_GROWL",static_cast<lua_Number>(EffectID::PARTICLE_ENDERDRAGON_GROWL));
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"SmokeDirection",0);
  tolua_beginmodule(tolua_S,"SmokeDirection");
   tolua_constant(tolua_S,"SOUTH_EAST",static_cast<lua_Number>(SmokeDirection::SOUTH_EAST));
   tolua_constant(tolua_S,"SOUTH",static_cast<lua_Number>(SmokeDirection::SOUTH));
   tolua_constant(tolua_S,"SOUTH_WEST",static_cast<lua_Number>(SmokeDirection::SOUTH_WEST));
   tolua_constant(tolua_S,"EAST",static_cast<lua_Number>(SmokeDirection::EAST));
   tolua_constant(tolua_S,"CENTRE",static_cast<lua_Number>(SmokeDirection::CENTRE));
   tolua_constant(tolua_S,"WEST",static_cast<lua_Number>(SmokeDirection::WEST));
   tolua_constant(tolua_S,"NORTH_EAST",static_cast<lua_Number>(SmokeDirection::NORTH_EAST));
   tolua_constant(tolua_S,"NORTH",static_cast<lua_Number>(SmokeDirection::NORTH));
   tolua_constant(tolua_S,"NORTH_WEST",static_cast<lua_Number>(SmokeDirection::NORTH_WEST));
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cServer","cServer","",nullptr);
  tolua_beginmodule(tolua_S,"cServer");
   tolua_function(tolua_S,"GetDescription",tolua_AllToLua_cServer_GetDescription00);
   tolua_function(tolua_S,"GetShutdownMessage",tolua_AllToLua_cServer_GetShutdownMessage00);
   tolua_function(tolua_S,"GetMaxPlayers",tolua_AllToLua_cServer_GetMaxPlayers00);
   tolua_function(tolua_S,"GetNumPlayers",tolua_AllToLua_cServer_GetNumPlayers00);
   tolua_function(tolua_S,"SetMaxPlayers",tolua_AllToLua_cServer_SetMaxPlayers00);
   tolua_function(tolua_S,"UnregisterForgeMod",tolua_AllToLua_cServer_UnregisterForgeMod00);
   tolua_function(tolua_S,"IsPlayerInQueue",tolua_AllToLua_cServer_IsPlayerInQueue00);
   tolua_function(tolua_S,"DoesAllowMultiLogin",tolua_AllToLua_cServer_DoesAllowMultiLogin00);
   tolua_function(tolua_S,"IsHardcore",tolua_AllToLua_cServer_IsHardcore00);
   tolua_function(tolua_S,"GetServerID",tolua_AllToLua_cServer_GetServerID00);
   tolua_function(tolua_S,"ShouldAuthenticate",tolua_AllToLua_cServer_ShouldAuthenticate00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cWorld","cWorld","",nullptr);
  tolua_beginmodule(tolua_S,"cWorld");
   tolua_function(tolua_S,"IsSavingEnabled",tolua_AllToLua_cWorld_IsSavingEnabled00);
   tolua_function(tolua_S,"SetSavingEnabled",tolua_AllToLua_cWorld_SetSavingEnabled00);
   tolua_function(tolua_S,"GetTicksUntilWeatherChange",tolua_AllToLua_cWorld_GetTicksUntilWeatherChange00);
   tolua_function(tolua_S,"IsDaylightCycleEnabled",tolua_AllToLua_cWorld_IsDaylightCycleEnabled00);
   tolua_function(tolua_S,"SetDaylightCycleEnabled",tolua_AllToLua_cWorld_SetDaylightCycleEnabled00);
   tolua_function(tolua_S,"SetTicksUntilWeatherChange",tolua_AllToLua_cWorld_SetTicksUntilWeatherChange00);
   tolua_function(tolua_S,"GetDefaultWeatherInterval",tolua_AllToLua_cWorld_GetDefaultWeatherInterval00);
   tolua_function(tolua_S,"GetGameMode",tolua_AllToLua_cWorld_GetGameMode00);
   tolua_function(tolua_S,"IsGameModeCreative",tolua_AllToLua_cWorld_IsGameModeCreative00);
   tolua_function(tolua_S,"IsGameModeSurvival",tolua_AllToLua_cWorld_IsGameModeSurvival00);
   tolua_function(tolua_S,"IsGameModeAdventure",tolua_AllToLua_cWorld_IsGameModeAdventure00);
   tolua_function(tolua_S,"IsGameModeSpectator",tolua_AllToLua_cWorld_IsGameModeSpectator00);
   tolua_function(tolua_S,"IsPVPEnabled",tolua_AllToLua_cWorld_IsPVPEnabled00);
   tolua_function(tolua_S,"IsFarmlandTramplingEnabled",tolua_AllToLua_cWorld_IsFarmlandTramplingEnabled00);
   tolua_function(tolua_S,"IsDeepSnowEnabled",tolua_AllToLua_cWorld_IsDeepSnowEnabled00);
   tolua_function(tolua_S,"ShouldLavaSpawnFire",tolua_AllToLua_cWorld_ShouldLavaSpawnFire00);
   tolua_function(tolua_S,"VillagersShouldHarvestCrops",tolua_AllToLua_cWorld_VillagersShouldHarvestCrops00);
   tolua_function(tolua_S,"GetDimension",tolua_AllToLua_cWorld_GetDimension00);
   tolua_function(tolua_S,"GetHeight",tolua_AllToLua_cWorld_GetHeight00);
   tolua_function(tolua_S,"BroadcastChat",tolua_AllToLua_cWorld_BroadcastChat00);
   tolua_function(tolua_S,"BroadcastChatInfo",tolua_AllToLua_cWorld_BroadcastChatInfo00);
   tolua_function(tolua_S,"BroadcastChatFailure",tolua_AllToLua_cWorld_BroadcastChatFailure00);
   tolua_function(tolua_S,"BroadcastChatSuccess",tolua_AllToLua_cWorld_BroadcastChatSuccess00);
   tolua_function(tolua_S,"BroadcastChatWarning",tolua_AllToLua_cWorld_BroadcastChatWarning00);
   tolua_function(tolua_S,"BroadcastChatFatal",tolua_AllToLua_cWorld_BroadcastChatFatal00);
   tolua_function(tolua_S,"BroadcastChatDeath",tolua_AllToLua_cWorld_BroadcastChatDeath00);
   tolua_function(tolua_S,"BroadcastChat",tolua_AllToLua_cWorld_BroadcastChat01);
   tolua_function(tolua_S,"BroadcastEntityAnimation",tolua_AllToLua_cWorld_BroadcastEntityAnimation00);
   tolua_function(tolua_S,"BroadcastPlayerListHeaderFooter",tolua_AllToLua_cWorld_BroadcastPlayerListHeaderFooter00);
   tolua_function(tolua_S,"QueueUnloadUnusedChunks",tolua_AllToLua_cWorld_QueueUnloadUnusedChunks00);
   tolua_function(tolua_S,"SetCommandBlockCommand",tolua_AllToLua_cWorld_SetCommandBlockCommand00);
   tolua_function(tolua_S,"IsTrapdoorOpen",tolua_AllToLua_cWorld_IsTrapdoorOpen00);
   tolua_function(tolua_S,"SetTrapdoorOpen",tolua_AllToLua_cWorld_SetTrapdoorOpen00);
   tolua_function(tolua_S,"RegenerateChunk",tolua_AllToLua_cWorld_RegenerateChunk00);
   tolua_function(tolua_S,"GenerateChunk",tolua_AllToLua_cWorld_GenerateChunk00);
   tolua_function(tolua_S,"SpawnItemPickups",tolua_AllToLua_cWorld_SpawnItemPickups00);
   tolua_function(tolua_S,"SpawnItemPickups",tolua_AllToLua_cWorld_SpawnItemPickups01);
   tolua_function(tolua_S,"SpawnItemPickups",tolua_AllToLua_cWorld_SpawnItemPickups02);
   tolua_function(tolua_S,"SpawnItemPickups",tolua_AllToLua_cWorld_SpawnItemPickups03);
   tolua_function(tolua_S,"SpawnItemPickups",tolua_AllToLua_cWorld_SpawnItemPickups04);
   tolua_function(tolua_S,"SpawnItemPickup",tolua_AllToLua_cWorld_SpawnItemPickup00);
   tolua_function(tolua_S,"SpawnItemPickup",tolua_AllToLua_cWorld_SpawnItemPickup01);
   tolua_function(tolua_S,"SpawnFallingBlock",tolua_AllToLua_cWorld_SpawnFallingBlock00);
   tolua_function(tolua_S,"SpawnFallingBlock",tolua_AllToLua_cWorld_SpawnFallingBlock01);
   tolua_function(tolua_S,"SpawnFallingBlock",tolua_AllToLua_cWorld_SpawnFallingBlock02);
   tolua_function(tolua_S,"SpawnMinecart",tolua_AllToLua_cWorld_SpawnMinecart00);
   tolua_function(tolua_S,"SpawnMinecart",tolua_AllToLua_cWorld_SpawnMinecart01);
   tolua_function(tolua_S,"SpawnMinecart",tolua_AllToLua_cWorld_SpawnMinecart02);
   tolua_function(tolua_S,"SpawnMinecart",tolua_AllToLua_cWorld_SpawnMinecart03);
   tolua_function(tolua_S,"SpawnBoat",tolua_AllToLua_cWorld_SpawnBoat00);
   tolua_function(tolua_S,"SpawnBoat",tolua_AllToLua_cWorld_SpawnBoat01);
   tolua_function(tolua_S,"SpawnExperienceOrb",tolua_AllToLua_cWorld_SpawnExperienceOrb00);
   tolua_function(tolua_S,"SpawnExperienceOrb",tolua_AllToLua_cWorld_SpawnExperienceOrb01);
   tolua_function(tolua_S,"SpawnPrimedTNT",tolua_AllToLua_cWorld_SpawnPrimedTNT00);
   tolua_function(tolua_S,"SpawnPrimedTNT",tolua_AllToLua_cWorld_SpawnPrimedTNT01);
   tolua_function(tolua_S,"SpawnEnderCrystal",tolua_AllToLua_cWorld_SpawnEnderCrystal00);
   tolua_function(tolua_S,"DigBlock",tolua_AllToLua_cWorld_DigBlock00);
   tolua_function(tolua_S,"DigBlock",tolua_AllToLua_cWorld_DigBlock01);
   tolua_function(tolua_S,"DropBlockAsPickups",tolua_AllToLua_cWorld_DropBlockAsPickups00);
   tolua_function(tolua_S,"PickupsFromBlock",tolua_AllToLua_cWorld_PickupsFromBlock00);
   tolua_function(tolua_S,"SendBlockTo",tolua_AllToLua_cWorld_SendBlockTo00);
   tolua_function(tolua_S,"SetSpawn",tolua_AllToLua_cWorld_SetSpawn00);
   tolua_function(tolua_S,"GetSpawnX",tolua_AllToLua_cWorld_GetSpawnX00);
   tolua_function(tolua_S,"GetSpawnY",tolua_AllToLua_cWorld_GetSpawnY00);
   tolua_function(tolua_S,"GetSpawnZ",tolua_AllToLua_cWorld_GetSpawnZ00);
   tolua_function(tolua_S,"WakeUpSimulators",tolua_AllToLua_cWorld_WakeUpSimulators00);
   tolua_function(tolua_S,"WakeUpSimulatorsInArea",tolua_AllToLua_cWorld_WakeUpSimulatorsInArea00);
   tolua_function(tolua_S,"UseBlockEntity",tolua_AllToLua_cWorld_UseBlockEntity00);
   tolua_function(tolua_S,"GrowPlantAt",tolua_AllToLua_cWorld_GrowPlantAt00);
   tolua_function(tolua_S,"GrowRipePlant",tolua_AllToLua_cWorld_GrowRipePlant00);
   tolua_function(tolua_S,"GrowRipePlant",tolua_AllToLua_cWorld_GrowRipePlant01);
   tolua_function(tolua_S,"GetBiomeAt",tolua_AllToLua_cWorld_GetBiomeAt00);
   tolua_function(tolua_S,"SetBiomeAt",tolua_AllToLua_cWorld_SetBiomeAt00);
   tolua_function(tolua_S,"SetAreaBiome",tolua_AllToLua_cWorld_SetAreaBiome00);
   tolua_function(tolua_S,"SetAreaBiome",tolua_AllToLua_cWorld_SetAreaBiome01);
   tolua_function(tolua_S,"GetName",tolua_AllToLua_cWorld_GetName00);
   tolua_function(tolua_S,"GetDataPath",tolua_AllToLua_cWorld_GetDataPath00);
   tolua_function(tolua_S,"GetIniFileName",tolua_AllToLua_cWorld_GetIniFileName00);
   tolua_function(tolua_S,"GetScoreBoard",tolua_AllToLua_cWorld_GetScoreBoard00);
   tolua_function(tolua_S,"GetMapManager",tolua_AllToLua_cWorld_GetMapManager00);
   tolua_function(tolua_S,"AreCommandBlocksEnabled",tolua_AllToLua_cWorld_AreCommandBlocksEnabled00);
   tolua_function(tolua_S,"SetCommandBlocksEnabled",tolua_AllToLua_cWorld_SetCommandBlocksEnabled00);
   tolua_function(tolua_S,"GetTNTShrapnelLevel",tolua_AllToLua_cWorld_GetTNTShrapnelLevel00);
   tolua_function(tolua_S,"SetTNTShrapnelLevel",tolua_AllToLua_cWorld_SetTNTShrapnelLevel00);
   tolua_function(tolua_S,"GetMaxViewDistance",tolua_AllToLua_cWorld_GetMaxViewDistance00);
   tolua_function(tolua_S,"SetMaxViewDistance",tolua_AllToLua_cWorld_SetMaxViewDistance00);
   tolua_function(tolua_S,"ShouldUseChatPrefixes",tolua_AllToLua_cWorld_ShouldUseChatPrefixes00);
   tolua_function(tolua_S,"SetShouldUseChatPrefixes",tolua_AllToLua_cWorld_SetShouldUseChatPrefixes00);
   tolua_function(tolua_S,"ShouldBroadcastDeathMessages",tolua_AllToLua_cWorld_ShouldBroadcastDeathMessages00);
   tolua_function(tolua_S,"ShouldBroadcastAchievementMessages",tolua_AllToLua_cWorld_ShouldBroadcastAchievementMessages00);
   tolua_function(tolua_S,"GetLinkedNetherWorldName",tolua_AllToLua_cWorld_GetLinkedNetherWorldName00);
   tolua_function(tolua_S,"SetLinkedNetherWorldName",tolua_AllToLua_cWorld_SetLinkedNetherWorldName00);
   tolua_function(tolua_S,"GetLinkedEndWorldName",tolua_AllToLua_cWorld_GetLinkedEndWorldName00);
   tolua_function(tolua_S,"SetLinkedEndWorldName",tolua_AllToLua_cWorld_SetLinkedEndWorldName00);
   tolua_function(tolua_S,"GetLinkedOverworldName",tolua_AllToLua_cWorld_GetLinkedOverworldName00);
   tolua_function(tolua_S,"SetLinkedOverworldName",tolua_AllToLua_cWorld_SetLinkedOverworldName00);
   tolua_function(tolua_S,"GetMinNetherPortalWidth",tolua_AllToLua_cWorld_GetMinNetherPortalWidth00);
   tolua_function(tolua_S,"GetMaxNetherPortalWidth",tolua_AllToLua_cWorld_GetMaxNetherPortalWidth00);
   tolua_function(tolua_S,"SetMinNetherPortalWidth",tolua_AllToLua_cWorld_SetMinNetherPortalWidth00);
   tolua_function(tolua_S,"SetMaxNetherPortalWidth",tolua_AllToLua_cWorld_SetMaxNetherPortalWidth00);
   tolua_function(tolua_S,"GetMinNetherPortalHeight",tolua_AllToLua_cWorld_GetMinNetherPortalHeight00);
   tolua_function(tolua_S,"GetMaxNetherPortalHeight",tolua_AllToLua_cWorld_GetMaxNetherPortalHeight00);
   tolua_function(tolua_S,"SetMinNetherPortalHeight",tolua_AllToLua_cWorld_SetMinNetherPortalHeight00);
   tolua_function(tolua_S,"SetMaxNetherPortalHeight",tolua_AllToLua_cWorld_SetMaxNetherPortalHeight00);
   tolua_function(tolua_S,"QueueSaveAllChunks",tolua_AllToLua_cWorld_QueueSaveAllChunks00);
   tolua_function(tolua_S,"GetNumChunks",tolua_AllToLua_cWorld_GetNumChunks00);
   tolua_function(tolua_S,"GetNumUnusedDirtyChunks",tolua_AllToLua_cWorld_GetNumUnusedDirtyChunks00);
   tolua_function(tolua_S,"GetGeneratorQueueLength",tolua_AllToLua_cWorld_GetGeneratorQueueLength00);
   tolua_function(tolua_S,"GetLightingQueueLength",tolua_AllToLua_cWorld_GetLightingQueueLength00);
   tolua_function(tolua_S,"GetStorageLoadQueueLength",tolua_AllToLua_cWorld_GetStorageLoadQueueLength00);
   tolua_function(tolua_S,"GetStorageSaveQueueLength",tolua_AllToLua_cWorld_GetStorageSaveQueueLength00);
   tolua_function(tolua_S,"QueueBlockForTick",tolua_AllToLua_cWorld_QueueBlockForTick00);
   tolua_function(tolua_S,"CastThunderbolt",tolua_AllToLua_cWorld_CastThunderbolt00);
   tolua_function(tolua_S,"CastThunderbolt",tolua_AllToLua_cWorld_CastThunderbolt01);
   tolua_function(tolua_S,"SetWeather",tolua_AllToLua_cWorld_SetWeather00);
   tolua_function(tolua_S,"ChangeWeather",tolua_AllToLua_cWorld_ChangeWeather00);
   tolua_function(tolua_S,"GetWeather",tolua_AllToLua_cWorld_GetWeather00);
   tolua_function(tolua_S,"IsWeatherSunny",tolua_AllToLua_cWorld_IsWeatherSunny00);
   tolua_function(tolua_S,"IsWeatherSunnyAt",tolua_AllToLua_cWorld_IsWeatherSunnyAt00);
   tolua_function(tolua_S,"IsWeatherRain",tolua_AllToLua_cWorld_IsWeatherRain00);
   tolua_function(tolua_S,"IsWeatherRainAt",tolua_AllToLua_cWorld_IsWeatherRainAt00);
   tolua_function(tolua_S,"IsWeatherStorm",tolua_AllToLua_cWorld_IsWeatherStorm00);
   tolua_function(tolua_S,"IsWeatherStormAt",tolua_AllToLua_cWorld_IsWeatherStormAt00);
   tolua_function(tolua_S,"IsWeatherWet",tolua_AllToLua_cWorld_IsWeatherWet00);
   tolua_function(tolua_S,"IsWeatherWetAt",tolua_AllToLua_cWorld_IsWeatherWetAt00);
   tolua_function(tolua_S,"IsWeatherWetAtXYZ",tolua_AllToLua_cWorld_IsWeatherWetAtXYZ00);
   tolua_function(tolua_S,"GetSeed",tolua_AllToLua_cWorld_GetSeed00);
   tolua_function(tolua_S,"SetNextBlockToTick",tolua_AllToLua_cWorld_SetNextBlockToTick00);
   tolua_function(tolua_S,"GetMaxSugarcaneHeight",tolua_AllToLua_cWorld_GetMaxSugarcaneHeight00);
   tolua_function(tolua_S,"GetMaxCactusHeight",tolua_AllToLua_cWorld_GetMaxCactusHeight00);
   tolua_function(tolua_S,"IsBlockDirectlyWatered",tolua_AllToLua_cWorld_IsBlockDirectlyWatered00);
   tolua_function(tolua_S,"SpawnMob",tolua_AllToLua_cWorld_SpawnMob00);
   tolua_function(tolua_S,"CreateProjectile",tolua_AllToLua_cWorld_CreateProjectile00);
   tolua_function(tolua_S,"CreateProjectile",tolua_AllToLua_cWorld_CreateProjectile01);
   tolua_function(tolua_S,"SetChunkAlwaysTicked",tolua_AllToLua_cWorld_SetChunkAlwaysTicked00);
   tolua_function(tolua_S,"IsSlimeChunk",tolua_AllToLua_cWorld_IsSlimeChunk00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cInventory","cInventory","",nullptr);
  tolua_beginmodule(tolua_S,"cInventory");
   tolua_constant(tolua_S,"invArmorCount",cInventory::invArmorCount);
   tolua_constant(tolua_S,"invInventoryCount",cInventory::invInventoryCount);
   tolua_constant(tolua_S,"invHotbarCount",cInventory::invHotbarCount);
   tolua_constant(tolua_S,"invShieldCount",cInventory::invShieldCount);
   tolua_constant(tolua_S,"invArmorOffset",cInventory::invArmorOffset);
   tolua_constant(tolua_S,"invInventoryOffset",cInventory::invInventoryOffset);
   tolua_constant(tolua_S,"invHotbarOffset",cInventory::invHotbarOffset);
   tolua_constant(tolua_S,"invShieldOffset",cInventory::invShieldOffset);
   tolua_constant(tolua_S,"invNumSlots",cInventory::invNumSlots);
   tolua_function(tolua_S,"Clear",tolua_AllToLua_cInventory_Clear00);
   tolua_function(tolua_S,"HowManyCanFit",tolua_AllToLua_cInventory_HowManyCanFit00);
   tolua_function(tolua_S,"HowManyCanFit",tolua_AllToLua_cInventory_HowManyCanFit01);
   tolua_function(tolua_S,"AddItem",tolua_AllToLua_cInventory_AddItem00);
   tolua_function(tolua_S,"AddItems",tolua_AllToLua_cInventory_AddItems00);
   tolua_function(tolua_S,"RemoveItem",tolua_AllToLua_cInventory_RemoveItem00);
   tolua_function(tolua_S,"FindItem",tolua_AllToLua_cInventory_FindItem00);
   tolua_function(tolua_S,"RemoveOneEquippedItem",tolua_AllToLua_cInventory_RemoveOneEquippedItem00);
   tolua_function(tolua_S,"ReplaceOneEquippedItem",tolua_AllToLua_cInventory_ReplaceOneEquippedItem00);
   tolua_function(tolua_S,"HowManyItems",tolua_AllToLua_cInventory_HowManyItems00);
   tolua_function(tolua_S,"HasItems",tolua_AllToLua_cInventory_HasItems00);
   tolua_function(tolua_S,"SendEquippedSlot",tolua_AllToLua_cInventory_SendEquippedSlot00);
   tolua_function(tolua_S,"GetArmorGrid",tolua_AllToLua_cInventory_GetArmorGrid00);
   tolua_function(tolua_S,"GetInventoryGrid",tolua_AllToLua_cInventory_GetInventoryGrid00);
   tolua_function(tolua_S,"GetHotbarGrid",tolua_AllToLua_cInventory_GetHotbarGrid00);
   tolua_function(tolua_S,"GetOwner",tolua_AllToLua_cInventory_GetOwner00);
   tolua_function(tolua_S,"CopyToItems",tolua_AllToLua_cInventory_CopyToItems00);
   tolua_function(tolua_S,"GetSlot",tolua_AllToLua_cInventory_GetSlot00);
   tolua_function(tolua_S,"GetArmorSlot",tolua_AllToLua_cInventory_GetArmorSlot00);
   tolua_function(tolua_S,"GetInventorySlot",tolua_AllToLua_cInventory_GetInventorySlot00);
   tolua_function(tolua_S,"GetHotbarSlot",tolua_AllToLua_cInventory_GetHotbarSlot00);
   tolua_function(tolua_S,"GetShieldSlot",tolua_AllToLua_cInventory_GetShieldSlot00);
   tolua_function(tolua_S,"GetEquippedItem",tolua_AllToLua_cInventory_GetEquippedItem00);
   tolua_function(tolua_S,"SetSlot",tolua_AllToLua_cInventory_SetSlot00);
   tolua_function(tolua_S,"SetArmorSlot",tolua_AllToLua_cInventory_SetArmorSlot00);
   tolua_function(tolua_S,"SetInventorySlot",tolua_AllToLua_cInventory_SetInventorySlot00);
   tolua_function(tolua_S,"SetHotbarSlot",tolua_AllToLua_cInventory_SetHotbarSlot00);
   tolua_function(tolua_S,"SetShieldSlot",tolua_AllToLua_cInventory_SetShieldSlot00);
   tolua_function(tolua_S,"SetEquippedItem",tolua_AllToLua_cInventory_SetEquippedItem00);
   tolua_function(tolua_S,"SetEquippedSlotNum",tolua_AllToLua_cInventory_SetEquippedSlotNum00);
   tolua_function(tolua_S,"GetEquippedSlotNum",tolua_AllToLua_cInventory_GetEquippedSlotNum00);
   tolua_function(tolua_S,"ChangeSlotCount",tolua_AllToLua_cInventory_ChangeSlotCount00);
   tolua_function(tolua_S,"DamageItem",tolua_AllToLua_cInventory_DamageItem00);
   tolua_function(tolua_S,"DamageEquippedItem",tolua_AllToLua_cInventory_DamageEquippedItem00);
   tolua_function(tolua_S,"GetEquippedHelmet",tolua_AllToLua_cInventory_GetEquippedHelmet00);
   tolua_function(tolua_S,"GetEquippedChestplate",tolua_AllToLua_cInventory_GetEquippedChestplate00);
   tolua_function(tolua_S,"GetEquippedLeggings",tolua_AllToLua_cInventory_GetEquippedLeggings00);
   tolua_function(tolua_S,"GetEquippedBoots",tolua_AllToLua_cInventory_GetEquippedBoots00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"cEnchantments","cEnchantments","",tolua_collect_cEnchantments);
  #else
  tolua_cclass(tolua_S,"cEnchantments","cEnchantments","",nullptr);
  #endif
  tolua_beginmodule(tolua_S,"cEnchantments");
   tolua_constant(tolua_S,"enchProtection",cEnchantments::enchProtection);
   tolua_constant(tolua_S,"enchFireProtection",cEnchantments::enchFireProtection);
   tolua_constant(tolua_S,"enchFeatherFalling",cEnchantments::enchFeatherFalling);
   tolua_constant(tolua_S,"enchBlastProtection",cEnchantments::enchBlastProtection);
   tolua_constant(tolua_S,"enchProjectileProtection",cEnchantments::enchProjectileProtection);
   tolua_constant(tolua_S,"enchRespiration",cEnchantments::enchRespiration);
   tolua_constant(tolua_S,"enchAquaAffinity",cEnchantments::enchAquaAffinity);
   tolua_constant(tolua_S,"enchThorns",cEnchantments::enchThorns);
   tolua_constant(tolua_S,"enchDepthStrider",cEnchantments::enchDepthStrider);
   tolua_constant(tolua_S,"enchSharpness",cEnchantments::enchSharpness);
   tolua_constant(tolua_S,"enchSmite",cEnchantments::enchSmite);
   tolua_constant(tolua_S,"enchBaneOfArthropods",cEnchantments::enchBaneOfArthropods);
   tolua_constant(tolua_S,"enchKnockback",cEnchantments::enchKnockback);
   tolua_constant(tolua_S,"enchFireAspect",cEnchantments::enchFireAspect);
   tolua_constant(tolua_S,"enchLooting",cEnchantments::enchLooting);
   tolua_constant(tolua_S,"enchEfficiency",cEnchantments::enchEfficiency);
   tolua_constant(tolua_S,"enchSilkTouch",cEnchantments::enchSilkTouch);
   tolua_constant(tolua_S,"enchUnbreaking",cEnchantments::enchUnbreaking);
   tolua_constant(tolua_S,"enchFortune",cEnchantments::enchFortune);
   tolua_constant(tolua_S,"enchPower",cEnchantments::enchPower);
   tolua_constant(tolua_S,"enchPunch",cEnchantments::enchPunch);
   tolua_constant(tolua_S,"enchFlame",cEnchantments::enchFlame);
   tolua_constant(tolua_S,"enchInfinity",cEnchantments::enchInfinity);
   tolua_constant(tolua_S,"enchLuckOfTheSea",cEnchantments::enchLuckOfTheSea);
   tolua_constant(tolua_S,"enchLure",cEnchantments::enchLure);
   tolua_function(tolua_S,"new",tolua_AllToLua_cEnchantments_new00);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cEnchantments_new00_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cEnchantments_new00_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_cEnchantments_new01);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cEnchantments_new01_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cEnchantments_new01_local);
   tolua_function(tolua_S,"Add",tolua_AllToLua_cEnchantments_Add00);
   tolua_function(tolua_S,"AddFromString",tolua_AllToLua_cEnchantments_AddFromString00);
   tolua_function(tolua_S,"Count",tolua_AllToLua_cEnchantments_Count00);
   tolua_function(tolua_S,"ToString",tolua_AllToLua_cEnchantments_ToString00);
   tolua_function(tolua_S,"GetLevel",tolua_AllToLua_cEnchantments_GetLevel00);
   tolua_function(tolua_S,"SetLevel",tolua_AllToLua_cEnchantments_SetLevel00);
   tolua_function(tolua_S,"Clear",tolua_AllToLua_cEnchantments_Clear00);
   tolua_function(tolua_S,"IsEmpty",tolua_AllToLua_cEnchantments_IsEmpty00);
   tolua_function(tolua_S,"CanAddEnchantment",tolua_AllToLua_cEnchantments_CanAddEnchantment00);
   tolua_function(tolua_S,"StringToEnchantmentID",tolua_AllToLua_cEnchantments_StringToEnchantmentID00);
   tolua_function(tolua_S,".eq",tolua_AllToLua_cEnchantments__eq00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"cItem","cItem","",tolua_collect_cItem);
  #else
  tolua_cclass(tolua_S,"cItem","cItem","",nullptr);
  #endif
  tolua_beginmodule(tolua_S,"cItem");
   tolua_function(tolua_S,"new",tolua_AllToLua_cItem_new00);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cItem_new00_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cItem_new00_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_cItem_new01);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cItem_new01_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cItem_new01_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_cItem_new02);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cItem_new02_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cItem_new02_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_cItem_new03);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cItem_new03_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cItem_new03_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_cItem_new04);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cItem_new04_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cItem_new04_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_cItem_new05);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cItem_new05_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cItem_new05_local);
   tolua_function(tolua_S,"Empty",tolua_AllToLua_cItem_Empty00);
   tolua_function(tolua_S,"Clear",tolua_AllToLua_cItem_Clear00);
   tolua_function(tolua_S,"IsEmpty",tolua_AllToLua_cItem_IsEmpty00);
   tolua_function(tolua_S,"IsEqual",tolua_AllToLua_cItem_IsEqual00);
   tolua_function(tolua_S,"IsSameType",tolua_AllToLua_cItem_IsSameType00);
   tolua_function(tolua_S,"IsBothNameAndLoreEmpty",tolua_AllToLua_cItem_IsBothNameAndLoreEmpty00);
   tolua_function(tolua_S,"IsCustomNameEmpty",tolua_AllToLua_cItem_IsCustomNameEmpty00);
   tolua_function(tolua_S,"IsLoreEmpty",tolua_AllToLua_cItem_IsLoreEmpty00);
   tolua_function(tolua_S,"CopyOne",tolua_AllToLua_cItem_CopyOne00);
   tolua_function(tolua_S,"AddCount",tolua_AllToLua_cItem_AddCount00);
   tolua_function(tolua_S,"GetMaxDamage",tolua_AllToLua_cItem_GetMaxDamage00);
   tolua_function(tolua_S,"DamageItem",tolua_AllToLua_cItem_DamageItem00);
   tolua_function(tolua_S,"IsDamageable",tolua_AllToLua_cItem_IsDamageable00);
   tolua_function(tolua_S,"IsFullStack",tolua_AllToLua_cItem_IsFullStack00);
   tolua_function(tolua_S,"GetMaxStackSize",tolua_AllToLua_cItem_GetMaxStackSize00);
   tolua_function(tolua_S,"IsEnchantable",tolua_AllToLua_cItem_IsEnchantable00);
   tolua_function(tolua_S,"GetEnchantability",tolua_AllToLua_cItem_GetEnchantability00);
   tolua_function(tolua_S,"AddEnchantment",tolua_AllToLua_cItem_AddEnchantment00);
   tolua_function(tolua_S,"AddEnchantmentsFromItem",tolua_AllToLua_cItem_AddEnchantmentsFromItem00);
   tolua_variable(tolua_S,"m_ItemType",tolua_get_cItem_m_ItemType,tolua_set_cItem_m_ItemType);
   tolua_variable(tolua_S,"m_ItemCount",tolua_get_cItem_m_ItemCount,tolua_set_cItem_m_ItemCount);
   tolua_variable(tolua_S,"m_ItemDamage",tolua_get_cItem_m_ItemDamage,tolua_set_cItem_m_ItemDamage);
   tolua_variable(tolua_S,"m_Enchantments",tolua_get_cItem_m_Enchantments,tolua_set_cItem_m_Enchantments);
   tolua_variable(tolua_S,"m_CustomName",tolua_get_cItem_m_CustomName,tolua_set_cItem_m_CustomName);
   tolua_variable(tolua_S,"m_RepairCost",tolua_get_cItem_m_RepairCost,tolua_set_cItem_m_RepairCost);
   tolua_variable(tolua_S,"m_FireworkItem",tolua_get_cItem_m_FireworkItem,tolua_set_cItem_m_FireworkItem);
   tolua_variable(tolua_S,"m_ItemColor",tolua_get_cItem_m_ItemColor,tolua_set_cItem_m_ItemColor);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"cItems","cItems","",tolua_collect_cItems);
  #else
  tolua_cclass(tolua_S,"cItems","cItems","",nullptr);
  #endif
  tolua_beginmodule(tolua_S,"cItems");
   tolua_function(tolua_S,"new",tolua_AllToLua_cItems_new00);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cItems_new00_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cItems_new00_local);
   tolua_function(tolua_S,"Get",tolua_AllToLua_cItems_Get00);
   tolua_function(tolua_S,"Set",tolua_AllToLua_cItems_Set00);
   tolua_function(tolua_S,"Add",tolua_AllToLua_cItems_Add00);
   tolua_function(tolua_S,"Add",tolua_AllToLua_cItems_Add01);
   tolua_function(tolua_S,"Add",tolua_AllToLua_cItems_Add02);
   tolua_function(tolua_S,"Delete",tolua_AllToLua_cItems_Delete00);
   tolua_function(tolua_S,"Clear",tolua_AllToLua_cItems_Clear00);
   tolua_function(tolua_S,"Size",tolua_AllToLua_cItems_Size00);
   tolua_function(tolua_S,"Set",tolua_AllToLua_cItems_Set01);
   tolua_function(tolua_S,"Contains",tolua_AllToLua_cItems_Contains00);
   tolua_function(tolua_S,"ContainsType",tolua_AllToLua_cItems_ContainsType00);
   tolua_function(tolua_S,"Add",tolua_AllToLua_cItems_Add03);
   tolua_function(tolua_S,"AddItemGrid",tolua_AllToLua_cItems_AddItemGrid00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cItemGrid","cItemGrid","",nullptr);
  tolua_beginmodule(tolua_S,"cItemGrid");
   tolua_function(tolua_S,"GetWidth",tolua_AllToLua_cItemGrid_GetWidth00);
   tolua_function(tolua_S,"GetHeight",tolua_AllToLua_cItemGrid_GetHeight00);
   tolua_function(tolua_S,"GetNumSlots",tolua_AllToLua_cItemGrid_GetNumSlots00);
   tolua_function(tolua_S,"GetSlotNum",tolua_AllToLua_cItemGrid_GetSlotNum00);
   tolua_function(tolua_S,"GetSlot",tolua_AllToLua_cItemGrid_GetSlot00);
   tolua_function(tolua_S,"GetSlot",tolua_AllToLua_cItemGrid_GetSlot01);
   tolua_function(tolua_S,"SetSlot",tolua_AllToLua_cItemGrid_SetSlot00);
   tolua_function(tolua_S,"SetSlot",tolua_AllToLua_cItemGrid_SetSlot01);
   tolua_function(tolua_S,"SetSlot",tolua_AllToLua_cItemGrid_SetSlot02);
   tolua_function(tolua_S,"SetSlot",tolua_AllToLua_cItemGrid_SetSlot03);
   tolua_function(tolua_S,"EmptySlot",tolua_AllToLua_cItemGrid_EmptySlot00);
   tolua_function(tolua_S,"EmptySlot",tolua_AllToLua_cItemGrid_EmptySlot01);
   tolua_function(tolua_S,"IsSlotEmpty",tolua_AllToLua_cItemGrid_IsSlotEmpty00);
   tolua_function(tolua_S,"IsSlotEmpty",tolua_AllToLua_cItemGrid_IsSlotEmpty01);
   tolua_function(tolua_S,"Clear",tolua_AllToLua_cItemGrid_Clear00);
   tolua_function(tolua_S,"HowManyCanFit",tolua_AllToLua_cItemGrid_HowManyCanFit00);
   tolua_function(tolua_S,"AddItem",tolua_AllToLua_cItemGrid_AddItem00);
   tolua_function(tolua_S,"AddItems",tolua_AllToLua_cItemGrid_AddItems00);
   tolua_function(tolua_S,"RemoveItem",tolua_AllToLua_cItemGrid_RemoveItem00);
   tolua_function(tolua_S,"FindItem",tolua_AllToLua_cItemGrid_FindItem00);
   tolua_function(tolua_S,"ChangeSlotCount",tolua_AllToLua_cItemGrid_ChangeSlotCount00);
   tolua_function(tolua_S,"ChangeSlotCount",tolua_AllToLua_cItemGrid_ChangeSlotCount01);
   tolua_function(tolua_S,"RemoveOneItem",tolua_AllToLua_cItemGrid_RemoveOneItem00);
   tolua_function(tolua_S,"RemoveOneItem",tolua_AllToLua_cItemGrid_RemoveOneItem01);
   tolua_function(tolua_S,"HowManyItems",tolua_AllToLua_cItemGrid_HowManyItems00);
   tolua_function(tolua_S,"HasItems",tolua_AllToLua_cItemGrid_HasItems00);
   tolua_function(tolua_S,"GetFirstEmptySlot",tolua_AllToLua_cItemGrid_GetFirstEmptySlot00);
   tolua_function(tolua_S,"GetFirstUsedSlot",tolua_AllToLua_cItemGrid_GetFirstUsedSlot00);
   tolua_function(tolua_S,"GetLastEmptySlot",tolua_AllToLua_cItemGrid_GetLastEmptySlot00);
   tolua_function(tolua_S,"GetLastUsedSlot",tolua_AllToLua_cItemGrid_GetLastUsedSlot00);
   tolua_function(tolua_S,"GetNextEmptySlot",tolua_AllToLua_cItemGrid_GetNextEmptySlot00);
   tolua_function(tolua_S,"GetNextUsedSlot",tolua_AllToLua_cItemGrid_GetNextUsedSlot00);
   tolua_function(tolua_S,"CopyToItems",tolua_AllToLua_cItemGrid_CopyToItems00);
   tolua_function(tolua_S,"DamageItem",tolua_AllToLua_cItemGrid_DamageItem00);
   tolua_function(tolua_S,"DamageItem",tolua_AllToLua_cItemGrid_DamageItem01);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"HTTPFormData","HTTPFormData","",nullptr);
  tolua_beginmodule(tolua_S,"HTTPFormData");
   tolua_variable(tolua_S,"Name",tolua_get_HTTPFormData_Name,tolua_set_HTTPFormData_Name);
   tolua_variable(tolua_S,"Value",tolua_get_HTTPFormData_Value,tolua_set_HTTPFormData_Value);
   tolua_variable(tolua_S,"Type",tolua_get_HTTPFormData_Type,tolua_set_HTTPFormData_Type);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"HTTPRequest","HTTPRequest","",nullptr);
  tolua_beginmodule(tolua_S,"HTTPRequest");
   tolua_variable(tolua_S,"URL",tolua_get_HTTPRequest_URL,tolua_set_HTTPRequest_URL);
   tolua_variable(tolua_S,"Method",tolua_get_HTTPRequest_Method,tolua_set_HTTPRequest_Method);
   tolua_variable(tolua_S,"Path",tolua_get_HTTPRequest_Path,tolua_set_HTTPRequest_Path);
   tolua_variable(tolua_S,"Username",tolua_get_HTTPRequest_Username,tolua_set_HTTPRequest_Username);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"HTTPTemplateRequest","HTTPTemplateRequest","",nullptr);
  tolua_beginmodule(tolua_S,"HTTPTemplateRequest");
   tolua_variable(tolua_S,"Request",tolua_get_HTTPTemplateRequest_Request,tolua_set_HTTPTemplateRequest_Request);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cWebAdmin","cWebAdmin","",nullptr);
  tolua_beginmodule(tolua_S,"cWebAdmin");
   tolua_function(tolua_S,"Reload",tolua_AllToLua_cWebAdmin_Reload00);
   tolua_function(tolua_S,"GetPorts",tolua_AllToLua_cWebAdmin_GetPorts00);
   tolua_function(tolua_S,"GetBaseURL",tolua_AllToLua_cWebAdmin_GetBaseURL00);
   tolua_function(tolua_S,"GetContentTypeFromFileExt",tolua_AllToLua_cWebAdmin_GetContentTypeFromFileExt00);
   tolua_function(tolua_S,"GetHTMLEscapedString",tolua_AllToLua_cWebAdmin_GetHTMLEscapedString00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cRoot","cRoot","",nullptr);
  tolua_beginmodule(tolua_S,"cRoot");
   tolua_function(tolua_S,"Get",tolua_AllToLua_cRoot_Get00);
   tolua_function(tolua_S,"GetServer",tolua_AllToLua_cRoot_GetServer00);
   tolua_function(tolua_S,"GetDefaultWorld",tolua_AllToLua_cRoot_GetDefaultWorld00);
   tolua_function(tolua_S,"GetWorld",tolua_AllToLua_cRoot_GetWorld00);
   tolua_function(tolua_S,"GetServerUpTime",tolua_AllToLua_cRoot_GetServerUpTime00);
   tolua_function(tolua_S,"GetCraftingRecipes",tolua_AllToLua_cRoot_GetCraftingRecipes00);
   tolua_function(tolua_S,"GetFurnaceFuelBurnTime",tolua_AllToLua_cRoot_GetFurnaceFuelBurnTime00);
   tolua_function(tolua_S,"GetWebAdmin",tolua_AllToLua_cRoot_GetWebAdmin00);
   tolua_function(tolua_S,"GetPluginManager",tolua_AllToLua_cRoot_GetPluginManager00);
   tolua_function(tolua_S,"QueueExecuteConsoleCommand",tolua_AllToLua_cRoot_QueueExecuteConsoleCommand00);
   tolua_function(tolua_S,"GetTotalChunkCount",tolua_AllToLua_cRoot_GetTotalChunkCount00);
   tolua_function(tolua_S,"SaveAllChunks",tolua_AllToLua_cRoot_SaveAllChunks00);
   tolua_function(tolua_S,"SetSavingEnabled",tolua_AllToLua_cRoot_SetSavingEnabled00);
   tolua_function(tolua_S,"BroadcastPlayerListsHeaderFooter",tolua_AllToLua_cRoot_BroadcastPlayerListsHeaderFooter00);
   tolua_function(tolua_S,"BroadcastChat",tolua_AllToLua_cRoot_BroadcastChat00);
   tolua_function(tolua_S,"BroadcastChat",tolua_AllToLua_cRoot_BroadcastChat01);
   tolua_function(tolua_S,"BroadcastChatDeath",tolua_AllToLua_cRoot_BroadcastChatDeath00);
   tolua_function(tolua_S,"BroadcastChatFailure",tolua_AllToLua_cRoot_BroadcastChatFailure00);
   tolua_function(tolua_S,"BroadcastChatFatal",tolua_AllToLua_cRoot_BroadcastChatFatal00);
   tolua_function(tolua_S,"BroadcastChatInfo",tolua_AllToLua_cRoot_BroadcastChatInfo00);
   tolua_function(tolua_S,"BroadcastChatJoin",tolua_AllToLua_cRoot_BroadcastChatJoin00);
   tolua_function(tolua_S,"BroadcastChatLeave",tolua_AllToLua_cRoot_BroadcastChatLeave00);
   tolua_function(tolua_S,"BroadcastChatSuccess",tolua_AllToLua_cRoot_BroadcastChatSuccess00);
   tolua_function(tolua_S,"BroadcastChatWarning",tolua_AllToLua_cRoot_BroadcastChatWarning00);
   tolua_function(tolua_S,"GetProtocolVersionTextFromInt",tolua_AllToLua_cRoot_GetProtocolVersionTextFromInt00);
   tolua_function(tolua_S,"GetVirtualRAMUsage",tolua_AllToLua_cRoot_GetVirtualRAMUsage00);
   tolua_function(tolua_S,"GetPhysicalRAMUsage",tolua_AllToLua_cRoot_GetPhysicalRAMUsage00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"cCuboid","cCuboid","",tolua_collect_cCuboid);
  #else
  tolua_cclass(tolua_S,"cCuboid","cCuboid","",nullptr);
  #endif
  tolua_beginmodule(tolua_S,"cCuboid");
   tolua_variable(tolua_S,"p1",tolua_get_cCuboid_p1,tolua_set_cCuboid_p1);
   tolua_variable(tolua_S,"p2",tolua_get_cCuboid_p2,tolua_set_cCuboid_p2);
   tolua_function(tolua_S,"new",tolua_AllToLua_cCuboid_new00);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cCuboid_new00_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cCuboid_new00_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_cCuboid_new01);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cCuboid_new01_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cCuboid_new01_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_cCuboid_new02);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cCuboid_new02_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cCuboid_new02_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_cCuboid_new03);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cCuboid_new03_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cCuboid_new03_local);
   tolua_function(tolua_S,"Sort",tolua_AllToLua_cCuboid_Sort00);
   tolua_function(tolua_S,"DifX",tolua_AllToLua_cCuboid_DifX00);
   tolua_function(tolua_S,"DifY",tolua_AllToLua_cCuboid_DifY00);
   tolua_function(tolua_S,"DifZ",tolua_AllToLua_cCuboid_DifZ00);
   tolua_function(tolua_S,"GetVolume",tolua_AllToLua_cCuboid_GetVolume00);
   tolua_function(tolua_S,"DoesIntersect",tolua_AllToLua_cCuboid_DoesIntersect00);
   tolua_function(tolua_S,"IsCompletelyInside",tolua_AllToLua_cCuboid_IsCompletelyInside00);
   tolua_function(tolua_S,"Expand",tolua_AllToLua_cCuboid_Expand00);
   tolua_function(tolua_S,"Clamp",tolua_AllToLua_cCuboid_Clamp00);
   tolua_function(tolua_S,"ClampSize",tolua_AllToLua_cCuboid_ClampSize00);
   tolua_function(tolua_S,"ClampX",tolua_AllToLua_cCuboid_ClampX00);
   tolua_function(tolua_S,"ClampY",tolua_AllToLua_cCuboid_ClampY00);
   tolua_function(tolua_S,"ClampZ",tolua_AllToLua_cCuboid_ClampZ00);
   tolua_function(tolua_S,"IsSorted",tolua_AllToLua_cCuboid_IsSorted00);
   tolua_function(tolua_S,"Engulf",tolua_AllToLua_cCuboid_Engulf00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"cBoundingBox","cBoundingBox","",tolua_collect_cBoundingBox);
  #else
  tolua_cclass(tolua_S,"cBoundingBox","cBoundingBox","",nullptr);
  #endif
  tolua_beginmodule(tolua_S,"cBoundingBox");
   tolua_function(tolua_S,"new",tolua_AllToLua_cBoundingBox_new00);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cBoundingBox_new00_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cBoundingBox_new00_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_cBoundingBox_new01);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cBoundingBox_new01_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cBoundingBox_new01_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_cBoundingBox_new02);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cBoundingBox_new02_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cBoundingBox_new02_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_cBoundingBox_new03);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cBoundingBox_new03_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cBoundingBox_new03_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_cBoundingBox_new04);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cBoundingBox_new04_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cBoundingBox_new04_local);
   tolua_function(tolua_S,"new",tolua_AllToLua_cBoundingBox_new05);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cBoundingBox_new05_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cBoundingBox_new05_local);
   tolua_function(tolua_S,"Move",tolua_AllToLua_cBoundingBox_Move00);
   tolua_function(tolua_S,"Move",tolua_AllToLua_cBoundingBox_Move01);
   tolua_function(tolua_S,"Expand",tolua_AllToLua_cBoundingBox_Expand00);
   tolua_function(tolua_S,"DoesIntersect",tolua_AllToLua_cBoundingBox_DoesIntersect00);
   tolua_function(tolua_S,"Union",tolua_AllToLua_cBoundingBox_Union00);
   tolua_function(tolua_S,"IsInside",tolua_AllToLua_cBoundingBox_IsInside00);
   tolua_function(tolua_S,"IsInside",tolua_AllToLua_cBoundingBox_IsInside01);
   tolua_function(tolua_S,"IsInside",tolua_AllToLua_cBoundingBox_IsInside02);
   tolua_function(tolua_S,"IsInside",tolua_AllToLua_cBoundingBox_IsInside03);
   tolua_function(tolua_S,"IsInside",tolua_AllToLua_cBoundingBox_IsInside04);
   tolua_function(tolua_S,"IsInside",tolua_AllToLua_cBoundingBox_IsInside05);
   tolua_function(tolua_S,"GetMinX",tolua_AllToLua_cBoundingBox_GetMinX00);
   tolua_function(tolua_S,"GetMinY",tolua_AllToLua_cBoundingBox_GetMinY00);
   tolua_function(tolua_S,"GetMinZ",tolua_AllToLua_cBoundingBox_GetMinZ00);
   tolua_function(tolua_S,"GetMaxX",tolua_AllToLua_cBoundingBox_GetMaxX00);
   tolua_function(tolua_S,"GetMaxY",tolua_AllToLua_cBoundingBox_GetMaxY00);
   tolua_function(tolua_S,"GetMaxZ",tolua_AllToLua_cBoundingBox_GetMaxZ00);
   tolua_function(tolua_S,"GetMin",tolua_AllToLua_cBoundingBox_GetMin00);
   tolua_function(tolua_S,"GetMax",tolua_AllToLua_cBoundingBox_GetMax00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"cBlockArea","cBlockArea","",tolua_collect_cBlockArea);
  #else
  tolua_cclass(tolua_S,"cBlockArea","cBlockArea","",nullptr);
  #endif
  tolua_beginmodule(tolua_S,"cBlockArea");
   tolua_constant(tolua_S,"baTypes",cBlockArea::baTypes);
   tolua_constant(tolua_S,"baMetas",cBlockArea::baMetas);
   tolua_constant(tolua_S,"baLight",cBlockArea::baLight);
   tolua_constant(tolua_S,"baSkyLight",cBlockArea::baSkyLight);
   tolua_constant(tolua_S,"baBlockEntities",cBlockArea::baBlockEntities);
   tolua_constant(tolua_S,"msOverwrite",cBlockArea::msOverwrite);
   tolua_constant(tolua_S,"msFillAir",cBlockArea::msFillAir);
   tolua_constant(tolua_S,"msImprint",cBlockArea::msImprint);
   tolua_constant(tolua_S,"msLake",cBlockArea::msLake);
   tolua_constant(tolua_S,"msSpongePrint",cBlockArea::msSpongePrint);
   tolua_constant(tolua_S,"msDifference",cBlockArea::msDifference);
   tolua_constant(tolua_S,"msSimpleCompare",cBlockArea::msSimpleCompare);
   tolua_constant(tolua_S,"msMask",cBlockArea::msMask);
   tolua_function(tolua_S,"new",tolua_AllToLua_cBlockArea_new00);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cBlockArea_new00_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cBlockArea_new00_local);
   tolua_function(tolua_S,"IsValidDataTypeCombination",tolua_AllToLua_cBlockArea_IsValidDataTypeCombination00);
   tolua_function(tolua_S,"Clear",tolua_AllToLua_cBlockArea_Clear00);
   tolua_function(tolua_S,"SetOrigin",tolua_AllToLua_cBlockArea_SetOrigin00);
   tolua_function(tolua_S,"SetOrigin",tolua_AllToLua_cBlockArea_SetOrigin01);
   tolua_function(tolua_S,"IsValidRelCoords",tolua_AllToLua_cBlockArea_IsValidRelCoords00);
   tolua_function(tolua_S,"IsValidRelCoords",tolua_AllToLua_cBlockArea_IsValidRelCoords01);
   tolua_function(tolua_S,"IsValidCoords",tolua_AllToLua_cBlockArea_IsValidCoords00);
   tolua_function(tolua_S,"IsValidCoords",tolua_AllToLua_cBlockArea_IsValidCoords01);
   tolua_function(tolua_S,"CopyTo",tolua_AllToLua_cBlockArea_CopyTo00);
   tolua_function(tolua_S,"CopyFrom",tolua_AllToLua_cBlockArea_CopyFrom00);
   tolua_function(tolua_S,"DumpToRawFile",tolua_AllToLua_cBlockArea_DumpToRawFile00);
   tolua_function(tolua_S,"Crop",tolua_AllToLua_cBlockArea_Crop00);
   tolua_function(tolua_S,"Expand",tolua_AllToLua_cBlockArea_Expand00);
   tolua_function(tolua_S,"Merge",tolua_AllToLua_cBlockArea_Merge00);
   tolua_function(tolua_S,"Merge",tolua_AllToLua_cBlockArea_Merge01);
   tolua_function(tolua_S,"Fill",tolua_AllToLua_cBlockArea_Fill00);
   tolua_function(tolua_S,"RotateCCW",tolua_AllToLua_cBlockArea_RotateCCW00);
   tolua_function(tolua_S,"RotateCW",tolua_AllToLua_cBlockArea_RotateCW00);
   tolua_function(tolua_S,"MirrorXY",tolua_AllToLua_cBlockArea_MirrorXY00);
   tolua_function(tolua_S,"MirrorXZ",tolua_AllToLua_cBlockArea_MirrorXZ00);
   tolua_function(tolua_S,"MirrorYZ",tolua_AllToLua_cBlockArea_MirrorYZ00);
   tolua_function(tolua_S,"RotateCCWNoMeta",tolua_AllToLua_cBlockArea_RotateCCWNoMeta00);
   tolua_function(tolua_S,"RotateCWNoMeta",tolua_AllToLua_cBlockArea_RotateCWNoMeta00);
   tolua_function(tolua_S,"MirrorXYNoMeta",tolua_AllToLua_cBlockArea_MirrorXYNoMeta00);
   tolua_function(tolua_S,"MirrorXZNoMeta",tolua_AllToLua_cBlockArea_MirrorXZNoMeta00);
   tolua_function(tolua_S,"MirrorYZNoMeta",tolua_AllToLua_cBlockArea_MirrorYZNoMeta00);
   tolua_function(tolua_S,"SetWEOffset",tolua_AllToLua_cBlockArea_SetWEOffset00);
   tolua_function(tolua_S,"SetWEOffset",tolua_AllToLua_cBlockArea_SetWEOffset01);
   tolua_function(tolua_S,"GetWEOffset",tolua_AllToLua_cBlockArea_GetWEOffset00);
   tolua_function(tolua_S,"GetBounds",tolua_AllToLua_cBlockArea_GetBounds00);
   tolua_function(tolua_S,"GetSizeX",tolua_AllToLua_cBlockArea_GetSizeX00);
   tolua_function(tolua_S,"GetSizeY",tolua_AllToLua_cBlockArea_GetSizeY00);
   tolua_function(tolua_S,"GetSizeZ",tolua_AllToLua_cBlockArea_GetSizeZ00);
   tolua_function(tolua_S,"GetVolume",tolua_AllToLua_cBlockArea_GetVolume00);
   tolua_function(tolua_S,"GetOriginX",tolua_AllToLua_cBlockArea_GetOriginX00);
   tolua_function(tolua_S,"GetOriginY",tolua_AllToLua_cBlockArea_GetOriginY00);
   tolua_function(tolua_S,"GetOriginZ",tolua_AllToLua_cBlockArea_GetOriginZ00);
   tolua_function(tolua_S,"GetDataTypes",tolua_AllToLua_cBlockArea_GetDataTypes00);
   tolua_function(tolua_S,"HasBlockTypes",tolua_AllToLua_cBlockArea_HasBlockTypes00);
   tolua_function(tolua_S,"HasBlockMetas",tolua_AllToLua_cBlockArea_HasBlockMetas00);
   tolua_function(tolua_S,"HasBlockLights",tolua_AllToLua_cBlockArea_HasBlockLights00);
   tolua_function(tolua_S,"HasBlockSkyLights",tolua_AllToLua_cBlockArea_HasBlockSkyLights00);
   tolua_function(tolua_S,"HasBlockEntities",tolua_AllToLua_cBlockArea_HasBlockEntities00);
   tolua_function(tolua_S,"CountNonAirBlocks",tolua_AllToLua_cBlockArea_CountNonAirBlocks00);
   tolua_function(tolua_S,"CountSpecificBlocks",tolua_AllToLua_cBlockArea_CountSpecificBlocks00);
   tolua_function(tolua_S,"CountSpecificBlocks",tolua_AllToLua_cBlockArea_CountSpecificBlocks01);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cChunkDesc","cChunkDesc","",nullptr);
  tolua_beginmodule(tolua_S,"cChunkDesc");
   tolua_function(tolua_S,"GetChunkX",tolua_AllToLua_cChunkDesc_GetChunkX00);
   tolua_function(tolua_S,"GetChunkZ",tolua_AllToLua_cChunkDesc_GetChunkZ00);
   tolua_function(tolua_S,"FillBlocks",tolua_AllToLua_cChunkDesc_FillBlocks00);
   tolua_function(tolua_S,"SetBlockTypeMeta",tolua_AllToLua_cChunkDesc_SetBlockTypeMeta00);
   tolua_function(tolua_S,"SetBlockType",tolua_AllToLua_cChunkDesc_SetBlockType00);
   tolua_function(tolua_S,"GetBlockType",tolua_AllToLua_cChunkDesc_GetBlockType00);
   tolua_function(tolua_S,"SetBlockMeta",tolua_AllToLua_cChunkDesc_SetBlockMeta00);
   tolua_function(tolua_S,"GetBlockMeta",tolua_AllToLua_cChunkDesc_GetBlockMeta00);
   tolua_function(tolua_S,"SetBiome",tolua_AllToLua_cChunkDesc_SetBiome00);
   tolua_function(tolua_S,"GetBiome",tolua_AllToLua_cChunkDesc_GetBiome00);
   tolua_function(tolua_S,"SetHeight",tolua_AllToLua_cChunkDesc_SetHeight00);
   tolua_function(tolua_S,"GetHeight",tolua_AllToLua_cChunkDesc_GetHeight00);
   tolua_function(tolua_S,"SetUseDefaultBiomes",tolua_AllToLua_cChunkDesc_SetUseDefaultBiomes00);
   tolua_function(tolua_S,"IsUsingDefaultBiomes",tolua_AllToLua_cChunkDesc_IsUsingDefaultBiomes00);
   tolua_function(tolua_S,"SetUseDefaultHeight",tolua_AllToLua_cChunkDesc_SetUseDefaultHeight00);
   tolua_function(tolua_S,"IsUsingDefaultHeight",tolua_AllToLua_cChunkDesc_IsUsingDefaultHeight00);
   tolua_function(tolua_S,"SetUseDefaultComposition",tolua_AllToLua_cChunkDesc_SetUseDefaultComposition00);
   tolua_function(tolua_S,"IsUsingDefaultComposition",tolua_AllToLua_cChunkDesc_IsUsingDefaultComposition00);
   tolua_function(tolua_S,"SetUseDefaultFinish",tolua_AllToLua_cChunkDesc_SetUseDefaultFinish00);
   tolua_function(tolua_S,"IsUsingDefaultFinish",tolua_AllToLua_cChunkDesc_IsUsingDefaultFinish00);
   tolua_function(tolua_S,"WriteBlockArea",tolua_AllToLua_cChunkDesc_WriteBlockArea00);
   tolua_function(tolua_S,"ReadBlockArea",tolua_AllToLua_cChunkDesc_ReadBlockArea00);
   tolua_function(tolua_S,"GetMaxHeight",tolua_AllToLua_cChunkDesc_GetMaxHeight00);
   tolua_function(tolua_S,"GetMinHeight",tolua_AllToLua_cChunkDesc_GetMinHeight00);
   tolua_function(tolua_S,"FillRelCuboid",tolua_AllToLua_cChunkDesc_FillRelCuboid00);
   tolua_function(tolua_S,"FillRelCuboid",tolua_AllToLua_cChunkDesc_FillRelCuboid01);
   tolua_function(tolua_S,"ReplaceRelCuboid",tolua_AllToLua_cChunkDesc_ReplaceRelCuboid00);
   tolua_function(tolua_S,"ReplaceRelCuboid",tolua_AllToLua_cChunkDesc_ReplaceRelCuboid01);
   tolua_function(tolua_S,"FloorRelCuboid",tolua_AllToLua_cChunkDesc_FloorRelCuboid00);
   tolua_function(tolua_S,"FloorRelCuboid",tolua_AllToLua_cChunkDesc_FloorRelCuboid01);
   tolua_function(tolua_S,"RandomFillRelCuboid",tolua_AllToLua_cChunkDesc_RandomFillRelCuboid00);
   tolua_function(tolua_S,"RandomFillRelCuboid",tolua_AllToLua_cChunkDesc_RandomFillRelCuboid01);
   tolua_function(tolua_S,"GetBlockEntity",tolua_AllToLua_cChunkDesc_GetBlockEntity00);
   tolua_function(tolua_S,"UpdateHeightmap",tolua_AllToLua_cChunkDesc_UpdateHeightmap00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"cCraftingGrid","cCraftingGrid","",tolua_collect_cCraftingGrid);
  #else
  tolua_cclass(tolua_S,"cCraftingGrid","cCraftingGrid","",nullptr);
  #endif
  tolua_beginmodule(tolua_S,"cCraftingGrid");
   tolua_function(tolua_S,"new",tolua_AllToLua_cCraftingGrid_new00);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cCraftingGrid_new00_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cCraftingGrid_new00_local);
   tolua_function(tolua_S,"GetWidth",tolua_AllToLua_cCraftingGrid_GetWidth00);
   tolua_function(tolua_S,"GetHeight",tolua_AllToLua_cCraftingGrid_GetHeight00);
   tolua_function(tolua_S,"GetItem",tolua_AllToLua_cCraftingGrid_GetItem00);
   tolua_function(tolua_S,"SetItem",tolua_AllToLua_cCraftingGrid_SetItem00);
   tolua_function(tolua_S,"SetItem",tolua_AllToLua_cCraftingGrid_SetItem01);
   tolua_function(tolua_S,"Clear",tolua_AllToLua_cCraftingGrid_Clear00);
   tolua_function(tolua_S,"ConsumeGrid",tolua_AllToLua_cCraftingGrid_ConsumeGrid00);
   tolua_function(tolua_S,"Dump",tolua_AllToLua_cCraftingGrid_Dump00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cCraftingRecipe","cCraftingRecipe","",nullptr);
  tolua_beginmodule(tolua_S,"cCraftingRecipe");
   tolua_function(tolua_S,"Clear",tolua_AllToLua_cCraftingRecipe_Clear00);
   tolua_function(tolua_S,"GetIngredientsWidth",tolua_AllToLua_cCraftingRecipe_GetIngredientsWidth00);
   tolua_function(tolua_S,"GetIngredientsHeight",tolua_AllToLua_cCraftingRecipe_GetIngredientsHeight00);
   tolua_function(tolua_S,"GetIngredient",tolua_AllToLua_cCraftingRecipe_GetIngredient00);
   tolua_function(tolua_S,"GetResult",tolua_AllToLua_cCraftingRecipe_GetResult00);
   tolua_function(tolua_S,"SetResult",tolua_AllToLua_cCraftingRecipe_SetResult00);
   tolua_function(tolua_S,"SetResult",tolua_AllToLua_cCraftingRecipe_SetResult01);
   tolua_function(tolua_S,"SetIngredient",tolua_AllToLua_cCraftingRecipe_SetIngredient00);
   tolua_function(tolua_S,"SetIngredient",tolua_AllToLua_cCraftingRecipe_SetIngredient01);
   tolua_function(tolua_S,"ConsumeIngredients",tolua_AllToLua_cCraftingRecipe_ConsumeIngredients00);
   tolua_function(tolua_S,"Dump",tolua_AllToLua_cCraftingRecipe_Dump00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cWindow","cWindow","",nullptr);
  tolua_beginmodule(tolua_S,"cWindow");
   tolua_constant(tolua_S,"wtInventory",cWindow::wtInventory);
   tolua_constant(tolua_S,"wtChest",cWindow::wtChest);
   tolua_constant(tolua_S,"wtWorkbench",cWindow::wtWorkbench);
   tolua_constant(tolua_S,"wtFurnace",cWindow::wtFurnace);
   tolua_constant(tolua_S,"wtDropSpenser",cWindow::wtDropSpenser);
   tolua_constant(tolua_S,"wtEnchantment",cWindow::wtEnchantment);
   tolua_constant(tolua_S,"wtBrewery",cWindow::wtBrewery);
   tolua_constant(tolua_S,"wtNPCTrade",cWindow::wtNPCTrade);
   tolua_constant(tolua_S,"wtBeacon",cWindow::wtBeacon);
   tolua_constant(tolua_S,"wtAnvil",cWindow::wtAnvil);
   tolua_constant(tolua_S,"wtHopper",cWindow::wtHopper);
   tolua_constant(tolua_S,"wtDropper",cWindow::wtDropper);
   tolua_constant(tolua_S,"wtAnimalChest",cWindow::wtAnimalChest);
   tolua_function(tolua_S,"GetWindowID",tolua_AllToLua_cWindow_GetWindowID00);
   tolua_function(tolua_S,"GetWindowType",tolua_AllToLua_cWindow_GetWindowType00);
   tolua_function(tolua_S,"GetWindowTypeName",tolua_AllToLua_cWindow_GetWindowTypeName00);
   tolua_function(tolua_S,"GetSlot",tolua_AllToLua_cWindow_GetSlot00);
   tolua_function(tolua_S,"SetSlot",tolua_AllToLua_cWindow_SetSlot00);
   tolua_function(tolua_S,"IsSlotInPlayerMainInventory",tolua_AllToLua_cWindow_IsSlotInPlayerMainInventory00);
   tolua_function(tolua_S,"IsSlotInPlayerHotbar",tolua_AllToLua_cWindow_IsSlotInPlayerHotbar00);
   tolua_function(tolua_S,"IsSlotInPlayerInventory",tolua_AllToLua_cWindow_IsSlotInPlayerInventory00);
   tolua_function(tolua_S,"GetWindowTitle",tolua_AllToLua_cWindow_GetWindowTitle00);
   tolua_function(tolua_S,"SetWindowTitle",tolua_AllToLua_cWindow_SetWindowTitle00);
   tolua_function(tolua_S,"SetProperty",tolua_AllToLua_cWindow_SetProperty00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cCompositeChat","cCompositeChat","",nullptr);
  tolua_beginmodule(tolua_S,"cCompositeChat");
   tolua_function(tolua_S,"GetMessageType",tolua_AllToLua_cCompositeChat_GetMessageType00);
   tolua_function(tolua_S,"GetAdditionalMessageTypeData",tolua_AllToLua_cCompositeChat_GetAdditionalMessageTypeData00);
   tolua_function(tolua_S,"ExtractText",tolua_AllToLua_cCompositeChat_ExtractText00);
   tolua_function(tolua_S,"CreateJsonString",tolua_AllToLua_cCompositeChat_CreateJsonString00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cMap","cMap","",nullptr);
  tolua_beginmodule(tolua_S,"cMap");
   tolua_constant(tolua_S,"E_BASE_COLOR_TRANSPARENT",cMap::E_BASE_COLOR_TRANSPARENT);
   tolua_constant(tolua_S,"E_BASE_COLOR_LIGHT_GREEN",cMap::E_BASE_COLOR_LIGHT_GREEN);
   tolua_constant(tolua_S,"E_BASE_COLOR_LIGHT_BLUE",cMap::E_BASE_COLOR_LIGHT_BLUE);
   tolua_constant(tolua_S,"E_BASE_COLOR_LIGHT_BROWN",cMap::E_BASE_COLOR_LIGHT_BROWN);
   tolua_constant(tolua_S,"E_BASE_COLOR_GRAY_1",cMap::E_BASE_COLOR_GRAY_1);
   tolua_constant(tolua_S,"E_BASE_COLOR_RED",cMap::E_BASE_COLOR_RED);
   tolua_constant(tolua_S,"E_BASE_COLOR_PALE_BLUE",cMap::E_BASE_COLOR_PALE_BLUE);
   tolua_constant(tolua_S,"E_BASE_COLOR_GRAY_2",cMap::E_BASE_COLOR_GRAY_2);
   tolua_constant(tolua_S,"E_BASE_COLOR_DARK_GREEN",cMap::E_BASE_COLOR_DARK_GREEN);
   tolua_constant(tolua_S,"E_BASE_COLOR_WHITE",cMap::E_BASE_COLOR_WHITE);
   tolua_constant(tolua_S,"E_BASE_COLOR_LIGHT_GRAY",cMap::E_BASE_COLOR_LIGHT_GRAY);
   tolua_constant(tolua_S,"E_BASE_COLOR_BROWN",cMap::E_BASE_COLOR_BROWN);
   tolua_constant(tolua_S,"E_BASE_COLOR_DARK_GRAY",cMap::E_BASE_COLOR_DARK_GRAY);
   tolua_constant(tolua_S,"E_BASE_COLOR_BLUE",cMap::E_BASE_COLOR_BLUE);
   tolua_constant(tolua_S,"E_BASE_COLOR_DARK_BROWN",cMap::E_BASE_COLOR_DARK_BROWN);
   tolua_function(tolua_S,"Resize",tolua_AllToLua_cMap_Resize00);
   tolua_function(tolua_S,"SetPosition",tolua_AllToLua_cMap_SetPosition00);
   tolua_function(tolua_S,"SetScale",tolua_AllToLua_cMap_SetScale00);
   tolua_function(tolua_S,"SetPixel",tolua_AllToLua_cMap_SetPixel00);
   tolua_function(tolua_S,"GetPixel",tolua_AllToLua_cMap_GetPixel00);
   tolua_function(tolua_S,"GetWidth",tolua_AllToLua_cMap_GetWidth00);
   tolua_function(tolua_S,"GetHeight",tolua_AllToLua_cMap_GetHeight00);
   tolua_function(tolua_S,"GetScale",tolua_AllToLua_cMap_GetScale00);
   tolua_function(tolua_S,"GetCenterX",tolua_AllToLua_cMap_GetCenterX00);
   tolua_function(tolua_S,"GetCenterZ",tolua_AllToLua_cMap_GetCenterZ00);
   tolua_function(tolua_S,"GetID",tolua_AllToLua_cMap_GetID00);
   tolua_function(tolua_S,"GetWorld",tolua_AllToLua_cMap_GetWorld00);
   tolua_function(tolua_S,"GetName",tolua_AllToLua_cMap_GetName00);
   tolua_function(tolua_S,"GetDimension",tolua_AllToLua_cMap_GetDimension00);
   tolua_function(tolua_S,"GetNumPixels",tolua_AllToLua_cMap_GetNumPixels00);
   tolua_function(tolua_S,"GetPixelWidth",tolua_AllToLua_cMap_GetPixelWidth00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cMapManager","cMapManager","",nullptr);
  tolua_beginmodule(tolua_S,"cMapManager");
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cObjective","cObjective","",nullptr);
  tolua_beginmodule(tolua_S,"cObjective");
   tolua_constant(tolua_S,"otDummy",cObjective::otDummy);
   tolua_constant(tolua_S,"otDeathCount",cObjective::otDeathCount);
   tolua_constant(tolua_S,"otPlayerKillCount",cObjective::otPlayerKillCount);
   tolua_constant(tolua_S,"otTotalKillCount",cObjective::otTotalKillCount);
   tolua_constant(tolua_S,"otHealth",cObjective::otHealth);
   tolua_constant(tolua_S,"otAchievement",cObjective::otAchievement);
   tolua_constant(tolua_S,"otStat",cObjective::otStat);
   tolua_constant(tolua_S,"otStatItemCraft",cObjective::otStatItemCraft);
   tolua_constant(tolua_S,"otStatItemUse",cObjective::otStatItemUse);
   tolua_constant(tolua_S,"otStatItemBreak",cObjective::otStatItemBreak);
   tolua_constant(tolua_S,"otStatBlockMine",cObjective::otStatBlockMine);
   tolua_constant(tolua_S,"otStatEntityKill",cObjective::otStatEntityKill);
   tolua_constant(tolua_S,"otStatEntityKilledBy",cObjective::otStatEntityKilledBy);
   tolua_function(tolua_S,"GetType",tolua_AllToLua_cObjective_GetType00);
   tolua_function(tolua_S,"GetName",tolua_AllToLua_cObjective_GetName00);
   tolua_function(tolua_S,"GetDisplayName",tolua_AllToLua_cObjective_GetDisplayName00);
   tolua_function(tolua_S,"Reset",tolua_AllToLua_cObjective_Reset00);
   tolua_function(tolua_S,"GetScore",tolua_AllToLua_cObjective_GetScore00);
   tolua_function(tolua_S,"SetScore",tolua_AllToLua_cObjective_SetScore00);
   tolua_function(tolua_S,"ResetScore",tolua_AllToLua_cObjective_ResetScore00);
   tolua_function(tolua_S,"AddScore",tolua_AllToLua_cObjective_AddScore00);
   tolua_function(tolua_S,"SubScore",tolua_AllToLua_cObjective_SubScore00);
   tolua_function(tolua_S,"SetDisplayName",tolua_AllToLua_cObjective_SetDisplayName00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cTeam","cTeam","",nullptr);
  tolua_beginmodule(tolua_S,"cTeam");
   tolua_function(tolua_S,"AddPlayer",tolua_AllToLua_cTeam_AddPlayer00);
   tolua_function(tolua_S,"RemovePlayer",tolua_AllToLua_cTeam_RemovePlayer00);
   tolua_function(tolua_S,"HasPlayer",tolua_AllToLua_cTeam_HasPlayer00);
   tolua_function(tolua_S,"Reset",tolua_AllToLua_cTeam_Reset00);
   tolua_function(tolua_S,"GetNumPlayers",tolua_AllToLua_cTeam_GetNumPlayers00);
   tolua_function(tolua_S,"AllowsFriendlyFire",tolua_AllToLua_cTeam_AllowsFriendlyFire00);
   tolua_function(tolua_S,"CanSeeFriendlyInvisible",tolua_AllToLua_cTeam_CanSeeFriendlyInvisible00);
   tolua_function(tolua_S,"GetDisplayName",tolua_AllToLua_cTeam_GetDisplayName00);
   tolua_function(tolua_S,"GetName",tolua_AllToLua_cTeam_GetName00);
   tolua_function(tolua_S,"GetPrefix",tolua_AllToLua_cTeam_GetPrefix00);
   tolua_function(tolua_S,"GetSuffix",tolua_AllToLua_cTeam_GetSuffix00);
   tolua_function(tolua_S,"SetFriendlyFire",tolua_AllToLua_cTeam_SetFriendlyFire00);
   tolua_function(tolua_S,"SetCanSeeFriendlyInvisible",tolua_AllToLua_cTeam_SetCanSeeFriendlyInvisible00);
   tolua_function(tolua_S,"SetDisplayName",tolua_AllToLua_cTeam_SetDisplayName00);
   tolua_function(tolua_S,"SetPrefix",tolua_AllToLua_cTeam_SetPrefix00);
   tolua_function(tolua_S,"SetSuffix",tolua_AllToLua_cTeam_SetSuffix00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cScoreboard","cScoreboard","",nullptr);
  tolua_beginmodule(tolua_S,"cScoreboard");
   tolua_constant(tolua_S,"dsList",cScoreboard::dsList);
   tolua_constant(tolua_S,"dsSidebar",cScoreboard::dsSidebar);
   tolua_constant(tolua_S,"dsName",cScoreboard::dsName);
   tolua_constant(tolua_S,"dsCount",cScoreboard::dsCount);
   tolua_function(tolua_S,"RegisterObjective",tolua_AllToLua_cScoreboard_RegisterObjective00);
   tolua_function(tolua_S,"RemoveObjective",tolua_AllToLua_cScoreboard_RemoveObjective00);
   tolua_function(tolua_S,"GetObjective",tolua_AllToLua_cScoreboard_GetObjective00);
   tolua_function(tolua_S,"RegisterTeam",tolua_AllToLua_cScoreboard_RegisterTeam00);
   tolua_function(tolua_S,"RemoveTeam",tolua_AllToLua_cScoreboard_RemoveTeam00);
   tolua_function(tolua_S,"GetTeam",tolua_AllToLua_cScoreboard_GetTeam00);
   tolua_function(tolua_S,"SetDisplay",tolua_AllToLua_cScoreboard_SetDisplay00);
   tolua_function(tolua_S,"GetObjectiveIn",tolua_AllToLua_cScoreboard_GetObjectiveIn00);
   tolua_function(tolua_S,"GetNumObjectives",tolua_AllToLua_cScoreboard_GetNumObjectives00);
   tolua_function(tolua_S,"GetNumTeams",tolua_AllToLua_cScoreboard_GetNumTeams00);
   tolua_function(tolua_S,"AddPlayerScore",tolua_AllToLua_cScoreboard_AddPlayerScore00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cMojangAPI","cMojangAPI","",nullptr);
  tolua_beginmodule(tolua_S,"cMojangAPI");
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"cUUID","cUUID","",tolua_collect_cUUID);
  #else
  tolua_cclass(tolua_S,"cUUID","cUUID","",nullptr);
  #endif
  tolua_beginmodule(tolua_S,"cUUID");
   tolua_function(tolua_S,"new",tolua_AllToLua_cUUID_new00);
   tolua_function(tolua_S,"new_local",tolua_AllToLua_cUUID_new00_local);
   tolua_function(tolua_S,".call",tolua_AllToLua_cUUID_new00_local);
   tolua_function(tolua_S,"Compare",tolua_AllToLua_cUUID_Compare00);
   tolua_function(tolua_S,"IsNil",tolua_AllToLua_cUUID_IsNil00);
   tolua_function(tolua_S,"FromString",tolua_AllToLua_cUUID_FromString00);
   tolua_function(tolua_S,"ToShortString",tolua_AllToLua_cUUID_ToShortString00);
   tolua_function(tolua_S,"ToLongString",tolua_AllToLua_cUUID_ToLongString00);
   tolua_function(tolua_S,"Version",tolua_AllToLua_cUUID_Version00);
   tolua_function(tolua_S,"Variant",tolua_AllToLua_cUUID_Variant00);
   tolua_function(tolua_S,"GenerateVersion3",tolua_AllToLua_cUUID_GenerateVersion300);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"TakeDamageInfo","TakeDamageInfo","",nullptr);
  tolua_beginmodule(tolua_S,"TakeDamageInfo");
   tolua_variable(tolua_S,"DamageType",tolua_get_TakeDamageInfo_DamageType,tolua_set_TakeDamageInfo_DamageType);
   tolua_variable(tolua_S,"Attacker",tolua_get_TakeDamageInfo_Attacker_ptr,tolua_set_TakeDamageInfo_Attacker_ptr);
   tolua_variable(tolua_S,"RawDamage",tolua_get_TakeDamageInfo_RawDamage,tolua_set_TakeDamageInfo_RawDamage);
   tolua_variable(tolua_S,"FinalDamage",tolua_get_TakeDamageInfo_FinalDamage,tolua_set_TakeDamageInfo_FinalDamage);
   tolua_variable(tolua_S,"Knockback",tolua_get_TakeDamageInfo_Knockback,tolua_set_TakeDamageInfo_Knockback);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cEntity","cEntity","",nullptr);
  tolua_beginmodule(tolua_S,"cEntity");
   tolua_constant(tolua_S,"etEntity",cEntity::etEntity);
   tolua_constant(tolua_S,"etEnderCrystal",cEntity::etEnderCrystal);
   tolua_constant(tolua_S,"etPlayer",cEntity::etPlayer);
   tolua_constant(tolua_S,"etPickup",cEntity::etPickup);
   tolua_constant(tolua_S,"etMonster",cEntity::etMonster);
   tolua_constant(tolua_S,"etFallingBlock",cEntity::etFallingBlock);
   tolua_constant(tolua_S,"etMinecart",cEntity::etMinecart);
   tolua_constant(tolua_S,"etBoat",cEntity::etBoat);
   tolua_constant(tolua_S,"etTNT",cEntity::etTNT);
   tolua_constant(tolua_S,"etProjectile",cEntity::etProjectile);
   tolua_constant(tolua_S,"etExpOrb",cEntity::etExpOrb);
   tolua_constant(tolua_S,"etFloater",cEntity::etFloater);
   tolua_constant(tolua_S,"etItemFrame",cEntity::etItemFrame);
   tolua_constant(tolua_S,"etPainting",cEntity::etPainting);
   tolua_constant(tolua_S,"etLeashKnot",cEntity::etLeashKnot);
   tolua_constant(tolua_S,"etMob",cEntity::etMob);
   tolua_function(tolua_S,"GetEntityType",tolua_AllToLua_cEntity_GetEntityType00);
   tolua_function(tolua_S,"IsArrow",tolua_AllToLua_cEntity_IsArrow00);
   tolua_function(tolua_S,"IsEnderCrystal",tolua_AllToLua_cEntity_IsEnderCrystal00);
   tolua_function(tolua_S,"IsPlayer",tolua_AllToLua_cEntity_IsPlayer00);
   tolua_function(tolua_S,"IsPickup",tolua_AllToLua_cEntity_IsPickup00);
   tolua_function(tolua_S,"IsMob",tolua_AllToLua_cEntity_IsMob00);
   tolua_function(tolua_S,"IsPawn",tolua_AllToLua_cEntity_IsPawn00);
   tolua_function(tolua_S,"IsFallingBlock",tolua_AllToLua_cEntity_IsFallingBlock00);
   tolua_function(tolua_S,"IsMinecart",tolua_AllToLua_cEntity_IsMinecart00);
   tolua_function(tolua_S,"IsBoat",tolua_AllToLua_cEntity_IsBoat00);
   tolua_function(tolua_S,"IsTNT",tolua_AllToLua_cEntity_IsTNT00);
   tolua_function(tolua_S,"IsProjectile",tolua_AllToLua_cEntity_IsProjectile00);
   tolua_function(tolua_S,"IsExpOrb",tolua_AllToLua_cEntity_IsExpOrb00);
   tolua_function(tolua_S,"IsFloater",tolua_AllToLua_cEntity_IsFloater00);
   tolua_function(tolua_S,"IsItemFrame",tolua_AllToLua_cEntity_IsItemFrame00);
   tolua_function(tolua_S,"IsLeashKnot",tolua_AllToLua_cEntity_IsLeashKnot00);
   tolua_function(tolua_S,"IsPainting",tolua_AllToLua_cEntity_IsPainting00);
   tolua_function(tolua_S,"IsA",tolua_AllToLua_cEntity_IsA00);
   tolua_function(tolua_S,"GetClassStatic",tolua_AllToLua_cEntity_GetClassStatic00);
   tolua_function(tolua_S,"GetClass",tolua_AllToLua_cEntity_GetClass00);
   tolua_function(tolua_S,"GetParentClass",tolua_AllToLua_cEntity_GetParentClass00);
   tolua_function(tolua_S,"DoesPreventBlockPlacement",tolua_AllToLua_cEntity_DoesPreventBlockPlacement00);
   tolua_function(tolua_S,"GetWorld",tolua_AllToLua_cEntity_GetWorld00);
   tolua_function(tolua_S,"GetHeadYaw",tolua_AllToLua_cEntity_GetHeadYaw00);
   tolua_function(tolua_S,"GetHeight",tolua_AllToLua_cEntity_GetHeight00);
   tolua_function(tolua_S,"GetMass",tolua_AllToLua_cEntity_GetMass00);
   tolua_function(tolua_S,"GetPosX",tolua_AllToLua_cEntity_GetPosX00);
   tolua_function(tolua_S,"GetPosY",tolua_AllToLua_cEntity_GetPosY00);
   tolua_function(tolua_S,"GetPosZ",tolua_AllToLua_cEntity_GetPosZ00);
   tolua_function(tolua_S,"GetYaw",tolua_AllToLua_cEntity_GetYaw00);
   tolua_function(tolua_S,"GetPitch",tolua_AllToLua_cEntity_GetPitch00);
   tolua_function(tolua_S,"GetRoll",tolua_AllToLua_cEntity_GetRoll00);
   tolua_function(tolua_S,"GetLookVector",tolua_AllToLua_cEntity_GetLookVector00);
   tolua_function(tolua_S,"GetSpeedX",tolua_AllToLua_cEntity_GetSpeedX00);
   tolua_function(tolua_S,"GetSpeedY",tolua_AllToLua_cEntity_GetSpeedY00);
   tolua_function(tolua_S,"GetSpeedZ",tolua_AllToLua_cEntity_GetSpeedZ00);
   tolua_function(tolua_S,"GetWidth",tolua_AllToLua_cEntity_GetWidth00);
   tolua_function(tolua_S,"GetChunkX",tolua_AllToLua_cEntity_GetChunkX00);
   tolua_function(tolua_S,"GetChunkZ",tolua_AllToLua_cEntity_GetChunkZ00);
   tolua_function(tolua_S,"GetBoundingBox",tolua_AllToLua_cEntity_GetBoundingBox00);
   tolua_function(tolua_S,"SetHeadYaw",tolua_AllToLua_cEntity_SetHeadYaw00);
   tolua_function(tolua_S,"SetMass",tolua_AllToLua_cEntity_SetMass00);
   tolua_function(tolua_S,"SetPosX",tolua_AllToLua_cEntity_SetPosX00);
   tolua_function(tolua_S,"SetPosY",tolua_AllToLua_cEntity_SetPosY00);
   tolua_function(tolua_S,"SetPosZ",tolua_AllToLua_cEntity_SetPosZ00);
   tolua_function(tolua_S,"SetPosition",tolua_AllToLua_cEntity_SetPosition00);
   tolua_function(tolua_S,"SetPosition",tolua_AllToLua_cEntity_SetPosition01);
   tolua_function(tolua_S,"SetYaw",tolua_AllToLua_cEntity_SetYaw00);
   tolua_function(tolua_S,"SetPitch",tolua_AllToLua_cEntity_SetPitch00);
   tolua_function(tolua_S,"SetRoll",tolua_AllToLua_cEntity_SetRoll00);
   tolua_function(tolua_S,"SetSpeed",tolua_AllToLua_cEntity_SetSpeed00);
   tolua_function(tolua_S,"SetSpeed",tolua_AllToLua_cEntity_SetSpeed01);
   tolua_function(tolua_S,"SetSpeedX",tolua_AllToLua_cEntity_SetSpeedX00);
   tolua_function(tolua_S,"SetSpeedY",tolua_AllToLua_cEntity_SetSpeedY00);
   tolua_function(tolua_S,"SetSpeedZ",tolua_AllToLua_cEntity_SetSpeedZ00);
   tolua_function(tolua_S,"AddPosX",tolua_AllToLua_cEntity_AddPosX00);
   tolua_function(tolua_S,"AddPosY",tolua_AllToLua_cEntity_AddPosY00);
   tolua_function(tolua_S,"AddPosZ",tolua_AllToLua_cEntity_AddPosZ00);
   tolua_function(tolua_S,"AddPosition",tolua_AllToLua_cEntity_AddPosition00);
   tolua_function(tolua_S,"AddPosition",tolua_AllToLua_cEntity_AddPosition01);
   tolua_function(tolua_S,"AddSpeed",tolua_AllToLua_cEntity_AddSpeed00);
   tolua_function(tolua_S,"AddSpeed",tolua_AllToLua_cEntity_AddSpeed01);
   tolua_function(tolua_S,"AddSpeedX",tolua_AllToLua_cEntity_AddSpeedX00);
   tolua_function(tolua_S,"AddSpeedY",tolua_AllToLua_cEntity_AddSpeedY00);
   tolua_function(tolua_S,"AddSpeedZ",tolua_AllToLua_cEntity_AddSpeedZ00);
   tolua_function(tolua_S,"HandleSpeedFromAttachee",tolua_AllToLua_cEntity_HandleSpeedFromAttachee00);
   tolua_function(tolua_S,"SteerVehicle",tolua_AllToLua_cEntity_SteerVehicle00);
   tolua_function(tolua_S,"GetUniqueID",tolua_AllToLua_cEntity_GetUniqueID00);
   tolua_function(tolua_S,"IsDestroyed",tolua_AllToLua_cEntity_IsDestroyed00);
   tolua_function(tolua_S,"IsTicking",tolua_AllToLua_cEntity_IsTicking00);
   tolua_function(tolua_S,"TakeDamage",tolua_AllToLua_cEntity_TakeDamage00);
   tolua_function(tolua_S,"TakeDamage",tolua_AllToLua_cEntity_TakeDamage01);
   tolua_function(tolua_S,"TakeDamage",tolua_AllToLua_cEntity_TakeDamage02);
   tolua_function(tolua_S,"TakeDamage",tolua_AllToLua_cEntity_TakeDamage03);
   tolua_function(tolua_S,"GetGravity",tolua_AllToLua_cEntity_GetGravity00);
   tolua_function(tolua_S,"SetGravity",tolua_AllToLua_cEntity_SetGravity00);
   tolua_function(tolua_S,"GetAirDrag",tolua_AllToLua_cEntity_GetAirDrag00);
   tolua_function(tolua_S,"SetAirDrag",tolua_AllToLua_cEntity_SetAirDrag00);
   tolua_function(tolua_S,"SetYawFromSpeed",tolua_AllToLua_cEntity_SetYawFromSpeed00);
   tolua_function(tolua_S,"SetPitchFromSpeed",tolua_AllToLua_cEntity_SetPitchFromSpeed00);
   tolua_function(tolua_S,"GetRawDamageAgainst",tolua_AllToLua_cEntity_GetRawDamageAgainst00);
   tolua_function(tolua_S,"ArmorCoversAgainst",tolua_AllToLua_cEntity_ArmorCoversAgainst00);
   tolua_function(tolua_S,"GetArmorCoverAgainst",tolua_AllToLua_cEntity_GetArmorCoverAgainst00);
   tolua_function(tolua_S,"GetEnchantmentCoverAgainst",tolua_AllToLua_cEntity_GetEnchantmentCoverAgainst00);
   tolua_function(tolua_S,"GetEnchantmentBlastKnockbackReduction",tolua_AllToLua_cEntity_GetEnchantmentBlastKnockbackReduction00);
   tolua_function(tolua_S,"GetKnockbackAmountAgainst",tolua_AllToLua_cEntity_GetKnockbackAmountAgainst00);
   tolua_function(tolua_S,"GetEquippedWeapon",tolua_AllToLua_cEntity_GetEquippedWeapon00);
   tolua_function(tolua_S,"GetEquippedHelmet",tolua_AllToLua_cEntity_GetEquippedHelmet00);
   tolua_function(tolua_S,"GetEquippedChestplate",tolua_AllToLua_cEntity_GetEquippedChestplate00);
   tolua_function(tolua_S,"GetEquippedLeggings",tolua_AllToLua_cEntity_GetEquippedLeggings00);
   tolua_function(tolua_S,"GetEquippedBoots",tolua_AllToLua_cEntity_GetEquippedBoots00);
   tolua_function(tolua_S,"GetOffHandEquipedItem",tolua_AllToLua_cEntity_GetOffHandEquipedItem00);
   tolua_function(tolua_S,"ApplyArmorDamage",tolua_AllToLua_cEntity_ApplyArmorDamage00);
   tolua_function(tolua_S,"Killed",tolua_AllToLua_cEntity_Killed00);
   tolua_function(tolua_S,"Heal",tolua_AllToLua_cEntity_Heal00);
   tolua_function(tolua_S,"GetHealth",tolua_AllToLua_cEntity_GetHealth00);
   tolua_function(tolua_S,"SetHealth",tolua_AllToLua_cEntity_SetHealth00);
   tolua_function(tolua_S,"SetMaxHealth",tolua_AllToLua_cEntity_SetMaxHealth00);
   tolua_function(tolua_S,"GetMaxHealth",tolua_AllToLua_cEntity_GetMaxHealth00);
   tolua_function(tolua_S,"SetIsFireproof",tolua_AllToLua_cEntity_SetIsFireproof00);
   tolua_function(tolua_S,"IsFireproof",tolua_AllToLua_cEntity_IsFireproof00);
   tolua_function(tolua_S,"StartBurning",tolua_AllToLua_cEntity_StartBurning00);
   tolua_function(tolua_S,"StopBurning",tolua_AllToLua_cEntity_StopBurning00);
   tolua_function(tolua_S,"TeleportToEntity",tolua_AllToLua_cEntity_TeleportToEntity00);
   tolua_function(tolua_S,"TeleportToCoords",tolua_AllToLua_cEntity_TeleportToCoords00);
   tolua_function(tolua_S,"MoveToWorld",tolua_AllToLua_cEntity_MoveToWorld00);
   tolua_function(tolua_S,"MoveToWorld",tolua_AllToLua_cEntity_MoveToWorld01);
   tolua_function(tolua_S,"MoveToWorld",tolua_AllToLua_cEntity_MoveToWorld02);
   tolua_function(tolua_S,"MoveToWorld",tolua_AllToLua_cEntity_MoveToWorld03);
   tolua_function(tolua_S,"IsCrouched",tolua_AllToLua_cEntity_IsCrouched00);
   tolua_function(tolua_S,"IsElytraFlying",tolua_AllToLua_cEntity_IsElytraFlying00);
   tolua_function(tolua_S,"IsInvisible",tolua_AllToLua_cEntity_IsInvisible00);
   tolua_function(tolua_S,"IsOnFire",tolua_AllToLua_cEntity_IsOnFire00);
   tolua_function(tolua_S,"IsRclking",tolua_AllToLua_cEntity_IsRclking00);
   tolua_function(tolua_S,"IsRiding",tolua_AllToLua_cEntity_IsRiding00);
   tolua_function(tolua_S,"IsSprinting",tolua_AllToLua_cEntity_IsSprinting00);
   tolua_function(tolua_S,"IsInFire",tolua_AllToLua_cEntity_IsInFire00);
   tolua_function(tolua_S,"IsInLava",tolua_AllToLua_cEntity_IsInLava00);
   tolua_function(tolua_S,"IsInWater",tolua_AllToLua_cEntity_IsInWater00);
   tolua_function(tolua_S,"IsHeadInWater",tolua_AllToLua_cEntity_IsHeadInWater00);
   tolua_function(tolua_S,"GetAirLevel",tolua_AllToLua_cEntity_GetAirLevel00);
   tolua_function(tolua_S,"GetTicksAlive",tolua_AllToLua_cEntity_GetTicksAlive00);
   tolua_function(tolua_S,"GetInvulnerableTicks",tolua_AllToLua_cEntity_GetInvulnerableTicks00);
   tolua_function(tolua_S,"SetInvulnerableTicks",tolua_AllToLua_cEntity_SetInvulnerableTicks00);
   tolua_function(tolua_S,"IsOnGround",tolua_AllToLua_cEntity_IsOnGround00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cEnderCrystal","cEnderCrystal","cEntity",nullptr);
  tolua_beginmodule(tolua_S,"cEnderCrystal");
   tolua_function(tolua_S,"GetBeamTarget",tolua_AllToLua_cEnderCrystal_GetBeamTarget00);
   tolua_function(tolua_S,"SetBeamTarget",tolua_AllToLua_cEnderCrystal_SetBeamTarget00);
   tolua_function(tolua_S,"DisplaysBeam",tolua_AllToLua_cEnderCrystal_DisplaysBeam00);
   tolua_function(tolua_S,"SetDisplayBeam",tolua_AllToLua_cEnderCrystal_SetDisplayBeam00);
   tolua_function(tolua_S,"ShowsBottom",tolua_AllToLua_cEnderCrystal_ShowsBottom00);
   tolua_function(tolua_S,"SetShowBottom",tolua_AllToLua_cEnderCrystal_SetShowBottom00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cBoat","cBoat","cEntity",nullptr);
  tolua_beginmodule(tolua_S,"cBoat");
   tolua_constant(tolua_S,"bmOak",cBoat::bmOak);
   tolua_constant(tolua_S,"bmSpruce",cBoat::bmSpruce);
   tolua_constant(tolua_S,"bmBirch",cBoat::bmBirch);
   tolua_constant(tolua_S,"bmJungle",cBoat::bmJungle);
   tolua_constant(tolua_S,"bmAcacia",cBoat::bmAcacia);
   tolua_constant(tolua_S,"bmDarkOak",cBoat::bmDarkOak);
   tolua_function(tolua_S,"GetMaterial",tolua_AllToLua_cBoat_GetMaterial00);
   tolua_function(tolua_S,"SetMaterial",tolua_AllToLua_cBoat_SetMaterial00);
   tolua_function(tolua_S,"ItemToMaterial",tolua_AllToLua_cBoat_ItemToMaterial00);
   tolua_function(tolua_S,"MaterialToItem",tolua_AllToLua_cBoat_MaterialToItem00);
   tolua_function(tolua_S,"MaterialToString",tolua_AllToLua_cBoat_MaterialToString00);
   tolua_function(tolua_S,"StringToMaterial",tolua_AllToLua_cBoat_StringToMaterial00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cPawn","cPawn","cEntity",nullptr);
  tolua_beginmodule(tolua_S,"cPawn");
   tolua_function(tolua_S,"AddEntityEffect",tolua_AllToLua_cPawn_AddEntityEffect00);
   tolua_function(tolua_S,"RemoveEntityEffect",tolua_AllToLua_cPawn_RemoveEntityEffect00);
   tolua_function(tolua_S,"HasEntityEffect",tolua_AllToLua_cPawn_HasEntityEffect00);
   tolua_function(tolua_S,"ClearEntityEffects",tolua_AllToLua_cPawn_ClearEntityEffects00);
   tolua_function(tolua_S,"FindTeleportDestination",tolua_AllToLua_cPawn_FindTeleportDestination00);
   tolua_function(tolua_S,"FindTeleportDestination",tolua_AllToLua_cPawn_FindTeleportDestination01);
   tolua_function(tolua_S,"FindTeleportDestination",tolua_AllToLua_cPawn_FindTeleportDestination02);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cProjectileEntity","cProjectileEntity","cEntity",nullptr);
  tolua_beginmodule(tolua_S,"cProjectileEntity");
   tolua_constant(tolua_S,"pkArrow",cProjectileEntity::pkArrow);
   tolua_constant(tolua_S,"pkSnowball",cProjectileEntity::pkSnowball);
   tolua_constant(tolua_S,"pkEgg",cProjectileEntity::pkEgg);
   tolua_constant(tolua_S,"pkGhastFireball",cProjectileEntity::pkGhastFireball);
   tolua_constant(tolua_S,"pkFireCharge",cProjectileEntity::pkFireCharge);
   tolua_constant(tolua_S,"pkEnderPearl",cProjectileEntity::pkEnderPearl);
   tolua_constant(tolua_S,"pkExpBottle",cProjectileEntity::pkExpBottle);
   tolua_constant(tolua_S,"pkSplashPotion",cProjectileEntity::pkSplashPotion);
   tolua_constant(tolua_S,"pkFirework",cProjectileEntity::pkFirework);
   tolua_constant(tolua_S,"pkWitherSkull",cProjectileEntity::pkWitherSkull);
   tolua_function(tolua_S,"GetProjectileKind",tolua_AllToLua_cProjectileEntity_GetProjectileKind00);
   tolua_function(tolua_S,"GetCreatorUniqueID",tolua_AllToLua_cProjectileEntity_GetCreatorUniqueID00);
   tolua_function(tolua_S,"GetCreatorName",tolua_AllToLua_cProjectileEntity_GetCreatorName00);
   tolua_function(tolua_S,"GetMCAClassName",tolua_AllToLua_cProjectileEntity_GetMCAClassName00);
   tolua_function(tolua_S,"IsInGround",tolua_AllToLua_cProjectileEntity_IsInGround00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cArrowEntity","cArrowEntity","cProjectileEntity",nullptr);
  tolua_beginmodule(tolua_S,"cArrowEntity");
   tolua_constant(tolua_S,"psNoPickup",cArrowEntity::psNoPickup);
   tolua_constant(tolua_S,"psInSurvivalOrCreative",cArrowEntity::psInSurvivalOrCreative);
   tolua_constant(tolua_S,"psInCreative",cArrowEntity::psInCreative);
   tolua_function(tolua_S,"GetPickupState",tolua_AllToLua_cArrowEntity_GetPickupState00);
   tolua_function(tolua_S,"SetPickupState",tolua_AllToLua_cArrowEntity_SetPickupState00);
   tolua_function(tolua_S,"GetDamageCoeff",tolua_AllToLua_cArrowEntity_GetDamageCoeff00);
   tolua_function(tolua_S,"SetDamageCoeff",tolua_AllToLua_cArrowEntity_SetDamageCoeff00);
   tolua_function(tolua_S,"CanPickup",tolua_AllToLua_cArrowEntity_CanPickup00);
   tolua_function(tolua_S,"IsCritical",tolua_AllToLua_cArrowEntity_IsCritical00);
   tolua_function(tolua_S,"SetIsCritical",tolua_AllToLua_cArrowEntity_SetIsCritical00);
   tolua_function(tolua_S,"GetBlockHit",tolua_AllToLua_cArrowEntity_GetBlockHit00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cEntityEffect","cEntityEffect","",nullptr);
  tolua_beginmodule(tolua_S,"cEntityEffect");
   tolua_constant(tolua_S,"effNoEffect",cEntityEffect::effNoEffect);
   tolua_constant(tolua_S,"effSpeed",cEntityEffect::effSpeed);
   tolua_constant(tolua_S,"effSlowness",cEntityEffect::effSlowness);
   tolua_constant(tolua_S,"effHaste",cEntityEffect::effHaste);
   tolua_constant(tolua_S,"effMiningFatigue",cEntityEffect::effMiningFatigue);
   tolua_constant(tolua_S,"effStrength",cEntityEffect::effStrength);
   tolua_constant(tolua_S,"effInstantHealth",cEntityEffect::effInstantHealth);
   tolua_constant(tolua_S,"effInstantDamage",cEntityEffect::effInstantDamage);
   tolua_constant(tolua_S,"effJumpBoost",cEntityEffect::effJumpBoost);
   tolua_constant(tolua_S,"effNausea",cEntityEffect::effNausea);
   tolua_constant(tolua_S,"effRegeneration",cEntityEffect::effRegeneration);
   tolua_constant(tolua_S,"effResistance",cEntityEffect::effResistance);
   tolua_constant(tolua_S,"effFireResistance",cEntityEffect::effFireResistance);
   tolua_constant(tolua_S,"effWaterBreathing",cEntityEffect::effWaterBreathing);
   tolua_constant(tolua_S,"effInvisibility",cEntityEffect::effInvisibility);
   tolua_constant(tolua_S,"effBlindness",cEntityEffect::effBlindness);
   tolua_constant(tolua_S,"effNightVision",cEntityEffect::effNightVision);
   tolua_constant(tolua_S,"effHunger",cEntityEffect::effHunger);
   tolua_constant(tolua_S,"effWeakness",cEntityEffect::effWeakness);
   tolua_constant(tolua_S,"effPoison",cEntityEffect::effPoison);
   tolua_constant(tolua_S,"effWither",cEntityEffect::effWither);
   tolua_constant(tolua_S,"effHealthBoost",cEntityEffect::effHealthBoost);
   tolua_constant(tolua_S,"effAbsorption",cEntityEffect::effAbsorption);
   tolua_constant(tolua_S,"effSaturation",cEntityEffect::effSaturation);
   tolua_function(tolua_S,"GetPotionColor",tolua_AllToLua_cEntityEffect_GetPotionColor00);
   tolua_function(tolua_S,"GetPotionEffectType",tolua_AllToLua_cEntityEffect_GetPotionEffectType00);
   tolua_function(tolua_S,"GetPotionEffectIntensity",tolua_AllToLua_cEntityEffect_GetPotionEffectIntensity00);
   tolua_function(tolua_S,"GetPotionEffectDuration",tolua_AllToLua_cEntityEffect_GetPotionEffectDuration00);
   tolua_function(tolua_S,"IsPotionDrinkable",tolua_AllToLua_cEntityEffect_IsPotionDrinkable00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cExpBottleEntity","cExpBottleEntity","cProjectileEntity",nullptr);
  tolua_beginmodule(tolua_S,"cExpBottleEntity");
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cExpOrb","cExpOrb","cEntity",nullptr);
  tolua_beginmodule(tolua_S,"cExpOrb");
   tolua_function(tolua_S,"GetAge",tolua_AllToLua_cExpOrb_GetAge00);
   tolua_function(tolua_S,"SetAge",tolua_AllToLua_cExpOrb_SetAge00);
   tolua_function(tolua_S,"GetReward",tolua_AllToLua_cExpOrb_GetReward00);
   tolua_function(tolua_S,"SetReward",tolua_AllToLua_cExpOrb_SetReward00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cFallingBlock","cFallingBlock","cEntity",nullptr);
  tolua_beginmodule(tolua_S,"cFallingBlock");
   tolua_function(tolua_S,"GetBlockType",tolua_AllToLua_cFallingBlock_GetBlockType00);
   tolua_function(tolua_S,"GetBlockMeta",tolua_AllToLua_cFallingBlock_GetBlockMeta00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cFireChargeEntity","cFireChargeEntity","cProjectileEntity",nullptr);
  tolua_beginmodule(tolua_S,"cFireChargeEntity");
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cFireworkEntity","cFireworkEntity","cProjectileEntity",nullptr);
  tolua_beginmodule(tolua_S,"cFireworkEntity");
   tolua_function(tolua_S,"GetItem",tolua_AllToLua_cFireworkEntity_GetItem00);
   tolua_function(tolua_S,"SetItem",tolua_AllToLua_cFireworkEntity_SetItem00);
   tolua_function(tolua_S,"GetTicksToExplosion",tolua_AllToLua_cFireworkEntity_GetTicksToExplosion00);
   tolua_function(tolua_S,"SetTicksToExplosion",tolua_AllToLua_cFireworkEntity_SetTicksToExplosion00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cFloater","cFloater","cEntity",nullptr);
  tolua_beginmodule(tolua_S,"cFloater");
   tolua_function(tolua_S,"CanPickup",tolua_AllToLua_cFloater_CanPickup00);
   tolua_function(tolua_S,"GetOwnerID",tolua_AllToLua_cFloater_GetOwnerID00);
   tolua_function(tolua_S,"GetAttachedMobID",tolua_AllToLua_cFloater_GetAttachedMobID00);
   tolua_function(tolua_S,"GetBitePos",tolua_AllToLua_cFloater_GetBitePos00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cGhastFireballEntity","cGhastFireballEntity","cProjectileEntity",nullptr);
  tolua_beginmodule(tolua_S,"cGhastFireballEntity");
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cHangingEntity","cHangingEntity","cEntity",nullptr);
  tolua_beginmodule(tolua_S,"cHangingEntity");
   tolua_function(tolua_S,"GetFacing",tolua_AllToLua_cHangingEntity_GetFacing00);
   tolua_function(tolua_S,"IsValidSupportBlock",tolua_AllToLua_cHangingEntity_IsValidSupportBlock00);
   tolua_function(tolua_S,"SetFacing",tolua_AllToLua_cHangingEntity_SetFacing00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cItemFrame","cItemFrame","cHangingEntity",nullptr);
  tolua_beginmodule(tolua_S,"cItemFrame");
   tolua_function(tolua_S,"GetItem",tolua_AllToLua_cItemFrame_GetItem00);
   tolua_function(tolua_S,"SetItem",tolua_AllToLua_cItemFrame_SetItem00);
   tolua_function(tolua_S,"GetItemRotation",tolua_AllToLua_cItemFrame_GetItemRotation00);
   tolua_function(tolua_S,"SetItemRotation",tolua_AllToLua_cItemFrame_SetItemRotation00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cLeashKnot","cLeashKnot","cHangingEntity",nullptr);
  tolua_beginmodule(tolua_S,"cLeashKnot");
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cPlayer","cPlayer","cPawn",nullptr);
  tolua_beginmodule(tolua_S,"cPlayer");
   tolua_variable(tolua_S,"MAX_HEALTH",tolua_get_cPlayer_MAX_HEALTH,nullptr);
   tolua_variable(tolua_S,"MAX_FOOD_LEVEL",tolua_get_cPlayer_MAX_FOOD_LEVEL,nullptr);
   tolua_function(tolua_S,"SetCurrentExperience",tolua_AllToLua_cPlayer_SetCurrentExperience00);
   tolua_function(tolua_S,"DeltaExperience",tolua_AllToLua_cPlayer_DeltaExperience00);
   tolua_function(tolua_S,"GetXpLifetimeTotal",tolua_AllToLua_cPlayer_GetXpLifetimeTotal00);
   tolua_function(tolua_S,"GetCurrentXp",tolua_AllToLua_cPlayer_GetCurrentXp00);
   tolua_function(tolua_S,"GetXpLevel",tolua_AllToLua_cPlayer_GetXpLevel00);
   tolua_function(tolua_S,"GetXpPercentage",tolua_AllToLua_cPlayer_GetXpPercentage00);
   tolua_function(tolua_S,"XpForLevel",tolua_AllToLua_cPlayer_XpForLevel00);
   tolua_function(tolua_S,"CalcLevelFromXp",tolua_AllToLua_cPlayer_CalcLevelFromXp00);
   tolua_function(tolua_S,"GetEyeHeight",tolua_AllToLua_cPlayer_GetEyeHeight00);
   tolua_function(tolua_S,"GetEyePosition",tolua_AllToLua_cPlayer_GetEyePosition00);
   tolua_function(tolua_S,"GetInventory",tolua_AllToLua_cPlayer_GetInventory00);
   tolua_function(tolua_S,"GetEquippedItem",tolua_AllToLua_cPlayer_GetEquippedItem00);
   tolua_function(tolua_S,"Freeze",tolua_AllToLua_cPlayer_Freeze00);
   tolua_function(tolua_S,"IsFrozen",tolua_AllToLua_cPlayer_IsFrozen00);
   tolua_function(tolua_S,"Unfreeze",tolua_AllToLua_cPlayer_Unfreeze00);
   tolua_function(tolua_S,"SendRotation",tolua_AllToLua_cPlayer_SendRotation00);
   tolua_function(tolua_S,"SpectateEntity",tolua_AllToLua_cPlayer_SpectateEntity00);
   tolua_function(tolua_S,"GetThrowStartPos",tolua_AllToLua_cPlayer_GetThrowStartPos00);
   tolua_function(tolua_S,"GetThrowSpeed",tolua_AllToLua_cPlayer_GetThrowSpeed00);
   tolua_function(tolua_S,"GetGameMode",tolua_AllToLua_cPlayer_GetGameMode00);
   tolua_function(tolua_S,"GetEffectiveGameMode",tolua_AllToLua_cPlayer_GetEffectiveGameMode00);
   tolua_function(tolua_S,"SetGameMode",tolua_AllToLua_cPlayer_SetGameMode00);
   tolua_function(tolua_S,"IsGameModeCreative",tolua_AllToLua_cPlayer_IsGameModeCreative00);
   tolua_function(tolua_S,"IsGameModeSurvival",tolua_AllToLua_cPlayer_IsGameModeSurvival00);
   tolua_function(tolua_S,"IsGameModeAdventure",tolua_AllToLua_cPlayer_IsGameModeAdventure00);
   tolua_function(tolua_S,"IsGameModeSpectator",tolua_AllToLua_cPlayer_IsGameModeSpectator00);
   tolua_function(tolua_S,"IsFireproof",tolua_AllToLua_cPlayer_IsFireproof00);
   tolua_function(tolua_S,"CanMobsTarget",tolua_AllToLua_cPlayer_CanMobsTarget00);
   tolua_function(tolua_S,"GetIP",tolua_AllToLua_cPlayer_GetIP00);
   tolua_function(tolua_S,"GetStatistics",tolua_AllToLua_cPlayer_GetStatistics00);
   tolua_function(tolua_S,"GetTeam",tolua_AllToLua_cPlayer_GetTeam00);
   tolua_function(tolua_S,"GetTeam",tolua_AllToLua_cPlayer_GetTeam01);
   tolua_function(tolua_S,"SetTeam",tolua_AllToLua_cPlayer_SetTeam00);
   tolua_function(tolua_S,"ForceSetSpeed",tolua_AllToLua_cPlayer_ForceSetSpeed00);
   tolua_function(tolua_S,"GetWindow",tolua_AllToLua_cPlayer_GetWindow00);
   tolua_function(tolua_S,"OpenWindow",tolua_AllToLua_cPlayer_OpenWindow00);
   tolua_function(tolua_S,"CloseWindow",tolua_AllToLua_cPlayer_CloseWindow00);
   tolua_function(tolua_S,"CloseWindowIfID",tolua_AllToLua_cPlayer_CloseWindowIfID00);
   tolua_function(tolua_S,"GetClientHandle",tolua_AllToLua_cPlayer_GetClientHandle00);
   tolua_function(tolua_S,"SendMessage",tolua_AllToLua_cPlayer_SendMessage00);
   tolua_function(tolua_S,"SendMessageInfo",tolua_AllToLua_cPlayer_SendMessageInfo00);
   tolua_function(tolua_S,"SendMessageFailure",tolua_AllToLua_cPlayer_SendMessageFailure00);
   tolua_function(tolua_S,"SendMessageSuccess",tolua_AllToLua_cPlayer_SendMessageSuccess00);
   tolua_function(tolua_S,"SendMessageWarning",tolua_AllToLua_cPlayer_SendMessageWarning00);
   tolua_function(tolua_S,"SendMessageFatal",tolua_AllToLua_cPlayer_SendMessageFatal00);
   tolua_function(tolua_S,"SendMessagePrivateMsg",tolua_AllToLua_cPlayer_SendMessagePrivateMsg00);
   tolua_function(tolua_S,"SendMessage",tolua_AllToLua_cPlayer_SendMessage01);
   tolua_function(tolua_S,"SendMessageRaw",tolua_AllToLua_cPlayer_SendMessageRaw00);
   tolua_function(tolua_S,"SendSystemMessage",tolua_AllToLua_cPlayer_SendSystemMessage00);
   tolua_function(tolua_S,"SendAboveActionBarMessage",tolua_AllToLua_cPlayer_SendAboveActionBarMessage00);
   tolua_function(tolua_S,"SendSystemMessage",tolua_AllToLua_cPlayer_SendSystemMessage01);
   tolua_function(tolua_S,"SendAboveActionBarMessage",tolua_AllToLua_cPlayer_SendAboveActionBarMessage01);
   tolua_function(tolua_S,"GetName",tolua_AllToLua_cPlayer_GetName00);
   tolua_function(tolua_S,"HasPermission",tolua_AllToLua_cPlayer_HasPermission00);
   tolua_function(tolua_S,"GetColor",tolua_AllToLua_cPlayer_GetColor00);
   tolua_function(tolua_S,"GetPrefix",tolua_AllToLua_cPlayer_GetPrefix00);
   tolua_function(tolua_S,"GetSuffix",tolua_AllToLua_cPlayer_GetSuffix00);
   tolua_function(tolua_S,"GetPlayerListName",tolua_AllToLua_cPlayer_GetPlayerListName00);
   tolua_function(tolua_S,"TossEquippedItem",tolua_AllToLua_cPlayer_TossEquippedItem00);
   tolua_function(tolua_S,"ReplaceOneEquippedItemTossRest",tolua_AllToLua_cPlayer_ReplaceOneEquippedItemTossRest00);
   tolua_function(tolua_S,"TossHeldItem",tolua_AllToLua_cPlayer_TossHeldItem00);
   tolua_function(tolua_S,"TossPickup",tolua_AllToLua_cPlayer_TossPickup00);
   tolua_function(tolua_S,"Heal",tolua_AllToLua_cPlayer_Heal00);
   tolua_function(tolua_S,"GetFoodLevel",tolua_AllToLua_cPlayer_GetFoodLevel00);
   tolua_function(tolua_S,"GetFoodSaturationLevel",tolua_AllToLua_cPlayer_GetFoodSaturationLevel00);
   tolua_function(tolua_S,"GetFoodTickTimer",tolua_AllToLua_cPlayer_GetFoodTickTimer00);
   tolua_function(tolua_S,"GetFoodExhaustionLevel",tolua_AllToLua_cPlayer_GetFoodExhaustionLevel00);
   tolua_function(tolua_S,"IsSatiated",tolua_AllToLua_cPlayer_IsSatiated00);
   tolua_function(tolua_S,"SetFoodLevel",tolua_AllToLua_cPlayer_SetFoodLevel00);
   tolua_function(tolua_S,"SetFoodSaturationLevel",tolua_AllToLua_cPlayer_SetFoodSaturationLevel00);
   tolua_function(tolua_S,"SetFoodTickTimer",tolua_AllToLua_cPlayer_SetFoodTickTimer00);
   tolua_function(tolua_S,"SetFoodExhaustionLevel",tolua_AllToLua_cPlayer_SetFoodExhaustionLevel00);
   tolua_function(tolua_S,"Feed",tolua_AllToLua_cPlayer_Feed00);
   tolua_function(tolua_S,"AddFoodExhaustion",tolua_AllToLua_cPlayer_AddFoodExhaustion00);
   tolua_function(tolua_S,"IsEating",tolua_AllToLua_cPlayer_IsEating00);
   tolua_function(tolua_S,"IsFlying",tolua_AllToLua_cPlayer_IsFlying00);
   tolua_function(tolua_S,"IsInBed",tolua_AllToLua_cPlayer_IsInBed00);
   tolua_function(tolua_S,"IsLeftHanded",tolua_AllToLua_cPlayer_IsLeftHanded00);
   tolua_function(tolua_S,"IsFishing",tolua_AllToLua_cPlayer_IsFishing00);
   tolua_function(tolua_S,"SetIsFishing",tolua_AllToLua_cPlayer_SetIsFishing00);
   tolua_function(tolua_S,"GetFloaterID",tolua_AllToLua_cPlayer_GetFloaterID00);
   tolua_function(tolua_S,"Respawn",tolua_AllToLua_cPlayer_Respawn00);
   tolua_function(tolua_S,"SetVisible",tolua_AllToLua_cPlayer_SetVisible00);
   tolua_function(tolua_S,"GetDraggingItem",tolua_AllToLua_cPlayer_GetDraggingItem00);
   tolua_function(tolua_S,"SetDraggingItem",tolua_AllToLua_cPlayer_SetDraggingItem00);
   tolua_function(tolua_S,"GetMaxSpeed",tolua_AllToLua_cPlayer_GetMaxSpeed00);
   tolua_function(tolua_S,"GetNormalMaxSpeed",tolua_AllToLua_cPlayer_GetNormalMaxSpeed00);
   tolua_function(tolua_S,"GetSprintingMaxSpeed",tolua_AllToLua_cPlayer_GetSprintingMaxSpeed00);
   tolua_function(tolua_S,"GetFlyingMaxSpeed",tolua_AllToLua_cPlayer_GetFlyingMaxSpeed00);
   tolua_function(tolua_S,"SetNormalMaxSpeed",tolua_AllToLua_cPlayer_SetNormalMaxSpeed00);
   tolua_function(tolua_S,"SetSprintingMaxSpeed",tolua_AllToLua_cPlayer_SetSprintingMaxSpeed00);
   tolua_function(tolua_S,"SetFlyingMaxSpeed",tolua_AllToLua_cPlayer_SetFlyingMaxSpeed00);
   tolua_function(tolua_S,"SetCrouch",tolua_AllToLua_cPlayer_SetCrouch00);
   tolua_function(tolua_S,"SetElytraFlight",tolua_AllToLua_cPlayer_SetElytraFlight00);
   tolua_function(tolua_S,"SetFlying",tolua_AllToLua_cPlayer_SetFlying00);
   tolua_function(tolua_S,"SetLeftHanded",tolua_AllToLua_cPlayer_SetLeftHanded00);
   tolua_function(tolua_S,"SetSprint",tolua_AllToLua_cPlayer_SetSprint00);
   tolua_function(tolua_S,"SetCanFly",tolua_AllToLua_cPlayer_SetCanFly00);
   tolua_function(tolua_S,"HasCustomName",tolua_AllToLua_cPlayer_HasCustomName00);
   tolua_function(tolua_S,"GetCustomName",tolua_AllToLua_cPlayer_GetCustomName00);
   tolua_function(tolua_S,"SetCustomName",tolua_AllToLua_cPlayer_SetCustomName00);
   tolua_function(tolua_S,"GetLastBedPos",tolua_AllToLua_cPlayer_GetLastBedPos00);
   tolua_function(tolua_S,"IsRespawnPointForced",tolua_AllToLua_cPlayer_IsRespawnPointForced00);
   tolua_function(tolua_S,"SetBedPos",tolua_AllToLua_cPlayer_SetBedPos00);
   tolua_function(tolua_S,"SetBedPos",tolua_AllToLua_cPlayer_SetBedPos01);
   tolua_function(tolua_S,"SetRespawnPosition",tolua_AllToLua_cPlayer_SetRespawnPosition00);
   tolua_function(tolua_S,"CanFly",tolua_AllToLua_cPlayer_CanFly00);
   tolua_function(tolua_S,"LoadRank",tolua_AllToLua_cPlayer_LoadRank00);
   tolua_function(tolua_S,"SendBlocksAround",tolua_AllToLua_cPlayer_SendBlocksAround00);
   tolua_function(tolua_S,"HasSkinPart",tolua_AllToLua_cPlayer_HasSkinPart00);
   tolua_function(tolua_S,"GetSkinParts",tolua_AllToLua_cPlayer_GetSkinParts00);
   tolua_function(tolua_S,"SetSkinParts",tolua_AllToLua_cPlayer_SetSkinParts00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cPainting","cPainting","cHangingEntity",nullptr);
  tolua_beginmodule(tolua_S,"cPainting");
   tolua_function(tolua_S,"GetName",tolua_AllToLua_cPainting_GetName00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cPickup","cPickup","cEntity",nullptr);
  tolua_beginmodule(tolua_S,"cPickup");
   tolua_function(tolua_S,"GetItem",tolua_AllToLua_cPickup_GetItem00);
   tolua_function(tolua_S,"CollectedBy",tolua_AllToLua_cPickup_CollectedBy00);
   tolua_function(tolua_S,"CanCombine",tolua_AllToLua_cPickup_CanCombine00);
   tolua_function(tolua_S,"SetCanCombine",tolua_AllToLua_cPickup_SetCanCombine00);
   tolua_function(tolua_S,"GetAge",tolua_AllToLua_cPickup_GetAge00);
   tolua_function(tolua_S,"SetAge",tolua_AllToLua_cPickup_SetAge00);
   tolua_function(tolua_S,"GetLifetime",tolua_AllToLua_cPickup_GetLifetime00);
   tolua_function(tolua_S,"SetLifetime",tolua_AllToLua_cPickup_SetLifetime00);
   tolua_function(tolua_S,"IsCollected",tolua_AllToLua_cPickup_IsCollected00);
   tolua_function(tolua_S,"IsPlayerCreated",tolua_AllToLua_cPickup_IsPlayerCreated00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cSplashPotionEntity","cSplashPotionEntity","cProjectileEntity",nullptr);
  tolua_beginmodule(tolua_S,"cSplashPotionEntity");
   tolua_function(tolua_S,"GetEntityEffectType",tolua_AllToLua_cSplashPotionEntity_GetEntityEffectType00);
   tolua_function(tolua_S,"GetPotionColor",tolua_AllToLua_cSplashPotionEntity_GetPotionColor00);
   tolua_function(tolua_S,"GetItem",tolua_AllToLua_cSplashPotionEntity_GetItem00);
   tolua_function(tolua_S,"SetEntityEffectType",tolua_AllToLua_cSplashPotionEntity_SetEntityEffectType00);
   tolua_function(tolua_S,"SetPotionColor",tolua_AllToLua_cSplashPotionEntity_SetPotionColor00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cThrownEggEntity","cThrownEggEntity","cProjectileEntity",nullptr);
  tolua_beginmodule(tolua_S,"cThrownEggEntity");
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cThrownEnderPearlEntity","cThrownEnderPearlEntity","cProjectileEntity",nullptr);
  tolua_beginmodule(tolua_S,"cThrownEnderPearlEntity");
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cThrownSnowballEntity","cThrownSnowballEntity","cProjectileEntity",nullptr);
  tolua_beginmodule(tolua_S,"cThrownSnowballEntity");
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cTNTEntity","cTNTEntity","cEntity",nullptr);
  tolua_beginmodule(tolua_S,"cTNTEntity");
   tolua_function(tolua_S,"Explode",tolua_AllToLua_cTNTEntity_Explode00);
   tolua_function(tolua_S,"GetFuseTicks",tolua_AllToLua_cTNTEntity_GetFuseTicks00);
   tolua_function(tolua_S,"SetFuseTicks",tolua_AllToLua_cTNTEntity_SetFuseTicks00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cWitherSkullEntity","cWitherSkullEntity","cProjectileEntity",nullptr);
  tolua_beginmodule(tolua_S,"cWitherSkullEntity");
  tolua_endmodule(tolua_S);
  tolua_constant(tolua_S,"mtInvalidType",mtInvalidType);
  tolua_constant(tolua_S,"mtBat",mtBat);
  tolua_constant(tolua_S,"mtBlaze",mtBlaze);
  tolua_constant(tolua_S,"mtCat",mtCat);
  tolua_constant(tolua_S,"mtCaveSpider",mtCaveSpider);
  tolua_constant(tolua_S,"mtChicken",mtChicken);
  tolua_constant(tolua_S,"mtCod",mtCod);
  tolua_constant(tolua_S,"mtCow",mtCow);
  tolua_constant(tolua_S,"mtCreeper",mtCreeper);
  tolua_constant(tolua_S,"mtDolphin",mtDolphin);
  tolua_constant(tolua_S,"mtDonkey",mtDonkey);
  tolua_constant(tolua_S,"mtDrowned",mtDrowned);
  tolua_constant(tolua_S,"mtElderGuardian",mtElderGuardian);
  tolua_constant(tolua_S,"mtEnderDragon",mtEnderDragon);
  tolua_constant(tolua_S,"mtEnderman",mtEnderman);
  tolua_constant(tolua_S,"mtEndermite",mtEndermite);
  tolua_constant(tolua_S,"mtEvoker",mtEvoker);
  tolua_constant(tolua_S,"mtFox",mtFox);
  tolua_constant(tolua_S,"mtGhast",mtGhast);
  tolua_constant(tolua_S,"mtGiant",mtGiant);
  tolua_constant(tolua_S,"mtGuardian",mtGuardian);
  tolua_constant(tolua_S,"mtHorse",mtHorse);
  tolua_constant(tolua_S,"mtHoglin",mtHoglin);
  tolua_constant(tolua_S,"mtHusk",mtHusk);
  tolua_constant(tolua_S,"mtIllusioner",mtIllusioner);
  tolua_constant(tolua_S,"mtIronGolem",mtIronGolem);
  tolua_constant(tolua_S,"mtLlama",mtLlama);
  tolua_constant(tolua_S,"mtMagmaCube",mtMagmaCube);
  tolua_constant(tolua_S,"mtMooshroom",mtMooshroom);
  tolua_constant(tolua_S,"mtMule",mtMule);
  tolua_constant(tolua_S,"mtOcelot",mtOcelot);
  tolua_constant(tolua_S,"mtPanda",mtPanda);
  tolua_constant(tolua_S,"mtParrot",mtParrot);
  tolua_constant(tolua_S,"mtPhantom",mtPhantom);
  tolua_constant(tolua_S,"mtPig",mtPig);
  tolua_constant(tolua_S,"mtPiglin",mtPiglin);
  tolua_constant(tolua_S,"mtPiglinBrute",mtPiglinBrute);
  tolua_constant(tolua_S,"mtPillager",mtPillager);
  tolua_constant(tolua_S,"mtPolarBear",mtPolarBear);
  tolua_constant(tolua_S,"mtPufferfish",mtPufferfish);
  tolua_constant(tolua_S,"mtRabbit",mtRabbit);
  tolua_constant(tolua_S,"mtRavager",mtRavager);
  tolua_constant(tolua_S,"mtSalmon",mtSalmon);
  tolua_constant(tolua_S,"mtSheep",mtSheep);
  tolua_constant(tolua_S,"mtShulker",mtShulker);
  tolua_constant(tolua_S,"mtSilverfish",mtSilverfish);
  tolua_constant(tolua_S,"mtSkeleton",mtSkeleton);
  tolua_constant(tolua_S,"mtSkeletonHorse",mtSkeletonHorse);
  tolua_constant(tolua_S,"mtSlime",mtSlime);
  tolua_constant(tolua_S,"mtSnowGolem",mtSnowGolem);
  tolua_constant(tolua_S,"mtSpider",mtSpider);
  tolua_constant(tolua_S,"mtSquid",mtSquid);
  tolua_constant(tolua_S,"mtStray",mtStray);
  tolua_constant(tolua_S,"mtStrider",mtStrider);
  tolua_constant(tolua_S,"mtTraderLlama",mtTraderLlama);
  tolua_constant(tolua_S,"mtTropicalFish",mtTropicalFish);
  tolua_constant(tolua_S,"mtTurtle",mtTurtle);
  tolua_constant(tolua_S,"mtVex",mtVex);
  tolua_constant(tolua_S,"mtVillager",mtVillager);
  tolua_constant(tolua_S,"mtVindicator",mtVindicator);
  tolua_constant(tolua_S,"mtWanderingTrader",mtWanderingTrader);
  tolua_constant(tolua_S,"mtWitch",mtWitch);
  tolua_constant(tolua_S,"mtWither",mtWither);
  tolua_constant(tolua_S,"mtWitherSkeleton",mtWitherSkeleton);
  tolua_constant(tolua_S,"mtWolf",mtWolf);
  tolua_constant(tolua_S,"mtZoglin",mtZoglin);
  tolua_constant(tolua_S,"mtZombie",mtZombie);
  tolua_constant(tolua_S,"mtZombieHorse",mtZombieHorse);
  tolua_constant(tolua_S,"mtZombifiedPiglin",mtZombifiedPiglin);
  tolua_constant(tolua_S,"mtZombieVillager",mtZombieVillager);
  tolua_constant(tolua_S,"mtZombiePigman",mtZombiePigman);
  tolua_cclass(tolua_S,"cMonster","cMonster","cPawn",nullptr);
  tolua_beginmodule(tolua_S,"cMonster");
   tolua_constant(tolua_S,"mfHostile",cMonster::mfHostile);
   tolua_constant(tolua_S,"mfPassive",cMonster::mfPassive);
   tolua_constant(tolua_S,"mfAmbient",cMonster::mfAmbient);
   tolua_constant(tolua_S,"mfWater",cMonster::mfWater);
   tolua_constant(tolua_S,"mfNoSpawn",cMonster::mfNoSpawn);
   tolua_function(tolua_S,"MoveToPosition",tolua_AllToLua_cMonster_MoveToPosition00);
   tolua_function(tolua_S,"GetMobType",tolua_AllToLua_cMonster_GetMobType00);
   tolua_function(tolua_S,"GetMobFamily",tolua_AllToLua_cMonster_GetMobFamily00);
   tolua_function(tolua_S,"CanBeLeashed",tolua_AllToLua_cMonster_CanBeLeashed00);
   tolua_function(tolua_S,"SetCanBeLeashed",tolua_AllToLua_cMonster_SetCanBeLeashed00);
   tolua_function(tolua_S,"IsLeashed",tolua_AllToLua_cMonster_IsLeashed00);
   tolua_function(tolua_S,"LeashTo",tolua_AllToLua_cMonster_LeashTo00);
   tolua_function(tolua_S,"Unleash",tolua_AllToLua_cMonster_Unleash00);
   tolua_function(tolua_S,"GetLeashedTo",tolua_AllToLua_cMonster_GetLeashedTo00);
   tolua_function(tolua_S,"SetBurnsInDaylight",tolua_AllToLua_cMonster_SetBurnsInDaylight00);
   tolua_function(tolua_S,"BurnsInDaylight",tolua_AllToLua_cMonster_BurnsInDaylight00);
   tolua_function(tolua_S,"GetRelativeWalkSpeed",tolua_AllToLua_cMonster_GetRelativeWalkSpeed00);
   tolua_function(tolua_S,"SetRelativeWalkSpeed",tolua_AllToLua_cMonster_SetRelativeWalkSpeed00);
   tolua_function(tolua_S,"IsBaby",tolua_AllToLua_cMonster_IsBaby00);
   tolua_function(tolua_S,"GetAge",tolua_AllToLua_cMonster_GetAge00);
   tolua_function(tolua_S,"SetAge",tolua_AllToLua_cMonster_SetAge00);
   tolua_function(tolua_S,"HasCustomName",tolua_AllToLua_cMonster_HasCustomName00);
   tolua_function(tolua_S,"GetCustomName",tolua_AllToLua_cMonster_GetCustomName00);
   tolua_function(tolua_S,"SetCustomName",tolua_AllToLua_cMonster_SetCustomName00);
   tolua_function(tolua_S,"IsCustomNameAlwaysVisible",tolua_AllToLua_cMonster_IsCustomNameAlwaysVisible00);
   tolua_function(tolua_S,"SetCustomNameAlwaysVisible",tolua_AllToLua_cMonster_SetCustomNameAlwaysVisible00);
   tolua_function(tolua_S,"MobTypeToString",tolua_AllToLua_cMonster_MobTypeToString00);
   tolua_function(tolua_S,"MobTypeToVanillaName",tolua_AllToLua_cMonster_MobTypeToVanillaName00);
   tolua_function(tolua_S,"StringToMobType",tolua_AllToLua_cMonster_StringToMobType00);
   tolua_function(tolua_S,"FamilyFromType",tolua_AllToLua_cMonster_FamilyFromType00);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"cBlockEntity","cBlockEntity","",tolua_collect_cBlockEntity);
  #else
  tolua_cclass(tolua_S,"cBlockEntity","cBlockEntity","",nullptr);
  #endif
  tolua_beginmodule(tolua_S,"cBlockEntity");
   tolua_function(tolua_S,"GetPos",tolua_AllToLua_cBlockEntity_GetPos00);
   tolua_function(tolua_S,"GetPosX",tolua_AllToLua_cBlockEntity_GetPosX00);
   tolua_function(tolua_S,"GetPosY",tolua_AllToLua_cBlockEntity_GetPosY00);
   tolua_function(tolua_S,"GetPosZ",tolua_AllToLua_cBlockEntity_GetPosZ00);
   tolua_function(tolua_S,"GetRelPos",tolua_AllToLua_cBlockEntity_GetRelPos00);
   tolua_function(tolua_S,"GetBlockType",tolua_AllToLua_cBlockEntity_GetBlockType00);
   tolua_function(tolua_S,"GetWorld",tolua_AllToLua_cBlockEntity_GetWorld00);
   tolua_function(tolua_S,"GetChunkX",tolua_AllToLua_cBlockEntity_GetChunkX00);
   tolua_function(tolua_S,"GetChunkZ",tolua_AllToLua_cBlockEntity_GetChunkZ00);
   tolua_function(tolua_S,"GetRelX",tolua_AllToLua_cBlockEntity_GetRelX00);
   tolua_function(tolua_S,"GetRelZ",tolua_AllToLua_cBlockEntity_GetRelZ00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cBeaconEntity","cBeaconEntity","cBlockEntityWithItems",nullptr);
  tolua_beginmodule(tolua_S,"cBeaconEntity");
   tolua_function(tolua_S,"IsActive",tolua_AllToLua_cBeaconEntity_IsActive00);
   tolua_function(tolua_S,"GetBeaconLevel",tolua_AllToLua_cBeaconEntity_GetBeaconLevel00);
   tolua_function(tolua_S,"GetPrimaryEffect",tolua_AllToLua_cBeaconEntity_GetPrimaryEffect00);
   tolua_function(tolua_S,"GetSecondaryEffect",tolua_AllToLua_cBeaconEntity_GetSecondaryEffect00);
   tolua_function(tolua_S,"SetPrimaryEffect",tolua_AllToLua_cBeaconEntity_SetPrimaryEffect00);
   tolua_function(tolua_S,"SetSecondaryEffect",tolua_AllToLua_cBeaconEntity_SetSecondaryEffect00);
   tolua_function(tolua_S,"CalculatePyramidLevel",tolua_AllToLua_cBeaconEntity_CalculatePyramidLevel00);
   tolua_function(tolua_S,"IsBeaconBlocked",tolua_AllToLua_cBeaconEntity_IsBeaconBlocked00);
   tolua_function(tolua_S,"UpdateBeacon",tolua_AllToLua_cBeaconEntity_UpdateBeacon00);
   tolua_function(tolua_S,"GiveEffects",tolua_AllToLua_cBeaconEntity_GiveEffects00);
   tolua_function(tolua_S,"IsMineralBlock",tolua_AllToLua_cBeaconEntity_IsMineralBlock00);
   tolua_function(tolua_S,"IsValidEffect",tolua_AllToLua_cBeaconEntity_IsValidEffect00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cBedEntity","cBedEntity","cBlockEntity",nullptr);
  tolua_beginmodule(tolua_S,"cBedEntity");
   tolua_function(tolua_S,"GetColor",tolua_AllToLua_cBedEntity_GetColor00);
   tolua_function(tolua_S,"SetColor",tolua_AllToLua_cBedEntity_SetColor00);
   tolua_function(tolua_S,"IsPillowBlock",tolua_AllToLua_cBedEntity_IsPillowBlock00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cBlockEntityWithItems","cBlockEntityWithItems","cBlockEntity",nullptr);
  tolua_beginmodule(tolua_S,"cBlockEntityWithItems");
   tolua_function(tolua_S,"GetSlot",tolua_AllToLua_cBlockEntityWithItems_GetSlot00);
   tolua_function(tolua_S,"GetSlot",tolua_AllToLua_cBlockEntityWithItems_GetSlot01);
   tolua_function(tolua_S,"SetSlot",tolua_AllToLua_cBlockEntityWithItems_SetSlot00);
   tolua_function(tolua_S,"SetSlot",tolua_AllToLua_cBlockEntityWithItems_SetSlot01);
   tolua_function(tolua_S,"GetContents",tolua_AllToLua_cBlockEntityWithItems_GetContents00);
   tolua_variable(tolua_S,"__cBlockEntityWindowOwner__",tolua_get_cBlockEntityWithItems___cBlockEntityWindowOwner__,nullptr);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cBrewingstandEntity","cBrewingstandEntity","cBlockEntityWithItems",nullptr);
  tolua_beginmodule(tolua_S,"cBrewingstandEntity");
   tolua_constant(tolua_S,"bsLeftBottle",cBrewingstandEntity::bsLeftBottle);
   tolua_constant(tolua_S,"bsMiddleBottle",cBrewingstandEntity::bsMiddleBottle);
   tolua_constant(tolua_S,"bsRightBottle",cBrewingstandEntity::bsRightBottle);
   tolua_constant(tolua_S,"bsIngredient",cBrewingstandEntity::bsIngredient);
   tolua_constant(tolua_S,"bsFuel",cBrewingstandEntity::bsFuel);
   tolua_constant(tolua_S,"ContentsWidth",cBrewingstandEntity::ContentsWidth);
   tolua_constant(tolua_S,"ContentsHeight",cBrewingstandEntity::ContentsHeight);
   tolua_function(tolua_S,"GetBrewingTimeLeft",tolua_AllToLua_cBrewingstandEntity_GetBrewingTimeLeft00);
   tolua_function(tolua_S,"GetTimeBrewed",tolua_AllToLua_cBrewingstandEntity_GetTimeBrewed00);
   tolua_function(tolua_S,"GetRemainingFuel",tolua_AllToLua_cBrewingstandEntity_GetRemainingFuel00);
   tolua_function(tolua_S,"GetLeftBottleSlot",tolua_AllToLua_cBrewingstandEntity_GetLeftBottleSlot00);
   tolua_function(tolua_S,"GetMiddleBottleSlot",tolua_AllToLua_cBrewingstandEntity_GetMiddleBottleSlot00);
   tolua_function(tolua_S,"GetRightBottleSlot",tolua_AllToLua_cBrewingstandEntity_GetRightBottleSlot00);
   tolua_function(tolua_S,"GetIndgredientSlot",tolua_AllToLua_cBrewingstandEntity_GetIndgredientSlot00);
   tolua_function(tolua_S,"GetFuelSlot",tolua_AllToLua_cBrewingstandEntity_GetFuelSlot00);
   tolua_function(tolua_S,"GetResultItem",tolua_AllToLua_cBrewingstandEntity_GetResultItem00);
   tolua_function(tolua_S,"SetLeftBottleSlot",tolua_AllToLua_cBrewingstandEntity_SetLeftBottleSlot00);
   tolua_function(tolua_S,"SetMiddleBottleSlot",tolua_AllToLua_cBrewingstandEntity_SetMiddleBottleSlot00);
   tolua_function(tolua_S,"SetRightBottleSlot",tolua_AllToLua_cBrewingstandEntity_SetRightBottleSlot00);
   tolua_function(tolua_S,"SetIngredientSlot",tolua_AllToLua_cBrewingstandEntity_SetIngredientSlot00);
   tolua_function(tolua_S,"SetFuelSlot",tolua_AllToLua_cBrewingstandEntity_SetFuelSlot00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cChestEntity","cChestEntity","cBlockEntityWithItems",nullptr);
  tolua_beginmodule(tolua_S,"cChestEntity");
   tolua_constant(tolua_S,"ContentsHeight",cChestEntity::ContentsHeight);
   tolua_constant(tolua_S,"ContentsWidth",cChestEntity::ContentsWidth);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cCommandBlockEntity","cCommandBlockEntity","cBlockEntity",nullptr);
  tolua_beginmodule(tolua_S,"cCommandBlockEntity");
   tolua_function(tolua_S,"Activate",tolua_AllToLua_cCommandBlockEntity_Activate00);
   tolua_function(tolua_S,"SetCommand",tolua_AllToLua_cCommandBlockEntity_SetCommand00);
   tolua_function(tolua_S,"GetCommand",tolua_AllToLua_cCommandBlockEntity_GetCommand00);
   tolua_function(tolua_S,"GetLastOutput",tolua_AllToLua_cCommandBlockEntity_GetLastOutput00);
   tolua_function(tolua_S,"GetResult",tolua_AllToLua_cCommandBlockEntity_GetResult00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cDropSpenserEntity","cDropSpenserEntity","cBlockEntityWithItems",nullptr);
  tolua_beginmodule(tolua_S,"cDropSpenserEntity");
   tolua_constant(tolua_S,"ContentsHeight",cDropSpenserEntity::ContentsHeight);
   tolua_constant(tolua_S,"ContentsWidth",cDropSpenserEntity::ContentsWidth);
   tolua_function(tolua_S,"AddDropSpenserDir",tolua_AllToLua_cDropSpenserEntity_AddDropSpenserDir00);
   tolua_function(tolua_S,"Activate",tolua_AllToLua_cDropSpenserEntity_Activate00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cDispenserEntity","cDispenserEntity","cDropSpenserEntity",nullptr);
  tolua_beginmodule(tolua_S,"cDispenserEntity");
   tolua_function(tolua_S,"SpawnProjectileFromDispenser",tolua_AllToLua_cDispenserEntity_SpawnProjectileFromDispenser00);
   tolua_function(tolua_S,"SpawnProjectileFromDispenser",tolua_AllToLua_cDispenserEntity_SpawnProjectileFromDispenser01);
   tolua_function(tolua_S,"GetShootVector",tolua_AllToLua_cDispenserEntity_GetShootVector00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cDropperEntity","cDropperEntity","cDropSpenserEntity",nullptr);
  tolua_beginmodule(tolua_S,"cDropperEntity");
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cFurnaceEntity","cFurnaceEntity","cBlockEntityWithItems",nullptr);
  tolua_beginmodule(tolua_S,"cFurnaceEntity");
   tolua_constant(tolua_S,"fsInput",cFurnaceEntity::fsInput);
   tolua_constant(tolua_S,"fsFuel",cFurnaceEntity::fsFuel);
   tolua_constant(tolua_S,"fsOutput",cFurnaceEntity::fsOutput);
   tolua_constant(tolua_S,"ContentsWidth",cFurnaceEntity::ContentsWidth);
   tolua_constant(tolua_S,"ContentsHeight",cFurnaceEntity::ContentsHeight);
   tolua_function(tolua_S,"GetInputSlot",tolua_AllToLua_cFurnaceEntity_GetInputSlot00);
   tolua_function(tolua_S,"GetFuelSlot",tolua_AllToLua_cFurnaceEntity_GetFuelSlot00);
   tolua_function(tolua_S,"GetOutputSlot",tolua_AllToLua_cFurnaceEntity_GetOutputSlot00);
   tolua_function(tolua_S,"SetInputSlot",tolua_AllToLua_cFurnaceEntity_SetInputSlot00);
   tolua_function(tolua_S,"SetFuelSlot",tolua_AllToLua_cFurnaceEntity_SetFuelSlot00);
   tolua_function(tolua_S,"SetOutputSlot",tolua_AllToLua_cFurnaceEntity_SetOutputSlot00);
   tolua_function(tolua_S,"GetTimeCooked",tolua_AllToLua_cFurnaceEntity_GetTimeCooked00);
   tolua_function(tolua_S,"GetCookTimeLeft",tolua_AllToLua_cFurnaceEntity_GetCookTimeLeft00);
   tolua_function(tolua_S,"GetFuelBurnTimeLeft",tolua_AllToLua_cFurnaceEntity_GetFuelBurnTimeLeft00);
   tolua_function(tolua_S,"HasFuelTimeLeft",tolua_AllToLua_cFurnaceEntity_HasFuelTimeLeft00);
   tolua_function(tolua_S,"GetAndResetReward",tolua_AllToLua_cFurnaceEntity_GetAndResetReward00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cHopperEntity","cHopperEntity","cBlockEntityWithItems",nullptr);
  tolua_beginmodule(tolua_S,"cHopperEntity");
   tolua_constant(tolua_S,"ContentsHeight",cHopperEntity::ContentsHeight);
   tolua_constant(tolua_S,"ContentsWidth",cHopperEntity::ContentsWidth);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cJukeboxEntity","cJukeboxEntity","cBlockEntity",nullptr);
  tolua_beginmodule(tolua_S,"cJukeboxEntity");
   tolua_function(tolua_S,"GetRecord",tolua_AllToLua_cJukeboxEntity_GetRecord00);
   tolua_function(tolua_S,"SetRecord",tolua_AllToLua_cJukeboxEntity_SetRecord00);
   tolua_function(tolua_S,"PlayRecord",tolua_AllToLua_cJukeboxEntity_PlayRecord00);
   tolua_function(tolua_S,"EjectRecord",tolua_AllToLua_cJukeboxEntity_EjectRecord00);
   tolua_function(tolua_S,"IsPlayingRecord",tolua_AllToLua_cJukeboxEntity_IsPlayingRecord00);
   tolua_function(tolua_S,"IsRecordItem",tolua_AllToLua_cJukeboxEntity_IsRecordItem00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cNoteEntity","cNoteEntity","cBlockEntity",nullptr);
  tolua_beginmodule(tolua_S,"cNoteEntity");
   tolua_function(tolua_S,"GetNote",tolua_AllToLua_cNoteEntity_GetNote00);
   tolua_function(tolua_S,"SetNote",tolua_AllToLua_cNoteEntity_SetNote00);
   tolua_function(tolua_S,"IncrementNote",tolua_AllToLua_cNoteEntity_IncrementNote00);
   tolua_function(tolua_S,"MakeSound",tolua_AllToLua_cNoteEntity_MakeSound00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cSignEntity","cSignEntity","cBlockEntity",nullptr);
  tolua_beginmodule(tolua_S,"cSignEntity");
   tolua_function(tolua_S,"SetLines",tolua_AllToLua_cSignEntity_SetLines00);
   tolua_function(tolua_S,"SetLine",tolua_AllToLua_cSignEntity_SetLine00);
   tolua_function(tolua_S,"GetLine",tolua_AllToLua_cSignEntity_GetLine00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cMobHeadEntity","cMobHeadEntity","cBlockEntity",nullptr);
  tolua_beginmodule(tolua_S,"cMobHeadEntity");
   tolua_function(tolua_S,"SetType",tolua_AllToLua_cMobHeadEntity_SetType00);
   tolua_function(tolua_S,"SetRotation",tolua_AllToLua_cMobHeadEntity_SetRotation00);
   tolua_function(tolua_S,"SetOwner",tolua_AllToLua_cMobHeadEntity_SetOwner00);
   tolua_function(tolua_S,"GetType",tolua_AllToLua_cMobHeadEntity_GetType00);
   tolua_function(tolua_S,"GetRotation",tolua_AllToLua_cMobHeadEntity_GetRotation00);
   tolua_function(tolua_S,"GetOwnerName",tolua_AllToLua_cMobHeadEntity_GetOwnerName00);
   tolua_function(tolua_S,"GetOwnerTexture",tolua_AllToLua_cMobHeadEntity_GetOwnerTexture00);
   tolua_function(tolua_S,"GetOwnerTextureSignature",tolua_AllToLua_cMobHeadEntity_GetOwnerTextureSignature00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cMobSpawnerEntity","cMobSpawnerEntity","cBlockEntity",nullptr);
  tolua_beginmodule(tolua_S,"cMobSpawnerEntity");
   tolua_function(tolua_S,"UpdateActiveState",tolua_AllToLua_cMobSpawnerEntity_UpdateActiveState00);
   tolua_function(tolua_S,"ResetTimer",tolua_AllToLua_cMobSpawnerEntity_ResetTimer00);
   tolua_function(tolua_S,"SpawnEntity",tolua_AllToLua_cMobSpawnerEntity_SpawnEntity00);
   tolua_function(tolua_S,"GetNearbyMonsterNum",tolua_AllToLua_cMobSpawnerEntity_GetNearbyMonsterNum00);
   tolua_function(tolua_S,"GetNearbyPlayersNum",tolua_AllToLua_cMobSpawnerEntity_GetNearbyPlayersNum00);
   tolua_function(tolua_S,"GetEntity",tolua_AllToLua_cMobSpawnerEntity_GetEntity00);
   tolua_function(tolua_S,"GetSpawnCount",tolua_AllToLua_cMobSpawnerEntity_GetSpawnCount00);
   tolua_function(tolua_S,"GetSpawnRange",tolua_AllToLua_cMobSpawnerEntity_GetSpawnRange00);
   tolua_function(tolua_S,"GetSpawnDelay",tolua_AllToLua_cMobSpawnerEntity_GetSpawnDelay00);
   tolua_function(tolua_S,"GetMinSpawnDelay",tolua_AllToLua_cMobSpawnerEntity_GetMinSpawnDelay00);
   tolua_function(tolua_S,"GetMaxSpawnDelay",tolua_AllToLua_cMobSpawnerEntity_GetMaxSpawnDelay00);
   tolua_function(tolua_S,"GetMaxNearbyEntities",tolua_AllToLua_cMobSpawnerEntity_GetMaxNearbyEntities00);
   tolua_function(tolua_S,"GetRequiredPlayerRange",tolua_AllToLua_cMobSpawnerEntity_GetRequiredPlayerRange00);
   tolua_function(tolua_S,"SetEntity",tolua_AllToLua_cMobSpawnerEntity_SetEntity00);
   tolua_function(tolua_S,"SetSpawnDelay",tolua_AllToLua_cMobSpawnerEntity_SetSpawnDelay00);
   tolua_function(tolua_S,"SetSpawnCount",tolua_AllToLua_cMobSpawnerEntity_SetSpawnCount00);
   tolua_function(tolua_S,"SetSpawnRange",tolua_AllToLua_cMobSpawnerEntity_SetSpawnRange00);
   tolua_function(tolua_S,"SetMinSpawnDelay",tolua_AllToLua_cMobSpawnerEntity_SetMinSpawnDelay00);
   tolua_function(tolua_S,"SetMaxSpawnDelay",tolua_AllToLua_cMobSpawnerEntity_SetMaxSpawnDelay00);
   tolua_function(tolua_S,"SetMaxNearbyEntities",tolua_AllToLua_cMobSpawnerEntity_SetMaxNearbyEntities00);
   tolua_function(tolua_S,"SetRequiredPlayerRange",tolua_AllToLua_cMobSpawnerEntity_SetRequiredPlayerRange00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"cFlowerPotEntity","cFlowerPotEntity","cBlockEntity",nullptr);
  tolua_beginmodule(tolua_S,"cFlowerPotEntity");
   tolua_function(tolua_S,"IsItemInPot",tolua_AllToLua_cFlowerPotEntity_IsItemInPot00);
   tolua_function(tolua_S,"GetItem",tolua_AllToLua_cFlowerPotEntity_GetItem00);
   tolua_function(tolua_S,"SetItem",tolua_AllToLua_cFlowerPotEntity_SetItem00);
  tolua_endmodule(tolua_S);
  tolua_module(tolua_S,"CustomStatistic",0);
  tolua_beginmodule(tolua_S,"CustomStatistic");
   tolua_constant(tolua_S,"AnimalsBred",static_cast<lua_Number>(CustomStatistic::AnimalsBred));
   tolua_constant(tolua_S,"AviateOneCm",static_cast<lua_Number>(CustomStatistic::AviateOneCm));
   tolua_constant(tolua_S,"BellRing",static_cast<lua_Number>(CustomStatistic::BellRing));
   tolua_constant(tolua_S,"BoatOneCm",static_cast<lua_Number>(CustomStatistic::BoatOneCm));
   tolua_constant(tolua_S,"CleanArmor",static_cast<lua_Number>(CustomStatistic::CleanArmor));
   tolua_constant(tolua_S,"CleanBanner",static_cast<lua_Number>(CustomStatistic::CleanBanner));
   tolua_constant(tolua_S,"CleanShulkerBox",static_cast<lua_Number>(CustomStatistic::CleanShulkerBox));
   tolua_constant(tolua_S,"ClimbOneCm",static_cast<lua_Number>(CustomStatistic::ClimbOneCm));
   tolua_constant(tolua_S,"CrouchOneCm",static_cast<lua_Number>(CustomStatistic::CrouchOneCm));
   tolua_constant(tolua_S,"DamageAbsorbed",static_cast<lua_Number>(CustomStatistic::DamageAbsorbed));
   tolua_constant(tolua_S,"DamageBlockedByShield",static_cast<lua_Number>(CustomStatistic::DamageBlockedByShield));
   tolua_constant(tolua_S,"DamageDealt",static_cast<lua_Number>(CustomStatistic::DamageDealt));
   tolua_constant(tolua_S,"DamageDealtAbsorbed",static_cast<lua_Number>(CustomStatistic::DamageDealtAbsorbed));
   tolua_constant(tolua_S,"DamageDealtResisted",static_cast<lua_Number>(CustomStatistic::DamageDealtResisted));
   tolua_constant(tolua_S,"DamageResisted",static_cast<lua_Number>(CustomStatistic::DamageResisted));
   tolua_constant(tolua_S,"DamageTaken",static_cast<lua_Number>(CustomStatistic::DamageTaken));
   tolua_constant(tolua_S,"Deaths",static_cast<lua_Number>(CustomStatistic::Deaths));
   tolua_constant(tolua_S,"Drop",static_cast<lua_Number>(CustomStatistic::Drop));
   tolua_constant(tolua_S,"EatCakeSlice",static_cast<lua_Number>(CustomStatistic::EatCakeSlice));
   tolua_constant(tolua_S,"EnchantItem",static_cast<lua_Number>(CustomStatistic::EnchantItem));
   tolua_constant(tolua_S,"FallOneCm",static_cast<lua_Number>(CustomStatistic::FallOneCm));
   tolua_constant(tolua_S,"FillCauldron",static_cast<lua_Number>(CustomStatistic::FillCauldron));
   tolua_constant(tolua_S,"FishCaught",static_cast<lua_Number>(CustomStatistic::FishCaught));
   tolua_constant(tolua_S,"FlyOneCm",static_cast<lua_Number>(CustomStatistic::FlyOneCm));
   tolua_constant(tolua_S,"HorseOneCm",static_cast<lua_Number>(CustomStatistic::HorseOneCm));
   tolua_constant(tolua_S,"InspectDispenser",static_cast<lua_Number>(CustomStatistic::InspectDispenser));
   tolua_constant(tolua_S,"InspectDropper",static_cast<lua_Number>(CustomStatistic::InspectDropper));
   tolua_constant(tolua_S,"InspectHopper",static_cast<lua_Number>(CustomStatistic::InspectHopper));
   tolua_constant(tolua_S,"InteractWithAnvil",static_cast<lua_Number>(CustomStatistic::InteractWithAnvil));
   tolua_constant(tolua_S,"InteractWithBeacon",static_cast<lua_Number>(CustomStatistic::InteractWithBeacon));
   tolua_constant(tolua_S,"InteractWithBlastFurnace",static_cast<lua_Number>(CustomStatistic::InteractWithBlastFurnace));
   tolua_constant(tolua_S,"InteractWithBrewingstand",static_cast<lua_Number>(CustomStatistic::InteractWithBrewingstand));
   tolua_constant(tolua_S,"InteractWithCampfire",static_cast<lua_Number>(CustomStatistic::InteractWithCampfire));
   tolua_constant(tolua_S,"InteractWithCartographyTable",static_cast<lua_Number>(CustomStatistic::InteractWithCartographyTable));
   tolua_constant(tolua_S,"InteractWithCraftingTable",static_cast<lua_Number>(CustomStatistic::InteractWithCraftingTable));
   tolua_constant(tolua_S,"InteractWithFurnace",static_cast<lua_Number>(CustomStatistic::InteractWithFurnace));
   tolua_constant(tolua_S,"InteractWithGrindstone",static_cast<lua_Number>(CustomStatistic::InteractWithGrindstone));
   tolua_constant(tolua_S,"InteractWithLectern",static_cast<lua_Number>(CustomStatistic::InteractWithLectern));
   tolua_constant(tolua_S,"InteractWithLoom",static_cast<lua_Number>(CustomStatistic::InteractWithLoom));
   tolua_constant(tolua_S,"InteractWithSmithingTable",static_cast<lua_Number>(CustomStatistic::InteractWithSmithingTable));
   tolua_constant(tolua_S,"InteractWithSmoker",static_cast<lua_Number>(CustomStatistic::InteractWithSmoker));
   tolua_constant(tolua_S,"InteractWithStonecutter",static_cast<lua_Number>(CustomStatistic::InteractWithStonecutter));
   tolua_constant(tolua_S,"Jump",static_cast<lua_Number>(CustomStatistic::Jump));
   tolua_constant(tolua_S,"LeaveGame",static_cast<lua_Number>(CustomStatistic::LeaveGame));
   tolua_constant(tolua_S,"MinecartOneCm",static_cast<lua_Number>(CustomStatistic::MinecartOneCm));
   tolua_constant(tolua_S,"MobKills",static_cast<lua_Number>(CustomStatistic::MobKills));
   tolua_constant(tolua_S,"OpenBarrel",static_cast<lua_Number>(CustomStatistic::OpenBarrel));
   tolua_constant(tolua_S,"OpenChest",static_cast<lua_Number>(CustomStatistic::OpenChest));
   tolua_constant(tolua_S,"OpenEnderchest",static_cast<lua_Number>(CustomStatistic::OpenEnderchest));
   tolua_constant(tolua_S,"OpenShulkerBox",static_cast<lua_Number>(CustomStatistic::OpenShulkerBox));
   tolua_constant(tolua_S,"PigOneCm",static_cast<lua_Number>(CustomStatistic::PigOneCm));
   tolua_constant(tolua_S,"PlayNoteblock",static_cast<lua_Number>(CustomStatistic::PlayNoteblock));
   tolua_constant(tolua_S,"PlayOneMinute",static_cast<lua_Number>(CustomStatistic::PlayOneMinute));
   tolua_constant(tolua_S,"PlayRecord",static_cast<lua_Number>(CustomStatistic::PlayRecord));
   tolua_constant(tolua_S,"PlayerKills",static_cast<lua_Number>(CustomStatistic::PlayerKills));
   tolua_constant(tolua_S,"PotFlower",static_cast<lua_Number>(CustomStatistic::PotFlower));
   tolua_constant(tolua_S,"RaidTrigger",static_cast<lua_Number>(CustomStatistic::RaidTrigger));
   tolua_constant(tolua_S,"RaidWin",static_cast<lua_Number>(CustomStatistic::RaidWin));
   tolua_constant(tolua_S,"SleepInBed",static_cast<lua_Number>(CustomStatistic::SleepInBed));
   tolua_constant(tolua_S,"SneakTime",static_cast<lua_Number>(CustomStatistic::SneakTime));
   tolua_constant(tolua_S,"SprintOneCm",static_cast<lua_Number>(CustomStatistic::SprintOneCm));
   tolua_constant(tolua_S,"StriderOneCm",static_cast<lua_Number>(CustomStatistic::StriderOneCm));
   tolua_constant(tolua_S,"SwimOneCm",static_cast<lua_Number>(CustomStatistic::SwimOneCm));
   tolua_constant(tolua_S,"TalkedToVillager",static_cast<lua_Number>(CustomStatistic::TalkedToVillager));
   tolua_constant(tolua_S,"TargetHit",static_cast<lua_Number>(CustomStatistic::TargetHit));
   tolua_constant(tolua_S,"TimeSinceDeath",static_cast<lua_Number>(CustomStatistic::TimeSinceDeath));
   tolua_constant(tolua_S,"TimeSinceRest",static_cast<lua_Number>(CustomStatistic::TimeSinceRest));
   tolua_constant(tolua_S,"TradedWithVillager",static_cast<lua_Number>(CustomStatistic::TradedWithVillager));
   tolua_constant(tolua_S,"TriggerTrappedChest",static_cast<lua_Number>(CustomStatistic::TriggerTrappedChest));
   tolua_constant(tolua_S,"TuneNoteblock",static_cast<lua_Number>(CustomStatistic::TuneNoteblock));
   tolua_constant(tolua_S,"UseCauldron",static_cast<lua_Number>(CustomStatistic::UseCauldron));
   tolua_constant(tolua_S,"WalkOnWaterOneCm",static_cast<lua_Number>(CustomStatistic::WalkOnWaterOneCm));
   tolua_constant(tolua_S,"WalkOneCm",static_cast<lua_Number>(CustomStatistic::WalkOneCm));
   tolua_constant(tolua_S,"WalkUnderWaterOneCm",static_cast<lua_Number>(CustomStatistic::WalkUnderWaterOneCm));
   tolua_constant(tolua_S,"JunkFished",static_cast<lua_Number>(CustomStatistic::JunkFished));
   tolua_constant(tolua_S,"TreasureFished",static_cast<lua_Number>(CustomStatistic::TreasureFished));
  tolua_endmodule(tolua_S);
 tolua_endmodule(tolua_S);
 return 1;
}


#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
 TOLUA_API int luaopen_AllToLua (lua_State* tolua_S) {
 return tolua_AllToLua_open(tolua_S);
};
#endif