2014-03-02 04:12:29 -05:00
|
|
|
|
|
|
|
#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules
|
|
|
|
|
|
|
|
#include "DeprecatedBindings.h"
|
2014-03-25 13:15:05 -04:00
|
|
|
#undef TOLUA_TEMPLATE_BIND
|
2014-03-02 04:12:29 -05:00
|
|
|
#include "tolua++/include/tolua++.h"
|
|
|
|
|
|
|
|
|
2014-11-17 08:57:24 -05:00
|
|
|
#include "../World.h"
|
|
|
|
#include "../Entities/Player.h"
|
2014-11-17 12:01:56 -05:00
|
|
|
#include "LuaState.h"
|
2020-04-03 02:57:01 -04:00
|
|
|
#include "../BlockInfo.h"
|
2020-09-05 11:07:01 -04:00
|
|
|
#include "../BlockEntities/NoteEntity.h"
|
2014-03-02 04:12:29 -05:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/* get function: g_BlockLightValue */
|
|
|
|
#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockLightValue
|
|
|
|
static int tolua_get_AllToLua_g_BlockLightValue(lua_State* tolua_S)
|
|
|
|
{
|
2015-08-14 16:19:15 -04:00
|
|
|
cLuaState LuaState(tolua_S);
|
|
|
|
|
|
|
|
int BlockType = 0;
|
2014-03-02 04:12:29 -05:00
|
|
|
#ifndef TOLUA_RELEASE
|
|
|
|
{
|
|
|
|
tolua_Error tolua_err;
|
2014-07-19 08:53:41 -04:00
|
|
|
if (!tolua_isnumber(tolua_S, 2, 0, &tolua_err))
|
2014-04-03 03:26:44 -04:00
|
|
|
{
|
2014-07-19 08:53:41 -04:00
|
|
|
tolua_error(tolua_S, "#vinvalid type in array indexing.", &tolua_err);
|
2014-04-03 03:26:44 -04:00
|
|
|
}
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
|
|
|
#endif
|
2015-08-14 16:19:15 -04:00
|
|
|
LuaState.GetStackValue(2, BlockType);
|
2014-04-03 03:26:44 -04:00
|
|
|
if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
|
2014-03-02 04:12:29 -05:00
|
|
|
{
|
2014-10-20 16:55:07 -04:00
|
|
|
tolua_error(tolua_S, "array indexing out of range.", nullptr);
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
2015-08-14 16:19:15 -04:00
|
|
|
LuaState.Push(cBlockInfo::GetLightValue(static_cast<BLOCKTYPE>(BlockType)));
|
2014-04-03 03:26:44 -04:00
|
|
|
return 1;
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
2014-07-17 16:15:34 -04:00
|
|
|
#endif // #ifndef TOLUA_DISABLE
|
2014-03-02 04:12:29 -05:00
|
|
|
|
2014-03-02 10:34:16 -05:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-03-02 04:12:29 -05:00
|
|
|
/* get function: g_BlockSpreadLightFalloff */
|
|
|
|
#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockSpreadLightFalloff
|
|
|
|
static int tolua_get_AllToLua_g_BlockSpreadLightFalloff(lua_State* tolua_S)
|
|
|
|
{
|
2015-08-14 16:19:15 -04:00
|
|
|
cLuaState LuaState(tolua_S);
|
|
|
|
|
|
|
|
int BlockType = 0;
|
2014-03-02 04:12:29 -05:00
|
|
|
#ifndef TOLUA_RELEASE
|
|
|
|
{
|
|
|
|
tolua_Error tolua_err;
|
2014-07-19 08:53:41 -04:00
|
|
|
if (!tolua_isnumber(tolua_S, 2, 0, &tolua_err))
|
2014-12-05 10:59:11 -05:00
|
|
|
{
|
2014-07-19 08:53:41 -04:00
|
|
|
tolua_error(tolua_S, "#vinvalid type in array indexing.", &tolua_err);
|
2014-12-05 10:59:11 -05:00
|
|
|
}
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
|
|
|
#endif
|
2015-08-14 16:19:15 -04:00
|
|
|
LuaState.GetStackValue(2, BlockType);
|
2014-04-03 03:26:44 -04:00
|
|
|
if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
|
2014-03-02 04:12:29 -05:00
|
|
|
{
|
2014-10-20 16:55:07 -04:00
|
|
|
tolua_error(tolua_S, "array indexing out of range.", nullptr);
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
2015-08-14 16:19:15 -04:00
|
|
|
LuaState.Push(cBlockInfo::GetSpreadLightFalloff(static_cast<BLOCKTYPE>(BlockType)));
|
2014-04-03 03:26:44 -04:00
|
|
|
return 1;
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
2014-07-17 16:15:34 -04:00
|
|
|
#endif // #ifndef TOLUA_DISABLE
|
2014-03-02 04:12:29 -05:00
|
|
|
|
2014-03-02 10:34:16 -05:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-03-02 04:12:29 -05:00
|
|
|
/* get function: g_BlockTransparent */
|
|
|
|
#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockTransparent
|
|
|
|
static int tolua_get_AllToLua_g_BlockTransparent(lua_State* tolua_S)
|
|
|
|
{
|
2015-08-14 16:19:15 -04:00
|
|
|
cLuaState LuaState(tolua_S);
|
|
|
|
|
|
|
|
int BlockType = 0;
|
2014-03-02 04:12:29 -05:00
|
|
|
#ifndef TOLUA_RELEASE
|
|
|
|
{
|
|
|
|
tolua_Error tolua_err;
|
2014-07-19 08:53:41 -04:00
|
|
|
if (!tolua_isnumber(tolua_S, 2, 0, &tolua_err))
|
2014-12-05 10:59:11 -05:00
|
|
|
{
|
2014-07-19 08:53:41 -04:00
|
|
|
tolua_error(tolua_S, "#vinvalid type in array indexing.", &tolua_err);
|
2014-12-05 10:59:11 -05:00
|
|
|
}
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
|
|
|
#endif
|
2015-08-14 16:19:15 -04:00
|
|
|
LuaState.GetStackValue(2, BlockType);
|
2014-04-03 03:26:44 -04:00
|
|
|
if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
|
2014-03-02 04:12:29 -05:00
|
|
|
{
|
2014-10-20 16:55:07 -04:00
|
|
|
tolua_error(tolua_S, "array indexing out of range.", nullptr);
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
2015-08-14 16:19:15 -04:00
|
|
|
LuaState.Push(cBlockInfo::IsTransparent(static_cast<BLOCKTYPE>(BlockType)));
|
2014-04-03 03:26:44 -04:00
|
|
|
return 1;
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
2014-07-17 16:15:34 -04:00
|
|
|
#endif // #ifndef TOLUA_DISABLE
|
2014-03-02 04:12:29 -05:00
|
|
|
|
2014-03-02 10:34:16 -05:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-03-02 04:12:29 -05:00
|
|
|
/* get function: g_BlockOneHitDig */
|
|
|
|
#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockOneHitDig
|
|
|
|
static int tolua_get_AllToLua_g_BlockOneHitDig(lua_State* tolua_S)
|
|
|
|
{
|
2015-08-14 16:19:15 -04:00
|
|
|
cLuaState LuaState(tolua_S);
|
|
|
|
|
|
|
|
int BlockType = 0;
|
2014-03-02 04:12:29 -05:00
|
|
|
#ifndef TOLUA_RELEASE
|
|
|
|
{
|
|
|
|
tolua_Error tolua_err;
|
2014-07-19 08:53:41 -04:00
|
|
|
if (!tolua_isnumber(tolua_S, 2, 0, &tolua_err))
|
2014-12-05 10:59:11 -05:00
|
|
|
{
|
2014-07-19 08:53:41 -04:00
|
|
|
tolua_error(tolua_S, "#vinvalid type in array indexing.", &tolua_err);
|
2014-12-05 10:59:11 -05:00
|
|
|
}
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
|
|
|
#endif
|
2015-08-14 16:19:15 -04:00
|
|
|
LuaState.GetStackValue(2, BlockType);
|
2014-04-03 03:26:44 -04:00
|
|
|
if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
|
2014-03-02 04:12:29 -05:00
|
|
|
{
|
2014-10-20 16:55:07 -04:00
|
|
|
tolua_error(tolua_S, "array indexing out of range.", nullptr);
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
2015-08-14 16:19:15 -04:00
|
|
|
LuaState.Push(cBlockInfo::IsOneHitDig(static_cast<BLOCKTYPE>(BlockType)));
|
2014-04-03 03:26:44 -04:00
|
|
|
return 1;
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
2014-07-17 16:15:34 -04:00
|
|
|
#endif // #ifndef TOLUA_DISABLE
|
2014-03-02 04:12:29 -05:00
|
|
|
|
2014-03-02 10:34:16 -05:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-03-02 04:12:29 -05:00
|
|
|
/* get function: g_BlockPistonBreakable */
|
|
|
|
#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockPistonBreakable
|
|
|
|
static int tolua_get_AllToLua_g_BlockPistonBreakable(lua_State* tolua_S)
|
|
|
|
{
|
2015-08-14 16:19:15 -04:00
|
|
|
cLuaState LuaState(tolua_S);
|
|
|
|
|
|
|
|
int BlockType = 0;
|
2014-03-02 04:12:29 -05:00
|
|
|
#ifndef TOLUA_RELEASE
|
|
|
|
{
|
|
|
|
tolua_Error tolua_err;
|
2014-07-19 08:53:41 -04:00
|
|
|
if (!tolua_isnumber(tolua_S, 2, 0, &tolua_err))
|
2014-12-05 10:59:11 -05:00
|
|
|
{
|
2014-07-19 08:53:41 -04:00
|
|
|
tolua_error(tolua_S, "#vinvalid type in array indexing.", &tolua_err);
|
2014-12-05 10:59:11 -05:00
|
|
|
}
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
|
|
|
#endif
|
2015-08-14 16:19:15 -04:00
|
|
|
LuaState.GetStackValue(2, BlockType);
|
2014-04-03 03:26:44 -04:00
|
|
|
if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
|
2014-03-02 04:12:29 -05:00
|
|
|
{
|
2014-10-20 16:55:07 -04:00
|
|
|
tolua_error(tolua_S, "array indexing out of range.", nullptr);
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
2015-08-14 16:19:15 -04:00
|
|
|
LuaState.Push(cBlockInfo::IsPistonBreakable(static_cast<BLOCKTYPE>(BlockType)));
|
2014-04-03 03:26:44 -04:00
|
|
|
return 1;
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
2014-07-17 16:15:34 -04:00
|
|
|
#endif // #ifndef TOLUA_DISABLE
|
2014-03-02 04:12:29 -05:00
|
|
|
|
2014-03-02 10:34:16 -05:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-03-02 04:12:29 -05:00
|
|
|
/* get function: g_BlockIsSnowable */
|
|
|
|
#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockIsSnowable
|
|
|
|
static int tolua_get_AllToLua_g_BlockIsSnowable(lua_State* tolua_S)
|
|
|
|
{
|
2015-08-14 16:19:15 -04:00
|
|
|
cLuaState LuaState(tolua_S);
|
|
|
|
|
|
|
|
int BlockType = 0;
|
2014-03-02 04:12:29 -05:00
|
|
|
#ifndef TOLUA_RELEASE
|
|
|
|
{
|
|
|
|
tolua_Error tolua_err;
|
2014-07-19 08:53:41 -04:00
|
|
|
if (!tolua_isnumber(tolua_S, 2, 0, &tolua_err))
|
2014-12-05 10:59:11 -05:00
|
|
|
{
|
2014-07-19 08:53:41 -04:00
|
|
|
tolua_error(tolua_S, "#vinvalid type in array indexing.", &tolua_err);
|
2014-12-05 10:59:11 -05:00
|
|
|
}
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
|
|
|
#endif
|
2015-08-14 16:19:15 -04:00
|
|
|
LuaState.GetStackValue(2, BlockType);
|
2014-04-03 03:26:44 -04:00
|
|
|
if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
|
2014-03-02 04:12:29 -05:00
|
|
|
{
|
2014-10-20 16:55:07 -04:00
|
|
|
tolua_error(tolua_S, "array indexing out of range.", nullptr);
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
2015-08-14 16:19:15 -04:00
|
|
|
LuaState.Push(cBlockInfo::IsSnowable(static_cast<BLOCKTYPE>(BlockType)));
|
2014-04-03 03:26:44 -04:00
|
|
|
return 1;
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
2014-07-17 16:15:34 -04:00
|
|
|
#endif // #ifndef TOLUA_DISABLE
|
2014-03-02 04:12:29 -05:00
|
|
|
|
2014-03-02 10:34:16 -05:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-03-02 04:12:29 -05:00
|
|
|
/* get function: g_BlockIsSolid */
|
|
|
|
#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockIsSolid
|
|
|
|
static int tolua_get_AllToLua_g_BlockIsSolid(lua_State* tolua_S)
|
|
|
|
{
|
2015-08-14 16:19:15 -04:00
|
|
|
cLuaState LuaState(tolua_S);
|
|
|
|
|
|
|
|
int BlockType = 0;
|
2014-03-02 04:12:29 -05:00
|
|
|
#ifndef TOLUA_RELEASE
|
|
|
|
{
|
|
|
|
tolua_Error tolua_err;
|
2014-07-19 08:53:41 -04:00
|
|
|
if (!tolua_isnumber(tolua_S, 2, 0, &tolua_err))
|
2014-12-05 10:59:11 -05:00
|
|
|
{
|
2014-07-19 08:53:41 -04:00
|
|
|
tolua_error(tolua_S, "#vinvalid type in array indexing.", &tolua_err);
|
2014-12-05 10:59:11 -05:00
|
|
|
}
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
|
|
|
#endif
|
2015-08-14 16:19:15 -04:00
|
|
|
LuaState.GetStackValue(2, BlockType);
|
2014-04-03 03:26:44 -04:00
|
|
|
if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
|
2014-03-02 04:12:29 -05:00
|
|
|
{
|
2014-10-20 16:55:07 -04:00
|
|
|
tolua_error(tolua_S, "array indexing out of range.", nullptr);
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
2015-08-14 16:19:15 -04:00
|
|
|
LuaState.Push(cBlockInfo::IsSolid(static_cast<BLOCKTYPE>(BlockType)));
|
2014-04-03 03:26:44 -04:00
|
|
|
return 1;
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
2014-07-17 16:15:34 -04:00
|
|
|
#endif // #ifndef TOLUA_DISABLE
|
2014-03-02 04:12:29 -05:00
|
|
|
|
2014-03-02 10:34:16 -05:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-03-02 04:12:29 -05:00
|
|
|
/* get function: g_BlockFullyOccupiesVoxel */
|
|
|
|
#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockFullyOccupiesVoxel
|
|
|
|
static int tolua_get_AllToLua_g_BlockFullyOccupiesVoxel(lua_State* tolua_S)
|
|
|
|
{
|
2015-08-14 16:19:15 -04:00
|
|
|
cLuaState LuaState(tolua_S);
|
|
|
|
|
|
|
|
int BlockType = 0;
|
2014-03-02 04:12:29 -05:00
|
|
|
#ifndef TOLUA_RELEASE
|
|
|
|
{
|
|
|
|
tolua_Error tolua_err;
|
2014-07-19 08:53:41 -04:00
|
|
|
if (!tolua_isnumber(tolua_S, 2, 0, &tolua_err))
|
2014-12-05 10:59:11 -05:00
|
|
|
{
|
2014-07-19 08:53:41 -04:00
|
|
|
tolua_error(tolua_S, "#vinvalid type in array indexing.", &tolua_err);
|
2014-12-05 10:59:11 -05:00
|
|
|
}
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
|
|
|
#endif
|
2015-08-14 16:19:15 -04:00
|
|
|
LuaState.GetStackValue(2, BlockType);
|
2014-04-03 03:26:44 -04:00
|
|
|
if ((BlockType < 0) || (BlockType > E_BLOCK_MAX_TYPE_ID))
|
2014-03-02 04:12:29 -05:00
|
|
|
{
|
2014-10-20 16:55:07 -04:00
|
|
|
tolua_error(tolua_S, "array indexing out of range.", nullptr);
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
2015-08-14 16:19:15 -04:00
|
|
|
LuaState.Push(cBlockInfo::FullyOccupiesVoxel(static_cast<BLOCKTYPE>(BlockType)));
|
2014-04-03 03:26:44 -04:00
|
|
|
return 1;
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
2014-07-17 16:15:34 -04:00
|
|
|
#endif // #ifndef TOLUA_DISABLE
|
2014-03-02 04:12:29 -05:00
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-11-29 09:40:38 -05:00
|
|
|
/* function: StringToMobType */
|
|
|
|
static int tolua_AllToLua_StringToMobType00(lua_State* tolua_S)
|
|
|
|
{
|
|
|
|
cLuaState LuaState(tolua_S);
|
|
|
|
|
|
|
|
#ifndef TOLUA_RELEASE
|
|
|
|
tolua_Error tolua_err;
|
|
|
|
if (
|
2014-12-03 03:26:15 -05:00
|
|
|
!tolua_iscppstring(tolua_S, 1, 0, &tolua_err) ||
|
|
|
|
!tolua_isnoobj(tolua_S, 2, &tolua_err)
|
2014-11-29 09:40:38 -05:00
|
|
|
)
|
|
|
|
goto tolua_lerror;
|
|
|
|
else
|
|
|
|
#endif
|
|
|
|
{
|
2017-12-21 06:36:58 -05:00
|
|
|
const AString a_MobString = tolua_tocppstring(LuaState, 1, nullptr);
|
2014-11-29 09:40:38 -05:00
|
|
|
eMonsterType MobType = cMonster::StringToMobType(a_MobString);
|
2015-07-29 11:04:03 -04:00
|
|
|
tolua_pushnumber(LuaState, static_cast<lua_Number>(MobType));
|
|
|
|
tolua_pushcppstring(LuaState, a_MobString);
|
2014-11-29 09:40:38 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
LOGWARNING("Warning in function call 'StringToMobType': StringToMobType() is deprecated. Please use cMonster:StringToMobType()");
|
|
|
|
LuaState.LogStackTrace(0);
|
|
|
|
return 2;
|
|
|
|
|
|
|
|
#ifndef TOLUA_RELEASE
|
|
|
|
tolua_lerror:
|
|
|
|
tolua_error(LuaState, "#ferror in function 'StringToMobType'.", &tolua_err);
|
|
|
|
return 0;
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2018-02-20 05:43:28 -05:00
|
|
|
static int tolua_cBlockInfo_Get(lua_State * tolua_S)
|
|
|
|
{
|
|
|
|
cLuaState L(tolua_S);
|
|
|
|
if (
|
|
|
|
!L.CheckParamStaticSelf("cBlockInfo") ||
|
|
|
|
!L.CheckParamNumber(2)
|
|
|
|
)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
BLOCKTYPE BlockType{};
|
|
|
|
L.GetStackValue(2, BlockType);
|
|
|
|
|
|
|
|
LOGWARNING("cBlockInfo:Get() is deprecated, use the static querying functions instead");
|
|
|
|
L.LogStackTrace(0);
|
|
|
|
|
|
|
|
cBlockInfo & BlockInfo = const_cast<cBlockInfo &>(cBlockInfo::Get(BlockType));
|
|
|
|
L.Push(&BlockInfo);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2017-08-04 08:34:56 -04:00
|
|
|
static int tolua_cBlockInfo_GetPlaceSound(lua_State * tolua_S)
|
|
|
|
{
|
|
|
|
cLuaState L(tolua_S);
|
|
|
|
if (
|
|
|
|
!L.CheckParamStaticSelf("cBlockInfo") ||
|
|
|
|
!L.CheckParamNumber(2)
|
|
|
|
)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
L.Push("");
|
|
|
|
LOGWARNING("cBlockInfo:GetPlaceSound() is deprecated");
|
|
|
|
L.LogStackTrace(0);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int tolua_get_cBlockInfo_m_PlaceSound(lua_State * tolua_S)
|
|
|
|
{
|
|
|
|
cLuaState L(tolua_S);
|
|
|
|
if (!L.CheckParamSelf("const cBlockInfo"))
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
L.Push("");
|
|
|
|
LOGWARNING("cBlockInfo.m_PlaceSound is deprecated");
|
|
|
|
L.LogStackTrace(0);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int tolua_set_cBlockInfo_m_PlaceSound(lua_State * tolua_S)
|
|
|
|
{
|
|
|
|
cLuaState L(tolua_S);
|
|
|
|
if (!L.CheckParamSelf("cBlockInfo"))
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
LOGWARNING("cBlockInfo.m_PlaceSound is deprecated");
|
|
|
|
L.LogStackTrace(0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2018-02-20 05:43:28 -05:00
|
|
|
/** cBlockInfo variables: access the corresponding getter function instead of the variable.
|
|
|
|
\tparam VariableType The type of the variable being accessed.
|
|
|
|
\tparam GetterFunction The function called to get the value returned to lua. */
|
|
|
|
template <typename VariableType, VariableType (*GetterFunction)(BLOCKTYPE)>
|
|
|
|
static int tolua_get_cBlockInfo(lua_State * tolua_S)
|
2018-01-23 16:07:06 -05:00
|
|
|
{
|
|
|
|
cLuaState L(tolua_S);
|
|
|
|
if (!L.CheckParamSelf("const cBlockInfo"))
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
const cBlockInfo * Self = nullptr;
|
|
|
|
L.GetStackValue(1, Self);
|
|
|
|
|
2018-02-20 05:43:28 -05:00
|
|
|
L.Push(GetterFunction(Self->m_BlockType));
|
|
|
|
LOGWARNING("cBlockInfo variables are deprecated, use the static functions instead.");
|
2018-01-23 16:07:06 -05:00
|
|
|
L.LogStackTrace(0);
|
2018-02-20 05:43:28 -05:00
|
|
|
|
2018-01-23 16:07:06 -05:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2018-02-20 05:43:28 -05:00
|
|
|
/** cBlockInfo variables: Print deprecation message on assignment. */
|
|
|
|
static int tolua_set_cBlockInfo(lua_State * tolua_S)
|
2018-01-23 16:07:06 -05:00
|
|
|
{
|
|
|
|
cLuaState L(tolua_S);
|
|
|
|
if (!L.CheckParamSelf("cBlockInfo"))
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2018-02-20 05:43:28 -05:00
|
|
|
LOGWARNING("cBlockInfo variables are deprecated in favour of the static functions.");
|
2018-01-23 16:07:06 -05:00
|
|
|
L.LogStackTrace(0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2017-08-18 06:29:54 -04:00
|
|
|
static int tolua_get_cItem_m_Lore(lua_State * tolua_S)
|
|
|
|
{
|
|
|
|
// Maintain legacy m_Lore variable as Lore table split by ` (grave-accent)
|
|
|
|
cLuaState L(tolua_S);
|
|
|
|
if (!L.CheckParamSelf("const cItem"))
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
const cItem * Self = nullptr;
|
|
|
|
L.GetStackValue(1, Self);
|
|
|
|
|
|
|
|
AString LoreString = StringJoin(Self->m_LoreTable, "`");
|
|
|
|
|
|
|
|
L.Push(LoreString);
|
|
|
|
|
|
|
|
LOGWARNING("cItem.m_Lore is deprecated, use cItem.m_LoreTable instead");
|
|
|
|
L.LogStackTrace(0);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
static int tolua_set_cItem_m_Lore(lua_State * tolua_S)
|
|
|
|
{
|
|
|
|
// Maintain legacy m_Lore variable as Lore table split by ` (grave-accent)
|
|
|
|
cLuaState L(tolua_S);
|
|
|
|
if (
|
|
|
|
!L.CheckParamSelf("cItem") ||
|
|
|
|
!L.CheckParamString(2)
|
2018-02-20 05:43:28 -05:00
|
|
|
)
|
2017-08-18 06:29:54 -04:00
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
cItem * Self = nullptr;
|
|
|
|
AString LoreString;
|
|
|
|
L.GetStackValues(1, Self, LoreString);
|
|
|
|
|
|
|
|
Self->m_LoreTable = StringSplit(LoreString, "`");
|
|
|
|
|
|
|
|
LOGWARNING("cItem.m_Lore is deprecated, use cItem.m_LoreTable instead");
|
|
|
|
L.LogStackTrace(0);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-09-05 11:07:01 -04:00
|
|
|
/** function: cNoteEntity: GetNote */
|
|
|
|
static int tolua_cNoteEntity_GetPitch(lua_State * tolua_S)
|
|
|
|
{
|
|
|
|
cLuaState LuaState(tolua_S);
|
|
|
|
|
|
|
|
if (
|
|
|
|
!LuaState.CheckParamUserType(1, "cNoteEntity") ||
|
|
|
|
!LuaState.CheckParamEnd(2)
|
|
|
|
)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
cNoteEntity * Self = nullptr;
|
|
|
|
|
|
|
|
if (!LuaState.GetStackValues(1, Self))
|
|
|
|
{
|
|
|
|
tolua_error(LuaState, "Failed to read parameters", nullptr);
|
|
|
|
}
|
|
|
|
if (Self == nullptr)
|
|
|
|
{
|
|
|
|
tolua_error(LuaState, "invalid 'self' in function 'GetPitch'", nullptr);
|
|
|
|
}
|
|
|
|
LuaState.Push(Self->GetNote());
|
|
|
|
LOGWARNING("Warning: 'cNoteEntity:GetPitch' function is deprecated. Please use 'cNoteEntity:GetNote' instead.");
|
|
|
|
LuaState.LogStackTrace(0);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** function: cNoteEntity: IncrementNote */
|
|
|
|
static int tolua_cNoteEntity_IncrementPitch(lua_State * tolua_S)
|
|
|
|
{
|
|
|
|
cLuaState LuaState(tolua_S);
|
|
|
|
|
|
|
|
if (
|
|
|
|
!LuaState.CheckParamUserType(1, "cNoteEntity") ||
|
|
|
|
!LuaState.CheckParamEnd(2)
|
|
|
|
)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
cNoteEntity * Self = nullptr;
|
|
|
|
|
|
|
|
if (!LuaState.GetStackValues(1, Self))
|
|
|
|
{
|
|
|
|
tolua_error(LuaState, "Failed to read parameters", nullptr);
|
|
|
|
}
|
|
|
|
if (Self == nullptr)
|
|
|
|
{
|
|
|
|
tolua_error(LuaState, "invalid 'self' in function 'SetPitch'", nullptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
Self->IncrementNote();
|
|
|
|
LOGWARNING("Warning: 'cNoteEntity:IncrementPitch' function is deprecated. Please use 'cNoteEntity:IncrementNote' instead.");
|
|
|
|
LuaState.LogStackTrace(0);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** function: cNoteEntity: SetNote */
|
|
|
|
static int tolua_cNoteEntity_SetPitch(lua_State * tolua_S)
|
|
|
|
{
|
|
|
|
cLuaState LuaState(tolua_S);
|
|
|
|
|
|
|
|
if (
|
|
|
|
!LuaState.CheckParamUserType(1, "cNoteEntity") ||
|
|
|
|
!LuaState.CheckParamNumber(2) ||
|
|
|
|
!LuaState.CheckParamEnd(3)
|
|
|
|
)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
cNoteEntity * Self = nullptr;
|
|
|
|
int Note = -1;
|
|
|
|
|
|
|
|
if (!LuaState.GetStackValues(1, Self, Note))
|
|
|
|
{
|
|
|
|
tolua_error(LuaState, "Failed to read parameters", nullptr);
|
|
|
|
}
|
|
|
|
if (Self == nullptr)
|
|
|
|
{
|
|
|
|
tolua_error(LuaState, "invalid 'self' in function 'SetPitch'", nullptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
Self->SetNote(Note % 25);
|
|
|
|
LOGWARNING("Warning: 'cNoteEntity:SetPitch' function is deprecated. Please use 'cNoteEntity:SetNote' instead.");
|
|
|
|
LuaState.LogStackTrace(0);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2017-08-18 06:29:54 -04:00
|
|
|
|
2014-11-17 08:57:24 -05:00
|
|
|
/** function: cWorld:SetSignLines */
|
|
|
|
static int tolua_cWorld_SetSignLines(lua_State * tolua_S)
|
|
|
|
{
|
2014-11-17 12:01:56 -05:00
|
|
|
cLuaState LuaState(tolua_S);
|
|
|
|
|
2014-11-17 08:57:24 -05:00
|
|
|
#ifndef TOLUA_RELEASE
|
|
|
|
if (
|
2015-08-07 10:44:52 -04:00
|
|
|
!LuaState.CheckParamUserType(1, "cWorld") ||
|
|
|
|
!LuaState.CheckParamNumber(2, 4) ||
|
|
|
|
!LuaState.CheckParamString(5, 8) ||
|
|
|
|
!LuaState.CheckParamUserType(9, "cPlayer") ||
|
|
|
|
!LuaState.CheckParamEnd(10)
|
2014-11-17 08:57:24 -05:00
|
|
|
)
|
2015-08-07 10:44:52 -04:00
|
|
|
return 0;
|
2014-11-17 08:57:24 -05:00
|
|
|
else
|
|
|
|
#endif
|
|
|
|
{
|
2015-08-07 10:44:52 -04:00
|
|
|
cWorld * self = nullptr;
|
|
|
|
cPlayer * Player = nullptr;
|
|
|
|
int BlockX = 0;
|
|
|
|
int BlockY = 0;
|
|
|
|
int BlockZ = 0;
|
|
|
|
AString Line1;
|
|
|
|
AString Line2;
|
|
|
|
AString Line3;
|
|
|
|
AString Line4;
|
|
|
|
|
|
|
|
LuaState.GetStackValues(1, self, BlockX, BlockY, BlockZ, Line1, Line2, Line3, Line4, Player);
|
|
|
|
|
2014-11-17 08:57:24 -05:00
|
|
|
#ifndef TOLUA_RELEASE
|
|
|
|
if (self == nullptr)
|
|
|
|
{
|
2014-11-17 12:01:56 -05:00
|
|
|
tolua_error(LuaState, "invalid 'self' in function 'UpdateSign'", nullptr);
|
2014-11-17 08:57:24 -05:00
|
|
|
}
|
|
|
|
#endif
|
|
|
|
{
|
|
|
|
bool res = self->SetSignLines(BlockX, BlockY, BlockZ, Line1, Line2, Line3, Line4, Player);
|
2014-11-17 12:01:56 -05:00
|
|
|
tolua_pushboolean(LuaState, res ? 1 : 0);
|
2014-11-17 08:57:24 -05:00
|
|
|
}
|
|
|
|
}
|
2014-11-17 12:01:56 -05:00
|
|
|
LOGWARNING("Warning in function call 'UpdateSign': UpdateSign() is deprecated. Please use SetSignLines()");
|
|
|
|
LuaState.LogStackTrace(0);
|
2014-11-17 08:57:24 -05:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-08-26 08:08:37 -04:00
|
|
|
/** Function: cWorld:GrowTree.
|
|
|
|
Exported manually because of the obsolete int-based overload.
|
|
|
|
When removing from DeprecatedBindings, make sure the function is exported automatically. */
|
|
|
|
static int tolua_cWorld_GrowTree(lua_State * a_LuaState)
|
|
|
|
{
|
|
|
|
cLuaState LuaState(a_LuaState);
|
|
|
|
if (lua_isnumber(LuaState, 2))
|
|
|
|
{
|
|
|
|
// This is the obsolete signature, warn and translate:
|
|
|
|
LOGWARNING("Warning: cWorld:GrowTree function expects Vector3i-based coords rather than int-based coords. Emulating old-style call.");
|
|
|
|
LuaState.LogStackTrace(0);
|
|
|
|
cWorld * Self = nullptr;
|
|
|
|
int BlockX, BlockY, BlockZ;
|
|
|
|
if (!LuaState.GetStackValues(1, Self, BlockX, BlockY, BlockZ))
|
|
|
|
{
|
|
|
|
return LuaState.ApiParamError("Failed to read int-based coord parameters");
|
|
|
|
}
|
|
|
|
LuaState.Push(Self->GrowTree({BlockX, BlockY, BlockZ}));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// This is the correct signature, execute:
|
|
|
|
cWorld * Self = nullptr;
|
|
|
|
Vector3i BlockPos;
|
|
|
|
if (!LuaState.GetStackValues(1, Self, BlockPos))
|
|
|
|
{
|
|
|
|
return LuaState.ApiParamError("Failed to read Vector3i-based coord parameters");
|
|
|
|
}
|
|
|
|
LuaState.Push(Self->GrowTree(BlockPos));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** Function: cWorld:GrowTreeByBiome.
|
|
|
|
Exported manually because of the obsolete int-based overload.
|
|
|
|
When removing from DeprecatedBindings, make sure the function is exported automatically. */
|
|
|
|
static int tolua_cWorld_GrowTreeByBiome(lua_State * a_LuaState)
|
|
|
|
{
|
|
|
|
cLuaState LuaState(a_LuaState);
|
|
|
|
if (lua_isnumber(LuaState, 2))
|
|
|
|
{
|
|
|
|
// This is the obsolete signature, warn and translate:
|
|
|
|
LOGWARNING("Warning: cWorld:GrowTreeByBiome function expects Vector3i-based coords rather than int-based coords. Emulating old-style call.");
|
|
|
|
LuaState.LogStackTrace(0);
|
|
|
|
cWorld * Self = nullptr;
|
|
|
|
int BlockX, BlockY, BlockZ;
|
|
|
|
if (!LuaState.GetStackValues(1, Self, BlockX, BlockY, BlockZ))
|
|
|
|
{
|
|
|
|
return LuaState.ApiParamError("Failed to read int-based coord parameters");
|
|
|
|
}
|
|
|
|
LuaState.Push(Self->GrowTreeByBiome({BlockX, BlockY, BlockZ}));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// This is the correct signature, execute:
|
|
|
|
cWorld * Self = nullptr;
|
|
|
|
Vector3i BlockPos;
|
|
|
|
if (!LuaState.GetStackValues(1, Self, BlockPos))
|
|
|
|
{
|
|
|
|
return LuaState.ApiParamError("Failed to read Vector3i-based coord parameters");
|
|
|
|
}
|
|
|
|
LuaState.Push(Self->GrowTreeByBiome(BlockPos));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/** Function: cWorld:GrowTreeFromSapling.
|
|
|
|
Exported manually because of the obsolete int-based overload and obsolete SaplingMeta parameter.
|
|
|
|
When removing from DeprecatedBindings, make sure the function is exported automatically. */
|
|
|
|
static int tolua_cWorld_GrowTreeFromSapling(lua_State * a_LuaState)
|
|
|
|
{
|
|
|
|
cLuaState LuaState(a_LuaState);
|
|
|
|
if (lua_isnumber(LuaState, 2))
|
|
|
|
{
|
|
|
|
// This is the obsolete signature, warn and translate:
|
|
|
|
LOGWARNING("Warning: cWorld:GrowTreeFromSapling function expects Vector3i-based coords rather than int-based coords. Emulating old-style call.");
|
|
|
|
LuaState.LogStackTrace(0);
|
|
|
|
cWorld * Self = nullptr;
|
|
|
|
int BlockX, BlockY, BlockZ;
|
|
|
|
if (!LuaState.GetStackValues(1, Self, BlockX, BlockY, BlockZ))
|
|
|
|
{
|
|
|
|
return LuaState.ApiParamError("Failed to read int-based coord parameters");
|
|
|
|
}
|
|
|
|
LuaState.Push(Self->GrowTreeFromSapling({BlockX, BlockY, BlockZ}));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// This is the correct signature, execute:
|
|
|
|
cWorld * Self = nullptr;
|
|
|
|
Vector3i BlockPos;
|
|
|
|
if (!LuaState.GetStackValues(1, Self, BlockPos))
|
|
|
|
{
|
|
|
|
return LuaState.ApiParamError("Failed to read Vector3i-based coord parameters");
|
|
|
|
}
|
|
|
|
if (lua_isnumber(LuaState, 3))
|
|
|
|
{
|
|
|
|
// There's an extra parameter, the obsolete SaplingMeta
|
|
|
|
LOGWARNING("Warning: cWorld:GrowTreeFromSapling function no longer has the SaplingMeta parameter. Ignoring it now.");
|
|
|
|
LuaState.LogStackTrace(0);
|
|
|
|
}
|
|
|
|
LuaState.Push(Self->GrowTreeFromSapling(BlockPos));
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2020-04-17 05:36:37 -04:00
|
|
|
/** function: cWorld:SetNextBlockTick */
|
|
|
|
static int tolua_cWorld_SetNextBlockTick(lua_State * tolua_S)
|
|
|
|
{
|
|
|
|
cLuaState LuaState(tolua_S);
|
|
|
|
|
|
|
|
if (
|
|
|
|
!LuaState.CheckParamUserType(1, "cWorld") ||
|
|
|
|
!LuaState.CheckParamNumber(2, 4) ||
|
|
|
|
!LuaState.CheckParamEnd(5)
|
|
|
|
)
|
|
|
|
{
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
cWorld * Self = nullptr;
|
|
|
|
int BlockX = 0;
|
|
|
|
int BlockY = 0;
|
|
|
|
int BlockZ = 0;
|
|
|
|
|
|
|
|
if (!LuaState.GetStackValues(1, Self, BlockX, BlockY, BlockZ))
|
|
|
|
{
|
|
|
|
tolua_error(LuaState, "Failed to read parameters", nullptr);
|
|
|
|
}
|
|
|
|
if (Self == nullptr)
|
|
|
|
{
|
|
|
|
tolua_error(LuaState, "invalid 'self' in function 'SetNextBlockTick'", nullptr);
|
|
|
|
}
|
|
|
|
Self->SetNextBlockToTick({BlockX, BlockY, BlockZ});
|
|
|
|
LOGWARNING("Warning: 'cWorld:SetNextBlockTick' function is deprecated. Please use 'cWorld:SetNextBlockToTick' instead.");
|
|
|
|
LuaState.LogStackTrace(0);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2014-03-02 04:12:29 -05:00
|
|
|
void DeprecatedBindings::Bind(lua_State * tolua_S)
|
|
|
|
{
|
2014-10-20 16:55:07 -04:00
|
|
|
tolua_beginmodule(tolua_S, nullptr);
|
|
|
|
|
|
|
|
tolua_array(tolua_S, "g_BlockLightValue", tolua_get_AllToLua_g_BlockLightValue, nullptr);
|
|
|
|
tolua_array(tolua_S, "g_BlockSpreadLightFalloff", tolua_get_AllToLua_g_BlockSpreadLightFalloff, nullptr);
|
|
|
|
tolua_array(tolua_S, "g_BlockTransparent", tolua_get_AllToLua_g_BlockTransparent, nullptr);
|
|
|
|
tolua_array(tolua_S, "g_BlockOneHitDig", tolua_get_AllToLua_g_BlockOneHitDig, nullptr);
|
|
|
|
tolua_array(tolua_S, "g_BlockPistonBreakable", tolua_get_AllToLua_g_BlockPistonBreakable, nullptr);
|
|
|
|
tolua_array(tolua_S, "g_BlockIsSnowable", tolua_get_AllToLua_g_BlockIsSnowable, nullptr);
|
|
|
|
tolua_array(tolua_S, "g_BlockIsSolid", tolua_get_AllToLua_g_BlockIsSolid, nullptr);
|
|
|
|
tolua_array(tolua_S, "g_BlockFullyOccupiesVoxel", tolua_get_AllToLua_g_BlockFullyOccupiesVoxel, nullptr);
|
2014-03-02 04:30:20 -05:00
|
|
|
|
2014-11-29 09:40:38 -05:00
|
|
|
tolua_function(tolua_S, "StringToMobType", tolua_AllToLua_StringToMobType00);
|
|
|
|
|
2017-08-04 08:34:56 -04:00
|
|
|
tolua_beginmodule(tolua_S, "cBlockInfo");
|
2018-02-20 05:43:28 -05:00
|
|
|
tolua_function(tolua_S, "Get", tolua_cBlockInfo_Get);
|
|
|
|
tolua_function(tolua_S, "GetPlaceSound", tolua_cBlockInfo_GetPlaceSound);
|
|
|
|
tolua_variable(tolua_S, "m_PlaceSound", tolua_get_cBlockInfo_m_PlaceSound, tolua_set_cBlockInfo_m_PlaceSound);
|
|
|
|
tolua_variable(tolua_S, "m_LightValue", tolua_get_cBlockInfo<NIBBLETYPE, cBlockInfo::GetLightValue >, tolua_set_cBlockInfo);
|
|
|
|
tolua_variable(tolua_S, "m_SpreadLightFalloff", tolua_get_cBlockInfo<NIBBLETYPE, cBlockInfo::GetSpreadLightFalloff>, tolua_set_cBlockInfo);
|
|
|
|
tolua_variable(tolua_S, "m_Transparent", tolua_get_cBlockInfo<bool, cBlockInfo::IsTransparent >, tolua_set_cBlockInfo);
|
|
|
|
tolua_variable(tolua_S, "m_OneHitDig", tolua_get_cBlockInfo<bool, cBlockInfo::IsOneHitDig >, tolua_set_cBlockInfo);
|
|
|
|
tolua_variable(tolua_S, "m_PistonBreakable", tolua_get_cBlockInfo<bool, cBlockInfo::IsPistonBreakable >, tolua_set_cBlockInfo);
|
|
|
|
tolua_variable(tolua_S, "m_IsRainBlocker", tolua_get_cBlockInfo<bool, cBlockInfo::IsRainBlocker >, tolua_set_cBlockInfo);
|
|
|
|
tolua_variable(tolua_S, "m_IsSkylightDispersant", tolua_get_cBlockInfo<bool, cBlockInfo::IsSkylightDispersant >, tolua_set_cBlockInfo);
|
|
|
|
tolua_variable(tolua_S, "m_IsSnowable", tolua_get_cBlockInfo<bool, cBlockInfo::IsSnowable >, tolua_set_cBlockInfo);
|
|
|
|
tolua_variable(tolua_S, "m_IsSolid", tolua_get_cBlockInfo<bool, cBlockInfo::IsSolid >, tolua_set_cBlockInfo);
|
|
|
|
tolua_variable(tolua_S, "m_UseableBySpectator", tolua_get_cBlockInfo<bool, cBlockInfo::IsUseableBySpectator >, tolua_set_cBlockInfo);
|
|
|
|
tolua_variable(tolua_S, "m_FullyOccupiesVoxel", tolua_get_cBlockInfo<bool, cBlockInfo::FullyOccupiesVoxel >, tolua_set_cBlockInfo);
|
|
|
|
tolua_variable(tolua_S, "m_CanBeTerraformed", tolua_get_cBlockInfo<bool, cBlockInfo::CanBeTerraformed >, tolua_set_cBlockInfo);
|
|
|
|
tolua_variable(tolua_S, "m_BlockHeight", tolua_get_cBlockInfo<float, cBlockInfo::GetBlockHeight >, tolua_set_cBlockInfo);
|
|
|
|
tolua_variable(tolua_S, "m_Hardness", tolua_get_cBlockInfo<float, cBlockInfo::GetHardness >, tolua_set_cBlockInfo);
|
2017-08-04 08:34:56 -04:00
|
|
|
tolua_endmodule(tolua_S);
|
|
|
|
|
2017-08-18 06:29:54 -04:00
|
|
|
tolua_beginmodule(tolua_S, "cItem");
|
|
|
|
tolua_variable(tolua_S, "m_Lore", tolua_get_cItem_m_Lore, tolua_set_cItem_m_Lore);
|
|
|
|
tolua_endmodule(tolua_S);
|
|
|
|
|
2020-09-05 11:07:01 -04:00
|
|
|
tolua_beginmodule(tolua_S, "cNoteEntity");
|
|
|
|
tolua_function(tolua_S, "GetPitch", tolua_cNoteEntity_GetPitch);
|
|
|
|
tolua_function(tolua_S, "IncrementPitch", tolua_cNoteEntity_IncrementPitch);
|
|
|
|
tolua_function(tolua_S, "SetPitch", tolua_cNoteEntity_SetPitch);
|
|
|
|
tolua_endmodule(tolua_S);
|
|
|
|
|
2014-11-17 08:57:24 -05:00
|
|
|
tolua_beginmodule(tolua_S, "cWorld");
|
2020-08-26 08:08:37 -04:00
|
|
|
tolua_function(tolua_S, "GrowTree", tolua_cWorld_GrowTree);
|
|
|
|
tolua_function(tolua_S, "GrowTreeByBiome", tolua_cWorld_GrowTreeByBiome);
|
|
|
|
tolua_function(tolua_S, "GrowTreeFromSapling", tolua_cWorld_GrowTreeFromSapling);
|
|
|
|
tolua_function(tolua_S, "SetNextBlockTick", tolua_cWorld_SetNextBlockTick);
|
|
|
|
tolua_function(tolua_S, "UpdateSign", tolua_cWorld_SetSignLines);
|
2014-11-17 08:57:24 -05:00
|
|
|
tolua_endmodule(tolua_S);
|
|
|
|
|
2014-03-02 04:30:20 -05:00
|
|
|
tolua_endmodule(tolua_S);
|
2014-03-02 04:12:29 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|