dp_scripts.cpp - Hosted on DriveHQ Cloud IT Platform

/*
** Lua binding: dp_scripts
** Generated automatically by tolua++-1.0.92 on 05/08/08 20:51:16.
*/

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

#include "tolua++.h"

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

#include "DarkPuzzle.h"
#include "..\..\GameEngine\GameEngine.h"
#include "..\..\GameEngine\Character.h"
#include "..\..\GameEngine\GameLevel.h"
#include "..\..\GameEngine\Map.h"
#include "..\..\GameEngine\DataTypes.h"
#include "..\..\GameEngine\DebugFuncs.h"

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

static int tolua_collect_Vec3 (lua_State* tolua_S)
{
 Vec3* self = (Vec3*) tolua_tousertype(tolua_S,1,0);
	delete self;
	return 0;
}
#endif


/* function to register type */
static void tolua_reg_types (lua_State* tolua_S)
{
 tolua_usertype(tolua_S,"GameScreen");
 tolua_usertype(tolua_S,"Character");
 tolua_usertype(tolua_S,"Vec3Queue");
 tolua_usertype(tolua_S,"Game3DInstance");
 tolua_usertype(tolua_S,"GameEngine");
 tolua_usertype(tolua_S,"Vec3");
 tolua_usertype(tolua_S,"Map");
 tolua_usertype(tolua_S,"GameLevel");
}

/* get function: SpotLightRange of class  GameEngine */
#ifndef TOLUA_DISABLE_tolua_get_GameEngine_SpotLightRange
static int tolua_get_GameEngine_SpotLightRange(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)GameEngine::SpotLightRange);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: SpotLightRange of class  GameEngine */
#ifndef TOLUA_DISABLE_tolua_set_GameEngine_SpotLightRange
static int tolua_set_GameEngine_SpotLightRange(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  GameEngine::SpotLightRange = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: SpotLightRadius of class  GameEngine */
#ifndef TOLUA_DISABLE_tolua_get_GameEngine_SpotLightRadius
static int tolua_get_GameEngine_SpotLightRadius(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)GameEngine::SpotLightRadius);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: SpotLightRadius of class  GameEngine */
#ifndef TOLUA_DISABLE_tolua_set_GameEngine_SpotLightRadius
static int tolua_set_GameEngine_SpotLightRadius(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  GameEngine::SpotLightRadius = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PointLightRange of class  GameEngine */
#ifndef TOLUA_DISABLE_tolua_get_GameEngine_PointLightRange
static int tolua_get_GameEngine_PointLightRange(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)GameEngine::PointLightRange);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PointLightRange of class  GameEngine */
#ifndef TOLUA_DISABLE_tolua_set_GameEngine_PointLightRange
static int tolua_set_GameEngine_PointLightRange(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  GameEngine::PointLightRange = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: RunVelocity of class  GameEngine */
#ifndef TOLUA_DISABLE_tolua_get_GameEngine_RunVelocity
static int tolua_get_GameEngine_RunVelocity(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)GameEngine::RunVelocity);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: RunVelocity of class  GameEngine */
#ifndef TOLUA_DISABLE_tolua_set_GameEngine_RunVelocity
static int tolua_set_GameEngine_RunVelocity(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  GameEngine::RunVelocity = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: RunVelocityEpsilon of class  GameEngine */
#ifndef TOLUA_DISABLE_tolua_get_GameEngine_RunVelocityEpsilon
static int tolua_get_GameEngine_RunVelocityEpsilon(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)GameEngine::RunVelocityEpsilon);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: RunVelocityEpsilon of class  GameEngine */
#ifndef TOLUA_DISABLE_tolua_set_GameEngine_RunVelocityEpsilon
static int tolua_set_GameEngine_RunVelocityEpsilon(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  GameEngine::RunVelocityEpsilon = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: RunAcceleration of class  GameEngine */
#ifndef TOLUA_DISABLE_tolua_get_GameEngine_RunAcceleration
static int tolua_get_GameEngine_RunAcceleration(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)GameEngine::RunAcceleration);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: RunAcceleration of class  GameEngine */
#ifndef TOLUA_DISABLE_tolua_set_GameEngine_RunAcceleration
static int tolua_set_GameEngine_RunAcceleration(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  GameEngine::RunAcceleration = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: LightDirectionalDir of class  GameEngine */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_GameEngine_LightDirectionalDir00
static int tolua_dp_scripts_GameEngine_LightDirectionalDir00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"GameEngine",0,&tolua_err) ||
     !tolua_istable(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  float vals[3];
  {
#ifndef TOLUA_RELEASE
   if (!tolua_isnumberarray(tolua_S,2,3,0,&tolua_err))
    goto tolua_lerror;
   else
#endif
   {
    int i;
    for(i=0; i<3;i++)
    vals[i] = ((float)  tolua_tofieldnumber(tolua_S,2,i+1,0));
   }
  }
  {
   GameEngine::LightDirectionalDir(vals);
  }
  {
   int i;
   for(i=0; i<3;i++)
    tolua_pushfieldnumber(tolua_S,2,i+1,(lua_Number) vals[i]);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'LightDirectionalDir'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: RangeEpsilon of class  GameEngine */
#ifndef TOLUA_DISABLE_tolua_get_GameEngine_RangeEpsilon
static int tolua_get_GameEngine_RangeEpsilon(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)GameEngine::RangeEpsilon);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: RangeEpsilon of class  GameEngine */
#ifndef TOLUA_DISABLE_tolua_set_GameEngine_RangeEpsilon
static int tolua_set_GameEngine_RangeEpsilon(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  GameEngine::RangeEpsilon = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: PreferedFrameRate of class  GameEngine */
#ifndef TOLUA_DISABLE_tolua_get_GameEngine_PreferedFrameRate
static int tolua_get_GameEngine_PreferedFrameRate(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)GameEngine::PreferedFrameRate);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: PreferedFrameRate of class  GameEngine */
#ifndef TOLUA_DISABLE_tolua_set_GameEngine_PreferedFrameRate
static int tolua_set_GameEngine_PreferedFrameRate(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  GameEngine::PreferedFrameRate = ((double)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* method: Add of class  Character */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Character_Add00
static int tolua_dp_scripts_Character_Add00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Character",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isstring(tolua_S,3,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  char* modelName = ((char*)  tolua_tostring(tolua_S,2,0));
  const char* name = ((const char*)  tolua_tostring(tolua_S,3,0));
  {
   Character* tolua_ret = (Character*)  Character::Add(modelName,name);
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"Character");
  }
 }
 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: Get of class  Character */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Character_Get00
static int tolua_dp_scripts_Character_Get00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Character",0,&tolua_err) ||
     !tolua_isstring(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  char* name = ((char*)  tolua_tostring(tolua_S,2,0));
  {
   Character* tolua_ret = (Character*)  Character::Get(name);
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"Character");
  }
 }
 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: MoveTo of class  Character */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Character_MoveTo00
