Moved cWorld manual bindings out into a separate file.
This commit is contained in:
Mattes D
parent
0686b55901
commit
15771e4759
|
|
@ -18,6 +18,7 @@ SET (SRCS
|
|||
ManualBindings.cpp
|
||||
ManualBindings_Network.cpp
|
||||
ManualBindings_RankManager.cpp
|
||||
ManualBindings_World.cpp
|
||||
Plugin.cpp
|
||||
PluginLua.cpp
|
||||
PluginManager.cpp
|
||||
|
|
|
|||
|
|
@ -107,7 +107,7 @@ void cLuaState::Create(void)
|
|||
void cLuaState::RegisterAPILibs(void)
|
||||
{
|
||||
tolua_AllToLua_open(m_LuaState);
|
||||
ManualBindings::Bind(m_LuaState);
|
||||
cManualBindings::Bind(m_LuaState);
|
||||
DeprecatedBindings::Bind(m_LuaState);
|
||||
luaopen_lsqlite3(m_LuaState);
|
||||
luaopen_lxp(m_LuaState);
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,34 +1,567 @@
|
|||
|
||||
// ManualBindings.h
|
||||
|
||||
// Declares the cManualBindings class used as a namespace for functions exported to the Lua API manually
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
#pragma once
|
||||
|
||||
struct lua_State;
|
||||
class cPluginLua;
|
||||
#include "LuaState.h"
|
||||
|
||||
|
||||
|
||||
|
||||
// fwd:
|
||||
struct tolua_Error;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/** Provides namespace for the bindings. */
|
||||
class ManualBindings
|
||||
class cManualBindings
|
||||
{
|
||||
public:
|
||||
/** Binds all the manually implemented functions to tolua_S. */
|
||||
static void Bind(lua_State * tolua_S);
|
||||
|
||||
protected:
|
||||
/** Binds the manually implemented cNetwork-related API to tolua_S.
|
||||
Implemented in ManualBindings_Network.cpp. */
|
||||
static void BindNetwork(lua_State * tolua_S);
|
||||
|
||||
/** Binds the manually implemented cRankManager glue code to tolua_S.
|
||||
Implemented in ManualBindings_RankManager.cpp. */
|
||||
static void BindRankManager(lua_State * tolua_S);
|
||||
|
||||
/** Binds the manually implemented cNetwork-related API to tolua_S.
|
||||
Implemented in ManualBindings_Network.cpp. */
|
||||
static void BindNetwork(lua_State * tolua_S);
|
||||
/** Binds the manually implemented cWorld API functions to tolua_S.
|
||||
Implemented in ManualBindings_World.cpp. */
|
||||
static void BindWorld(lua_State * tolua_S);
|
||||
|
||||
|
||||
public:
|
||||
// Helper functions:
|
||||
static cPluginLua * GetLuaPlugin(lua_State * L);
|
||||
static int tolua_do_error(lua_State * L, const char * a_pMsg, tolua_Error * a_pToLuaError);
|
||||
static int lua_do_error(lua_State * L, const char * a_pFormat, ...);
|
||||
|
||||
|
||||
/** Binds the DoWith(ItemName) functions of regular classes. */
|
||||
template <
|
||||
class Ty1,
|
||||
class Ty2,
|
||||
bool (Ty1::*DoWithFn)(const AString &, cItemCallback<Ty2> &)
|
||||
>
|
||||
static int DoWith(lua_State * tolua_S)
|
||||
{
|
||||
// Check params:
|
||||
cLuaState L(tolua_S);
|
||||
if (
|
||||
!L.CheckParamString(2) ||
|
||||
!L.CheckParamFunction(3)
|
||||
)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Get parameters:
|
||||
Ty1 * Self;
|
||||
AString ItemName;
|
||||
cLuaState::cRef FnRef;
|
||||
L.GetStackValues(1, Self, ItemName, FnRef);
|
||||
if (Self == nullptr)
|
||||
{
|
||||
return lua_do_error(tolua_S, "Error in function call '#funcname#': Invalid 'self'");
|
||||
}
|
||||
if (ItemName.empty() || (ItemName[0] == 0))
|
||||
{
|
||||
return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a non-empty string for parameter #1");
|
||||
}
|
||||
if (!FnRef.IsValid())
|
||||
{
|
||||
return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a valid callback function for parameter #2");
|
||||
}
|
||||
|
||||
class cLuaCallback : public cItemCallback<Ty2>
|
||||
{
|
||||
public:
|
||||
cLuaCallback(cLuaState & a_LuaState, cLuaState::cRef & a_FnRef):
|
||||
m_LuaState(a_LuaState),
|
||||
m_FnRef(a_FnRef)
|
||||
{
|
||||
}
|
||||
|
||||
private:
|
||||
virtual bool Item(Ty2 * a_Item) override
|
||||
{
|
||||
bool ret = false;
|
||||
m_LuaState.Call(m_FnRef, a_Item, cLuaState::Return, ret);
|
||||
return ret;
|
||||
}
|
||||
cLuaState & m_LuaState;
|
||||
cLuaState::cRef & m_FnRef;
|
||||
} Callback(L, FnRef);
|
||||
|
||||
// Call the DoWith function:
|
||||
bool res = (Self->*DoWithFn)(ItemName, Callback);
|
||||
|
||||
// Push the result as the return value:
|
||||
L.Push(res);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/** Template for static functions DoWith(ItemName), on a type that has a static ::Get() function. */
|
||||
template <
|
||||
class Ty1,
|
||||
class Ty2,
|
||||
bool (Ty1::*DoWithFn)(const AString &, cItemCallback<Ty2> &)
|
||||
>
|
||||
static int StaticDoWith(lua_State * tolua_S)
|
||||
{
|
||||
// Check params:
|
||||
cLuaState L(tolua_S);
|
||||
if (
|
||||
!L.CheckParamString(2) ||
|
||||
!L.CheckParamFunction(3)
|
||||
)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Get parameters:
|
||||
AString ItemName;
|
||||
cLuaState::cRef FnRef;
|
||||
L.GetStackValues(2, ItemName, FnRef);
|
||||
if (ItemName.empty() || (ItemName[0] == 0))
|
||||
{
|
||||
return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a non-empty string for parameter #1");
|
||||
}
|
||||
if (!FnRef.IsValid())
|
||||
{
|
||||
return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a valid callback function for parameter #2");
|
||||
}
|
||||
|
||||
class cLuaCallback : public cItemCallback<Ty2>
|
||||
{
|
||||
public:
|
||||
cLuaCallback(cLuaState & a_LuaState, cLuaState::cRef & a_FnRef):
|
||||
m_LuaState(a_LuaState),
|
||||
m_FnRef(a_FnRef)
|
||||
{
|
||||
}
|
||||
|
||||
private:
|
||||
virtual bool Item(Ty2 * a_Item) override
|
||||
{
|
||||
bool ret = false;
|
||||
m_LuaState.Call(m_FnRef, a_Item, cLuaState::Return, ret);
|
||||
return ret;
|
||||
}
|
||||
cLuaState & m_LuaState;
|
||||
cLuaState::cRef & m_FnRef;
|
||||
} Callback(L, FnRef);
|
||||
|
||||
// Call the DoWith function:
|
||||
bool res = (Ty1::Get()->*DoWithFn)(ItemName, Callback);
|
||||
|
||||
// Push the result as the return value:
|
||||
L.Push(res);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <
|
||||
class Ty1,
|
||||
class Ty2,
|
||||
bool (Ty1::*DoWithFn)(UInt32, cItemCallback<Ty2> &)
|
||||
>
|
||||
static int DoWithID(lua_State * tolua_S)
|
||||
{
|
||||
// Check params:
|
||||
cLuaState L(tolua_S);
|
||||
if (
|
||||
!L.CheckParamNumber(2) ||
|
||||
!L.CheckParamFunction(3)
|
||||
)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Get parameters:
|
||||
Ty1 * Self = nullptr;
|
||||
int ItemID;
|
||||
cLuaState::cRef FnRef;
|
||||
L.GetStackValues(1, Self, ItemID, FnRef);
|
||||
if (Self == nullptr)
|
||||
{
|
||||
return lua_do_error(tolua_S, "Error in function call '#funcname#': Invalid 'self'");
|
||||
}
|
||||
if (!FnRef.IsValid())
|
||||
{
|
||||
return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a valid callback function for parameter #2");
|
||||
}
|
||||
|
||||
class cLuaCallback : public cItemCallback<Ty2>
|
||||
{
|
||||
public:
|
||||
cLuaCallback(cLuaState & a_LuaState, cLuaState::cRef & a_FnRef):
|
||||
m_LuaState(a_LuaState),
|
||||
m_FnRef(a_FnRef)
|
||||
{
|
||||
}
|
||||
|
||||
private:
|
||||
virtual bool Item(Ty2 * a_Item) override
|
||||
{
|
||||
bool ret = false;
|
||||
m_LuaState.Call(m_FnRef, a_Item, cLuaState::Return, ret);
|
||||
return ret;
|
||||
}
|
||||
cLuaState & m_LuaState;
|
||||
cLuaState::cRef & m_FnRef;
|
||||
} Callback(L, FnRef);
|
||||
|
||||
// Call the DoWith function:
|
||||
bool res = (Self->*DoWithFn)(ItemID, Callback);
|
||||
|
||||
// Push the result as the return value:
|
||||
L.Push(res);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <
|
||||
class Ty1,
|
||||
class Ty2,
|
||||
bool (Ty1::*DoWithFn)(int, int, int, cItemCallback<Ty2> &)
|
||||
>
|
||||
static int DoWithXYZ(lua_State * tolua_S)
|
||||
{
|
||||
// Check params:
|
||||
cLuaState L(tolua_S);
|
||||
if (
|
||||
!L.CheckParamNumber(2, 5) ||
|
||||
!L.CheckParamFunction(6)
|
||||
)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Get parameters:
|
||||
Ty1 * Self = nullptr;
|
||||
int BlockX, BlockY, BlockZ;
|
||||
cLuaState::cRef FnRef;
|
||||
L.GetStackValues(1, Self, BlockX, BlockY, BlockZ, FnRef);
|
||||
if (Self == nullptr)
|
||||
{
|
||||
return lua_do_error(tolua_S, "Error in function call '#funcname#': Invalid 'self'");
|
||||
}
|
||||
if (!FnRef.IsValid())
|
||||
{
|
||||
return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a valid callback function for parameter #5");
|
||||
}
|
||||
|
||||
class cLuaCallback : public cItemCallback<Ty2>
|
||||
{
|
||||
public:
|
||||
cLuaCallback(cLuaState & a_LuaState, cLuaState::cRef & a_FnRef):
|
||||
m_LuaState(a_LuaState),
|
||||
m_FnRef(a_FnRef)
|
||||
{
|
||||
}
|
||||
|
||||
private:
|
||||
virtual bool Item(Ty2 * a_Item) override
|
||||
{
|
||||
bool ret = false;
|
||||
m_LuaState.Call(m_FnRef, a_Item, cLuaState::Return, ret);
|
||||
return ret;
|
||||
}
|
||||
cLuaState & m_LuaState;
|
||||
cLuaState::cRef & m_FnRef;
|
||||
} Callback(L, FnRef);
|
||||
|
||||
// Call the DoWith function:
|
||||
bool res = (Self->*DoWithFn)(BlockX, BlockY, BlockZ, Callback);
|
||||
|
||||
// Push the result as the return value:
|
||||
L.Push(res);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <
|
||||
class Ty1,
|
||||
class Ty2,
|
||||
bool (Ty1::*ForEachFn)(int, int, cItemCallback<Ty2> &)
|
||||
>
|
||||
static int ForEachInChunk(lua_State * tolua_S)
|
||||
{
|
||||
// Check params:
|
||||
cLuaState L(tolua_S);
|
||||
if (
|
||||
!L.CheckParamNumber(2, 4) ||
|
||||
!L.CheckParamFunction(5)
|
||||
)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Get parameters:
|
||||
Ty1 * Self = nullptr;
|
||||
int ChunkX, ChunkZ;
|
||||
cLuaState::cRef FnRef;
|
||||
L.GetStackValues(1, Self, ChunkX, ChunkZ, FnRef);
|
||||
if (Self == nullptr)
|
||||
{
|
||||
return lua_do_error(tolua_S, "Error in function call '#funcname#': Invalid 'self'");
|
||||
}
|
||||
if (!FnRef.IsValid())
|
||||
{
|
||||
return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a valid callback function for parameter #4");
|
||||
}
|
||||
|
||||
class cLuaCallback : public cItemCallback<Ty2>
|
||||
{
|
||||
public:
|
||||
cLuaCallback(cLuaState & a_LuaState, cLuaState::cRef & a_FnRef):
|
||||
m_LuaState(a_LuaState),
|
||||
m_FnRef(a_FnRef)
|
||||
{
|
||||
}
|
||||
|
||||
private:
|
||||
virtual bool Item(Ty2 * a_Item) override
|
||||
{
|
||||
bool ret = false;
|
||||
m_LuaState.Call(m_FnRef, a_Item, cLuaState::Return, ret);
|
||||
return ret;
|
||||
}
|
||||
cLuaState & m_LuaState;
|
||||
cLuaState::cRef & m_FnRef;
|
||||
} Callback(L, FnRef);
|
||||
|
||||
// Call the DoWith function:
|
||||
bool res = (Self->*ForEachFn)(ChunkX, ChunkZ, Callback);
|
||||
|
||||
// Push the result as the return value:
|
||||
L.Push(res);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <
|
||||
class Ty1,
|
||||
class Ty2,
|
||||
bool (Ty1::*ForEachFn)(const cBoundingBox &, cItemCallback<Ty2> &)
|
||||
>
|
||||
static int ForEachInBox(lua_State * tolua_S)
|
||||
{
|
||||
// Check params:
|
||||
cLuaState L(tolua_S);
|
||||
if (
|
||||
!L.CheckParamUserType(1, "cWorld") ||
|
||||
!L.CheckParamUserType(2, "cBoundingBox") ||
|
||||
!L.CheckParamFunction(3) ||
|
||||
!L.CheckParamEnd(4)
|
||||
)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Get the params:
|
||||
Ty1 * Self = nullptr;
|
||||
cBoundingBox * Box = nullptr;
|
||||
cLuaState::cRef FnRef;
|
||||
L.GetStackValues(1, Self, Box, FnRef);
|
||||
if ((Self == nullptr) || (Box == nullptr))
|
||||
{
|
||||
LOGWARNING("Invalid world (%p) or boundingbox (%p)", Self, Box);
|
||||
L.LogStackTrace();
|
||||
return 0;
|
||||
}
|
||||
if (!FnRef.IsValid())
|
||||
{
|
||||
return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a valid callback function for parameter #2");
|
||||
}
|
||||
|
||||
// Callback wrapper for the Lua function:
|
||||
class cLuaCallback : public cItemCallback<Ty2>
|
||||
{
|
||||
public:
|
||||
cLuaCallback(cLuaState & a_LuaState, cLuaState::cRef & a_FuncRef) :
|
||||
m_LuaState(a_LuaState),
|
||||
m_FnRef(a_FuncRef)
|
||||
{
|
||||
}
|
||||
|
||||
private:
|
||||
cLuaState & m_LuaState;
|
||||
cLuaState::cRef & m_FnRef;
|
||||
|
||||
// cItemCallback<Ty2> overrides:
|
||||
virtual bool Item(Ty2 * a_Item) override
|
||||
{
|
||||
bool res = false;
|
||||
if (!m_LuaState.Call(m_FnRef, a_Item, cLuaState::Return, res))
|
||||
{
|
||||
LOGWARNING("Failed to call Lua callback");
|
||||
m_LuaState.LogStackTrace();
|
||||
return true; // Abort enumeration
|
||||
}
|
||||
|
||||
return res;
|
||||
}
|
||||
} Callback(L, FnRef);
|
||||
|
||||
bool res = (Self->*ForEachFn)(*Box, Callback);
|
||||
|
||||
// Push the result as the return value:
|
||||
L.Push(res);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
template <
|
||||
class Ty1,
|
||||
class Ty2,
|
||||
bool (Ty1::*ForEachFn)(cItemCallback<Ty2> &)
|
||||
>
|
||||
static int ForEach(lua_State * tolua_S)
|
||||
{
|
||||
// Check params:
|
||||
cLuaState L(tolua_S);
|
||||
if (
|
||||
!L.CheckParamFunction(2) ||
|
||||
!L.CheckParamEnd(3)
|
||||
)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Get the params:
|
||||
Ty1 * Self = nullptr;
|
||||
cLuaState::cRef FnRef;
|
||||
L.GetStackValues(1, Self, FnRef);
|
||||
if (Self == nullptr)
|
||||
{
|
||||
return lua_do_error(tolua_S, "Error in function call '#funcname#': Invalid 'self'.");
|
||||
}
|
||||
if (!FnRef.IsValid())
|
||||
{
|
||||
return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a valid callback function for parameter #1");
|
||||
}
|
||||
|
||||
class cLuaCallback : public cItemCallback<Ty2>
|
||||
{
|
||||
public:
|
||||
cLuaCallback(cLuaState & a_LuaState, cLuaState::cRef & a_FnRef):
|
||||
m_LuaState(a_LuaState),
|
||||
m_FnRef(a_FnRef)
|
||||
{
|
||||
}
|
||||
|
||||
private:
|
||||
cLuaState & m_LuaState;
|
||||
cLuaState::cRef & m_FnRef;
|
||||
|
||||
virtual bool Item(Ty2 * a_Item) override
|
||||
{
|
||||
bool res = false; // By default continue the enumeration
|
||||
m_LuaState.Call(m_FnRef, a_Item, cLuaState::Return, res);
|
||||
return res;
|
||||
}
|
||||
} Callback(L, FnRef);
|
||||
|
||||
// Call the enumeration:
|
||||
bool res = (Self->*ForEachFn)(Callback);
|
||||
|
||||
// Push the return value:
|
||||
L.Push(res);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
/** Implements bindings for ForEach() functions in a class that is static (has a ::Get() static function). */
|
||||
template <
|
||||
class Ty1,
|
||||
class Ty2,
|
||||
bool (Ty1::*ForEachFn)(cItemCallback<Ty2> &)
|
||||
>
|
||||
static int StaticForEach(lua_State * tolua_S)
|
||||
{
|
||||
// Check params:
|
||||
cLuaState L(tolua_S);
|
||||
if (
|
||||
!L.CheckParamFunction(2) ||
|
||||
!L.CheckParamEnd(3)
|
||||
)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Get the params:
|
||||
cLuaState::cRef FnRef(L, 2);
|
||||
if (!FnRef.IsValid())
|
||||
{
|
||||
return lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a valid callback function for parameter #1");
|
||||
}
|
||||
|
||||
class cLuaCallback : public cItemCallback<Ty2>
|
||||
{
|
||||
public:
|
||||
cLuaCallback(cLuaState & a_LuaState, cLuaState::cRef & a_FnRef):
|
||||
m_LuaState(a_LuaState),
|
||||
m_FnRef(a_FnRef)
|
||||
{
|
||||
}
|
||||
|
||||
private:
|
||||
cLuaState & m_LuaState;
|
||||
cLuaState::cRef & m_FnRef;
|
||||
|
||||
virtual bool Item(Ty2 * a_Item) override
|
||||
{
|
||||
bool res = false; // By default continue the enumeration
|
||||
m_LuaState.Call(m_FnRef, a_Item, cLuaState::Return, res);
|
||||
return res;
|
||||
}
|
||||
} Callback(L, FnRef);
|
||||
|
||||
// Call the enumeration:
|
||||
bool res = (Ty1::Get()->*ForEachFn)(Callback);
|
||||
|
||||
// Push the return value:
|
||||
L.Push(res);
|
||||
return 1;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
extern cPluginLua * GetLuaPlugin(lua_State * L);
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -39,7 +39,7 @@ static int tolua_cNetwork_Connect(lua_State * L)
|
|||
}
|
||||
|
||||
// Get the plugin instance:
|
||||
cPluginLua * Plugin = GetLuaPlugin(L);
|
||||
cPluginLua * Plugin = cManualBindings::GetLuaPlugin(L);
|
||||
if (Plugin == nullptr)
|
||||
{
|
||||
// An error message has been already printed in GetLuaPlugin()
|
||||
|
|
@ -92,7 +92,7 @@ static int tolua_cNetwork_CreateUDPEndpoint(lua_State * L)
|
|||
}
|
||||
|
||||
// Get the plugin instance:
|
||||
cPluginLua * Plugin = GetLuaPlugin(L);
|
||||
cPluginLua * Plugin = cManualBindings::GetLuaPlugin(L);
|
||||
if (Plugin == nullptr)
|
||||
{
|
||||
// An error message has been already printed in GetLuaPlugin()
|
||||
|
|
@ -171,7 +171,7 @@ static int tolua_cNetwork_HostnameToIP(lua_State * L)
|
|||
}
|
||||
|
||||
// Get the plugin instance:
|
||||
cPluginLua * Plugin = GetLuaPlugin(L);
|
||||
cPluginLua * Plugin = cManualBindings::GetLuaPlugin(L);
|
||||
if (Plugin == nullptr)
|
||||
{
|
||||
// An error message has been already printed in GetLuaPlugin()
|
||||
|
|
@ -212,7 +212,7 @@ static int tolua_cNetwork_IPToHostname(lua_State * L)
|
|||
}
|
||||
|
||||
// Get the plugin instance:
|
||||
cPluginLua * Plugin = GetLuaPlugin(L);
|
||||
cPluginLua * Plugin = cManualBindings::GetLuaPlugin(L);
|
||||
if (Plugin == nullptr)
|
||||
{
|
||||
// An error message has been already printed in GetLuaPlugin()
|
||||
|
|
@ -253,7 +253,7 @@ static int tolua_cNetwork_Listen(lua_State * L)
|
|||
}
|
||||
|
||||
// Get the plugin instance:
|
||||
cPluginLua * Plugin = GetLuaPlugin(L);
|
||||
cPluginLua * Plugin = cManualBindings::GetLuaPlugin(L);
|
||||
if (Plugin == nullptr)
|
||||
{
|
||||
// An error message has been already printed in GetLuaPlugin()
|
||||
|
|
@ -913,17 +913,17 @@ static int tolua_cUDPEndpoint_Send(lua_State * L)
|
|||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Register the bindings:
|
||||
|
||||
void ManualBindings::BindNetwork(lua_State * tolua_S)
|
||||
void cManualBindings::BindNetwork(lua_State * tolua_S)
|
||||
{
|
||||
// Create the cNetwork API classes:
|
||||
tolua_usertype(tolua_S, "cNetwork");
|
||||
tolua_cclass(tolua_S, "cNetwork", "cNetwork", "", nullptr);
|
||||
tolua_usertype(tolua_S, "cTCPLink");
|
||||
tolua_cclass(tolua_S, "cTCPLink", "cTCPLink", "", nullptr);
|
||||
tolua_usertype(tolua_S, "cServerHandle");
|
||||
tolua_cclass(tolua_S, "cServerHandle", "cServerHandle", "", tolua_collect_cServerHandle);
|
||||
tolua_usertype(tolua_S, "cTCPLink");
|
||||
tolua_usertype(tolua_S, "cUDPEndpoint");
|
||||
tolua_cclass(tolua_S, "cUDPEndpoint", "cUDPEndpoint", "", tolua_collect_cUDPEndpoint);
|
||||
tolua_cclass(tolua_S, "cNetwork", "cNetwork", "", nullptr);
|
||||
tolua_cclass(tolua_S, "cServerHandle", "cServerHandle", "", tolua_collect_cServerHandle);
|
||||
tolua_cclass(tolua_S, "cTCPLink", "cTCPLink", "", nullptr);
|
||||
tolua_cclass(tolua_S, "cUDPEndpoint", "cUDPEndpoint", "", tolua_collect_cUDPEndpoint);
|
||||
|
||||
// Fill in the functions (alpha-sorted):
|
||||
tolua_beginmodule(tolua_S, "cNetwork");
|
||||
|
|
|
|||
|
|
@ -1280,7 +1280,7 @@ static int tolua_cRankManager_SetRankVisuals(lua_State * L)
|
|||
|
||||
|
||||
|
||||
void ManualBindings::BindRankManager(lua_State * tolua_S)
|
||||
void cManualBindings::BindRankManager(lua_State * tolua_S)
|
||||
{
|
||||
// Create the cRankManager class in the API:
|
||||
tolua_usertype(tolua_S, "cRankManager");
|
||||
|
|
|
|||
|
|
@ -0,0 +1,588 @@
|
|||
|
||||
// ManualBindings_World.cpp
|
||||
|
||||
// Implements the manual Lua API bindings for the cWorld class
|
||||
|
||||
#include "Globals.h"
|
||||
#include "tolua++/include/tolua++.h"
|
||||
#include "../World.h"
|
||||
#include "../Broadcaster.h"
|
||||
#include "ManualBindings.h"
|
||||
#include "LuaState.h"
|
||||
#include "PluginLua.h"
|
||||
#include "LuaChunkStay.h"
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
static int tolua_cWorld_BroadcastParticleEffect(lua_State * tolua_S)
|
||||
{
|
||||
/* Function signature:
|
||||
World:BroadcastParticleEffect("Name", PosX, PosY, PosZ, OffX, OffY, OffZ, ParticleData, ParticleAmount, [ExcludeClient], [OptionalParam1], [OptionalParam2]
|
||||
*/
|
||||
cLuaState L(tolua_S);
|
||||
if (
|
||||
!L.CheckParamUserType(1, "cWorld") ||
|
||||
!L.CheckParamString (2) ||
|
||||
!L.CheckParamNumber (3, 10)
|
||||
)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Read the params:
|
||||
cWorld * World = nullptr;
|
||||
AString Name;
|
||||
float PosX, PosY, PosZ, OffX, OffY, OffZ;
|
||||
float ParticleData;
|
||||
int ParticleAmmount;
|
||||
cClientHandle * ExcludeClient = nullptr;
|
||||
L.GetStackValues(1, World, Name, PosX, PosY, PosZ, OffX, OffY, OffZ, ParticleData, ParticleAmmount, ExcludeClient);
|
||||
if (World == nullptr)
|
||||
{
|
||||
LOGWARNING("World:BroadcastParticleEffect(): invalid world parameter");
|
||||
L.LogStackTrace();
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Read up to 2 more optional data params:
|
||||
std::array<int, 2> data;
|
||||
for (int i = 0; (i < 2) && L.IsParamNumber(11 + i); i++)
|
||||
{
|
||||
L.GetStackValue(11 + i, data[i]);
|
||||
}
|
||||
|
||||
World->GetBroadcaster().BroadcastParticleEffect(Name, Vector3f(PosX, PosY, PosZ), Vector3f(OffX, OffY, OffZ), ParticleData, ParticleAmmount, ExcludeClient);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
static int tolua_cWorld_ChunkStay(lua_State * tolua_S)
|
||||
{
|
||||
/* Function signature:
|
||||
World:ChunkStay(ChunkCoordTable, OnChunkAvailable, OnAllChunksAvailable)
|
||||
ChunkCoordTable == { {Chunk1x, Chunk1z}, {Chunk2x, Chunk2z}, ... }
|
||||
*/
|
||||
|
||||
cLuaState L(tolua_S);
|
||||
if (
|
||||
!L.CheckParamUserType (1, "cWorld") ||
|
||||
!L.CheckParamTable (2) ||
|
||||
!L.CheckParamFunctionOrNil(3, 4)
|
||||
)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
cPluginLua * Plugin = cManualBindings::GetLuaPlugin(tolua_S);
|
||||
if (Plugin == nullptr)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Read the params:
|
||||
cWorld * World = (cWorld *)tolua_tousertype(tolua_S, 1, nullptr);
|
||||
if (World == nullptr)
|
||||
{
|
||||
LOGWARNING("World:ChunkStay(): invalid world parameter");
|
||||
L.LogStackTrace();
|
||||
return 0;
|
||||
}
|
||||
|
||||
cLuaChunkStay * ChunkStay = new cLuaChunkStay(*Plugin);
|
||||
|
||||
if (!ChunkStay->AddChunks(2))
|
||||
{
|
||||
delete ChunkStay;
|
||||
ChunkStay = nullptr;
|
||||
return 0;
|
||||
}
|
||||
|
||||
ChunkStay->Enable(*World->GetChunkMap(), 3, 4);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
static int tolua_cWorld_GetBlockInfo(lua_State * tolua_S)
|
||||
{
|
||||
// Exported manually, because tolua would generate useless additional parameters (a_BlockType .. a_BlockSkyLight)
|
||||
// Function signature: GetBlockInfo(BlockX, BlockY, BlockZ) -> BlockValid, [BlockType, BlockMeta, BlockSkyLight, BlockBlockLight]
|
||||
|
||||
// Check params:
|
||||
cLuaState L(tolua_S);
|
||||
if (
|
||||
!L.CheckParamUserType(1, "cWorld") ||
|
||||
!L.CheckParamNumber(2, 4) ||
|
||||
!L.CheckParamEnd(5)
|
||||
)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Get params:
|
||||
cWorld * Self = nullptr;
|
||||
int BlockX, BlockY, BlockZ;
|
||||
L.GetStackValues(1, Self, BlockX, BlockY, BlockZ);
|
||||
if (Self == nullptr)
|
||||
{
|
||||
return cManualBindings::lua_do_error(tolua_S, "Error in function call '#funcname#': Invalid 'self'");
|
||||
}
|
||||
|
||||
// Call the function:
|
||||
BLOCKTYPE BlockType;
|
||||
NIBBLETYPE BlockMeta, BlockSkyLight, BlockBlockLight;
|
||||
bool res = Self->GetBlockInfo(BlockX, BlockY, BlockZ, BlockType, BlockMeta, BlockSkyLight, BlockBlockLight);
|
||||
|
||||
// Push the returned values:
|
||||
L.Push(res);
|
||||
if (res)
|
||||
{
|
||||
L.Push(BlockType);
|
||||
L.Push(BlockMeta);
|
||||
L.Push(BlockSkyLight);
|
||||
L.Push(BlockBlockLight);
|
||||
return 5;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
static int tolua_cWorld_GetBlockTypeMeta(lua_State * tolua_S)
|
||||
{
|
||||
// Exported manually, because tolua would generate useless additional parameters (a_BlockType, a_BlockMeta)
|
||||
// Function signature: GetBlockTypeMeta(BlockX, BlockY, BlockZ) -> BlockValid, [BlockType, BlockMeta]
|
||||
|
||||
// Check params:
|
||||
cLuaState L(tolua_S);
|
||||
if (
|
||||
!L.CheckParamUserType(1, "cWorld") ||
|
||||
!L.CheckParamNumber(2, 4) ||
|
||||
!L.CheckParamEnd(5)
|
||||
)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Get params:
|
||||
cWorld * Self = nullptr;
|
||||
int BlockX, BlockY, BlockZ;
|
||||
L.GetStackValues(1, Self, BlockX, BlockY, BlockZ);
|
||||
if (Self == nullptr)
|
||||
{
|
||||
return cManualBindings::lua_do_error(tolua_S, "Error in function call '#funcname#': Invalid 'self'");
|
||||
}
|
||||
|
||||
// Call the function:
|
||||
BLOCKTYPE BlockType;
|
||||
NIBBLETYPE BlockMeta;
|
||||
bool res = Self->GetBlockTypeMeta(BlockX, BlockY, BlockZ, BlockType, BlockMeta);
|
||||
|
||||
// Push the returned values:
|
||||
L.Push(res);
|
||||
if (res)
|
||||
{
|
||||
L.Push(BlockType);
|
||||
L.Push(BlockMeta);
|
||||
return 3;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
static int tolua_cWorld_GetSignLines(lua_State * tolua_S)
|
||||
{
|
||||
// Exported manually, because tolua would generate useless additional parameters (a_Line1 .. a_Line4)
|
||||
|
||||
// Check params:
|
||||
cLuaState L(tolua_S);
|
||||
if (
|
||||
!L.CheckParamUserType(1, "cWorld") ||
|
||||
!L.CheckParamNumber(2, 4) ||
|
||||
!L.CheckParamEnd(5)
|
||||
)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Get params:
|
||||
cWorld * Self = nullptr;
|
||||
int BlockX, BlockY, BlockZ;
|
||||
L.GetStackValues(1, Self, BlockX, BlockY, BlockZ);
|
||||
if (Self == nullptr)
|
||||
{
|
||||
return cManualBindings::lua_do_error(tolua_S, "Error in function call '#funcname#': Invalid 'self'");
|
||||
}
|
||||
|
||||
// Call the function:
|
||||
AString Line1, Line2, Line3, Line4;
|
||||
bool res = Self->GetSignLines(BlockX, BlockY, BlockZ, Line1, Line2, Line3, Line4);
|
||||
|
||||
// Push the returned values:
|
||||
L.Push(res);
|
||||
if (res)
|
||||
{
|
||||
L.Push(Line1);
|
||||
L.Push(Line2);
|
||||
L.Push(Line3);
|
||||
L.Push(Line4);
|
||||
return 5;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
static int tolua_cWorld_PrepareChunk(lua_State * tolua_S)
|
||||
{
|
||||
/* Function signature:
|
||||
World:PrepareChunk(ChunkX, ChunkZ, Callback)
|
||||
*/
|
||||
|
||||
// Check the param types:
|
||||
cLuaState L(tolua_S);
|
||||
if (
|
||||
!L.CheckParamUserType (1, "cWorld") ||
|
||||
!L.CheckParamNumber (2, 3) ||
|
||||
!L.CheckParamFunctionOrNil(4)
|
||||
)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Read the params:
|
||||
cWorld * world = nullptr;
|
||||
int chunkX = 0, chunkZ = 0;
|
||||
L.GetStackValues(1, world, chunkX, chunkZ);
|
||||
if (world == nullptr)
|
||||
{
|
||||
LOGWARNING("World:PrepareChunk(): invalid world parameter");
|
||||
L.LogStackTrace();
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Wrap the Lua callback inside a C++ callback class:
|
||||
class cCallback:
|
||||
public cChunkCoordCallback
|
||||
{
|
||||
public:
|
||||
cCallback(lua_State * a_LuaState):
|
||||
m_LuaState(a_LuaState),
|
||||
m_Callback(m_LuaState, 4)
|
||||
{
|
||||
}
|
||||
|
||||
// cChunkCoordCallback override:
|
||||
virtual void Call(int a_CBChunkX, int a_CBChunkZ) override
|
||||
{
|
||||
if (m_Callback.IsValid())
|
||||
{
|
||||
m_LuaState.Call(m_Callback, a_CBChunkX, a_CBChunkZ);
|
||||
}
|
||||
|
||||
// This is the last reference of this object, we must delete it so that it doesn't leak:
|
||||
delete this;
|
||||
}
|
||||
|
||||
protected:
|
||||
cLuaState m_LuaState;
|
||||
cLuaState::cRef m_Callback;
|
||||
};
|
||||
cCallback * callback = new cCallback(tolua_S);
|
||||
|
||||
// Call the chunk preparation:
|
||||
world->PrepareChunk(chunkX, chunkZ, callback);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
class cLuaWorldTask :
|
||||
public cWorld::cTask,
|
||||
public cPluginLua::cResettable
|
||||
{
|
||||
public:
|
||||
cLuaWorldTask(cPluginLua & a_Plugin, int a_FnRef) :
|
||||
cPluginLua::cResettable(a_Plugin),
|
||||
m_FnRef(a_FnRef)
|
||||
{
|
||||
}
|
||||
|
||||
protected:
|
||||
int m_FnRef;
|
||||
|
||||
// cWorld::cTask overrides:
|
||||
virtual void Run(cWorld & a_World) override
|
||||
{
|
||||
cCSLock Lock(m_CSPlugin);
|
||||
if (m_Plugin != nullptr)
|
||||
{
|
||||
m_Plugin->Call(m_FnRef, &a_World);
|
||||
}
|
||||
}
|
||||
} ;
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
static int tolua_cWorld_QueueTask(lua_State * tolua_S)
|
||||
{
|
||||
// Binding for cWorld::QueueTask
|
||||
// Params: function
|
||||
|
||||
// Retrieve the cPlugin from the LuaState:
|
||||
cPluginLua * Plugin = cManualBindings::GetLuaPlugin(tolua_S);
|
||||
if (Plugin == nullptr)
|
||||
{
|
||||
// An error message has been already printed in GetLuaPlugin()
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Retrieve the args:
|
||||
cWorld * self = (cWorld *)tolua_tousertype(tolua_S, 1, nullptr);
|
||||
if (self == nullptr)
|
||||
{
|
||||
return cManualBindings::lua_do_error(tolua_S, "Error in function call '#funcname#': Not called on an object instance");
|
||||
}
|
||||
if (!lua_isfunction(tolua_S, 2))
|
||||
{
|
||||
return cManualBindings::lua_do_error(tolua_S, "Error in function call '#funcname#': Expected a function for parameter #1");
|
||||
}
|
||||
|
||||
// Create a reference to the function:
|
||||
int FnRef = luaL_ref(tolua_S, LUA_REGISTRYINDEX);
|
||||
if (FnRef == LUA_REFNIL)
|
||||
{
|
||||
return cManualBindings::lua_do_error(tolua_S, "Error in function call '#funcname#': Could not get function reference of parameter #1");
|
||||
}
|
||||
|
||||
auto task = std::make_shared<cLuaWorldTask>(*Plugin, FnRef);
|
||||
Plugin->AddResettable(task);
|
||||
self->QueueTask(task);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
static int tolua_cWorld_SetSignLines(lua_State * tolua_S)
|
||||
{
|
||||
// Exported manually, because tolua would generate useless additional return values (a_Line1 .. a_Line4)
|
||||
|
||||
// Check params:
|
||||
cLuaState L(tolua_S);
|
||||
if (
|
||||
!L.CheckParamUserType(1, "cWorld") ||
|
||||
!L.CheckParamNumber(2, 4) ||
|
||||
!L.CheckParamString(5, 8) ||
|
||||
!L.CheckParamEnd(9)
|
||||
)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Get params:
|
||||
cWorld * Self = nullptr;
|
||||
int BlockX, BlockY, BlockZ;
|
||||
AString Line1, Line2, Line3, Line4;
|
||||
L.GetStackValues(1, Self, BlockX, BlockY, BlockZ, Line1, Line2, Line3, Line4);
|
||||
if (Self == nullptr)
|
||||
{
|
||||
return cManualBindings::lua_do_error(tolua_S, "Error in function call '#funcname#': Invalid 'self'");
|
||||
}
|
||||
|
||||
// Call the function:
|
||||
bool res = Self->SetSignLines(BlockX, BlockY, BlockZ, Line1, Line2, Line3, Line4);
|
||||
|
||||
// Push the returned values:
|
||||
L.Push(res);
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
class cLuaScheduledWorldTask :
|
||||
public cWorld::cTask,
|
||||
public cPluginLua::cResettable
|
||||
{
|
||||
public:
|
||||
cLuaScheduledWorldTask(cPluginLua & a_Plugin, int a_FnRef) :
|
||||
cPluginLua::cResettable(a_Plugin),
|
||||
m_FnRef(a_FnRef)
|
||||
{
|
||||
}
|
||||
|
||||
protected:
|
||||
int m_FnRef;
|
||||
|
||||
// cWorld::cTask overrides:
|
||||
virtual void Run(cWorld & a_World) override
|
||||
{
|
||||
cCSLock Lock(m_CSPlugin);
|
||||
if (m_Plugin != nullptr)
|
||||
{
|
||||
m_Plugin->Call(m_FnRef, &a_World);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
static int tolua_cWorld_ScheduleTask(lua_State * tolua_S)
|
||||
{
|
||||
// Binding for cWorld::ScheduleTask
|
||||
// Params: function, Ticks
|
||||
|
||||
// Retrieve the cPlugin from the LuaState:
|
||||
cPluginLua * Plugin = cManualBindings::GetLuaPlugin(tolua_S);
|
||||
if (Plugin == nullptr)
|
||||
{
|
||||
// An error message has been already printed in GetLuaPlugin()
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Retrieve the args:
|
||||
cLuaState L(tolua_S);
|
||||
if (
|
||||
!L.CheckParamUserType(1, "cWorld") ||
|
||||
!L.CheckParamNumber (2) ||
|
||||
!L.CheckParamFunction(3)
|
||||
)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
cWorld * World = (cWorld *)tolua_tousertype(tolua_S, 1, nullptr);
|
||||
if (World == nullptr)
|
||||
{
|
||||
return cManualBindings::lua_do_error(tolua_S, "Error in function call '#funcname#': Not called on an object instance");
|
||||
}
|
||||
|
||||
// Create a reference to the function:
|
||||
int FnRef = luaL_ref(tolua_S, LUA_REGISTRYINDEX);
|
||||
if (FnRef == LUA_REFNIL)
|
||||
{
|
||||
return cManualBindings::lua_do_error(tolua_S, "Error in function call '#funcname#': Could not get function reference of parameter #1");
|
||||
}
|
||||
|
||||
int DelayTicks = (int)tolua_tonumber(tolua_S, 2, 0);
|
||||
|
||||
auto task = std::make_shared<cLuaScheduledWorldTask>(*Plugin, FnRef);
|
||||
Plugin->AddResettable(task);
|
||||
World->ScheduleTask(DelayTicks, task);
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
static int tolua_cWorld_TryGetHeight(lua_State * tolua_S)
|
||||
{
|
||||
/* Exported manually, because tolua would require the out-only param a_Height to be used when calling
|
||||
Function signature: world:TryGetHeight(a_World, a_BlockX, a_BlockZ) -> IsValid, Height
|
||||
*/
|
||||
|
||||
// Check params:
|
||||
cLuaState L(tolua_S);
|
||||
if (
|
||||
!L.CheckParamUserType(1, "cWorld") ||
|
||||
!L.CheckParamNumber(2, 3) ||
|
||||
!L.CheckParamEnd(4)
|
||||
)
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Get params:
|
||||
cWorld * self = nullptr;
|
||||
int BlockX, BlockZ;
|
||||
L.GetStackValues(1, self, BlockX, BlockZ);
|
||||
if (self == nullptr)
|
||||
{
|
||||
tolua_error(tolua_S, "Invalid 'self' in function 'TryGetHeight'", nullptr);
|
||||
return 0;
|
||||
}
|
||||
|
||||
// Call the implementation:
|
||||
int Height = 0;
|
||||
bool res = self->TryGetHeight(BlockX, BlockZ, Height);
|
||||
L.Push(res ? 1 : 0);
|
||||
if (res)
|
||||
{
|
||||
L.Push(Height);
|
||||
return 2;
|
||||
}
|
||||
return 1;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
void cManualBindings::BindWorld(lua_State * tolua_S)
|
||||
{
|
||||
tolua_beginmodule(tolua_S, nullptr);
|
||||
tolua_beginmodule(tolua_S, "cWorld");
|
||||
tolua_function(tolua_S, "BroadcastParticleEffect", tolua_cWorld_BroadcastParticleEffect);
|
||||
tolua_function(tolua_S, "ChunkStay", tolua_cWorld_ChunkStay);
|
||||
tolua_function(tolua_S, "DoWithBlockEntityAt", DoWithXYZ<cWorld, cBlockEntity, &cWorld::DoWithBlockEntityAt>);
|
||||
tolua_function(tolua_S, "DoWithBeaconAt", DoWithXYZ<cWorld, cBeaconEntity, &cWorld::DoWithBeaconAt>);
|
||||
tolua_function(tolua_S, "DoWithChestAt", DoWithXYZ<cWorld, cChestEntity, &cWorld::DoWithChestAt>);
|
||||
tolua_function(tolua_S, "DoWithDispenserAt", DoWithXYZ<cWorld, cDispenserEntity, &cWorld::DoWithDispenserAt>);
|
||||
tolua_function(tolua_S, "DoWithDropSpenserAt", DoWithXYZ<cWorld, cDropSpenserEntity, &cWorld::DoWithDropSpenserAt>);
|
||||
tolua_function(tolua_S, "DoWithDropperAt", DoWithXYZ<cWorld, cDropperEntity, &cWorld::DoWithDropperAt>);
|
||||
tolua_function(tolua_S, "DoWithEntityByID", DoWithID< cWorld, cEntity, &cWorld::DoWithEntityByID>);
|
||||
tolua_function(tolua_S, "DoWithFurnaceAt", DoWithXYZ<cWorld, cFurnaceEntity, &cWorld::DoWithFurnaceAt>);
|
||||
tolua_function(tolua_S, "DoWithNoteBlockAt", DoWithXYZ<cWorld, cNoteEntity, &cWorld::DoWithNoteBlockAt>);
|
||||
tolua_function(tolua_S, "DoWithCommandBlockAt", DoWithXYZ<cWorld, cCommandBlockEntity, &cWorld::DoWithCommandBlockAt>);
|
||||
tolua_function(tolua_S, "DoWithMobHeadAt", DoWithXYZ<cWorld, cMobHeadEntity, &cWorld::DoWithMobHeadAt>);
|
||||
tolua_function(tolua_S, "DoWithFlowerPotAt", DoWithXYZ<cWorld, cFlowerPotEntity, &cWorld::DoWithFlowerPotAt>);
|
||||
tolua_function(tolua_S, "DoWithPlayer", DoWith< cWorld, cPlayer, &cWorld::DoWithPlayer>);
|
||||
tolua_function(tolua_S, "FindAndDoWithPlayer", DoWith< cWorld, cPlayer, &cWorld::FindAndDoWithPlayer>);
|
||||
tolua_function(tolua_S, "DoWithPlayerByUUID", DoWith< cWorld, cPlayer, &cWorld::DoWithPlayerByUUID>);
|
||||
tolua_function(tolua_S, "ForEachBlockEntityInChunk", ForEachInChunk<cWorld, cBlockEntity, &cWorld::ForEachBlockEntityInChunk>);
|
||||
tolua_function(tolua_S, "ForEachChestInChunk", ForEachInChunk<cWorld, cChestEntity, &cWorld::ForEachChestInChunk>);
|
||||
tolua_function(tolua_S, "ForEachEntity", ForEach< cWorld, cEntity, &cWorld::ForEachEntity>);
|
||||
tolua_function(tolua_S, "ForEachEntityInBox", ForEachInBox< cWorld, cEntity, &cWorld::ForEachEntityInBox>);
|
||||
tolua_function(tolua_S, "ForEachEntityInChunk", ForEachInChunk<cWorld, cEntity, &cWorld::ForEachEntityInChunk>);
|
||||
tolua_function(tolua_S, "ForEachFurnaceInChunk", ForEachInChunk<cWorld, cFurnaceEntity, &cWorld::ForEachFurnaceInChunk>);
|
||||
tolua_function(tolua_S, "ForEachPlayer", ForEach< cWorld, cPlayer, &cWorld::ForEachPlayer>);
|
||||
tolua_function(tolua_S, "GetBlockInfo", tolua_cWorld_GetBlockInfo);
|
||||
tolua_function(tolua_S, "GetBlockTypeMeta", tolua_cWorld_GetBlockTypeMeta);
|
||||
tolua_function(tolua_S, "GetSignLines", tolua_cWorld_GetSignLines);
|
||||
tolua_function(tolua_S, "PrepareChunk", tolua_cWorld_PrepareChunk);
|
||||
tolua_function(tolua_S, "QueueTask", tolua_cWorld_QueueTask);
|
||||
tolua_function(tolua_S, "ScheduleTask", tolua_cWorld_ScheduleTask);
|
||||
tolua_function(tolua_S, "SetSignLines", tolua_cWorld_SetSignLines);
|
||||
tolua_function(tolua_S, "TryGetHeight", tolua_cWorld_TryGetHeight);
|
||||
tolua_endmodule(tolua_S);
|
||||
tolua_endmodule(tolua_S);
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
Loading…
Reference in New Issue