static int tolua_dp_scripts_Character_MoveTo00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Character",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Vec3",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Character* self = (Character*)  tolua_tousertype(tolua_S,1,0);
  Vec3 pos = *((Vec3*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'MoveTo'",NULL);
#endif
  {
   self->MoveTo(pos);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'MoveTo'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: SetPos of class  Character */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Character_SetPos00
static int tolua_dp_scripts_Character_SetPos00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Character",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Vec3",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Character* self = (Character*)  tolua_tousertype(tolua_S,1,0);
  Vec3 pos = *((Vec3*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetPos'",NULL);
#endif
  {
   self->SetPos(pos);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetPos'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPos of class  Character */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Character_GetPos00
static int tolua_dp_scripts_Character_GetPos00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Character",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Character* self = (Character*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPos'",NULL);
#endif
  {
   Vec3 tolua_ret = (Vec3)  self->GetPos();
   {
#ifdef __cplusplus
    void* tolua_obj = new Vec3(tolua_ret);
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vec3));
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#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: IsAt of class  Character */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Character_IsAt00
static int tolua_dp_scripts_Character_IsAt00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Character",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Vec3",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Character* self = (Character*)  tolua_tousertype(tolua_S,1,0);
  Vec3 pos = *((Vec3*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsAt'",NULL);
#endif
  {
   bool tolua_ret = (bool)  self->IsAt(pos);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsAt'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: WayPointPop of class  Character */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Character_WayPointPop00
static int tolua_dp_scripts_Character_WayPointPop00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Character",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Character* self = (Character*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'WayPointPop'",NULL);
#endif
  {
   Vec3 tolua_ret = (Vec3)  self->WayPointPop();
   {
#ifdef __cplusplus
    void* tolua_obj = new Vec3(tolua_ret);
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vec3));
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'WayPointPop'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

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

/* method: InitMakePath of class  Character */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Character_InitMakePath00
static int tolua_dp_scripts_Character_InitMakePath00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Character",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Vec3",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Character* self = (Character*)  tolua_tousertype(tolua_S,1,0);
  Vec3 to = *((Vec3*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'InitMakePath'",NULL);
#endif
  {
   self->InitMakePath(to);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'InitMakePath'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: InitMakeSmoothPath of class  Character */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Character_InitMakeSmoothPath00
static int tolua_dp_scripts_Character_InitMakeSmoothPath00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Character",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Vec3",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Character* self = (Character*)  tolua_tousertype(tolua_S,1,0);
  Vec3 to = *((Vec3*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'InitMakeSmoothPath'",NULL);
#endif
  {
   self->InitMakeSmoothPath(to);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'InitMakeSmoothPath'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

/* method: GetEvaluatedPos of class  Character */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Character_GetEvaluatedPos00
static int tolua_dp_scripts_Character_GetEvaluatedPos00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Character",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Character* self = (Character*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEvaluatedPos'",NULL);
#endif
  {
   Vec3 tolua_ret = (Vec3)  self->GetEvaluatedPos();
   {
#ifdef __cplusplus
    void* tolua_obj = new Vec3(tolua_ret);
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vec3));
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetEvaluatedPos'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: IsCovered of class  Character */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Character_IsCovered00
static int tolua_dp_scripts_Character_IsCovered00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Character",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"const Vec3",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"const Vec3",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vec3* from = ((const Vec3*)  tolua_tousertype(tolua_S,2,0));
  const Vec3* to = ((const Vec3*)  tolua_tousertype(tolua_S,3,0));
  {
   bool tolua_ret = (bool)  Character::IsCovered(*from,*to);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsCovered'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: SetHero of class  Character */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Character_SetHero00
static int tolua_dp_scripts_Character_SetHero00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Character",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Character",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Character* hero = ((Character*)  tolua_tousertype(tolua_S,2,0));
  {
   Character::SetHero(hero);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'SetHero'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: GetName of class  Character */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Character_GetName00
static int tolua_dp_scripts_Character_GetName00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Character",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Character* self = (Character*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetName'",NULL);
#endif
  {
   char* tolua_ret = (char*)  self->GetName();
   tolua_pushstring(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

/* get function: FireRange of class  Character */
#ifndef TOLUA_DISABLE_tolua_get_Character_FireRange
static int tolua_get_Character_FireRange(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)Character::FireRange);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FireRange of class  Character */
#ifndef TOLUA_DISABLE_tolua_set_Character_FireRange
static int tolua_set_Character_FireRange(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  Character::FireRange = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FireHeight of class  Character */
#ifndef TOLUA_DISABLE_tolua_get_Character_FireHeight
static int tolua_get_Character_FireHeight(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)Character::FireHeight);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FireHeight of class  Character */
#ifndef TOLUA_DISABLE_tolua_set_Character_FireHeight
static int tolua_set_Character_FireHeight(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  Character::FireHeight = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: EvaluateRange of class  Character */
#ifndef TOLUA_DISABLE_tolua_get_Character_EvaluateRange
static int tolua_get_Character_EvaluateRange(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)Character::EvaluateRange);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: EvaluateRange of class  Character */
#ifndef TOLUA_DISABLE_tolua_set_Character_EvaluateRange
static int tolua_set_Character_EvaluateRange(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  Character::EvaluateRange = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: WayPointQueueLength of class  Character */
#ifndef TOLUA_DISABLE_tolua_get_Character_WayPointQueueLength
static int tolua_get_Character_WayPointQueueLength(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)Character::WayPointQueueLength);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: WayPointQueueLength of class  Character */
#ifndef TOLUA_DISABLE_tolua_set_Character_WayPointQueueLength
static int tolua_set_Character_WayPointQueueLength(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  Character::WayPointQueueLength = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: GetMouseHitPos of class  GameLevel */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_GameLevel_GetMouseHitPos00
static int tolua_dp_scripts_GameLevel_GetMouseHitPos00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"GameLevel",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  GameLevel* self = (GameLevel*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMouseHitPos'",NULL);
#endif
  {
   Vec3 tolua_ret = (Vec3)  self->GetMouseHitPos();
   {
#ifdef __cplusplus
    void* tolua_obj = new Vec3(tolua_ret);
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vec3));
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMouseHitPos'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetMouseHitNorm of class  GameLevel */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_GameLevel_GetMouseHitNorm00
static int tolua_dp_scripts_GameLevel_GetMouseHitNorm00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"GameLevel",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  GameLevel* self = (GameLevel*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetMouseHitNorm'",NULL);
#endif
  {
   Vec3 tolua_ret = (Vec3)  self->GetMouseHitNorm();
   {
#ifdef __cplusplus
    void* tolua_obj = new Vec3(tolua_ret);
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vec3));
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetMouseHitNorm'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DrawDebugLine of class  GameLevel */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_GameLevel_DrawDebugLine00
static int tolua_dp_scripts_GameLevel_DrawDebugLine00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"GameLevel",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Vec3",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"Vec3",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"Vec3",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vec3 fromP = *((Vec3*)  tolua_tousertype(tolua_S,2,0));
  Vec3 toP = *((Vec3*)  tolua_tousertype(tolua_S,3,0));
  Vec3 color = *((Vec3*)  tolua_tousertype(tolua_S,4,0));
  {
   GameLevel::DrawDebugLine(fromP,toP,color);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DrawDebugLine'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DrawDebugLine of class  GameLevel */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_GameLevel_DrawDebugLine01
static int tolua_dp_scripts_GameLevel_DrawDebugLine01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"GameLevel",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Vec3",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"Vec3",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  Vec3 fromP = *((Vec3*)  tolua_tousertype(tolua_S,2,0));
  Vec3 toP = *((Vec3*)  tolua_tousertype(tolua_S,3,0));
  {
   GameLevel::DrawDebugLine(fromP,toP);
  }
 }
 return 0;
tolua_lerror:
 return tolua_dp_scripts_GameLevel_DrawDebugLine00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: DrawDebugLineDelta of class  GameLevel */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_GameLevel_DrawDebugLineDelta00
static int tolua_dp_scripts_GameLevel_DrawDebugLineDelta00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"GameLevel",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Vec3",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"Vec3",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vec3 fromP = *((Vec3*)  tolua_tousertype(tolua_S,2,0));
  Vec3 delta = *((Vec3*)  tolua_tousertype(tolua_S,3,0));
  {
   GameLevel::DrawDebugLineDelta(fromP,delta);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DrawDebugLineDelta'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: DrawDebugLineDelta of class  GameLevel */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_GameLevel_DrawDebugLineDelta01
static int tolua_dp_scripts_GameLevel_DrawDebugLineDelta01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"GameLevel",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Vec3",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"Vec3",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"Vec3",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,5,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  Vec3 fromP = *((Vec3*)  tolua_tousertype(tolua_S,2,0));
  Vec3 delta = *((Vec3*)  tolua_tousertype(tolua_S,3,0));
  Vec3 color = *((Vec3*)  tolua_tousertype(tolua_S,4,0));
  {
   GameLevel::DrawDebugLineDelta(fromP,delta,color);
  }
 }
 return 0;
tolua_lerror:
 return tolua_dp_scripts_GameLevel_DrawDebugLineDelta00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: RayCast of class  GameLevel */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_GameLevel_RayCast00
static int tolua_dp_scripts_GameLevel_RayCast00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"GameLevel",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Vec3",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"Vec3",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,4,"Vec3",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,5,"Vec3",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,6,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vec3 fromP = *((Vec3*)  tolua_tousertype(tolua_S,2,0));
  Vec3 toP = *((Vec3*)  tolua_tousertype(tolua_S,3,0));
  Vec3* pHitPos = ((Vec3*)  tolua_tousertype(tolua_S,4,0));
  Vec3* pNormalVec = ((Vec3*)  tolua_tousertype(tolua_S,5,0));
  {
   bool tolua_ret = (bool)  GameLevel::RayCast(fromP,toP,pHitPos,pNormalVec);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'RayCast'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: RayCastTwoWay of class  GameLevel */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_GameLevel_RayCastTwoWay00
static int tolua_dp_scripts_GameLevel_RayCastTwoWay00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"GameLevel",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Vec3",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,3,"Vec3",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,4,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vec3 pos1 = *((Vec3*)  tolua_tousertype(tolua_S,2,0));
  Vec3 pos2 = *((Vec3*)  tolua_tousertype(tolua_S,3,0));
  {
   bool tolua_ret = (bool)  GameLevel::RayCastTwoWay(pos1,pos2);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'RayCastTwoWay'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

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

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

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

/* method: IsAccessible of class  Map */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Map_IsAccessible01
static int tolua_dp_scripts_Map_IsAccessible01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Map",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
 {
  Map* self = (Map*)  tolua_tousertype(tolua_S,1,0);
  int posX = ((int)  tolua_tonumber(tolua_S,2,0));
  int posY = ((int)  tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsAccessible'",NULL);
#endif
  {
   bool tolua_ret = (bool)  self->IsAccessible(posX,posY);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
tolua_lerror:
 return tolua_dp_scripts_Map_IsAccessible00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetPosition of class  Map */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Map_GetPosition00
static int tolua_dp_scripts_Map_GetPosition00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Map",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
 {
  Map* self = (Map*)  tolua_tousertype(tolua_S,1,0);
  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 'GetPosition'",NULL);
#endif
  {
   Vec3 tolua_ret = (Vec3)  self->GetPosition(x,y);
   {
#ifdef __cplusplus
    void* tolua_obj = new Vec3(tolua_ret);
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vec3));
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetPosition'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: GetCell of class  Map */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Map_GetCell00
static int tolua_dp_scripts_Map_GetCell00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Map",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Vec3",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
 {
  Map* self = (Map*)  tolua_tousertype(tolua_S,1,0);
  Vec3 pos = *((Vec3*)  tolua_tousertype(tolua_S,2,0));
  int x = ((int)  tolua_tonumber(tolua_S,3,0));
  int y = ((int)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetCell'",NULL);
#endif
  {
   self->GetCell(pos,x,y);
   tolua_pushnumber(tolua_S,(lua_Number)x);
   tolua_pushnumber(tolua_S,(lua_Number)y);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'GetCell'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

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

/* method: IsConnectX of class  Map */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Map_IsConnectX00
static int tolua_dp_scripts_Map_IsConnectX00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Map",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
 {
  Map* self = (Map*)  tolua_tousertype(tolua_S,1,0);
  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 'IsConnectX'",NULL);
#endif
  {
   bool tolua_ret = (bool)  self->IsConnectX(x,y);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsConnectX'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsConnectY of class  Map */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Map_IsConnectY00
static int tolua_dp_scripts_Map_IsConnectY00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Map",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
 {
  Map* self = (Map*)  tolua_tousertype(tolua_S,1,0);
  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 'IsConnectY'",NULL);
#endif
  {
   bool tolua_ret = (bool)  self->IsConnectY(x,y);
   tolua_pushboolean(tolua_S,(bool)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'IsConnectY'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* get function: WalkableHeight of class  Map */
#ifndef TOLUA_DISABLE_tolua_get_Map_WalkableHeight
static int tolua_get_Map_WalkableHeight(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)Map::WalkableHeight);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: WalkableHeight of class  Map */
#ifndef TOLUA_DISABLE_tolua_set_Map_WalkableHeight
static int tolua_set_Map_WalkableHeight(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  Map::WalkableHeight = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: GridSize of class  Map */
#ifndef TOLUA_DISABLE_tolua_get_Map_GridSize
static int tolua_get_Map_GridSize(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)Map::GridSize);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: GridSize of class  Map */
#ifndef TOLUA_DISABLE_tolua_set_Map_GridSize
static int tolua_set_Map_GridSize(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  Map::GridSize = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: FootHeight of class  Map */
#ifndef TOLUA_DISABLE_tolua_get_Map_FootHeight
static int tolua_get_Map_FootHeight(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)Map::FootHeight);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: FootHeight of class  Map */
#ifndef TOLUA_DISABLE_tolua_set_Map_FootHeight
static int tolua_set_Map_FootHeight(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  Map::FootHeight = ((float)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: InfiniteDistance of class  Map */
#ifndef TOLUA_DISABLE_tolua_get_Map_InfiniteDistance
static int tolua_get_Map_InfiniteDistance(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)Map::InfiniteDistance);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: InfiniteDistance of class  Map */
#ifndef TOLUA_DISABLE_tolua_set_Map_InfiniteDistance
static int tolua_set_Map_InfiniteDistance(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  Map::InfiniteDistance = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

/* get function: MaximumSearchDistance of class  Map */
#ifndef TOLUA_DISABLE_tolua_get_Map_MaximumSearchDistance
static int tolua_get_Map_MaximumSearchDistance(lua_State* tolua_S)
{
  tolua_pushnumber(tolua_S,(lua_Number)Map::MaximumSearchDistance);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: MaximumSearchDistance of class  Map */
#ifndef TOLUA_DISABLE_tolua_set_Map_MaximumSearchDistance
static int tolua_set_Map_MaximumSearchDistance(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
   tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
  Map::MaximumSearchDistance = ((int)  tolua_tonumber(tolua_S,2,0))
;
 return 0;
}
#endif //#ifndef TOLUA_DISABLE

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

/* set function: x of class  Vec3 */
#ifndef TOLUA_DISABLE_tolua_set_Vec3_x
static int tolua_set_Vec3_x(lua_State* tolua_S)
{
  Vec3* self = (Vec3*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'x'",NULL);
  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  Vec3 */
#ifndef TOLUA_DISABLE_tolua_get_Vec3_y
static int tolua_get_Vec3_y(lua_State* tolua_S)
{
  Vec3* self = (Vec3*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->y);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: y of class  Vec3 */
#ifndef TOLUA_DISABLE_tolua_set_Vec3_y
static int tolua_set_Vec3_y(lua_State* tolua_S)
{
  Vec3* self = (Vec3*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'y'",NULL);
  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  Vec3 */
#ifndef TOLUA_DISABLE_tolua_get_Vec3_z
static int tolua_get_Vec3_z(lua_State* tolua_S)
{
  Vec3* self = (Vec3*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'z'",NULL);
#endif
  tolua_pushnumber(tolua_S,(lua_Number)self->z);
 return 1;
}
#endif //#ifndef TOLUA_DISABLE

/* set function: z of class  Vec3 */
#ifndef TOLUA_DISABLE_tolua_set_Vec3_z
static int tolua_set_Vec3_z(lua_State* tolua_S)
{
  Vec3* self = (Vec3*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  tolua_Error tolua_err;
  if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'z'",NULL);
  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: make of class  Vec3 */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Vec3_make00
static int tolua_dp_scripts_Vec3_make00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vec3",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   Vec3 tolua_ret = (Vec3)  Vec3::make();
   {
#ifdef __cplusplus
    void* tolua_obj = new Vec3(tolua_ret);
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vec3));
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'make'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: make of class  Vec3 */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Vec3_make01
static int tolua_dp_scripts_Vec3_make01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vec3",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 x = ((float)  tolua_tonumber(tolua_S,2,0));
  float y = ((float)  tolua_tonumber(tolua_S,3,0));
  float z = ((float)  tolua_tonumber(tolua_S,4,0));
  {
   Vec3 tolua_ret = (Vec3)  Vec3::make(x,y,z);
   {
#ifdef __cplusplus
    void* tolua_obj = new Vec3(tolua_ret);
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vec3));
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#endif
   }
  }
 }
 return 1;
tolua_lerror:
 return tolua_dp_scripts_Vec3_make00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: operator+ of class  Vec3 */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Vec3__add00
static int tolua_dp_scripts_Vec3__add00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vec3",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"const Vec3",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vec3* self = (const Vec3*)  tolua_tousertype(tolua_S,1,0);
  const Vec3* op = ((const Vec3*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'",NULL);
#endif
  {
   Vec3 tolua_ret = (Vec3)  self->operator+(*op);
   {
#ifdef __cplusplus
    void* tolua_obj = new Vec3(tolua_ret);
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vec3));
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#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  Vec3 */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Vec3__sub00
static int tolua_dp_scripts_Vec3__sub00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vec3",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"const Vec3",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vec3* self = (const Vec3*)  tolua_tousertype(tolua_S,1,0);
  const Vec3* op = ((const Vec3*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'",NULL);
#endif
  {
   Vec3 tolua_ret = (Vec3)  self->operator-(*op);
   {
#ifdef __cplusplus
    void* tolua_obj = new Vec3(tolua_ret);
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vec3));
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#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  Vec3 */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Vec3__mul00
static int tolua_dp_scripts_Vec3__mul00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vec3",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vec3* self = (const Vec3*)  tolua_tousertype(tolua_S,1,0);
  const float op = ((const float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'",NULL);
#endif
  {
   Vec3 tolua_ret = (Vec3)  self->operator*(op);
   {
#ifdef __cplusplus
    void* tolua_obj = new Vec3(tolua_ret);
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vec3));
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#endif
   }
   tolua_pushnumber(tolua_S,(lua_Number)op);
  }
 }
 return 2;
#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  Vec3 */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Vec3__div00
static int tolua_dp_scripts_Vec3__div00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vec3",0,&tolua_err) ||
     !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vec3* self = (const Vec3*)  tolua_tousertype(tolua_S,1,0);
  const float op = ((const float)  tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator/'",NULL);
#endif
  {
   Vec3 tolua_ret = (Vec3)  self->operator/(op);
   {
#ifdef __cplusplus
    void* tolua_obj = new Vec3(tolua_ret);
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vec3));
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#endif
   }
   tolua_pushnumber(tolua_S,(lua_Number)op);
  }
 }
 return 2;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function '.div'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Set of class  Vec3 */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Vec3_Set00
static int tolua_dp_scripts_Vec3_Set00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vec3",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
 {
  Vec3* self = (Vec3*)  tolua_tousertype(tolua_S,1,0);
  float px = ((float)  tolua_tonumber(tolua_S,2,0));
  float py = ((float)  tolua_tonumber(tolua_S,3,0));
  float pz = ((float)  tolua_tonumber(tolua_S,4,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Set'",NULL);
#endif
  {
   self->Set(px,py,pz);
  }
 }
 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: Set of class  Vec3 */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Vec3_Set01
static int tolua_dp_scripts_Vec3_Set01(lua_State* tolua_S)
{
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vec3",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Vec3",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
 {
  Vec3* self = (Vec3*)  tolua_tousertype(tolua_S,1,0);
  Vec3 vec = *((Vec3*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Set'",NULL);
#endif
  {
   self->Set(vec);
  }
 }
 return 0;
tolua_lerror:
 return tolua_dp_scripts_Vec3_Set00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE

/* method: Length of class  Vec3 */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Vec3_Length00
static int tolua_dp_scripts_Vec3_Length00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vec3",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vec3* self = (const Vec3*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Length'",NULL);
#endif
  {
   float tolua_ret = (float)  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: Length2D of class  Vec3 */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Vec3_Length2D00
static int tolua_dp_scripts_Vec3_Length2D00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"const Vec3",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  const Vec3* self = (const Vec3*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Length2D'",NULL);
#endif
  {
   float tolua_ret = (float)  self->Length2D();
   tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Length2D'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

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

/* method: delete of class  Vec3 */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Vec3_delete00
static int tolua_dp_scripts_Vec3_delete00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vec3",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vec3* self = (Vec3*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'",NULL);
#endif
  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: new of class  Vec3 */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Vec3_new00
static int tolua_dp_scripts_Vec3_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vec3",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   Vec3* tolua_ret = (Vec3*)  new Vec3();
   tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vec3");
  }
 }
 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  Vec3 */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Vec3_new00_local
static int tolua_dp_scripts_Vec3_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertable(tolua_S,1,"Vec3",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  {
   Vec3* tolua_ret = (Vec3*)  new Vec3();
   tolua_pushusertype_and_takeownership(tolua_S,(void *)tolua_ret,"Vec3");
  }
 }
 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: Pop of class  Vec3Queue */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Vec3Queue_Pop00
static int tolua_dp_scripts_Vec3Queue_Pop00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vec3Queue",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vec3Queue* self = (Vec3Queue*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Pop'",NULL);
#endif
  {
   Vec3 tolua_ret = (Vec3)  self->Pop();
   {
#ifdef __cplusplus
    void* tolua_obj = new Vec3(tolua_ret);
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#else
    void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vec3));
    tolua_pushusertype_and_takeownership(tolua_S,tolua_obj,"Vec3");
#endif
   }
  }
 }
 return 1;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Pop'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Push of class  Vec3Queue */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Vec3Queue_Push00
static int tolua_dp_scripts_Vec3Queue_Push00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vec3Queue",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Vec3",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vec3Queue* self = (Vec3Queue*)  tolua_tousertype(tolua_S,1,0);
  Vec3 pos = *((Vec3*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Push'",NULL);
#endif
  {
   self->Push(pos);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Push'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: PushBack of class  Vec3Queue */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Vec3Queue_PushBack00
static int tolua_dp_scripts_Vec3Queue_PushBack00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vec3Queue",0,&tolua_err) ||
     !tolua_isusertype(tolua_S,2,"Vec3",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,3,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vec3Queue* self = (Vec3Queue*)  tolua_tousertype(tolua_S,1,0);
  Vec3 pos = *((Vec3*)  tolua_tousertype(tolua_S,2,0));
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'PushBack'",NULL);
#endif
  {
   self->PushBack(pos);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'PushBack'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: IsEmpty of class  Vec3Queue */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Vec3Queue_IsEmpty00
static int tolua_dp_scripts_Vec3Queue_IsEmpty00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vec3Queue",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vec3Queue* self = (Vec3Queue*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsEmpty'",NULL);
#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: Clean of class  Vec3Queue */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Vec3Queue_Clean00
static int tolua_dp_scripts_Vec3Queue_Clean00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vec3Queue",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vec3Queue* self = (Vec3Queue*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Clean'",NULL);
#endif
  {
   self->Clean();
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'Clean'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* method: Size of class  Vec3Queue */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_Vec3Queue_Size00
static int tolua_dp_scripts_Vec3Queue_Size00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"Vec3Queue",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  Vec3Queue* self = (Vec3Queue*)  tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
  if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Size'",NULL);
#endif
  {
   int tolua_ret = (int)  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

/* function: MouseHitMove */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_MouseHitMove00
static int tolua_dp_scripts_MouseHitMove00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"GameLevel",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  GameLevel* level = ((GameLevel*)  tolua_tousertype(tolua_S,1,0));
  {
   MouseHitMove(level);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'MouseHitMove'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: MouseHitDraw */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_MouseHitDraw00
static int tolua_dp_scripts_MouseHitDraw00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"GameLevel",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  GameLevel* level = ((GameLevel*)  tolua_tousertype(tolua_S,1,0));
  {
   MouseHitDraw(level);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'MouseHitDraw'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: MouseFindPath */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_MouseFindPath00
static int tolua_dp_scripts_MouseFindPath00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"GameLevel",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  GameLevel* level = ((GameLevel*)  tolua_tousertype(tolua_S,1,0));
  {
   MouseFindPath(level);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'MouseFindPath'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: MouseFindPathSmooth */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_MouseFindPathSmooth00
static int tolua_dp_scripts_MouseFindPathSmooth00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"GameLevel",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  GameLevel* level = ((GameLevel*)  tolua_tousertype(tolua_S,1,0));
  {
   MouseFindPathSmooth(level);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'MouseFindPathSmooth'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: MouseMoveWayPoint */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_MouseMoveWayPoint00
static int tolua_dp_scripts_MouseMoveWayPoint00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"GameLevel",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  GameLevel* level = ((GameLevel*)  tolua_tousertype(tolua_S,1,0));
  {
   MouseMoveWayPoint(level);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'MouseMoveWayPoint'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* function: DrawMapConnection */
#ifndef TOLUA_DISABLE_tolua_dp_scripts_DrawMapConnection00
static int tolua_dp_scripts_DrawMapConnection00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
 tolua_Error tolua_err;
 if (
     !tolua_isusertype(tolua_S,1,"GameLevel",0,&tolua_err) ||
     !tolua_isnoobj(tolua_S,2,&tolua_err)
 )
  goto tolua_lerror;
 else
#endif
 {
  GameLevel* level = ((GameLevel*)  tolua_tousertype(tolua_S,1,0));
  {
   DrawMapConnection(level);
  }
 }
 return 0;
#ifndef TOLUA_RELEASE
 tolua_lerror:
 tolua_error(tolua_S,"#ferror in function 'DrawMapConnection'.",&tolua_err);
 return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE

/* Open function */
TOLUA_API int tolua_dp_scripts_open (lua_State* tolua_S)
{
 tolua_open(tolua_S);
 tolua_reg_types(tolua_S);
 tolua_module(tolua_S,NULL,0);
 tolua_beginmodule(tolua_S,NULL);
  tolua_cclass(tolua_S,"GameEngine","GameEngine","GameScreen",NULL);
  tolua_beginmodule(tolua_S,"GameEngine");
   tolua_variable(tolua_S,"SpotLightRange",tolua_get_GameEngine_SpotLightRange,tolua_set_GameEngine_SpotLightRange);
   tolua_variable(tolua_S,"SpotLightRadius",tolua_get_GameEngine_SpotLightRadius,tolua_set_GameEngine_SpotLightRadius);
   tolua_variable(tolua_S,"PointLightRange",tolua_get_GameEngine_PointLightRange,tolua_set_GameEngine_PointLightRange);
   tolua_variable(tolua_S,"RunVelocity",tolua_get_GameEngine_RunVelocity,tolua_set_GameEngine_RunVelocity);
   tolua_variable(tolua_S,"RunVelocityEpsilon",tolua_get_GameEngine_RunVelocityEpsilon,tolua_set_GameEngine_RunVelocityEpsilon);
   tolua_variable(tolua_S,"RunAcceleration",tolua_get_GameEngine_RunAcceleration,tolua_set_GameEngine_RunAcceleration);
   tolua_function(tolua_S,"LightDirectionalDir",tolua_dp_scripts_GameEngine_LightDirectionalDir00);
   tolua_variable(tolua_S,"RangeEpsilon",tolua_get_GameEngine_RangeEpsilon,tolua_set_GameEngine_RangeEpsilon);
   tolua_variable(tolua_S,"PreferedFrameRate",tolua_get_GameEngine_PreferedFrameRate,tolua_set_GameEngine_PreferedFrameRate);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Character","Character","Game3DInstance",NULL);
  tolua_beginmodule(tolua_S,"Character");
   tolua_function(tolua_S,"Add",tolua_dp_scripts_Character_Add00);
   tolua_function(tolua_S,"Get",tolua_dp_scripts_Character_Get00);
   tolua_function(tolua_S,"MoveTo",tolua_dp_scripts_Character_MoveTo00);
   tolua_function(tolua_S,"SetPos",tolua_dp_scripts_Character_SetPos00);
   tolua_function(tolua_S,"GetPos",tolua_dp_scripts_Character_GetPos00);
   tolua_function(tolua_S,"IsAt",tolua_dp_scripts_Character_IsAt00);
   tolua_function(tolua_S,"Stop",tolua_dp_scripts_Character_Stop00);
   tolua_function(tolua_S,"IsWayPointEmpty",tolua_dp_scripts_Character_IsWayPointEmpty00);
   tolua_function(tolua_S,"WayPointPop",tolua_dp_scripts_Character_WayPointPop00);
   tolua_function(tolua_S,"InitComputeDistanceMap",tolua_dp_scripts_Character_InitComputeDistanceMap00);
   tolua_function(tolua_S,"InitComputeDistanceMapBreath",tolua_dp_scripts_Character_InitComputeDistanceMapBreath00);
   tolua_function(tolua_S,"ComputeDistanceMapStep",tolua_dp_scripts_Character_ComputeDistanceMapStep00);
   tolua_function(tolua_S,"ComputeDistanceMapBreathStep",tolua_dp_scripts_Character_ComputeDistanceMapBreathStep00);
   tolua_function(tolua_S,"InitMakePath",tolua_dp_scripts_Character_InitMakePath00);
   tolua_function(tolua_S,"MakePathStep",tolua_dp_scripts_Character_MakePathStep00);
   tolua_function(tolua_S,"InitMakeSmoothPath",tolua_dp_scripts_Character_InitMakeSmoothPath00);
   tolua_function(tolua_S,"MakeSmoothPathStep",tolua_dp_scripts_Character_MakeSmoothPathStep00);
   tolua_function(tolua_S,"InitEvaluateEvadeStep",tolua_dp_scripts_Character_InitEvaluateEvadeStep00);
   tolua_function(tolua_S,"EvaluateEvadeStep",tolua_dp_scripts_Character_EvaluateEvadeStep00);
   tolua_function(tolua_S,"GetEvaluatedPos",tolua_dp_scripts_Character_GetEvaluatedPos00);
   tolua_function(tolua_S,"IsEvaluateSuccess",tolua_dp_scripts_Character_IsEvaluateSuccess00);
   tolua_function(tolua_S,"IsCovered",tolua_dp_scripts_Character_IsCovered00);
   tolua_function(tolua_S,"GetHero",tolua_dp_scripts_Character_GetHero00);
   tolua_function(tolua_S,"SetHero",tolua_dp_scripts_Character_SetHero00);
   tolua_function(tolua_S,"FireToHero",tolua_dp_scripts_Character_FireToHero00);
   tolua_function(tolua_S,"GetName",tolua_dp_scripts_Character_GetName00);
   tolua_variable(tolua_S,"FireRange",tolua_get_Character_FireRange,tolua_set_Character_FireRange);
   tolua_variable(tolua_S,"FireHeight",tolua_get_Character_FireHeight,tolua_set_Character_FireHeight);
   tolua_variable(tolua_S,"EvaluateRange",tolua_get_Character_EvaluateRange,tolua_set_Character_EvaluateRange);
   tolua_variable(tolua_S,"WayPointQueueLength",tolua_get_Character_WayPointQueueLength,tolua_set_Character_WayPointQueueLength);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"GameLevel","GameLevel","GameScreen",NULL);
  tolua_beginmodule(tolua_S,"GameLevel");
   tolua_function(tolua_S,"GetInstance",tolua_dp_scripts_GameLevel_GetInstance00);
   tolua_function(tolua_S,"IsMouseHit",tolua_dp_scripts_GameLevel_IsMouseHit00);
   tolua_function(tolua_S,"GetMouseHitPos",tolua_dp_scripts_GameLevel_GetMouseHitPos00);
   tolua_function(tolua_S,"GetMouseHitNorm",tolua_dp_scripts_GameLevel_GetMouseHitNorm00);
   tolua_function(tolua_S,"DrawDebugLine",tolua_dp_scripts_GameLevel_DrawDebugLine00);
   tolua_function(tolua_S,"DrawDebugLine",tolua_dp_scripts_GameLevel_DrawDebugLine01);
   tolua_function(tolua_S,"DrawDebugLineDelta",tolua_dp_scripts_GameLevel_DrawDebugLineDelta00);
   tolua_function(tolua_S,"DrawDebugLineDelta",tolua_dp_scripts_GameLevel_DrawDebugLineDelta01);
   tolua_function(tolua_S,"RayCast",tolua_dp_scripts_GameLevel_RayCast00);
   tolua_function(tolua_S,"RayCastTwoWay",tolua_dp_scripts_GameLevel_RayCastTwoWay00);
   tolua_function(tolua_S,"GetMap",tolua_dp_scripts_GameLevel_GetMap00);
   tolua_function(tolua_S,"SetMapSizeX",tolua_dp_scripts_GameLevel_SetMapSizeX00);
   tolua_function(tolua_S,"SetMapSizeY",tolua_dp_scripts_GameLevel_SetMapSizeY00);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Map","Map","",NULL);
  tolua_beginmodule(tolua_S,"Map");
   tolua_function(tolua_S,"GetInstance",tolua_dp_scripts_Map_GetInstance00);
   tolua_function(tolua_S,"IsAccessible",tolua_dp_scripts_Map_IsAccessible00);
   tolua_function(tolua_S,"IsAccessible",tolua_dp_scripts_Map_IsAccessible01);
   tolua_function(tolua_S,"GetPosition",tolua_dp_scripts_Map_GetPosition00);
   tolua_function(tolua_S,"GetCell",tolua_dp_scripts_Map_GetCell00);
   tolua_function(tolua_S,"SizeX",tolua_dp_scripts_Map_SizeX00);
   tolua_function(tolua_S,"SizeY",tolua_dp_scripts_Map_SizeY00);
   tolua_function(tolua_S,"IsConnectX",tolua_dp_scripts_Map_IsConnectX00);
   tolua_function(tolua_S,"IsConnectY",tolua_dp_scripts_Map_IsConnectY00);
   tolua_variable(tolua_S,"WalkableHeight",tolua_get_Map_WalkableHeight,tolua_set_Map_WalkableHeight);
   tolua_variable(tolua_S,"GridSize",tolua_get_Map_GridSize,tolua_set_Map_GridSize);
   tolua_variable(tolua_S,"FootHeight",tolua_get_Map_FootHeight,tolua_set_Map_FootHeight);
   tolua_variable(tolua_S,"InfiniteDistance",tolua_get_Map_InfiniteDistance,tolua_set_Map_InfiniteDistance);
   tolua_variable(tolua_S,"MaximumSearchDistance",tolua_get_Map_MaximumSearchDistance,tolua_set_Map_MaximumSearchDistance);
  tolua_endmodule(tolua_S);
  #ifdef __cplusplus
  tolua_cclass(tolua_S,"Vec3","Vec3","",tolua_collect_Vec3);
  #else
  tolua_cclass(tolua_S,"Vec3","Vec3","",NULL);
  #endif
  tolua_beginmodule(tolua_S,"Vec3");
   tolua_variable(tolua_S,"x",tolua_get_Vec3_x,tolua_set_Vec3_x);
   tolua_variable(tolua_S,"y",tolua_get_Vec3_y,tolua_set_Vec3_y);
   tolua_variable(tolua_S,"z",tolua_get_Vec3_z,tolua_set_Vec3_z);
   tolua_function(tolua_S,"make",tolua_dp_scripts_Vec3_make00);
   tolua_function(tolua_S,"make",tolua_dp_scripts_Vec3_make01);
   tolua_function(tolua_S,".add",tolua_dp_scripts_Vec3__add00);
   tolua_function(tolua_S,".sub",tolua_dp_scripts_Vec3__sub00);
   tolua_function(tolua_S,".mul",tolua_dp_scripts_Vec3__mul00);
   tolua_function(tolua_S,".div",tolua_dp_scripts_Vec3__div00);
   tolua_function(tolua_S,"Set",tolua_dp_scripts_Vec3_Set00);
   tolua_function(tolua_S,"Set",tolua_dp_scripts_Vec3_Set01);
   tolua_function(tolua_S,"Length",tolua_dp_scripts_Vec3_Length00);
   tolua_function(tolua_S,"Length2D",tolua_dp_scripts_Vec3_Length2D00);
   tolua_function(tolua_S,"IsAt",tolua_dp_scripts_Vec3_IsAt00);
   tolua_function(tolua_S,"delete",tolua_dp_scripts_Vec3_delete00);
   tolua_function(tolua_S,"new",tolua_dp_scripts_Vec3_new00);
   tolua_function(tolua_S,"new_local",tolua_dp_scripts_Vec3_new00_local);
   tolua_function(tolua_S,".call",tolua_dp_scripts_Vec3_new00_local);
  tolua_endmodule(tolua_S);
  tolua_cclass(tolua_S,"Vec3Queue","Vec3Queue","",NULL);
  tolua_beginmodule(tolua_S,"Vec3Queue");
   tolua_function(tolua_S,"Pop",tolua_dp_scripts_Vec3Queue_Pop00);
   tolua_function(tolua_S,"Push",tolua_dp_scripts_Vec3Queue_Push00);
   tolua_function(tolua_S,"PushBack",tolua_dp_scripts_Vec3Queue_PushBack00);
   tolua_function(tolua_S,"IsEmpty",tolua_dp_scripts_Vec3Queue_IsEmpty00);
   tolua_function(tolua_S,"Clean",tolua_dp_scripts_Vec3Queue_Clean00);
   tolua_function(tolua_S,"Size",tolua_dp_scripts_Vec3Queue_Size00);
  tolua_endmodule(tolua_S);
  tolua_function(tolua_S,"MouseHitMove",tolua_dp_scripts_MouseHitMove00);
  tolua_function(tolua_S,"MouseHitDraw",tolua_dp_scripts_MouseHitDraw00);
  tolua_function(tolua_S,"MouseFindPath",tolua_dp_scripts_MouseFindPath00);
  tolua_function(tolua_S,"MouseFindPathSmooth",tolua_dp_scripts_MouseFindPathSmooth00);
  tolua_function(tolua_S,"MouseMoveWayPoint",tolua_dp_scripts_MouseMoveWayPoint00);
  tolua_function(tolua_S,"DrawMapConnection",tolua_dp_scripts_DrawMapConnection00);
 tolua_endmodule(tolua_S);
 return 1;
}


#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
 TOLUA_API int luaopen_dp_scripts (lua_State* tolua_S) {
 return tolua_dp_scripts_open(tolua_S);
};
#endif
dp_scripts.cpp
Page URL
File URL
Prev 1/6 Next
Download ( 92 KB )
Leading Cloud Surveillance, recording and storage service. IP camera remote viewing, live streaming, broadcasting
Leading Enterprise Cloud IT Service. Cloud File Server, Drive Mapping, FTP Hosting, Online Storage
Note: The DriveHQ service banners will NOT be displayed if the file owner is a paid member.
Comments
Total ratings: 0 Average rating:
Not Rated
Would you like to comment?

Join DriveHQ for a free account, or Logon if you are already a member.