diff options
Diffstat (limited to '')
233 files changed, 35759 insertions, 0 deletions
diff --git a/source/AllToLua.bat b/source/AllToLua.bat new file mode 100644 index 000000000..24f56a0e5 --- /dev/null +++ b/source/AllToLua.bat @@ -0,0 +1,3 @@ +"tolua++.exe" -L virtual_method_hooks.lua -o Bindings.cpp -H Bindings.h AllToLua.pkg
+PAUSE
+echo "tolua++.exe" -o Bindings.cpp -H Bindings.h AllToLua.pkg
\ No newline at end of file diff --git a/source/AllToLua.pkg b/source/AllToLua.pkg new file mode 100644 index 000000000..8338f0088 --- /dev/null +++ b/source/AllToLua.pkg @@ -0,0 +1,41 @@ +$#include "tolua_base.h"
+
+$cfile "cTorch.h"
+$cfile "cStairs.h"
+$cfile "cLadder.h"
+
+$cfile "../iniFile/iniFile.h"
+
+$cfile "BlockID.h"
+$cfile "PacketID.h"
+$cfile "Defines.h"
+$cfile "LuaFunctions.h"
+$cfile "cStringMap.h"
+$cfile "cChatColor.h"
+$cfile "cClientHandle.h"
+$cfile "cEntity.h"
+$cfile "cPawn.h"
+$cfile "cPlayer.h"
+$cfile "cPluginManager.h"
+$cfile "cPlugin.h"
+$cfile "cPlugin_Lua.h"
+$cfile "cServer.h"
+$cfile "cWorld.h"
+$cfile "cInventory.h"
+$cfile "cItem.h"
+$cfile "cWebAdmin.h"
+$cfile "cWebPlugin.h"
+$cfile "cPickup.h"
+$cfile "cRoot.h"
+$cfile "cTCPLink.h"
+$cfile "Vector3f.h"
+$cfile "Vector3d.h"
+$cfile "Vector3i.h"
+$cfile "Matrix4f.h"
+$cfile "cCuboid.h"
+$cfile "cMCLogger.h"
+$cfile "cTracer.h"
+$cfile "cGroup.h"
+$cfile "packets/cPacket_Login.h"
+$cfile "packets/cPacket_BlockDig.h"
+$cfile "packets/cPacket_BlockPlace.h"
\ No newline at end of file diff --git a/source/Bindings.cpp b/source/Bindings.cpp new file mode 100644 index 000000000..7a0174852 --- /dev/null +++ b/source/Bindings.cpp @@ -0,0 +1,15468 @@ +/*
+** Lua binding: AllToLua
+** Generated automatically by tolua++-1.0.92 on 07/15/11 01:36:28.
+*/
+
+#ifndef __cplusplus
+#include "stdlib.h"
+#endif
+#include "string.h"
+
+#include "tolua++.h"
+
+/* Exported function */
+TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S);
+
+#include "tolua_base.h"
+#include "cTorch.h"
+#include "cStairs.h"
+#include "cLadder.h"
+#include "../iniFile/iniFile.h"
+#include "BlockID.h"
+#include "PacketID.h"
+#include "Defines.h"
+#include "LuaFunctions.h"
+#include "cStringMap.h"
+#include "cChatColor.h"
+#include "cClientHandle.h"
+#include "cEntity.h"
+#include "cPawn.h"
+#include "cPlayer.h"
+#include "cPluginManager.h"
+#include "cPlugin.h"
+#include "cPlugin_Lua.h"
+#include "cServer.h"
+#include "cWorld.h"
+#include "cInventory.h"
+#include "cItem.h"
+#include "cWebAdmin.h"
+#include "cWebPlugin.h"
+#include "cPickup.h"
+#include "cRoot.h"
+#include "cTCPLink.h"
+#include "Vector3f.h"
+#include "Vector3d.h"
+#include "Vector3i.h"
+#include "Matrix4f.h"
+#include "cCuboid.h"
+#include "cMCLogger.h"
+#include "cTracer.h"
+#include "cGroup.h"
+#include "packets/cPacket_Login.h"
+#include "packets/cPacket_BlockDig.h"
+#include "packets/cPacket_BlockPlace.h"
+
+/* function to release collected object via destructor */
+#ifdef __cplusplus
+
+static int tolua_collect_cItem (lua_State* tolua_S)
+{
+ cItem* self = (cItem*) tolua_tousertype(tolua_S,1,0);
+ Mtolua_delete(self);
+ return 0;
+}
+
+static int tolua_collect_Vector3f (lua_State* tolua_S)
+{
+ Vector3f* self = (Vector3f*) tolua_tousertype(tolua_S,1,0);
+ Mtolua_delete(self);
+ return 0;
+}
+
+static int tolua_collect_cIniFile (lua_State* tolua_S)
+{
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+ Mtolua_delete(self);
+ return 0;
+}
+
+static int tolua_collect_cPickup (lua_State* tolua_S)
+{
+ cPickup* self = (cPickup*) tolua_tousertype(tolua_S,1,0);
+ Mtolua_delete(self);
+ return 0;
+}
+
+static int tolua_collect_cPacket_BlockDig (lua_State* tolua_S)
+{
+ cPacket_BlockDig* self = (cPacket_BlockDig*) tolua_tousertype(tolua_S,1,0);
+ Mtolua_delete(self);
+ return 0;
+}
+
+static int tolua_collect_cTracer (lua_State* tolua_S)
+{
+ cTracer* self = (cTracer*) tolua_tousertype(tolua_S,1,0);
+ Mtolua_delete(self);
+ return 0;
+}
+
+static int tolua_collect_cPlugin (lua_State* tolua_S)
+{
+ cPlugin* self = (cPlugin*) tolua_tousertype(tolua_S,1,0);
+ Mtolua_delete(self);
+ return 0;
+}
+
+static int tolua_collect_cMCLogger (lua_State* tolua_S)
+{
+ cMCLogger* self = (cMCLogger*) tolua_tousertype(tolua_S,1,0);
+ Mtolua_delete(self);
+ return 0;
+}
+
+static int tolua_collect_cCuboid (lua_State* tolua_S)
+{
+ cCuboid* self = (cCuboid*) tolua_tousertype(tolua_S,1,0);
+ Mtolua_delete(self);
+ return 0;
+}
+
+static int tolua_collect_cWebPlugin (lua_State* tolua_S)
+{
+ cWebPlugin* self = (cWebPlugin*) tolua_tousertype(tolua_S,1,0);
+ Mtolua_delete(self);
+ return 0;
+}
+
+static int tolua_collect_Vector3i (lua_State* tolua_S)
+{
+ Vector3i* self = (Vector3i*) tolua_tousertype(tolua_S,1,0);
+ Mtolua_delete(self);
+ return 0;
+}
+
+static int tolua_collect_cEntity (lua_State* tolua_S)
+{
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+ Mtolua_delete(self);
+ return 0;
+}
+
+static int tolua_collect_cTCPLink (lua_State* tolua_S)
+{
+ cTCPLink* self = (cTCPLink*) tolua_tousertype(tolua_S,1,0);
+ Mtolua_delete(self);
+ return 0;
+}
+
+static int tolua_collect_Vector3d (lua_State* tolua_S)
+{
+ Vector3d* self = (Vector3d*) tolua_tousertype(tolua_S,1,0);
+ Mtolua_delete(self);
+ return 0;
+}
+#endif
+
+
+/* function to register type */
+static void tolua_reg_types (lua_State* tolua_S)
+{
+ tolua_usertype(tolua_S,"TakeDamageInfo");
+ tolua_usertype(tolua_S,"cPlugin");
+ tolua_usertype(tolua_S,"cStringMap");
+ tolua_usertype(tolua_S,"cServer");
+ tolua_usertype(tolua_S,"cRoot");
+ tolua_usertype(tolua_S,"cPlugin::CommandStruct");
+ tolua_usertype(tolua_S,"cPickup");
+ tolua_usertype(tolua_S,"cRecipeChecker");
+ tolua_usertype(tolua_S,"cPacket_Login");
+ tolua_usertype(tolua_S,"cClientHandle");
+ tolua_usertype(tolua_S,"Lua__cPacket_BlockDig");
+ tolua_usertype(tolua_S,"cFurnaceRecipe");
+ tolua_usertype(tolua_S,"cCuboid");
+ tolua_usertype(tolua_S,"cChatColor");
+ tolua_usertype(tolua_S,"cMCLogger");
+ tolua_usertype(tolua_S,"cPacket_PickupSpawn");
+ tolua_usertype(tolua_S,"Lua__cWebPlugin");
+ tolua_usertype(tolua_S,"Lua__cPawn");
+ tolua_usertype(tolua_S,"cGroup");
+ tolua_usertype(tolua_S,"cItem");
+ tolua_usertype(tolua_S,"Vector3f");
+ tolua_usertype(tolua_S,"cPlugin_Lua");
+ tolua_usertype(tolua_S,"cTracer");
+ tolua_usertype(tolua_S,"Lua__cPlayer");
+ tolua_usertype(tolua_S,"cPacket");
+ tolua_usertype(tolua_S,"cPacket_BlockDig");
+ tolua_usertype(tolua_S,"cWebAdmin");
+ tolua_usertype(tolua_S,"Vector3i");
+ tolua_usertype(tolua_S,"cBlockEntity");
+ tolua_usertype(tolua_S,"cWorld");
+ tolua_usertype(tolua_S,"Lua__cTCPLink");
+ tolua_usertype(tolua_S,"Lua__cPlugin");
+ tolua_usertype(tolua_S,"cTCPLink");
+ tolua_usertype(tolua_S,"cPacket_BlockPlace");
+ tolua_usertype(tolua_S,"cLadder");
+ tolua_usertype(tolua_S,"cGroupManager");
+ tolua_usertype(tolua_S,"cPluginManager");
+ tolua_usertype(tolua_S,"cIniFile");
+ tolua_usertype(tolua_S,"cWebPlugin");
+ tolua_usertype(tolua_S,"HTTPRequest");
+ tolua_usertype(tolua_S,"cPawn");
+ tolua_usertype(tolua_S,"cPlayer");
+ tolua_usertype(tolua_S,"cTorch");
+ tolua_usertype(tolua_S,"Lua__cPickup");
+ tolua_usertype(tolua_S,"cEntity");
+ tolua_usertype(tolua_S,"cInventory");
+ tolua_usertype(tolua_S,"Lua__cEntity");
+ tolua_usertype(tolua_S,"cStairs");
+ tolua_usertype(tolua_S,"Vector3d");
+}
+
+/* method: DirectionToMetaData of class cTorch */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cTorch_DirectionToMetaData00
+static int tolua_AllToLua_cTorch_DirectionToMetaData00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cTorch",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ char a_Direction = ((char) tolua_tonumber(tolua_S,2,0));
+ {
+ char tolua_ret = (char) cTorch::DirectionToMetaData(a_Direction);
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'DirectionToMetaData'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: MetaDataToDirection of class cTorch */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cTorch_MetaDataToDirection00
+static int tolua_AllToLua_cTorch_MetaDataToDirection00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cTorch",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ char a_MetaData = ((char) tolua_tonumber(tolua_S,2,0));
+ {
+ char tolua_ret = (char) cTorch::MetaDataToDirection(a_MetaData);
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'MetaDataToDirection'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: RotationToMetaData of class cStairs */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cStairs_RotationToMetaData00
+static int tolua_AllToLua_cStairs_RotationToMetaData00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cStairs",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ float a_Rotation = ((float) tolua_tonumber(tolua_S,2,0));
+ {
+ char tolua_ret = (char) cStairs::RotationToMetaData(a_Rotation);
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'RotationToMetaData'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: DirectionToMetaData of class cLadder */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cLadder_DirectionToMetaData00
+static int tolua_AllToLua_cLadder_DirectionToMetaData00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cLadder",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ char a_Direction = ((char) tolua_tonumber(tolua_S,2,0));
+ {
+ char tolua_ret = (char) cLadder::DirectionToMetaData(a_Direction);
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'DirectionToMetaData'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: MetaDataToDirection of class cLadder */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cLadder_MetaDataToDirection00
+static int tolua_AllToLua_cLadder_MetaDataToDirection00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cLadder",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ char a_MetaData = ((char) tolua_tonumber(tolua_S,2,0));
+ {
+ char tolua_ret = (char) cLadder::MetaDataToDirection(a_MetaData);
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'MetaDataToDirection'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_new00
+static int tolua_AllToLua_cIniFile_new00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,1,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const std::string iniPath = ((const std::string) tolua_tocppstring(tolua_S,2,""));
+ {
+ cIniFile* tolua_ret = (cIniFile*) Mtolua_new((cIniFile)(iniPath));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cIniFile");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new_local of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_new00_local
+static int tolua_AllToLua_cIniFile_new00_local(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,1,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const std::string iniPath = ((const std::string) tolua_tocppstring(tolua_S,2,""));
+ {
+ cIniFile* tolua_ret = (cIniFile*) Mtolua_new((cIniFile)(iniPath));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cIniFile");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: CaseSensitive of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_CaseSensitive00
+static int tolua_AllToLua_cIniFile_CaseSensitive00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CaseSensitive'", NULL);
+#endif
+ {
+ self->CaseSensitive();
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'CaseSensitive'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: CaseInsensitive of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_CaseInsensitive00
+static int tolua_AllToLua_cIniFile_CaseInsensitive00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CaseInsensitive'", NULL);
+#endif
+ {
+ self->CaseInsensitive();
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'CaseInsensitive'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Path of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_Path00
+static int tolua_AllToLua_cIniFile_Path00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string newPath = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Path'", NULL);
+#endif
+ {
+ self->Path(newPath);
+ tolua_pushcppstring(tolua_S,(const char*)newPath);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Path'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Path of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_Path01
+static int tolua_AllToLua_cIniFile_Path01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const cIniFile* self = (const cIniFile*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Path'", NULL);
+#endif
+ {
+ std::string tolua_ret = (std::string) self->Path();
+ tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_cIniFile_Path00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetPath of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_SetPath00
+static int tolua_AllToLua_cIniFile_SetPath00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string newPath = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetPath'", NULL);
+#endif
+ {
+ self->SetPath(newPath);
+ tolua_pushcppstring(tolua_S,(const char*)newPath);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetPath'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: ReadFile of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_ReadFile00
+static int tolua_AllToLua_cIniFile_ReadFile00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ReadFile'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->ReadFile();
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'ReadFile'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: WriteFile of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_WriteFile00
+static int tolua_AllToLua_cIniFile_WriteFile00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'WriteFile'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->WriteFile();
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'WriteFile'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Erase of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_Erase00
+static int tolua_AllToLua_cIniFile_Erase00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Erase'", NULL);
+#endif
+ {
+ self->Erase();
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Erase'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Clear of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_Clear00
+static int tolua_AllToLua_cIniFile_Clear00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Clear'", NULL);
+#endif
+ {
+ self->Clear();
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Clear'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Reset of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_Reset00
+static int tolua_AllToLua_cIniFile_Reset00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Reset'", NULL);
+#endif
+ {
+ self->Reset();
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Reset'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: FindKey of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_FindKey00
+static int tolua_AllToLua_cIniFile_FindKey00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const cIniFile* self = (const cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string keyname = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'FindKey'", NULL);
+#endif
+ {
+ long tolua_ret = (long) self->FindKey(keyname);
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)keyname);
+ }
+ }
+ return 2;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'FindKey'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: FindValue of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_FindValue00
+static int tolua_AllToLua_cIniFile_FindValue00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const cIniFile* self = (const cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const unsigned keyID = ((const unsigned) tolua_tonumber(tolua_S,2,0));
+ const std::string valuename = ((const std::string) tolua_tocppstring(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'FindValue'", NULL);
+#endif
+ {
+ long tolua_ret = (long) self->FindValue(keyID,valuename);
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)valuename);
+ }
+ }
+ return 2;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'FindValue'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: NumKeys of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_NumKeys00
+static int tolua_AllToLua_cIniFile_NumKeys00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const cIniFile* self = (const cIniFile*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NumKeys'", NULL);
+#endif
+ {
+ unsigned tolua_ret = (unsigned) self->NumKeys();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'NumKeys'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetNumKeys of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetNumKeys00
+static int tolua_AllToLua_cIniFile_GetNumKeys00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const cIniFile* self = (const cIniFile*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumKeys'", NULL);
+#endif
+ {
+ unsigned tolua_ret = (unsigned) self->GetNumKeys();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetNumKeys'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: AddKeyName of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_AddKeyName00
+static int tolua_AllToLua_cIniFile_AddKeyName00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string keyname = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddKeyName'", NULL);
+#endif
+ {
+ unsigned tolua_ret = (unsigned) self->AddKeyName(keyname);
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)keyname);
+ }
+ }
+ return 2;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'AddKeyName'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: KeyName of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_KeyName00
+static int tolua_AllToLua_cIniFile_KeyName00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const cIniFile* self = (const cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const unsigned keyID = ((const unsigned) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'KeyName'", NULL);
+#endif
+ {
+ std::string tolua_ret = (std::string) self->KeyName(keyID);
+ tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'KeyName'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetKeyName of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetKeyName00
+static int tolua_AllToLua_cIniFile_GetKeyName00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const cIniFile* self = (const cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const unsigned keyID = ((const unsigned) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetKeyName'", NULL);
+#endif
+ {
+ std::string tolua_ret = (std::string) self->GetKeyName(keyID);
+ tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetKeyName'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: NumValues of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_NumValues00
+static int tolua_AllToLua_cIniFile_NumValues00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string keyname = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NumValues'", NULL);
+#endif
+ {
+ unsigned tolua_ret = (unsigned) self->NumValues(keyname);
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)keyname);
+ }
+ }
+ return 2;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'NumValues'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetNumValues of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetNumValues00
+static int tolua_AllToLua_cIniFile_GetNumValues00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string keyname = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumValues'", NULL);
+#endif
+ {
+ unsigned tolua_ret = (unsigned) self->GetNumValues(keyname);
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)keyname);
+ }
+ }
+ return 2;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetNumValues'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: NumValues of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_NumValues01
+static int tolua_AllToLua_cIniFile_NumValues01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const unsigned keyID = ((const unsigned) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NumValues'", NULL);
+#endif
+ {
+ unsigned tolua_ret = (unsigned) self->NumValues(keyID);
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_cIniFile_NumValues00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetNumValues of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetNumValues01
+static int tolua_AllToLua_cIniFile_GetNumValues01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const unsigned keyID = ((const unsigned) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumValues'", NULL);
+#endif
+ {
+ unsigned tolua_ret = (unsigned) self->GetNumValues(keyID);
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_cIniFile_GetNumValues00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: ValueName of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_ValueName00
+static int tolua_AllToLua_cIniFile_ValueName00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const cIniFile* self = (const cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string keyname = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+ const unsigned valueID = ((const unsigned) tolua_tonumber(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ValueName'", NULL);
+#endif
+ {
+ std::string tolua_ret = (std::string) self->ValueName(keyname,valueID);
+ tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)keyname);
+ }
+ }
+ return 2;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'ValueName'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetValueName of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValueName00
+static int tolua_AllToLua_cIniFile_GetValueName00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const cIniFile* self = (const cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string keyname = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+ const unsigned valueID = ((const unsigned) tolua_tonumber(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValueName'", NULL);
+#endif
+ {
+ std::string tolua_ret = (std::string) self->GetValueName(keyname,valueID);
+ tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)keyname);
+ }
+ }
+ return 2;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetValueName'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: ValueName of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_ValueName01
+static int tolua_AllToLua_cIniFile_ValueName01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const cIniFile* self = (const cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const unsigned keyID = ((const unsigned) tolua_tonumber(tolua_S,2,0));
+ const unsigned valueID = ((const unsigned) tolua_tonumber(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ValueName'", NULL);
+#endif
+ {
+ std::string tolua_ret = (std::string) self->ValueName(keyID,valueID);
+ tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_cIniFile_ValueName00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetValueName of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValueName01
+static int tolua_AllToLua_cIniFile_GetValueName01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const cIniFile* self = (const cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const unsigned keyID = ((const unsigned) tolua_tonumber(tolua_S,2,0));
+ const unsigned valueID = ((const unsigned) tolua_tonumber(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValueName'", NULL);
+#endif
+ {
+ std::string tolua_ret = (std::string) self->GetValueName(keyID,valueID);
+ tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_cIniFile_GetValueName00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetValue of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValue00
+static int tolua_AllToLua_cIniFile_GetValue00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const cIniFile* self = (const cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string keyname = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+ const std::string valuename = ((const std::string) tolua_tocppstring(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValue'", NULL);
+#endif
+ {
+ std::string tolua_ret = (std::string) self->GetValue(keyname,valuename);
+ tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)keyname);
+ tolua_pushcppstring(tolua_S,(const char*)valuename);
+ }
+ }
+ return 3;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetValue'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetValue of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValue01
+static int tolua_AllToLua_cIniFile_GetValue01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const cIniFile* self = (const cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string keyname = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+ const std::string valuename = ((const std::string) tolua_tocppstring(tolua_S,3,0));
+ const std::string defValue = ((const std::string) tolua_tocppstring(tolua_S,4,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValue'", NULL);
+#endif
+ {
+ std::string tolua_ret = (std::string) self->GetValue(keyname,valuename,defValue);
+ tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)keyname);
+ tolua_pushcppstring(tolua_S,(const char*)valuename);
+ tolua_pushcppstring(tolua_S,(const char*)defValue);
+ }
+ }
+ return 4;
+tolua_lerror:
+ return tolua_AllToLua_cIniFile_GetValue00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetValue of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValue02
+static int tolua_AllToLua_cIniFile_GetValue02(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const cIniFile* self = (const cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const unsigned keyID = ((const unsigned) tolua_tonumber(tolua_S,2,0));
+ const unsigned valueID = ((const unsigned) tolua_tonumber(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValue'", NULL);
+#endif
+ {
+ std::string tolua_ret = (std::string) self->GetValue(keyID,valueID);
+ tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_cIniFile_GetValue01(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetValue of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValue03
+static int tolua_AllToLua_cIniFile_GetValue03(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const cIniFile* self = (const cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const unsigned keyID = ((const unsigned) tolua_tonumber(tolua_S,2,0));
+ const unsigned valueID = ((const unsigned) tolua_tonumber(tolua_S,3,0));
+ const std::string defValue = ((const std::string) tolua_tocppstring(tolua_S,4,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValue'", NULL);
+#endif
+ {
+ std::string tolua_ret = (std::string) self->GetValue(keyID,valueID,defValue);
+ tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)defValue);
+ }
+ }
+ return 2;
+tolua_lerror:
+ return tolua_AllToLua_cIniFile_GetValue02(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetValueI of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValueI00
+static int tolua_AllToLua_cIniFile_GetValueI00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const cIniFile* self = (const cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string keyname = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+ const std::string valuename = ((const std::string) tolua_tocppstring(tolua_S,3,0));
+ const int defValue = ((const int) tolua_tonumber(tolua_S,4,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValueI'", NULL);
+#endif
+ {
+ int tolua_ret = (int) self->GetValueI(keyname,valuename,defValue);
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)keyname);
+ tolua_pushcppstring(tolua_S,(const char*)valuename);
+ }
+ }
+ return 3;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetValueI'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetValueB of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValueB00
+static int tolua_AllToLua_cIniFile_GetValueB00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
+ !tolua_isboolean(tolua_S,4,1,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const cIniFile* self = (const cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string keyname = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+ const std::string valuename = ((const std::string) tolua_tocppstring(tolua_S,3,0));
+ const bool defValue = ((const bool) tolua_toboolean(tolua_S,4,false));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValueB'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->GetValueB(keyname,valuename,defValue);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)keyname);
+ tolua_pushcppstring(tolua_S,(const char*)valuename);
+ }
+ }
+ return 3;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetValueB'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetValueF of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_GetValueF00
+static int tolua_AllToLua_cIniFile_GetValueF00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const cIniFile* self = (const cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string keyname = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+ const std::string valuename = ((const std::string) tolua_tocppstring(tolua_S,3,0));
+ const double defValue = ((const double) tolua_tonumber(tolua_S,4,0.0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetValueF'", NULL);
+#endif
+ {
+ double tolua_ret = (double) self->GetValueF(keyname,valuename,defValue);
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)keyname);
+ tolua_pushcppstring(tolua_S,(const char*)valuename);
+ }
+ }
+ return 3;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetValueF'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetValue of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_SetValue00
+static int tolua_AllToLua_cIniFile_SetValue00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const unsigned keyID = ((const unsigned) tolua_tonumber(tolua_S,2,0));
+ const unsigned valueID = ((const unsigned) tolua_tonumber(tolua_S,3,0));
+ const std::string value = ((const std::string) tolua_tocppstring(tolua_S,4,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetValue'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->SetValue(keyID,valueID,value);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)value);
+ }
+ }
+ return 2;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetValue'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetValue of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_SetValue01
+static int tolua_AllToLua_cIniFile_SetValue01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
+ !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,6,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string keyname = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+ const std::string valuename = ((const std::string) tolua_tocppstring(tolua_S,3,0));
+ const std::string value = ((const std::string) tolua_tocppstring(tolua_S,4,0));
+ const bool create = ((const bool) tolua_toboolean(tolua_S,5,true));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetValue'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->SetValue(keyname,valuename,value,create);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)keyname);
+ tolua_pushcppstring(tolua_S,(const char*)valuename);
+ tolua_pushcppstring(tolua_S,(const char*)value);
+ }
+ }
+ return 4;
+tolua_lerror:
+ return tolua_AllToLua_cIniFile_SetValue00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetValueI of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_SetValueI00
+static int tolua_AllToLua_cIniFile_SetValueI00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,6,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string keyname = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+ const std::string valuename = ((const std::string) tolua_tocppstring(tolua_S,3,0));
+ const int value = ((const int) tolua_tonumber(tolua_S,4,0));
+ const bool create = ((const bool) tolua_toboolean(tolua_S,5,true));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetValueI'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->SetValueI(keyname,valuename,value,create);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)keyname);
+ tolua_pushcppstring(tolua_S,(const char*)valuename);
+ }
+ }
+ return 3;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetValueI'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetValueB of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_SetValueB00
+static int tolua_AllToLua_cIniFile_SetValueB00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
+ !tolua_isboolean(tolua_S,4,0,&tolua_err) ||
+ !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,6,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string keyname = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+ const std::string valuename = ((const std::string) tolua_tocppstring(tolua_S,3,0));
+ const bool value = ((const bool) tolua_toboolean(tolua_S,4,0));
+ const bool create = ((const bool) tolua_toboolean(tolua_S,5,true));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetValueB'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->SetValueB(keyname,valuename,value,create);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)keyname);
+ tolua_pushcppstring(tolua_S,(const char*)valuename);
+ }
+ }
+ return 3;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetValueB'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetValueF of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_SetValueF00
+static int tolua_AllToLua_cIniFile_SetValueF00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,6,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string keyname = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+ const std::string valuename = ((const std::string) tolua_tocppstring(tolua_S,3,0));
+ const double value = ((const double) tolua_tonumber(tolua_S,4,0));
+ const bool create = ((const bool) tolua_toboolean(tolua_S,5,true));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetValueF'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->SetValueF(keyname,valuename,value,create);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)keyname);
+ tolua_pushcppstring(tolua_S,(const char*)valuename);
+ }
+ }
+ return 3;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetValueF'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: DeleteValue of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_DeleteValue00
+static int tolua_AllToLua_cIniFile_DeleteValue00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string keyname = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+ const std::string valuename = ((const std::string) tolua_tocppstring(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteValue'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->DeleteValue(keyname,valuename);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)keyname);
+ tolua_pushcppstring(tolua_S,(const char*)valuename);
+ }
+ }
+ return 3;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'DeleteValue'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: DeleteKey of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_DeleteKey00
+static int tolua_AllToLua_cIniFile_DeleteKey00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string keyname = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteKey'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->DeleteKey(keyname);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)keyname);
+ }
+ }
+ return 2;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'DeleteKey'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: NumHeaderComments of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_NumHeaderComments00
+static int tolua_AllToLua_cIniFile_NumHeaderComments00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NumHeaderComments'", NULL);
+#endif
+ {
+ unsigned tolua_ret = (unsigned) self->NumHeaderComments();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'NumHeaderComments'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: HeaderComment of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_HeaderComment00
+static int tolua_AllToLua_cIniFile_HeaderComment00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string comment = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HeaderComment'", NULL);
+#endif
+ {
+ self->HeaderComment(comment);
+ tolua_pushcppstring(tolua_S,(const char*)comment);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'HeaderComment'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: HeaderComment of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_HeaderComment01
+static int tolua_AllToLua_cIniFile_HeaderComment01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const cIniFile* self = (const cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const unsigned commentID = ((const unsigned) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HeaderComment'", NULL);
+#endif
+ {
+ std::string tolua_ret = (std::string) self->HeaderComment(commentID);
+ tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_cIniFile_HeaderComment00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: DeleteHeaderComment of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_DeleteHeaderComment00
+static int tolua_AllToLua_cIniFile_DeleteHeaderComment00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+ unsigned commentID = ((unsigned) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteHeaderComment'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->DeleteHeaderComment(commentID);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'DeleteHeaderComment'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: DeleteHeaderComments of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_DeleteHeaderComments00
+static int tolua_AllToLua_cIniFile_DeleteHeaderComments00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteHeaderComments'", NULL);
+#endif
+ {
+ self->DeleteHeaderComments();
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'DeleteHeaderComments'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: NumKeyComments of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_NumKeyComments00
+static int tolua_AllToLua_cIniFile_NumKeyComments00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const cIniFile* self = (const cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const unsigned keyID = ((const unsigned) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NumKeyComments'", NULL);
+#endif
+ {
+ unsigned tolua_ret = (unsigned) self->NumKeyComments(keyID);
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'NumKeyComments'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: NumKeyComments of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_NumKeyComments01
+static int tolua_AllToLua_cIniFile_NumKeyComments01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const cIniFile* self = (const cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string keyname = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NumKeyComments'", NULL);
+#endif
+ {
+ unsigned tolua_ret = (unsigned) self->NumKeyComments(keyname);
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)keyname);
+ }
+ }
+ return 2;
+tolua_lerror:
+ return tolua_AllToLua_cIniFile_NumKeyComments00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: KeyComment of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_KeyComment00
+static int tolua_AllToLua_cIniFile_KeyComment00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const unsigned keyID = ((const unsigned) tolua_tonumber(tolua_S,2,0));
+ const std::string comment = ((const std::string) tolua_tocppstring(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'KeyComment'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->KeyComment(keyID,comment);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)comment);
+ }
+ }
+ return 2;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'KeyComment'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: KeyComment of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_KeyComment01
+static int tolua_AllToLua_cIniFile_KeyComment01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string keyname = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+ const std::string comment = ((const std::string) tolua_tocppstring(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'KeyComment'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->KeyComment(keyname,comment);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)keyname);
+ tolua_pushcppstring(tolua_S,(const char*)comment);
+ }
+ }
+ return 3;
+tolua_lerror:
+ return tolua_AllToLua_cIniFile_KeyComment00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: KeyComment of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_KeyComment02
+static int tolua_AllToLua_cIniFile_KeyComment02(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const cIniFile* self = (const cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const unsigned keyID = ((const unsigned) tolua_tonumber(tolua_S,2,0));
+ const unsigned commentID = ((const unsigned) tolua_tonumber(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'KeyComment'", NULL);
+#endif
+ {
+ std::string tolua_ret = (std::string) self->KeyComment(keyID,commentID);
+ tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_cIniFile_KeyComment01(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: KeyComment of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_KeyComment03
+static int tolua_AllToLua_cIniFile_KeyComment03(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const cIniFile* self = (const cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string keyname = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+ const unsigned commentID = ((const unsigned) tolua_tonumber(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'KeyComment'", NULL);
+#endif
+ {
+ std::string tolua_ret = (std::string) self->KeyComment(keyname,commentID);
+ tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)keyname);
+ }
+ }
+ return 2;
+tolua_lerror:
+ return tolua_AllToLua_cIniFile_KeyComment02(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: DeleteKeyComment of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_DeleteKeyComment00
+static int tolua_AllToLua_cIniFile_DeleteKeyComment00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const unsigned keyID = ((const unsigned) tolua_tonumber(tolua_S,2,0));
+ const unsigned commentID = ((const unsigned) tolua_tonumber(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteKeyComment'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->DeleteKeyComment(keyID,commentID);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'DeleteKeyComment'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: DeleteKeyComment of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_DeleteKeyComment01
+static int tolua_AllToLua_cIniFile_DeleteKeyComment01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string keyname = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+ const unsigned commentID = ((const unsigned) tolua_tonumber(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteKeyComment'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->DeleteKeyComment(keyname,commentID);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)keyname);
+ }
+ }
+ return 2;
+tolua_lerror:
+ return tolua_AllToLua_cIniFile_DeleteKeyComment00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: DeleteKeyComments of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_DeleteKeyComments00
+static int tolua_AllToLua_cIniFile_DeleteKeyComments00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const unsigned keyID = ((const unsigned) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteKeyComments'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->DeleteKeyComments(keyID);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'DeleteKeyComments'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: DeleteKeyComments of class cIniFile */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cIniFile_DeleteKeyComments01
+static int tolua_AllToLua_cIniFile_DeleteKeyComments01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cIniFile",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
+ const std::string keyname = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DeleteKeyComments'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->DeleteKeyComments(keyname);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)keyname);
+ }
+ }
+ return 2;
+tolua_lerror:
+ return tolua_AllToLua_cIniFile_DeleteKeyComments00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: g_BlockLightValue */
+#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockLightValue
+static int tolua_get_AllToLua_g_BlockLightValue(lua_State* tolua_S)
+{
+ int tolua_index;
+#ifndef TOLUA_RELEASE
+ {
+ tolua_Error tolua_err;
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+ }
+#endif
+ tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+#ifndef TOLUA_RELEASE
+ if (tolua_index<0)
+ tolua_error(tolua_S,"array indexing out of range.",NULL);
+#endif
+ tolua_pushnumber(tolua_S,(lua_Number)g_BlockLightValue[tolua_index]);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: g_BlockLightValue */
+#ifndef TOLUA_DISABLE_tolua_set_AllToLua_g_BlockLightValue
+static int tolua_set_AllToLua_g_BlockLightValue(lua_State* tolua_S)
+{
+ int tolua_index;
+#ifndef TOLUA_RELEASE
+ {
+ tolua_Error tolua_err;
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+ }
+#endif
+ tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+#ifndef TOLUA_RELEASE
+ if (tolua_index<0)
+ tolua_error(tolua_S,"array indexing out of range.",NULL);
+#endif
+ g_BlockLightValue[tolua_index] = ((char) tolua_tonumber(tolua_S,3,0));
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: g_BlockSpreadLightFalloff */
+#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockSpreadLightFalloff
+static int tolua_get_AllToLua_g_BlockSpreadLightFalloff(lua_State* tolua_S)
+{
+ int tolua_index;
+#ifndef TOLUA_RELEASE
+ {
+ tolua_Error tolua_err;
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+ }
+#endif
+ tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+#ifndef TOLUA_RELEASE
+ if (tolua_index<0)
+ tolua_error(tolua_S,"array indexing out of range.",NULL);
+#endif
+ tolua_pushnumber(tolua_S,(lua_Number)g_BlockSpreadLightFalloff[tolua_index]);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: g_BlockSpreadLightFalloff */
+#ifndef TOLUA_DISABLE_tolua_set_AllToLua_g_BlockSpreadLightFalloff
+static int tolua_set_AllToLua_g_BlockSpreadLightFalloff(lua_State* tolua_S)
+{
+ int tolua_index;
+#ifndef TOLUA_RELEASE
+ {
+ tolua_Error tolua_err;
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+ }
+#endif
+ tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+#ifndef TOLUA_RELEASE
+ if (tolua_index<0)
+ tolua_error(tolua_S,"array indexing out of range.",NULL);
+#endif
+ g_BlockSpreadLightFalloff[tolua_index] = ((char) tolua_tonumber(tolua_S,3,0));
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: g_BlockTransparent */
+#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockTransparent
+static int tolua_get_AllToLua_g_BlockTransparent(lua_State* tolua_S)
+{
+ int tolua_index;
+#ifndef TOLUA_RELEASE
+ {
+ tolua_Error tolua_err;
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+ }
+#endif
+ tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+#ifndef TOLUA_RELEASE
+ if (tolua_index<0)
+ tolua_error(tolua_S,"array indexing out of range.",NULL);
+#endif
+ tolua_pushboolean(tolua_S,(bool)g_BlockTransparent[tolua_index]);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: g_BlockTransparent */
+#ifndef TOLUA_DISABLE_tolua_set_AllToLua_g_BlockTransparent
+static int tolua_set_AllToLua_g_BlockTransparent(lua_State* tolua_S)
+{
+ int tolua_index;
+#ifndef TOLUA_RELEASE
+ {
+ tolua_Error tolua_err;
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+ }
+#endif
+ tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+#ifndef TOLUA_RELEASE
+ if (tolua_index<0)
+ tolua_error(tolua_S,"array indexing out of range.",NULL);
+#endif
+ g_BlockTransparent[tolua_index] = ((bool) tolua_toboolean(tolua_S,3,0));
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: g_BlockOneHitDig */
+#ifndef TOLUA_DISABLE_tolua_get_AllToLua_g_BlockOneHitDig
+static int tolua_get_AllToLua_g_BlockOneHitDig(lua_State* tolua_S)
+{
+ int tolua_index;
+#ifndef TOLUA_RELEASE
+ {
+ tolua_Error tolua_err;
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+ }
+#endif
+ tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+#ifndef TOLUA_RELEASE
+ if (tolua_index<0)
+ tolua_error(tolua_S,"array indexing out of range.",NULL);
+#endif
+ tolua_pushboolean(tolua_S,(bool)g_BlockOneHitDig[tolua_index]);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: g_BlockOneHitDig */
+#ifndef TOLUA_DISABLE_tolua_set_AllToLua_g_BlockOneHitDig
+static int tolua_set_AllToLua_g_BlockOneHitDig(lua_State* tolua_S)
+{
+ int tolua_index;
+#ifndef TOLUA_RELEASE
+ {
+ tolua_Error tolua_err;
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in array indexing.",&tolua_err);
+ }
+#endif
+ tolua_index = (int)tolua_tonumber(tolua_S,2,0);
+#ifndef TOLUA_RELEASE
+ if (tolua_index<0)
+ tolua_error(tolua_S,"array indexing out of range.",NULL);
+#endif
+ g_BlockOneHitDig[tolua_index] = ((bool) tolua_toboolean(tolua_S,3,0));
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* function: IsValidBlock */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_IsValidBlock00
+static int tolua_AllToLua_IsValidBlock00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ int a_BlockID = ((int) tolua_tonumber(tolua_S,1,0));
+ {
+ bool tolua_ret = (bool) IsValidBlock(a_BlockID);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'IsValidBlock'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* function: isValidItem */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_isValidItem00
+static int tolua_AllToLua_isValidItem00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ int a_ItemID = ((int) tolua_tonumber(tolua_S,1,0));
+ {
+ bool tolua_ret = (bool) isValidItem(a_ItemID);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'isValidItem'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* function: AddDirection */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_AddDirection00
+static int tolua_AllToLua_AddDirection00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isnumber(tolua_S,1,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ !tolua_isboolean(tolua_S,5,1,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,6,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ int a_X = ((int) tolua_tonumber(tolua_S,1,0));
+ char a_Y = ((char) tolua_tonumber(tolua_S,2,0));
+ int a_Z = ((int) tolua_tonumber(tolua_S,3,0));
+ char a_Direction = ((char) tolua_tonumber(tolua_S,4,0));
+ bool a_bInverse = ((bool) tolua_toboolean(tolua_S,5,false));
+ {
+ AddDirection(a_X,a_Y,a_Z,a_Direction,a_bInverse);
+ tolua_pushnumber(tolua_S,(lua_Number)a_X);
+ tolua_pushnumber(tolua_S,(lua_Number)a_Y);
+ tolua_pushnumber(tolua_S,(lua_Number)a_Z);
+ }
+ }
+ return 3;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'AddDirection'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* function: GetTime */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_GetTime00
+static int tolua_AllToLua_GetTime00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isnoobj(tolua_S,1,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ {
+ unsigned int tolua_ret = (unsigned int) GetTime();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetTime'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* function: GetChar */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_GetChar00
+static int tolua_AllToLua_GetChar00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_iscppstring(tolua_S,1,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ std::string a_Str = ((std::string) tolua_tocppstring(tolua_S,1,0));
+ unsigned int a_Idx = ((unsigned int) tolua_tonumber(tolua_S,2,0));
+ {
+ std::string tolua_ret = (std::string) GetChar(a_Str,a_Idx);
+ tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)a_Str);
+ }
+ }
+ return 2;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetChar'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: clear of class cStringMap */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cStringMap_clear00
+static int tolua_AllToLua_cStringMap_clear00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cStringMap",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cStringMap* self = (cStringMap*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'clear'", NULL);
+#endif
+ {
+ self->clear();
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'clear'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: size of class cStringMap */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cStringMap_size00
+static int tolua_AllToLua_cStringMap_size00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cStringMap",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const cStringMap* self = (const cStringMap*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'size'", NULL);
+#endif
+ {
+ unsigned int tolua_ret = (unsigned 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
+
+/* method: get of class cStringMap */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cStringMap_get00
+static int tolua_AllToLua_cStringMap_get00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cStringMap",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cStringMap* self = (cStringMap*) tolua_tousertype(tolua_S,1,0);
+ const std::string index = ((const std::string) tolua_tocppstring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'get'", NULL);
+#endif
+ {
+ std::string tolua_ret = (std::string) self->get(index);
+ tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
+ tolua_pushcppstring(tolua_S,(const char*)index);
+ }
+ }
+ return 2;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'get'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: Color of class cChatColor */
+#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Color
+static int tolua_get_cChatColor_Color(lua_State* tolua_S)
+{
+ tolua_pushcppstring(tolua_S,(const char*)cChatColor::Color);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: Black of class cChatColor */
+#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Black
+static int tolua_get_cChatColor_Black(lua_State* tolua_S)
+{
+ tolua_pushcppstring(tolua_S,(const char*)cChatColor::Black);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: Navy of class cChatColor */
+#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Navy
+static int tolua_get_cChatColor_Navy(lua_State* tolua_S)
+{
+ tolua_pushcppstring(tolua_S,(const char*)cChatColor::Navy);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: Green of class cChatColor */
+#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Green
+static int tolua_get_cChatColor_Green(lua_State* tolua_S)
+{
+ tolua_pushcppstring(tolua_S,(const char*)cChatColor::Green);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: Blue of class cChatColor */
+#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Blue
+static int tolua_get_cChatColor_Blue(lua_State* tolua_S)
+{
+ tolua_pushcppstring(tolua_S,(const char*)cChatColor::Blue);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: Red of class cChatColor */
+#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Red
+static int tolua_get_cChatColor_Red(lua_State* tolua_S)
+{
+ tolua_pushcppstring(tolua_S,(const char*)cChatColor::Red);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: Purple of class cChatColor */
+#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Purple
+static int tolua_get_cChatColor_Purple(lua_State* tolua_S)
+{
+ tolua_pushcppstring(tolua_S,(const char*)cChatColor::Purple);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: Gold of class cChatColor */
+#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Gold
+static int tolua_get_cChatColor_Gold(lua_State* tolua_S)
+{
+ tolua_pushcppstring(tolua_S,(const char*)cChatColor::Gold);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: LightGray of class cChatColor */
+#ifndef TOLUA_DISABLE_tolua_get_cChatColor_LightGray
+static int tolua_get_cChatColor_LightGray(lua_State* tolua_S)
+{
+ tolua_pushcppstring(tolua_S,(const char*)cChatColor::LightGray);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: Gray of class cChatColor */
+#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Gray
+static int tolua_get_cChatColor_Gray(lua_State* tolua_S)
+{
+ tolua_pushcppstring(tolua_S,(const char*)cChatColor::Gray);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: DarkPurple of class cChatColor */
+#ifndef TOLUA_DISABLE_tolua_get_cChatColor_DarkPurple
+static int tolua_get_cChatColor_DarkPurple(lua_State* tolua_S)
+{
+ tolua_pushcppstring(tolua_S,(const char*)cChatColor::DarkPurple);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: LightGreen of class cChatColor */
+#ifndef TOLUA_DISABLE_tolua_get_cChatColor_LightGreen
+static int tolua_get_cChatColor_LightGreen(lua_State* tolua_S)
+{
+ tolua_pushcppstring(tolua_S,(const char*)cChatColor::LightGreen);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: LightBlue of class cChatColor */
+#ifndef TOLUA_DISABLE_tolua_get_cChatColor_LightBlue
+static int tolua_get_cChatColor_LightBlue(lua_State* tolua_S)
+{
+ tolua_pushcppstring(tolua_S,(const char*)cChatColor::LightBlue);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: Rose of class cChatColor */
+#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Rose
+static int tolua_get_cChatColor_Rose(lua_State* tolua_S)
+{
+ tolua_pushcppstring(tolua_S,(const char*)cChatColor::Rose);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: LightPurple of class cChatColor */
+#ifndef TOLUA_DISABLE_tolua_get_cChatColor_LightPurple
+static int tolua_get_cChatColor_LightPurple(lua_State* tolua_S)
+{
+ tolua_pushcppstring(tolua_S,(const char*)cChatColor::LightPurple);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: Yellow of class cChatColor */
+#ifndef TOLUA_DISABLE_tolua_get_cChatColor_Yellow
+static int tolua_get_cChatColor_Yellow(lua_State* tolua_S)
+{
+ tolua_pushcppstring(tolua_S,(const char*)cChatColor::Yellow);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: White of class cChatColor */
+#ifndef TOLUA_DISABLE_tolua_get_cChatColor_White
+static int tolua_get_cChatColor_White(lua_State* tolua_S)
+{
+ tolua_pushcppstring(tolua_S,(const char*)cChatColor::White);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: MakeColor of class cChatColor */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cChatColor_MakeColor00
+static int tolua_AllToLua_cChatColor_MakeColor00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cChatColor",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ char a_Color = ((char) tolua_tonumber(tolua_S,2,0));
+ {
+ const std::string tolua_ret = (const std::string) cChatColor::MakeColor(a_Color);
+ tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'MakeColor'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetPlayer of class cClientHandle */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_GetPlayer00
+static int tolua_AllToLua_cClientHandle_GetPlayer00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cClientHandle* self = (cClientHandle*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPlayer'", NULL);
+#endif
+ {
+ cPlayer* tolua_ret = (cPlayer*) self->GetPlayer();
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cPlayer");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetPlayer'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Kick of class cClientHandle */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cClientHandle_Kick00
+static int tolua_AllToLua_cClientHandle_Kick00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cClientHandle",0,&tolua_err) ||
+ !tolua_isstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cClientHandle* self = (cClientHandle*) tolua_tousertype(tolua_S,1,0);
+ const char* a_Reason = ((const char*) tolua_tostring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Kick'", NULL);
+#endif
+ {
+ self->Kick(a_Reason);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Kick'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: delete of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_delete00
+static int tolua_AllToLua_cEntity_delete00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
+#endif
+ Mtolua_delete(self);
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Initialize of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_Initialize00
+static int tolua_AllToLua_cEntity_Initialize00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Initialize'", NULL);
+#endif
+ {
+ self->Initialize();
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Initialize'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetEntityType of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetEntityType00
+static int tolua_AllToLua_cEntity_GetEntityType00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEntityType'", NULL);
+#endif
+ {
+ unsigned int tolua_ret = (unsigned int) self->GetEntityType();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetEntityType'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: IsA of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsA00
+static int tolua_AllToLua_cEntity_IsA00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+ const char* a_EntityType = ((const char*) tolua_tostring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsA'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->IsA(a_EntityType);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'IsA'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetClass of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetClass00
+static int tolua_AllToLua_cEntity_GetClass00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetClass'", NULL);
+#endif
+ {
+ const char* tolua_ret = (const char*) self->GetClass();
+ tolua_pushstring(tolua_S,(const char*)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetClass'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetPosition of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetPosition00
+static int tolua_AllToLua_cEntity_GetPosition00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPosition'", NULL);
+#endif
+ {
+ const Vector3d& tolua_ret = (const Vector3d&) self->GetPosition();
+ tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Vector3d");
+ }
+ }
+ 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: GetPosX of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetPosX00
+static int tolua_AllToLua_cEntity_GetPosX00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPosX'", NULL);
+#endif
+ {
+ const double tolua_ret = (const double) self->GetPosX();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetPosX'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetPosY of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetPosY00
+static int tolua_AllToLua_cEntity_GetPosY00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPosY'", NULL);
+#endif
+ {
+ const double tolua_ret = (const double) self->GetPosY();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetPosY'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetPosZ of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetPosZ00
+static int tolua_AllToLua_cEntity_GetPosZ00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPosZ'", NULL);
+#endif
+ {
+ const double tolua_ret = (const double) self->GetPosZ();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetPosZ'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetRot of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetRot00
+static int tolua_AllToLua_cEntity_GetRot00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetRot'", NULL);
+#endif
+ {
+ const Vector3f& tolua_ret = (const Vector3f&) self->GetRot();
+ tolua_pushusertype(tolua_S,(void*)&tolua_ret,"const Vector3f");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetRot'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetRotation of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetRotation00
+static int tolua_AllToLua_cEntity_GetRotation00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetRotation'", NULL);
+#endif
+ {
+ float tolua_ret = (float) self->GetRotation();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetRotation'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetPitch of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetPitch00
+static int tolua_AllToLua_cEntity_GetPitch00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPitch'", NULL);
+#endif
+ {
+ float tolua_ret = (float) self->GetPitch();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetPitch'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetRoll of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetRoll00
+static int tolua_AllToLua_cEntity_GetRoll00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetRoll'", NULL);
+#endif
+ {
+ float tolua_ret = (float) self->GetRoll();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetRoll'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetLookVector of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetLookVector00
+static int tolua_AllToLua_cEntity_GetLookVector00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetLookVector'", NULL);
+#endif
+ {
+ Vector3f tolua_ret = (Vector3f) self->GetLookVector();
+ {
+#ifdef __cplusplus
+ void* tolua_obj = Mtolua_new((Vector3f)(tolua_ret));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3f");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#else
+ void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3f));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3f");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#endif
+ }
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetLookVector'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetPosX of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetPosX00
+static int tolua_AllToLua_cEntity_SetPosX00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+ const double a_PosX = ((const double) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetPosX'", NULL);
+#endif
+ {
+ self->SetPosX(a_PosX);
+ tolua_pushnumber(tolua_S,(lua_Number)a_PosX);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetPosX'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetPosY of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetPosY00
+static int tolua_AllToLua_cEntity_SetPosY00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+ const double a_PosY = ((const double) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetPosY'", NULL);
+#endif
+ {
+ self->SetPosY(a_PosY);
+ tolua_pushnumber(tolua_S,(lua_Number)a_PosY);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetPosY'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetPosZ of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetPosZ00
+static int tolua_AllToLua_cEntity_SetPosZ00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+ const double a_PosZ = ((const double) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetPosZ'", NULL);
+#endif
+ {
+ self->SetPosZ(a_PosZ);
+ tolua_pushnumber(tolua_S,(lua_Number)a_PosZ);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetPosZ'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetPosition of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetPosition00
+static int tolua_AllToLua_cEntity_SetPosition00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+ const double a_PosX = ((const double) tolua_tonumber(tolua_S,2,0));
+ const double a_PosY = ((const double) tolua_tonumber(tolua_S,3,0));
+ const double a_PosZ = ((const double) tolua_tonumber(tolua_S,4,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetPosition'", NULL);
+#endif
+ {
+ self->SetPosition(a_PosX,a_PosY,a_PosZ);
+ tolua_pushnumber(tolua_S,(lua_Number)a_PosX);
+ tolua_pushnumber(tolua_S,(lua_Number)a_PosY);
+ tolua_pushnumber(tolua_S,(lua_Number)a_PosZ);
+ }
+ }
+ return 3;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetPosition'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetPosition of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetPosition01
+static int tolua_AllToLua_cEntity_SetPosition01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3d",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+ const Vector3d* a_Pos = ((const Vector3d*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetPosition'", NULL);
+#endif
+ {
+ self->SetPosition(*a_Pos);
+ }
+ }
+ return 0;
+tolua_lerror:
+ return tolua_AllToLua_cEntity_SetPosition00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetRot of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetRot00
+static int tolua_AllToLua_cEntity_SetRot00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3f",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+ const Vector3f* a_Rot = ((const Vector3f*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetRot'", NULL);
+#endif
+ {
+ self->SetRot(*a_Rot);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetRot'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetRotation of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetRotation00
+static int tolua_AllToLua_cEntity_SetRotation00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+ float a_Rotation = ((float) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetRotation'", NULL);
+#endif
+ {
+ self->SetRotation(a_Rotation);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetRotation'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetPitch of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetPitch00
+static int tolua_AllToLua_cEntity_SetPitch00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+ float a_Pitch = ((float) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetPitch'", NULL);
+#endif
+ {
+ self->SetPitch(a_Pitch);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetPitch'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetRoll of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SetRoll00
+static int tolua_AllToLua_cEntity_SetRoll00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+ float a_Roll = ((float) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetRoll'", NULL);
+#endif
+ {
+ self->SetRoll(a_Roll);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetRoll'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetUniqueID of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_GetUniqueID00
+static int tolua_AllToLua_cEntity_GetUniqueID00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetUniqueID'", NULL);
+#endif
+ {
+ int tolua_ret = (int) self->GetUniqueID();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetUniqueID'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: IsDestroyed of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_IsDestroyed00
+static int tolua_AllToLua_cEntity_IsDestroyed00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsDestroyed'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->IsDestroyed();
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'IsDestroyed'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Destroy of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_Destroy00
+static int tolua_AllToLua_cEntity_Destroy00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Destroy'", NULL);
+#endif
+ {
+ self->Destroy();
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Destroy'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Tick of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_Tick00
+static int tolua_AllToLua_cEntity_Tick00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+ float a_Dt = ((float) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Tick'", NULL);
+#endif
+ {
+ self->Tick(a_Dt);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Tick'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SpawnOn of class cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cEntity_SpawnOn00
+static int tolua_AllToLua_cEntity_SpawnOn00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cEntity",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cClientHandle",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cEntity* self = (cEntity*) tolua_tousertype(tolua_S,1,0);
+ cClientHandle* a_Target = ((cClientHandle*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SpawnOn'", NULL);
+#endif
+ {
+ self->SpawnOn(a_Target);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SpawnOn'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+ class Lua__cEntity : public cEntity, public ToluaBase {
+public:
+ void Initialize( void ) {
+ if (push_method("Initialize", tolua_AllToLua_cEntity_Initialize00)) {
+ ToluaBase::dbcall(lua_state, 1, 0);
+ } else {
+ return ( void ) cEntity:: Initialize();
+ };
+ };
+ unsigned int GetEntityType( void ) {
+ if (push_method("GetEntityType", tolua_AllToLua_cEntity_GetEntityType00)) {
+ ToluaBase::dbcall(lua_state, 1, 1);
+ unsigned int tolua_ret = (unsigned int )tolua_tonumber(lua_state, -1, 0);
+ lua_pop(lua_state, 1);
+ return tolua_ret;
+ } else {
+ return (unsigned int ) cEntity:: GetEntityType();
+ };
+ };
+ bool IsA( const char* a_EntityType) {
+ if (push_method("IsA", tolua_AllToLua_cEntity_IsA00)) {
+ tolua_pushstring(lua_state, (const char*)a_EntityType);
+ ToluaBase::dbcall(lua_state, 2, 1);
+ bool tolua_ret = ( bool )tolua_toboolean(lua_state, -1, 0);
+ lua_pop(lua_state, 1);
+ return tolua_ret;
+ } else {
+ return ( bool ) cEntity:: IsA(a_EntityType);
+ };
+ };
+ const char* GetClass( void ) {
+ if (push_method("GetClass", tolua_AllToLua_cEntity_GetClass00)) {
+ ToluaBase::dbcall(lua_state, 1, 1);
+ const char* tolua_ret = ( const char* )tolua_tostring(lua_state, -1, 0);
+ lua_pop(lua_state, 1);
+ return tolua_ret;
+ } else {
+ return ( const char* ) cEntity:: GetClass();
+ };
+ };
+ void Tick( float a_Dt) {
+ if (push_method("Tick", tolua_AllToLua_cEntity_Tick00)) {
+ tolua_pushnumber(lua_state, (lua_Number)a_Dt);
+ ToluaBase::dbcall(lua_state, 2, 0);
+ } else {
+ if (lua_state)
+ LOG("pure-virtual method cEntity::Tick not implemented.");
+ else {
+ LOG("pure-virtual method cEntity::Tick called with no lua_state. Aborting");
+ ::abort();
+ };
+ return ( void )0;
+ };
+ };
+ void SpawnOn( cClientHandle* a_Target) {
+ if (push_method("SpawnOn", tolua_AllToLua_cEntity_SpawnOn00)) {
+ tolua_pushusertype(lua_state, (void*)a_Target, "cClientHandle");
+ ToluaBase::dbcall(lua_state, 2, 0);
+ } else {
+ if (lua_state)
+ LOG("pure-virtual method cEntity::SpawnOn not implemented.");
+ else {
+ LOG("pure-virtual method cEntity::SpawnOn called with no lua_state. Aborting");
+ ::abort();
+ };
+ return ( void )0;
+ };
+ };
+
+ void cEntity__Initialize( void ) {
+ return ( void )cEntity::Initialize();
+ };
+ unsigned int cEntity__GetEntityType( void ) {
+ return (unsigned int )cEntity::GetEntityType();
+ };
+ bool cEntity__IsA( const char* a_EntityType) {
+ return ( bool )cEntity::IsA(a_EntityType);
+ };
+ const char* cEntity__GetClass( void ) {
+ return ( const char* )cEntity::GetClass();
+ };
+ Lua__cEntity( const double& a_X, const double& a_Y, const double& a_Z): cEntity(a_X,a_Y,a_Z){};
+};
+
+/* method: tolua__set_instance of class Lua__cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cEntity_tolua__set_instance00
+static int tolua_AllToLua_Lua__cEntity_tolua__set_instance00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cEntity* self = (Lua__cEntity*) tolua_tousertype(tolua_S,1,0);
+ lua_State* L = tolua_S;
+ lua_Object lo = ((lua_Object) tolua_tovalue(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'tolua__set_instance'", NULL);
+#endif
+ {
+ self->tolua__set_instance(L,lo);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'tolua__set_instance'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cEntity__Initialize of class Lua__cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cEntity_cEntity__Initialize00
+static int tolua_AllToLua_Lua__cEntity_cEntity__Initialize00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cEntity* self = (Lua__cEntity*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cEntity__Initialize'", NULL);
+#endif
+ {
+ self->cEntity__Initialize();
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'cEntity__Initialize'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cEntity__GetEntityType of class Lua__cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cEntity_cEntity__GetEntityType00
+static int tolua_AllToLua_Lua__cEntity_cEntity__GetEntityType00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cEntity* self = (Lua__cEntity*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cEntity__GetEntityType'", NULL);
+#endif
+ {
+ unsigned int tolua_ret = (unsigned int) self->cEntity__GetEntityType();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'cEntity__GetEntityType'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cEntity__IsA of class Lua__cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cEntity_cEntity__IsA00
+static int tolua_AllToLua_Lua__cEntity_cEntity__IsA00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cEntity",0,&tolua_err) ||
+ !tolua_isstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cEntity* self = (Lua__cEntity*) tolua_tousertype(tolua_S,1,0);
+ const char* a_EntityType = ((const char*) tolua_tostring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cEntity__IsA'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->cEntity__IsA(a_EntityType);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'cEntity__IsA'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cEntity__GetClass of class Lua__cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cEntity_cEntity__GetClass00
+static int tolua_AllToLua_Lua__cEntity_cEntity__GetClass00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cEntity* self = (Lua__cEntity*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cEntity__GetClass'", NULL);
+#endif
+ {
+ const char* tolua_ret = (const char*) self->cEntity__GetClass();
+ tolua_pushstring(tolua_S,(const char*)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'cEntity__GetClass'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class Lua__cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cEntity_new00
+static int tolua_AllToLua_Lua__cEntity_new00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Lua__cEntity",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const double a_X = ((const double) tolua_tonumber(tolua_S,2,0));
+ const double a_Y = ((const double) tolua_tonumber(tolua_S,3,0));
+ const double a_Z = ((const double) tolua_tonumber(tolua_S,4,0));
+ {
+ Lua__cEntity* tolua_ret = (Lua__cEntity*) Mtolua_new((Lua__cEntity)(a_X,a_Y,a_Z));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Lua__cEntity");
+ tolua_pushnumber(tolua_S,(lua_Number)a_X);
+ tolua_pushnumber(tolua_S,(lua_Number)a_Y);
+ tolua_pushnumber(tolua_S,(lua_Number)a_Z);
+ }
+ }
+ return 4;
+#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 Lua__cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cEntity_new00_local
+static int tolua_AllToLua_Lua__cEntity_new00_local(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Lua__cEntity",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const double a_X = ((const double) tolua_tonumber(tolua_S,2,0));
+ const double a_Y = ((const double) tolua_tonumber(tolua_S,3,0));
+ const double a_Z = ((const double) tolua_tonumber(tolua_S,4,0));
+ {
+ Lua__cEntity* tolua_ret = (Lua__cEntity*) Mtolua_new((Lua__cEntity)(a_X,a_Y,a_Z));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Lua__cEntity");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ tolua_pushnumber(tolua_S,(lua_Number)a_X);
+ tolua_pushnumber(tolua_S,(lua_Number)a_Y);
+ tolua_pushnumber(tolua_S,(lua_Number)a_Z);
+ }
+ }
+ return 4;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: delete of class Lua__cEntity */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cEntity_delete00
+static int tolua_AllToLua_Lua__cEntity_delete00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cEntity* self = (Lua__cEntity*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
+#endif
+ Mtolua_delete(self);
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+/* function to release collected object via destructor */
+#ifdef __cplusplus
+
+static int tolua_collect_Lua__cEntity (lua_State* tolua_S)
+{
+ Lua__cEntity* self = (Lua__cEntity*) tolua_tousertype(tolua_S,1,0);
+ delete self;
+ return 0;
+}
+#endif
+
+/* get function: Damage of class TakeDamageInfo */
+#ifndef TOLUA_DISABLE_tolua_get_TakeDamageInfo_Damage
+static int tolua_get_TakeDamageInfo_Damage(lua_State* tolua_S)
+{
+ TakeDamageInfo* self = (TakeDamageInfo*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Damage'",NULL);
+#endif
+ tolua_pushnumber(tolua_S,(lua_Number)self->Damage);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: Damage of class TakeDamageInfo */
+#ifndef TOLUA_DISABLE_tolua_set_TakeDamageInfo_Damage
+static int tolua_set_TakeDamageInfo_Damage(lua_State* tolua_S)
+{
+ TakeDamageInfo* self = (TakeDamageInfo*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Damage'",NULL);
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->Damage = ((int) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: Instigator of class TakeDamageInfo */
+#ifndef TOLUA_DISABLE_tolua_get_TakeDamageInfo_Instigator_ptr
+static int tolua_get_TakeDamageInfo_Instigator_ptr(lua_State* tolua_S)
+{
+ TakeDamageInfo* self = (TakeDamageInfo*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Instigator'",NULL);
+#endif
+ tolua_pushusertype(tolua_S,(void*)self->Instigator,"cEntity");
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: Instigator of class TakeDamageInfo */
+#ifndef TOLUA_DISABLE_tolua_set_TakeDamageInfo_Instigator_ptr
+static int tolua_set_TakeDamageInfo_Instigator_ptr(lua_State* tolua_S)
+{
+ TakeDamageInfo* self = (TakeDamageInfo*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Instigator'",NULL);
+ if (!tolua_isusertype(tolua_S,2,"cEntity",0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->Instigator = ((cEntity*) tolua_tousertype(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: TeleportTo of class cPawn */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPawn_TeleportTo00
+static int tolua_AllToLua_cPawn_TeleportTo00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPawn",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPawn* self = (cPawn*) tolua_tousertype(tolua_S,1,0);
+ cEntity* a_Entity = ((cEntity*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'TeleportTo'", NULL);
+#endif
+ {
+ self->TeleportTo(a_Entity);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'TeleportTo'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: TeleportTo of class cPawn */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPawn_TeleportTo01
+static int tolua_AllToLua_cPawn_TeleportTo01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPawn",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ cPawn* self = (cPawn*) tolua_tousertype(tolua_S,1,0);
+ const double a_PosX = ((const double) tolua_tonumber(tolua_S,2,0));
+ const double a_PosY = ((const double) tolua_tonumber(tolua_S,3,0));
+ const double a_PosZ = ((const double) tolua_tonumber(tolua_S,4,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'TeleportTo'", NULL);
+#endif
+ {
+ self->TeleportTo(a_PosX,a_PosY,a_PosZ);
+ tolua_pushnumber(tolua_S,(lua_Number)a_PosX);
+ tolua_pushnumber(tolua_S,(lua_Number)a_PosY);
+ tolua_pushnumber(tolua_S,(lua_Number)a_PosZ);
+ }
+ }
+ return 3;
+tolua_lerror:
+ return tolua_AllToLua_cPawn_TeleportTo00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Heal of class cPawn */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPawn_Heal00
+static int tolua_AllToLua_cPawn_Heal00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPawn",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPawn* self = (cPawn*) tolua_tousertype(tolua_S,1,0);
+ int a_Health = ((int) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Heal'", NULL);
+#endif
+ {
+ self->Heal(a_Health);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Heal'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: TakeDamage of class cPawn */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPawn_TakeDamage00
+static int tolua_AllToLua_cPawn_TakeDamage00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPawn",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,3,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPawn* self = (cPawn*) tolua_tousertype(tolua_S,1,0);
+ int a_Damage = ((int) tolua_tonumber(tolua_S,2,0));
+ cEntity* a_Instigator = ((cEntity*) tolua_tousertype(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'TakeDamage'", NULL);
+#endif
+ {
+ self->TakeDamage(a_Damage,a_Instigator);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'TakeDamage'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: KilledBy of class cPawn */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPawn_KilledBy00
+static int tolua_AllToLua_cPawn_KilledBy00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPawn",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPawn* self = (cPawn*) tolua_tousertype(tolua_S,1,0);
+ cEntity* a_Killer = ((cEntity*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'KilledBy'", NULL);
+#endif
+ {
+ self->KilledBy(a_Killer);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'KilledBy'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetHealth of class cPawn */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPawn_GetHealth00
+static int tolua_AllToLua_cPawn_GetHealth00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPawn",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPawn* self = (cPawn*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetHealth'", NULL);
+#endif
+ {
+ int tolua_ret = (int) self->GetHealth();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetHealth'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+ class Lua__cPawn : public cPawn, public ToluaBase {
+public:
+ void TeleportTo( cEntity* a_Entity) {
+ if (push_method("TeleportTo", tolua_AllToLua_cPawn_TeleportTo00)) {
+ tolua_pushusertype(lua_state, (void*)a_Entity, "cEntity");
+ ToluaBase::dbcall(lua_state, 2, 0);
+ } else {
+ return ( void ) cPawn:: TeleportTo(a_Entity);
+ };
+ };
+ void TeleportTo( const double& a_PosX, const double& a_PosY, const double& a_PosZ) {
+ if (push_method("TeleportTo", tolua_AllToLua_cPawn_TeleportTo01)) {
+ tolua_pushnumber(lua_state, (lua_Number)a_PosX);
+ tolua_pushnumber(lua_state, (lua_Number)a_PosY);
+ tolua_pushnumber(lua_state, (lua_Number)a_PosZ);
+ ToluaBase::dbcall(lua_state, 4, 0);
+ } else {
+ return ( void ) cPawn:: TeleportTo(a_PosX,a_PosY,a_PosZ);
+ };
+ };
+ void TakeDamage( int a_Damage, cEntity* a_Instigator) {
+ if (push_method("TakeDamage", tolua_AllToLua_cPawn_TakeDamage00)) {
+ tolua_pushnumber(lua_state, (lua_Number)a_Damage);
+ tolua_pushusertype(lua_state, (void*)a_Instigator, "cEntity");
+ ToluaBase::dbcall(lua_state, 3, 0);
+ } else {
+ return ( void ) cPawn:: TakeDamage(a_Damage,a_Instigator);
+ };
+ };
+ void KilledBy( cEntity* a_Killer) {
+ if (push_method("KilledBy", tolua_AllToLua_cPawn_KilledBy00)) {
+ tolua_pushusertype(lua_state, (void*)a_Killer, "cEntity");
+ ToluaBase::dbcall(lua_state, 2, 0);
+ } else {
+ return ( void ) cPawn:: KilledBy(a_Killer);
+ };
+ };
+ void Initialize( void ) {
+ if (push_method("Initialize", tolua_AllToLua_cEntity_Initialize00)) {
+ ToluaBase::dbcall(lua_state, 1, 0);
+ } else {
+ return ( void ) cPawn:: Initialize();
+ };
+ };
+ unsigned int GetEntityType( void ) {
+ if (push_method("GetEntityType", tolua_AllToLua_cEntity_GetEntityType00)) {
+ ToluaBase::dbcall(lua_state, 1, 1);
+ unsigned int tolua_ret = (unsigned int )tolua_tonumber(lua_state, -1, 0);
+ lua_pop(lua_state, 1);
+ return tolua_ret;
+ } else {
+ return (unsigned int ) cPawn:: GetEntityType();
+ };
+ };
+ bool IsA( const char* a_EntityType) {
+ if (push_method("IsA", tolua_AllToLua_cEntity_IsA00)) {
+ tolua_pushstring(lua_state, (const char*)a_EntityType);
+ ToluaBase::dbcall(lua_state, 2, 1);
+ bool tolua_ret = ( bool )tolua_toboolean(lua_state, -1, 0);
+ lua_pop(lua_state, 1);
+ return tolua_ret;
+ } else {
+ return ( bool ) cPawn:: IsA(a_EntityType);
+ };
+ };
+ const char* GetClass( void ) {
+ if (push_method("GetClass", tolua_AllToLua_cEntity_GetClass00)) {
+ ToluaBase::dbcall(lua_state, 1, 1);
+ const char* tolua_ret = ( const char* )tolua_tostring(lua_state, -1, 0);
+ lua_pop(lua_state, 1);
+ return tolua_ret;
+ } else {
+ return ( const char* ) cPawn:: GetClass();
+ };
+ };
+ void Tick( float a_Dt) {
+ if (push_method("Tick", tolua_AllToLua_cEntity_Tick00)) {
+ tolua_pushnumber(lua_state, (lua_Number)a_Dt);
+ ToluaBase::dbcall(lua_state, 2, 0);
+ } else {
+ if (lua_state)
+ LOG("pure-virtual method cPawn::Tick not implemented.");
+ else {
+ LOG("pure-virtual method cPawn::Tick called with no lua_state. Aborting");
+ ::abort();
+ };
+ return ( void )0;
+ };
+ };
+ void SpawnOn( cClientHandle* a_Target) {
+ if (push_method("SpawnOn", tolua_AllToLua_cEntity_SpawnOn00)) {
+ tolua_pushusertype(lua_state, (void*)a_Target, "cClientHandle");
+ ToluaBase::dbcall(lua_state, 2, 0);
+ } else {
+ if (lua_state)
+ LOG("pure-virtual method cPawn::SpawnOn not implemented.");
+ else {
+ LOG("pure-virtual method cPawn::SpawnOn called with no lua_state. Aborting");
+ ::abort();
+ };
+ return ( void )0;
+ };
+ };
+
+ void cPawn__TeleportTo( cEntity* a_Entity) {
+ return ( void )cPawn::TeleportTo(a_Entity);
+ };
+ void cPawn__TeleportTo( const double& a_PosX, const double& a_PosY, const double& a_PosZ) {
+ return ( void )cPawn::TeleportTo(a_PosX,a_PosY,a_PosZ);
+ };
+ void cPawn__TakeDamage( int a_Damage, cEntity* a_Instigator) {
+ return ( void )cPawn::TakeDamage(a_Damage,a_Instigator);
+ };
+ void cPawn__KilledBy( cEntity* a_Killer) {
+ return ( void )cPawn::KilledBy(a_Killer);
+ };
+ void cPawn__Initialize( void ) {
+ return ( void )cPawn::Initialize();
+ };
+ unsigned int cPawn__GetEntityType( void ) {
+ return (unsigned int )cPawn::GetEntityType();
+ };
+ bool cPawn__IsA( const char* a_EntityType) {
+ return ( bool )cPawn::IsA(a_EntityType);
+ };
+ const char* cPawn__GetClass( void ) {
+ return ( const char* )cPawn::GetClass();
+ };
+};
+
+/* method: tolua__set_instance of class Lua__cPawn */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPawn_tolua__set_instance00
+static int tolua_AllToLua_Lua__cPawn_tolua__set_instance00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPawn",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPawn* self = (Lua__cPawn*) tolua_tousertype(tolua_S,1,0);
+ lua_State* L = tolua_S;
+ lua_Object lo = ((lua_Object) tolua_tovalue(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'tolua__set_instance'", NULL);
+#endif
+ {
+ self->tolua__set_instance(L,lo);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'tolua__set_instance'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cPawn__TeleportTo of class Lua__cPawn */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPawn_cPawn__TeleportTo00
+static int tolua_AllToLua_Lua__cPawn_cPawn__TeleportTo00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPawn",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPawn* self = (Lua__cPawn*) tolua_tousertype(tolua_S,1,0);
+ cEntity* a_Entity = ((cEntity*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cPawn__TeleportTo'", NULL);
+#endif
+ {
+ self->cPawn__TeleportTo(a_Entity);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'cPawn__TeleportTo'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cPawn__TeleportTo of class Lua__cPawn */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPawn_cPawn__TeleportTo01
+static int tolua_AllToLua_Lua__cPawn_cPawn__TeleportTo01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPawn",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ Lua__cPawn* self = (Lua__cPawn*) tolua_tousertype(tolua_S,1,0);
+ const double a_PosX = ((const double) tolua_tonumber(tolua_S,2,0));
+ const double a_PosY = ((const double) tolua_tonumber(tolua_S,3,0));
+ const double a_PosZ = ((const double) tolua_tonumber(tolua_S,4,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cPawn__TeleportTo'", NULL);
+#endif
+ {
+ self->cPawn__TeleportTo(a_PosX,a_PosY,a_PosZ);
+ tolua_pushnumber(tolua_S,(lua_Number)a_PosX);
+ tolua_pushnumber(tolua_S,(lua_Number)a_PosY);
+ tolua_pushnumber(tolua_S,(lua_Number)a_PosZ);
+ }
+ }
+ return 3;
+tolua_lerror:
+ return tolua_AllToLua_Lua__cPawn_cPawn__TeleportTo00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cPawn__TakeDamage of class Lua__cPawn */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPawn_cPawn__TakeDamage00
+static int tolua_AllToLua_Lua__cPawn_cPawn__TakeDamage00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPawn",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,3,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPawn* self = (Lua__cPawn*) tolua_tousertype(tolua_S,1,0);
+ int a_Damage = ((int) tolua_tonumber(tolua_S,2,0));
+ cEntity* a_Instigator = ((cEntity*) tolua_tousertype(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cPawn__TakeDamage'", NULL);
+#endif
+ {
+ self->cPawn__TakeDamage(a_Damage,a_Instigator);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'cPawn__TakeDamage'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cPawn__KilledBy of class Lua__cPawn */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPawn_cPawn__KilledBy00
+static int tolua_AllToLua_Lua__cPawn_cPawn__KilledBy00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPawn",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPawn* self = (Lua__cPawn*) tolua_tousertype(tolua_S,1,0);
+ cEntity* a_Killer = ((cEntity*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cPawn__KilledBy'", NULL);
+#endif
+ {
+ self->cPawn__KilledBy(a_Killer);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'cPawn__KilledBy'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetEyeHeight of class cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetEyeHeight00
+static int tolua_AllToLua_cPlayer_GetEyeHeight00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEyeHeight'", NULL);
+#endif
+ {
+ double tolua_ret = (double) self->GetEyeHeight();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetEyeHeight'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetEyePosition of class cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetEyePosition00
+static int tolua_AllToLua_cPlayer_GetEyePosition00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEyePosition'", NULL);
+#endif
+ {
+ Vector3d tolua_ret = (Vector3d) self->GetEyePosition();
+ {
+#ifdef __cplusplus
+ void* tolua_obj = Mtolua_new((Vector3d)(tolua_ret));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#else
+ void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3d));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#endif
+ }
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetEyePosition'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetFlying of class cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetFlying00
+static int tolua_AllToLua_cPlayer_GetFlying00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetFlying'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->GetFlying();
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetFlying'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetStance of class cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetStance00
+static int tolua_AllToLua_cPlayer_GetStance00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetStance'", NULL);
+#endif
+ {
+ const double tolua_ret = (const double) self->GetStance();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetStance'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetInventory of class cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetInventory00
+static int tolua_AllToLua_cPlayer_GetInventory00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetInventory'", NULL);
+#endif
+ {
+ cInventory& tolua_ret = (cInventory&) self->GetInventory();
+ tolua_pushusertype(tolua_S,(void*)&tolua_ret,"cInventory");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetInventory'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: TeleportTo of class cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_TeleportTo00
+static int tolua_AllToLua_cPlayer_TeleportTo00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+ cEntity* a_Entity = ((cEntity*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'TeleportTo'", NULL);
+#endif
+ {
+ self->TeleportTo(a_Entity);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'TeleportTo'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: TeleportTo of class cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_TeleportTo01
+static int tolua_AllToLua_cPlayer_TeleportTo01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+ const double a_PosX = ((const double) tolua_tonumber(tolua_S,2,0));
+ const double a_PosY = ((const double) tolua_tonumber(tolua_S,3,0));
+ const double a_PosZ = ((const double) tolua_tonumber(tolua_S,4,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'TeleportTo'", NULL);
+#endif
+ {
+ self->TeleportTo(a_PosX,a_PosY,a_PosZ);
+ tolua_pushnumber(tolua_S,(lua_Number)a_PosX);
+ tolua_pushnumber(tolua_S,(lua_Number)a_PosY);
+ tolua_pushnumber(tolua_S,(lua_Number)a_PosZ);
+ }
+ }
+ return 3;
+tolua_lerror:
+ return tolua_AllToLua_cPlayer_TeleportTo00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: MoveTo of class cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_MoveTo00
+static int tolua_AllToLua_cPlayer_MoveTo00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3d",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+ const Vector3d* a_NewPos = ((const Vector3d*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'MoveTo'", NULL);
+#endif
+ {
+ self->MoveTo(*a_NewPos);
+ }
+ }
+ 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: GetClientHandle of class cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetClientHandle00
+static int tolua_AllToLua_cPlayer_GetClientHandle00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetClientHandle'", NULL);
+#endif
+ {
+ cClientHandle* tolua_ret = (cClientHandle*) self->GetClientHandle();
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cClientHandle");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetClientHandle'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SendMessage of class cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SendMessage00
+static int tolua_AllToLua_cPlayer_SendMessage00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
+ !tolua_isstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+ const char* a_Message = ((const char*) tolua_tostring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendMessage'", NULL);
+#endif
+ {
+ self->SendMessage(a_Message);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SendMessage'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetName of class cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetName00
+static int tolua_AllToLua_cPlayer_GetName00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetName'", NULL);
+#endif
+ {
+ const char* tolua_ret = (const 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
+
+/* method: SetName of class cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetName00
+static int tolua_AllToLua_cPlayer_SetName00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
+ !tolua_isstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+ const char* a_Name = ((const char*) tolua_tostring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetName'", NULL);
+#endif
+ {
+ self->SetName(a_Name);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetName'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: AddToGroup of class cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_AddToGroup00
+static int tolua_AllToLua_cPlayer_AddToGroup00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
+ !tolua_isstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+ const char* a_GroupName = ((const char*) tolua_tostring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddToGroup'", NULL);
+#endif
+ {
+ self->AddToGroup(a_GroupName);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'AddToGroup'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: CanUseCommand of class cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_CanUseCommand00
+static int tolua_AllToLua_cPlayer_CanUseCommand00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
+ !tolua_isstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+ const char* a_Command = ((const char*) tolua_tostring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CanUseCommand'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->CanUseCommand(a_Command);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'CanUseCommand'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: HasPermission of class cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_HasPermission00
+static int tolua_AllToLua_cPlayer_HasPermission00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
+ !tolua_isstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+ const char* a_Permission = ((const char*) tolua_tostring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HasPermission'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->HasPermission(a_Permission);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'HasPermission'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: IsInGroup of class cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_IsInGroup00
+static int tolua_AllToLua_cPlayer_IsInGroup00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
+ !tolua_isstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+ const char* a_Group = ((const char*) tolua_tostring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsInGroup'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->IsInGroup(a_Group);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'IsInGroup'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetColor of class cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_GetColor00
+static int tolua_AllToLua_cPlayer_GetColor00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetColor'", NULL);
+#endif
+ {
+ std::string tolua_ret = (std::string) self->GetColor();
+ tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetColor'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: TossItem of class cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_TossItem00
+static int tolua_AllToLua_cPlayer_TossItem00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
+ !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+ bool a_bDraggingItem = ((bool) tolua_toboolean(tolua_S,2,0));
+ int a_Amount = ((int) tolua_tonumber(tolua_S,3,1));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'TossItem'", NULL);
+#endif
+ {
+ self->TossItem(a_bDraggingItem,a_Amount);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'TossItem'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Heal of class cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_Heal00
+static int tolua_AllToLua_cPlayer_Heal00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+ int a_Health = ((int) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Heal'", NULL);
+#endif
+ {
+ self->Heal(a_Health);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Heal'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: TakeDamage of class cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_TakeDamage00
+static int tolua_AllToLua_cPlayer_TakeDamage00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,3,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+ int a_Damage = ((int) tolua_tonumber(tolua_S,2,0));
+ cEntity* a_Instigator = ((cEntity*) tolua_tousertype(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'TakeDamage'", NULL);
+#endif
+ {
+ self->TakeDamage(a_Damage,a_Instigator);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'TakeDamage'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: KilledBy of class cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_KilledBy00
+static int tolua_AllToLua_cPlayer_KilledBy00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+ cEntity* a_Killer = ((cEntity*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'KilledBy'", NULL);
+#endif
+ {
+ self->KilledBy(a_Killer);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'KilledBy'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Respawn of class cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_Respawn00
+static int tolua_AllToLua_cPlayer_Respawn00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Respawn'", NULL);
+#endif
+ {
+ self->Respawn();
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Respawn'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetVisible of class cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_SetVisible00
+static int tolua_AllToLua_cPlayer_SetVisible00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
+ !tolua_isboolean(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+ bool a_bVisible = ((bool) tolua_toboolean(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetVisible'", NULL);
+#endif
+ {
+ self->SetVisible(a_bVisible);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetVisible'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: IsVisible of class cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlayer_IsVisible00
+static int tolua_AllToLua_cPlayer_IsVisible00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsVisible'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->IsVisible();
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'IsVisible'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+ class Lua__cPlayer : public cPlayer, public ToluaBase {
+public:
+ void TeleportTo( cEntity* a_Entity) {
+ if (push_method("TeleportTo", tolua_AllToLua_cPlayer_TeleportTo00)) {
+ tolua_pushusertype(lua_state, (void*)a_Entity, "cEntity");
+ ToluaBase::dbcall(lua_state, 2, 0);
+ } else {
+ return ( void ) cPlayer:: TeleportTo(a_Entity);
+ };
+ };
+ void TeleportTo( const double& a_PosX, const double& a_PosY, const double& a_PosZ) {
+ if (push_method("TeleportTo", tolua_AllToLua_cPlayer_TeleportTo01)) {
+ tolua_pushnumber(lua_state, (lua_Number)a_PosX);
+ tolua_pushnumber(lua_state, (lua_Number)a_PosY);
+ tolua_pushnumber(lua_state, (lua_Number)a_PosZ);
+ ToluaBase::dbcall(lua_state, 4, 0);
+ } else {
+ return ( void ) cPlayer:: TeleportTo(a_PosX,a_PosY,a_PosZ);
+ };
+ };
+ void MoveTo( const Vector3d& a_NewPos) {
+ if (push_method("MoveTo", tolua_AllToLua_cPlayer_MoveTo00)) {
+ tolua_pushusertype(lua_state, (void*)&a_NewPos, "const Vector3d");
+ ToluaBase::dbcall(lua_state, 2, 0);
+ } else {
+ return ( void ) cPlayer:: MoveTo(a_NewPos);
+ };
+ };
+ void TakeDamage( int a_Damage, cEntity* a_Instigator) {
+ if (push_method("TakeDamage", tolua_AllToLua_cPawn_TakeDamage00)) {
+ tolua_pushnumber(lua_state, (lua_Number)a_Damage);
+ tolua_pushusertype(lua_state, (void*)a_Instigator, "cEntity");
+ ToluaBase::dbcall(lua_state, 3, 0);
+ } else {
+ return ( void ) cPlayer:: TakeDamage(a_Damage,a_Instigator);
+ };
+ };
+ void KilledBy( cEntity* a_Killer) {
+ if (push_method("KilledBy", tolua_AllToLua_cPawn_KilledBy00)) {
+ tolua_pushusertype(lua_state, (void*)a_Killer, "cEntity");
+ ToluaBase::dbcall(lua_state, 2, 0);
+ } else {
+ return ( void ) cPlayer:: KilledBy(a_Killer);
+ };
+ };
+ void Initialize( void ) {
+ if (push_method("Initialize", tolua_AllToLua_cEntity_Initialize00)) {
+ ToluaBase::dbcall(lua_state, 1, 0);
+ } else {
+ return ( void ) cPlayer:: Initialize();
+ };
+ };
+ unsigned int GetEntityType( void ) {
+ if (push_method("GetEntityType", tolua_AllToLua_cEntity_GetEntityType00)) {
+ ToluaBase::dbcall(lua_state, 1, 1);
+ unsigned int tolua_ret = (unsigned int )tolua_tonumber(lua_state, -1, 0);
+ lua_pop(lua_state, 1);
+ return tolua_ret;
+ } else {
+ return (unsigned int ) cPlayer:: GetEntityType();
+ };
+ };
+ bool IsA( const char* a_EntityType) {
+ if (push_method("IsA", tolua_AllToLua_cEntity_IsA00)) {
+ tolua_pushstring(lua_state, (const char*)a_EntityType);
+ ToluaBase::dbcall(lua_state, 2, 1);
+ bool tolua_ret = ( bool )tolua_toboolean(lua_state, -1, 0);
+ lua_pop(lua_state, 1);
+ return tolua_ret;
+ } else {
+ return ( bool ) cPlayer:: IsA(a_EntityType);
+ };
+ };
+ const char* GetClass( void ) {
+ if (push_method("GetClass", tolua_AllToLua_cEntity_GetClass00)) {
+ ToluaBase::dbcall(lua_state, 1, 1);
+ const char* tolua_ret = ( const char* )tolua_tostring(lua_state, -1, 0);
+ lua_pop(lua_state, 1);
+ return tolua_ret;
+ } else {
+ return ( const char* ) cPlayer:: GetClass();
+ };
+ };
+ void Tick( float a_Dt) {
+ if (push_method("Tick", tolua_AllToLua_cEntity_Tick00)) {
+ tolua_pushnumber(lua_state, (lua_Number)a_Dt);
+ ToluaBase::dbcall(lua_state, 2, 0);
+ } else {
+ if (lua_state)
+ LOG("pure-virtual method cPlayer::Tick not implemented.");
+ else {
+ LOG("pure-virtual method cPlayer::Tick called with no lua_state. Aborting");
+ ::abort();
+ };
+ return ( void )0;
+ };
+ };
+ void SpawnOn( cClientHandle* a_Target) {
+ if (push_method("SpawnOn", tolua_AllToLua_cEntity_SpawnOn00)) {
+ tolua_pushusertype(lua_state, (void*)a_Target, "cClientHandle");
+ ToluaBase::dbcall(lua_state, 2, 0);
+ } else {
+ if (lua_state)
+ LOG("pure-virtual method cPlayer::SpawnOn not implemented.");
+ else {
+ LOG("pure-virtual method cPlayer::SpawnOn called with no lua_state. Aborting");
+ ::abort();
+ };
+ return ( void )0;
+ };
+ };
+
+ void cPlayer__TeleportTo( cEntity* a_Entity) {
+ return ( void )cPlayer::TeleportTo(a_Entity);
+ };
+ void cPlayer__TeleportTo( const double& a_PosX, const double& a_PosY, const double& a_PosZ) {
+ return ( void )cPlayer::TeleportTo(a_PosX,a_PosY,a_PosZ);
+ };
+ void cPlayer__MoveTo( const Vector3d& a_NewPos) {
+ return ( void )cPlayer::MoveTo(a_NewPos);
+ };
+ void cPlayer__TakeDamage( int a_Damage, cEntity* a_Instigator) {
+ return ( void )cPlayer::TakeDamage(a_Damage,a_Instigator);
+ };
+ void cPlayer__KilledBy( cEntity* a_Killer) {
+ return ( void )cPlayer::KilledBy(a_Killer);
+ };
+ void cPlayer__Initialize( void ) {
+ return ( void )cPlayer::Initialize();
+ };
+ unsigned int cPlayer__GetEntityType( void ) {
+ return (unsigned int )cPlayer::GetEntityType();
+ };
+ bool cPlayer__IsA( const char* a_EntityType) {
+ return ( bool )cPlayer::IsA(a_EntityType);
+ };
+ const char* cPlayer__GetClass( void ) {
+ return ( const char* )cPlayer::GetClass();
+ };
+};
+
+/* method: tolua__set_instance of class Lua__cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPlayer_tolua__set_instance00
+static int tolua_AllToLua_Lua__cPlayer_tolua__set_instance00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPlayer* self = (Lua__cPlayer*) tolua_tousertype(tolua_S,1,0);
+ lua_State* L = tolua_S;
+ lua_Object lo = ((lua_Object) tolua_tovalue(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'tolua__set_instance'", NULL);
+#endif
+ {
+ self->tolua__set_instance(L,lo);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'tolua__set_instance'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cPlayer__TeleportTo of class Lua__cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPlayer_cPlayer__TeleportTo00
+static int tolua_AllToLua_Lua__cPlayer_cPlayer__TeleportTo00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPlayer",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPlayer* self = (Lua__cPlayer*) tolua_tousertype(tolua_S,1,0);
+ cEntity* a_Entity = ((cEntity*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cPlayer__TeleportTo'", NULL);
+#endif
+ {
+ self->cPlayer__TeleportTo(a_Entity);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'cPlayer__TeleportTo'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cPlayer__TeleportTo of class Lua__cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPlayer_cPlayer__TeleportTo01
+static int tolua_AllToLua_Lua__cPlayer_cPlayer__TeleportTo01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPlayer",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
+ {
+ Lua__cPlayer* self = (Lua__cPlayer*) tolua_tousertype(tolua_S,1,0);
+ const double a_PosX = ((const double) tolua_tonumber(tolua_S,2,0));
+ const double a_PosY = ((const double) tolua_tonumber(tolua_S,3,0));
+ const double a_PosZ = ((const double) tolua_tonumber(tolua_S,4,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cPlayer__TeleportTo'", NULL);
+#endif
+ {
+ self->cPlayer__TeleportTo(a_PosX,a_PosY,a_PosZ);
+ tolua_pushnumber(tolua_S,(lua_Number)a_PosX);
+ tolua_pushnumber(tolua_S,(lua_Number)a_PosY);
+ tolua_pushnumber(tolua_S,(lua_Number)a_PosZ);
+ }
+ }
+ return 3;
+tolua_lerror:
+ return tolua_AllToLua_Lua__cPlayer_cPlayer__TeleportTo00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cPlayer__MoveTo of class Lua__cPlayer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPlayer_cPlayer__MoveTo00
+static int tolua_AllToLua_Lua__cPlayer_cPlayer__MoveTo00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPlayer",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3d",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPlayer* self = (Lua__cPlayer*) tolua_tousertype(tolua_S,1,0);
+ const Vector3d* a_NewPos = ((const Vector3d*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cPlayer__MoveTo'", NULL);
+#endif
+ {
+ self->cPlayer__MoveTo(*a_NewPos);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'cPlayer__MoveTo'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetPluginManager of class cPluginManager */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_GetPluginManager00
+static int tolua_AllToLua_cPluginManager_GetPluginManager00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cPluginManager",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ {
+ cPluginManager* tolua_ret = (cPluginManager*) cPluginManager::GetPluginManager();
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cPluginManager");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetPluginManager'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetPlugin of class cPluginManager */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_GetPlugin00
+static int tolua_AllToLua_cPluginManager_GetPlugin00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPluginManager",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPluginManager* self = (cPluginManager*) tolua_tousertype(tolua_S,1,0);
+ std::string a_Plugin = ((std::string) tolua_tocppstring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPlugin'", NULL);
+#endif
+ {
+ cPlugin* tolua_ret = (cPlugin*) self->GetPlugin(a_Plugin);
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cPlugin");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetPlugin'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: ReloadPlugins of class cPluginManager */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_ReloadPlugins00
+static int tolua_AllToLua_cPluginManager_ReloadPlugins00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPluginManager",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPluginManager* self = (cPluginManager*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ReloadPlugins'", NULL);
+#endif
+ {
+ self->ReloadPlugins();
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'ReloadPlugins'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: AddPlugin of class cPluginManager */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_AddPlugin00
+static int tolua_AllToLua_cPluginManager_AddPlugin00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPluginManager",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPlugin",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPluginManager* self = (cPluginManager*) tolua_tousertype(tolua_S,1,0);
+ lua_State* a_LuaState = tolua_S;
+ cPlugin* a_Plugin = ((cPlugin*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddPlugin'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->AddPlugin(a_LuaState,a_Plugin);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'AddPlugin'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: AddHook of class cPluginManager */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_AddHook00
+static int tolua_AllToLua_cPluginManager_AddHook00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPluginManager",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPlugin",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPluginManager* self = (cPluginManager*) tolua_tousertype(tolua_S,1,0);
+ cPlugin* a_Plugin = ((cPlugin*) tolua_tousertype(tolua_S,2,0));
+ cPluginManager::PluginHook a_Hook = ((cPluginManager::PluginHook) (int) tolua_tonumber(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddHook'", NULL);
+#endif
+ {
+ self->AddHook(a_Plugin,a_Hook);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'AddHook'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetNumPlugins of class cPluginManager */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_GetNumPlugins00
+static int tolua_AllToLua_cPluginManager_GetNumPlugins00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPluginManager",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPluginManager* self = (cPluginManager*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumPlugins'", NULL);
+#endif
+ {
+ unsigned int tolua_ret = (unsigned int) self->GetNumPlugins();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetNumPlugins'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: RemovePlugin of class cPluginManager */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_RemovePlugin00
+static int tolua_AllToLua_cPluginManager_RemovePlugin00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPluginManager",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPlugin",0,&tolua_err) ||
+ !tolua_isboolean(tolua_S,3,1,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPluginManager* self = (cPluginManager*) tolua_tousertype(tolua_S,1,0);
+ cPlugin* a_Plugin = ((cPlugin*) tolua_tousertype(tolua_S,2,0));
+ bool a_bDelete = ((bool) tolua_toboolean(tolua_S,3,false));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'RemovePlugin'", NULL);
+#endif
+ {
+ self->RemovePlugin(a_Plugin,a_bDelete);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'RemovePlugin'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: RemoveLuaPlugin of class cPluginManager */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_RemoveLuaPlugin00
+static int tolua_AllToLua_cPluginManager_RemoveLuaPlugin00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPluginManager",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPluginManager* self = (cPluginManager*) tolua_tousertype(tolua_S,1,0);
+ std::string a_FileName = ((std::string) tolua_tocppstring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'RemoveLuaPlugin'", NULL);
+#endif
+ {
+ self->RemoveLuaPlugin(a_FileName);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'RemoveLuaPlugin'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetLuaPlugin of class cPluginManager */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPluginManager_GetLuaPlugin00
+static int tolua_AllToLua_cPluginManager_GetLuaPlugin00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPluginManager",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPluginManager* self = (cPluginManager*) tolua_tousertype(tolua_S,1,0);
+ lua_State* a_State = tolua_S;
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetLuaPlugin'", NULL);
+#endif
+ {
+ cPlugin_Lua* tolua_ret = (cPlugin_Lua*) self->GetLuaPlugin(a_State);
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cPlugin_Lua");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetLuaPlugin'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: delete of class cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_delete00
+static int tolua_AllToLua_cPlugin_delete00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlugin",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlugin* self = (cPlugin*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
+#endif
+ Mtolua_delete(self);
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: OnDisable of class cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_OnDisable00
+static int tolua_AllToLua_cPlugin_OnDisable00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlugin",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlugin* self = (cPlugin*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'OnDisable'", NULL);
+#endif
+ {
+ self->OnDisable();
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'OnDisable'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Initialize of class cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_Initialize00
+static int tolua_AllToLua_cPlugin_Initialize00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlugin",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlugin* self = (cPlugin*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Initialize'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->Initialize();
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Initialize'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Tick of class cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_Tick00
+static int tolua_AllToLua_cPlugin_Tick00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlugin",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlugin* self = (cPlugin*) tolua_tousertype(tolua_S,1,0);
+ float a_Dt = ((float) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Tick'", NULL);
+#endif
+ {
+ self->Tick(a_Dt);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Tick'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: OnCollectItem of class cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_OnCollectItem00
+static int tolua_AllToLua_cPlugin_OnCollectItem00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlugin",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPickup",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,3,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlugin* self = (cPlugin*) tolua_tousertype(tolua_S,1,0);
+ cPickup* a_Pickup = ((cPickup*) tolua_tousertype(tolua_S,2,0));
+ cPlayer* a_Player = ((cPlayer*) tolua_tousertype(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'OnCollectItem'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->OnCollectItem(a_Pickup,a_Player);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'OnCollectItem'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: OnDisconnect of class cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_OnDisconnect00
+static int tolua_AllToLua_cPlugin_OnDisconnect00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlugin",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,3,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlugin* self = (cPlugin*) tolua_tousertype(tolua_S,1,0);
+ std::string a_Reason = ((std::string) tolua_tocppstring(tolua_S,2,0));
+ cPlayer* a_Player = ((cPlayer*) tolua_tousertype(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'OnDisconnect'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->OnDisconnect(a_Reason,a_Player);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'OnDisconnect'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: OnBlockPlace of class cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_OnBlockPlace00
+static int tolua_AllToLua_cPlugin_OnBlockPlace00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlugin",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPacket_BlockPlace",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,3,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlugin* self = (cPlugin*) tolua_tousertype(tolua_S,1,0);
+ cPacket_BlockPlace* a_PacketData = ((cPacket_BlockPlace*) tolua_tousertype(tolua_S,2,0));
+ cPlayer* a_Player = ((cPlayer*) tolua_tousertype(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'OnBlockPlace'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->OnBlockPlace(a_PacketData,a_Player);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'OnBlockPlace'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: OnBlockDig of class cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_OnBlockDig00
+static int tolua_AllToLua_cPlugin_OnBlockDig00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlugin",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPacket_BlockDig",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,3,"cPlayer",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,4,"cItem",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlugin* self = (cPlugin*) tolua_tousertype(tolua_S,1,0);
+ cPacket_BlockDig* a_PacketData = ((cPacket_BlockDig*) tolua_tousertype(tolua_S,2,0));
+ cPlayer* a_Player = ((cPlayer*) tolua_tousertype(tolua_S,3,0));
+ cItem* a_PickupItem = ((cItem*) tolua_tousertype(tolua_S,4,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'OnBlockDig'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->OnBlockDig(a_PacketData,a_Player,a_PickupItem);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'OnBlockDig'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: OnChat of class cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_OnChat00
+static int tolua_AllToLua_cPlugin_OnChat00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlugin",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,3,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlugin* self = (cPlugin*) tolua_tousertype(tolua_S,1,0);
+ std::string a_Chat = ((std::string) tolua_tocppstring(tolua_S,2,0));
+ cPlayer* a_Player = ((cPlayer*) tolua_tousertype(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'OnChat'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->OnChat(a_Chat,a_Player);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'OnChat'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: OnLogin of class cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_OnLogin00
+static int tolua_AllToLua_cPlugin_OnLogin00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlugin",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPacket_Login",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlugin* self = (cPlugin*) tolua_tousertype(tolua_S,1,0);
+ cPacket_Login* a_PacketData = ((cPacket_Login*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'OnLogin'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->OnLogin(a_PacketData);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'OnLogin'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: OnPlayerSpawn of class cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_OnPlayerSpawn00
+static int tolua_AllToLua_cPlugin_OnPlayerSpawn00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlugin",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlugin* self = (cPlugin*) tolua_tousertype(tolua_S,1,0);
+ cPlayer* a_Player = ((cPlayer*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'OnPlayerSpawn'", NULL);
+#endif
+ {
+ self->OnPlayerSpawn(a_Player);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'OnPlayerSpawn'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: OnPlayerJoin of class cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_OnPlayerJoin00
+static int tolua_AllToLua_cPlugin_OnPlayerJoin00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlugin",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlugin* self = (cPlugin*) tolua_tousertype(tolua_S,1,0);
+ cPlayer* a_Player = ((cPlayer*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'OnPlayerJoin'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->OnPlayerJoin(a_Player);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'OnPlayerJoin'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: OnPlayerMove of class cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_OnPlayerMove00
+static int tolua_AllToLua_cPlugin_OnPlayerMove00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlugin",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlugin* self = (cPlugin*) tolua_tousertype(tolua_S,1,0);
+ cPlayer* a_Player = ((cPlayer*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'OnPlayerMove'", NULL);
+#endif
+ {
+ self->OnPlayerMove(a_Player);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'OnPlayerMove'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: OnTakeDamage of class cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_OnTakeDamage00
+static int tolua_AllToLua_cPlugin_OnTakeDamage00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlugin",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPawn",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,3,"TakeDamageInfo",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlugin* self = (cPlugin*) tolua_tousertype(tolua_S,1,0);
+ cPawn* a_Pawn = ((cPawn*) tolua_tousertype(tolua_S,2,0));
+ TakeDamageInfo* a_TakeDamageInfo = ((TakeDamageInfo*) tolua_tousertype(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'OnTakeDamage'", NULL);
+#endif
+ {
+ self->OnTakeDamage(a_Pawn,a_TakeDamageInfo);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'OnTakeDamage'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: OnKilled of class cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_OnKilled00
+static int tolua_AllToLua_cPlugin_OnKilled00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlugin",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPawn",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,3,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlugin* self = (cPlugin*) tolua_tousertype(tolua_S,1,0);
+ cPawn* a_Killed = ((cPawn*) tolua_tousertype(tolua_S,2,0));
+ cEntity* a_Killer = ((cEntity*) tolua_tousertype(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'OnKilled'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->OnKilled(a_Killed,a_Killer);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'OnKilled'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetName of class cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_GetName00
+static int tolua_AllToLua_cPlugin_GetName00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cPlugin",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const cPlugin* self = (const cPlugin*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetName'", NULL);
+#endif
+ {
+ std::string tolua_ret = (std::string) self->GetName();
+ tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetName'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetName of class cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_SetName00
+static int tolua_AllToLua_cPlugin_SetName00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlugin",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlugin* self = (cPlugin*) tolua_tousertype(tolua_S,1,0);
+ std::string a_Name = ((std::string) tolua_tocppstring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetName'", NULL);
+#endif
+ {
+ self->SetName(a_Name);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetName'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetVersion of class cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_GetVersion00
+static int tolua_AllToLua_cPlugin_GetVersion00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cPlugin",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const cPlugin* self = (const cPlugin*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetVersion'", NULL);
+#endif
+ {
+ int tolua_ret = (int) self->GetVersion();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetVersion'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetVersion of class cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_SetVersion00
+static int tolua_AllToLua_cPlugin_SetVersion00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlugin",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlugin* self = (cPlugin*) tolua_tousertype(tolua_S,1,0);
+ int a_Version = ((int) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetVersion'", NULL);
+#endif
+ {
+ self->SetVersion(a_Version);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetVersion'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: Command of class CommandStruct */
+#ifndef TOLUA_DISABLE_tolua_get_cPlugin__CommandStruct_Command
+static int tolua_get_cPlugin__CommandStruct_Command(lua_State* tolua_S)
+{
+ cPlugin::CommandStruct* self = (cPlugin::CommandStruct*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Command'",NULL);
+#endif
+ tolua_pushcppstring(tolua_S,(const char*)self->Command);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: Command of class CommandStruct */
+#ifndef TOLUA_DISABLE_tolua_set_cPlugin__CommandStruct_Command
+static int tolua_set_cPlugin__CommandStruct_Command(lua_State* tolua_S)
+{
+ cPlugin::CommandStruct* self = (cPlugin::CommandStruct*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Command'",NULL);
+ if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->Command = ((std::string) tolua_tocppstring(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: Description of class CommandStruct */
+#ifndef TOLUA_DISABLE_tolua_get_cPlugin__CommandStruct_Description
+static int tolua_get_cPlugin__CommandStruct_Description(lua_State* tolua_S)
+{
+ cPlugin::CommandStruct* self = (cPlugin::CommandStruct*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Description'",NULL);
+#endif
+ tolua_pushcppstring(tolua_S,(const char*)self->Description);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: Description of class CommandStruct */
+#ifndef TOLUA_DISABLE_tolua_set_cPlugin__CommandStruct_Description
+static int tolua_set_cPlugin__CommandStruct_Description(lua_State* tolua_S)
+{
+ cPlugin::CommandStruct* self = (cPlugin::CommandStruct*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Description'",NULL);
+ if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->Description = ((std::string) tolua_tocppstring(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: Permission of class CommandStruct */
+#ifndef TOLUA_DISABLE_tolua_get_cPlugin__CommandStruct_Permission
+static int tolua_get_cPlugin__CommandStruct_Permission(lua_State* tolua_S)
+{
+ cPlugin::CommandStruct* self = (cPlugin::CommandStruct*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Permission'",NULL);
+#endif
+ tolua_pushcppstring(tolua_S,(const char*)self->Permission);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: Permission of class CommandStruct */
+#ifndef TOLUA_DISABLE_tolua_set_cPlugin__CommandStruct_Permission
+static int tolua_set_cPlugin__CommandStruct_Permission(lua_State* tolua_S)
+{
+ cPlugin::CommandStruct* self = (cPlugin::CommandStruct*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Permission'",NULL);
+ if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->Permission = ((std::string) tolua_tocppstring(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: AddCommand of class cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_AddCommand00
+static int tolua_AllToLua_cPlugin_AddCommand00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlugin",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,3,0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,4,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlugin* self = (cPlugin*) tolua_tousertype(tolua_S,1,0);
+ std::string a_Command = ((std::string) tolua_tocppstring(tolua_S,2,0));
+ std::string a_Description = ((std::string) tolua_tocppstring(tolua_S,3,0));
+ std::string a_Permission = ((std::string) tolua_tocppstring(tolua_S,4,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddCommand'", NULL);
+#endif
+ {
+ self->AddCommand(a_Command,a_Description,a_Permission);
+ tolua_pushcppstring(tolua_S,(const char*)a_Command);
+ tolua_pushcppstring(tolua_S,(const char*)a_Description);
+ tolua_pushcppstring(tolua_S,(const char*)a_Permission);
+ }
+ }
+ return 3;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'AddCommand'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+ class Lua__cPlugin : public cPlugin, public ToluaBase {
+public:
+ void OnDisable( void ) {
+ if (push_method("OnDisable", tolua_AllToLua_cPlugin_OnDisable00)) {
+ ToluaBase::dbcall(lua_state, 1, 0);
+ } else {
+ return ( void ) cPlugin:: OnDisable();
+ };
+ };
+ bool Initialize( void ) {
+ if (push_method("Initialize", tolua_AllToLua_cPlugin_Initialize00)) {
+ ToluaBase::dbcall(lua_state, 1, 1);
+ bool tolua_ret = ( bool )tolua_toboolean(lua_state, -1, 0);
+ lua_pop(lua_state, 1);
+ return tolua_ret;
+ } else {
+ if (lua_state)
+ LOG("pure-virtual method cPlugin::Initialize not implemented.");
+ else {
+ LOG("pure-virtual method cPlugin::Initialize called with no lua_state. Aborting");
+ ::abort();
+ };
+ return ( bool )0;
+ };
+ };
+ void Tick( float a_Dt) {
+ if (push_method("Tick", tolua_AllToLua_cPlugin_Tick00)) {
+ tolua_pushnumber(lua_state, (lua_Number)a_Dt);
+ ToluaBase::dbcall(lua_state, 2, 0);
+ } else {
+ return ( void ) cPlugin:: Tick(a_Dt);
+ };
+ };
+ bool OnCollectItem( cPickup* a_Pickup, cPlayer* a_Player) {
+ if (push_method("OnCollectItem", tolua_AllToLua_cPlugin_OnCollectItem00)) {
+ tolua_pushusertype(lua_state, (void*)a_Pickup, "cPickup");
+ tolua_pushusertype(lua_state, (void*)a_Player, "cPlayer");
+ ToluaBase::dbcall(lua_state, 3, 1);
+ bool tolua_ret = ( bool )tolua_toboolean(lua_state, -1, 0);
+ lua_pop(lua_state, 1);
+ return tolua_ret;
+ } else {
+ return ( bool ) cPlugin:: OnCollectItem(a_Pickup,a_Player);
+ };
+ };
+ bool OnDisconnect( std::string a_Reason, cPlayer* a_Player) {
+ if (push_method("OnDisconnect", tolua_AllToLua_cPlugin_OnDisconnect00)) {
+ tolua_pushcppstring(lua_state, (const char*)a_Reason);
+ tolua_pushusertype(lua_state, (void*)a_Player, "cPlayer");
+ ToluaBase::dbcall(lua_state, 3, 1);
+ bool tolua_ret = ( bool )tolua_toboolean(lua_state, -1, 0);
+ lua_pop(lua_state, 1);
+ return tolua_ret;
+ } else {
+ return ( bool ) cPlugin:: OnDisconnect(a_Reason,a_Player);
+ };
+ };
+ bool OnBlockPlace( cPacket_BlockPlace* a_PacketData, cPlayer* a_Player) {
+ if (push_method("OnBlockPlace", tolua_AllToLua_cPlugin_OnBlockPlace00)) {
+ tolua_pushusertype(lua_state, (void*)a_PacketData, "cPacket_BlockPlace");
+ tolua_pushusertype(lua_state, (void*)a_Player, "cPlayer");
+ ToluaBase::dbcall(lua_state, 3, 1);
+ bool tolua_ret = ( bool )tolua_toboolean(lua_state, -1, 0);
+ lua_pop(lua_state, 1);
+ return tolua_ret;
+ } else {
+ return ( bool ) cPlugin:: OnBlockPlace(a_PacketData,a_Player);
+ };
+ };
+ bool OnBlockDig( cPacket_BlockDig* a_PacketData, cPlayer* a_Player, cItem* a_PickupItem) {
+ if (push_method("OnBlockDig", tolua_AllToLua_cPlugin_OnBlockDig00)) {
+ tolua_pushusertype(lua_state, (void*)a_PacketData, "cPacket_BlockDig");
+ tolua_pushusertype(lua_state, (void*)a_Player, "cPlayer");
+ tolua_pushusertype(lua_state, (void*)a_PickupItem, "cItem");
+ ToluaBase::dbcall(lua_state, 4, 1);
+ bool tolua_ret = ( bool )tolua_toboolean(lua_state, -1, 0);
+ lua_pop(lua_state, 1);
+ return tolua_ret;
+ } else {
+ return ( bool ) cPlugin:: OnBlockDig(a_PacketData,a_Player,a_PickupItem);
+ };
+ };
+ bool OnChat( std::string a_Chat, cPlayer* a_Player) {
+ if (push_method("OnChat", tolua_AllToLua_cPlugin_OnChat00)) {
+ tolua_pushcppstring(lua_state, (const char*)a_Chat);
+ tolua_pushusertype(lua_state, (void*)a_Player, "cPlayer");
+ ToluaBase::dbcall(lua_state, 3, 1);
+ bool tolua_ret = ( bool )tolua_toboolean(lua_state, -1, 0);
+ lua_pop(lua_state, 1);
+ return tolua_ret;
+ } else {
+ return ( bool ) cPlugin:: OnChat(a_Chat,a_Player);
+ };
+ };
+ bool OnLogin( cPacket_Login* a_PacketData) {
+ if (push_method("OnLogin", tolua_AllToLua_cPlugin_OnLogin00)) {
+ tolua_pushusertype(lua_state, (void*)a_PacketData, "cPacket_Login");
+ ToluaBase::dbcall(lua_state, 2, 1);
+ bool tolua_ret = ( bool )tolua_toboolean(lua_state, -1, 0);
+ lua_pop(lua_state, 1);
+ return tolua_ret;
+ } else {
+ return ( bool ) cPlugin:: OnLogin(a_PacketData);
+ };
+ };
+ void OnPlayerSpawn( cPlayer* a_Player) {
+ if (push_method("OnPlayerSpawn", tolua_AllToLua_cPlugin_OnPlayerSpawn00)) {
+ tolua_pushusertype(lua_state, (void*)a_Player, "cPlayer");
+ ToluaBase::dbcall(lua_state, 2, 0);
+ } else {
+ return ( void ) cPlugin:: OnPlayerSpawn(a_Player);
+ };
+ };
+ bool OnPlayerJoin( cPlayer* a_Player) {
+ if (push_method("OnPlayerJoin", tolua_AllToLua_cPlugin_OnPlayerJoin00)) {
+ tolua_pushusertype(lua_state, (void*)a_Player, "cPlayer");
+ ToluaBase::dbcall(lua_state, 2, 1);
+ bool tolua_ret = ( bool )tolua_toboolean(lua_state, -1, 0);
+ lua_pop(lua_state, 1);
+ return tolua_ret;
+ } else {
+ return ( bool ) cPlugin:: OnPlayerJoin(a_Player);
+ };
+ };
+ void OnPlayerMove( cPlayer* a_Player) {
+ if (push_method("OnPlayerMove", tolua_AllToLua_cPlugin_OnPlayerMove00)) {
+ tolua_pushusertype(lua_state, (void*)a_Player, "cPlayer");
+ ToluaBase::dbcall(lua_state, 2, 0);
+ } else {
+ return ( void ) cPlugin:: OnPlayerMove(a_Player);
+ };
+ };
+ void OnTakeDamage( cPawn* a_Pawn, TakeDamageInfo* a_TakeDamageInfo) {
+ if (push_method("OnTakeDamage", tolua_AllToLua_cPlugin_OnTakeDamage00)) {
+ tolua_pushusertype(lua_state, (void*)a_Pawn, "cPawn");
+ tolua_pushusertype(lua_state, (void*)a_TakeDamageInfo, "TakeDamageInfo");
+ ToluaBase::dbcall(lua_state, 3, 0);
+ } else {
+ return ( void ) cPlugin:: OnTakeDamage(a_Pawn,a_TakeDamageInfo);
+ };
+ };
+ bool OnKilled( cPawn* a_Killed, cEntity* a_Killer) {
+ if (push_method("OnKilled", tolua_AllToLua_cPlugin_OnKilled00)) {
+ tolua_pushusertype(lua_state, (void*)a_Killed, "cPawn");
+ tolua_pushusertype(lua_state, (void*)a_Killer, "cEntity");
+ ToluaBase::dbcall(lua_state, 3, 1);
+ bool tolua_ret = ( bool )tolua_toboolean(lua_state, -1, 0);
+ lua_pop(lua_state, 1);
+ return tolua_ret;
+ } else {
+ return ( bool ) cPlugin:: OnKilled(a_Killed,a_Killer);
+ };
+ };
+
+ void cPlugin__OnDisable( void ) {
+ return ( void )cPlugin::OnDisable();
+ };
+ void cPlugin__Tick( float a_Dt) {
+ return ( void )cPlugin::Tick(a_Dt);
+ };
+ bool cPlugin__OnCollectItem( cPickup* a_Pickup, cPlayer* a_Player) {
+ return ( bool )cPlugin::OnCollectItem(a_Pickup,a_Player);
+ };
+ bool cPlugin__OnDisconnect( std::string a_Reason, cPlayer* a_Player) {
+ return ( bool )cPlugin::OnDisconnect(a_Reason,a_Player);
+ };
+ bool cPlugin__OnBlockPlace( cPacket_BlockPlace* a_PacketData, cPlayer* a_Player) {
+ return ( bool )cPlugin::OnBlockPlace(a_PacketData,a_Player);
+ };
+ bool cPlugin__OnBlockDig( cPacket_BlockDig* a_PacketData, cPlayer* a_Player, cItem* a_PickupItem) {
+ return ( bool )cPlugin::OnBlockDig(a_PacketData,a_Player,a_PickupItem);
+ };
+ bool cPlugin__OnChat( std::string a_Chat, cPlayer* a_Player) {
+ return ( bool )cPlugin::OnChat(a_Chat,a_Player);
+ };
+ bool cPlugin__OnLogin( cPacket_Login* a_PacketData) {
+ return ( bool )cPlugin::OnLogin(a_PacketData);
+ };
+ void cPlugin__OnPlayerSpawn( cPlayer* a_Player) {
+ return ( void )cPlugin::OnPlayerSpawn(a_Player);
+ };
+ bool cPlugin__OnPlayerJoin( cPlayer* a_Player) {
+ return ( bool )cPlugin::OnPlayerJoin(a_Player);
+ };
+ void cPlugin__OnPlayerMove( cPlayer* a_Player) {
+ return ( void )cPlugin::OnPlayerMove(a_Player);
+ };
+ void cPlugin__OnTakeDamage( cPawn* a_Pawn, TakeDamageInfo* a_TakeDamageInfo) {
+ return ( void )cPlugin::OnTakeDamage(a_Pawn,a_TakeDamageInfo);
+ };
+ bool cPlugin__OnKilled( cPawn* a_Killed, cEntity* a_Killer) {
+ return ( bool )cPlugin::OnKilled(a_Killed,a_Killer);
+ };
+ Lua__cPlugin( void ): cPlugin(){};
+};
+
+/* method: tolua__set_instance of class Lua__cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPlugin_tolua__set_instance00
+static int tolua_AllToLua_Lua__cPlugin_tolua__set_instance00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPlugin",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPlugin* self = (Lua__cPlugin*) tolua_tousertype(tolua_S,1,0);
+ lua_State* L = tolua_S;
+ lua_Object lo = ((lua_Object) tolua_tovalue(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'tolua__set_instance'", NULL);
+#endif
+ {
+ self->tolua__set_instance(L,lo);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'tolua__set_instance'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cPlugin__OnDisable of class Lua__cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPlugin_cPlugin__OnDisable00
+static int tolua_AllToLua_Lua__cPlugin_cPlugin__OnDisable00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPlugin",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPlugin* self = (Lua__cPlugin*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cPlugin__OnDisable'", NULL);
+#endif
+ {
+ self->cPlugin__OnDisable();
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'cPlugin__OnDisable'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cPlugin__Tick of class Lua__cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPlugin_cPlugin__Tick00
+static int tolua_AllToLua_Lua__cPlugin_cPlugin__Tick00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPlugin",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPlugin* self = (Lua__cPlugin*) tolua_tousertype(tolua_S,1,0);
+ float a_Dt = ((float) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cPlugin__Tick'", NULL);
+#endif
+ {
+ self->cPlugin__Tick(a_Dt);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'cPlugin__Tick'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cPlugin__OnCollectItem of class Lua__cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPlugin_cPlugin__OnCollectItem00
+static int tolua_AllToLua_Lua__cPlugin_cPlugin__OnCollectItem00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPlugin",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPickup",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,3,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPlugin* self = (Lua__cPlugin*) tolua_tousertype(tolua_S,1,0);
+ cPickup* a_Pickup = ((cPickup*) tolua_tousertype(tolua_S,2,0));
+ cPlayer* a_Player = ((cPlayer*) tolua_tousertype(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cPlugin__OnCollectItem'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->cPlugin__OnCollectItem(a_Pickup,a_Player);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'cPlugin__OnCollectItem'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cPlugin__OnDisconnect of class Lua__cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPlugin_cPlugin__OnDisconnect00
+static int tolua_AllToLua_Lua__cPlugin_cPlugin__OnDisconnect00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPlugin",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,3,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPlugin* self = (Lua__cPlugin*) tolua_tousertype(tolua_S,1,0);
+ std::string a_Reason = ((std::string) tolua_tocppstring(tolua_S,2,0));
+ cPlayer* a_Player = ((cPlayer*) tolua_tousertype(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cPlugin__OnDisconnect'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->cPlugin__OnDisconnect(a_Reason,a_Player);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'cPlugin__OnDisconnect'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cPlugin__OnBlockPlace of class Lua__cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPlugin_cPlugin__OnBlockPlace00
+static int tolua_AllToLua_Lua__cPlugin_cPlugin__OnBlockPlace00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPlugin",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPacket_BlockPlace",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,3,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPlugin* self = (Lua__cPlugin*) tolua_tousertype(tolua_S,1,0);
+ cPacket_BlockPlace* a_PacketData = ((cPacket_BlockPlace*) tolua_tousertype(tolua_S,2,0));
+ cPlayer* a_Player = ((cPlayer*) tolua_tousertype(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cPlugin__OnBlockPlace'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->cPlugin__OnBlockPlace(a_PacketData,a_Player);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'cPlugin__OnBlockPlace'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cPlugin__OnBlockDig of class Lua__cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPlugin_cPlugin__OnBlockDig00
+static int tolua_AllToLua_Lua__cPlugin_cPlugin__OnBlockDig00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPlugin",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPacket_BlockDig",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,3,"cPlayer",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,4,"cItem",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPlugin* self = (Lua__cPlugin*) tolua_tousertype(tolua_S,1,0);
+ cPacket_BlockDig* a_PacketData = ((cPacket_BlockDig*) tolua_tousertype(tolua_S,2,0));
+ cPlayer* a_Player = ((cPlayer*) tolua_tousertype(tolua_S,3,0));
+ cItem* a_PickupItem = ((cItem*) tolua_tousertype(tolua_S,4,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cPlugin__OnBlockDig'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->cPlugin__OnBlockDig(a_PacketData,a_Player,a_PickupItem);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'cPlugin__OnBlockDig'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cPlugin__OnChat of class Lua__cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPlugin_cPlugin__OnChat00
+static int tolua_AllToLua_Lua__cPlugin_cPlugin__OnChat00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPlugin",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,3,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPlugin* self = (Lua__cPlugin*) tolua_tousertype(tolua_S,1,0);
+ std::string a_Chat = ((std::string) tolua_tocppstring(tolua_S,2,0));
+ cPlayer* a_Player = ((cPlayer*) tolua_tousertype(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cPlugin__OnChat'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->cPlugin__OnChat(a_Chat,a_Player);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'cPlugin__OnChat'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cPlugin__OnLogin of class Lua__cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPlugin_cPlugin__OnLogin00
+static int tolua_AllToLua_Lua__cPlugin_cPlugin__OnLogin00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPlugin",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPacket_Login",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPlugin* self = (Lua__cPlugin*) tolua_tousertype(tolua_S,1,0);
+ cPacket_Login* a_PacketData = ((cPacket_Login*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cPlugin__OnLogin'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->cPlugin__OnLogin(a_PacketData);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'cPlugin__OnLogin'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cPlugin__OnPlayerSpawn of class Lua__cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPlugin_cPlugin__OnPlayerSpawn00
+static int tolua_AllToLua_Lua__cPlugin_cPlugin__OnPlayerSpawn00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPlugin",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPlugin* self = (Lua__cPlugin*) tolua_tousertype(tolua_S,1,0);
+ cPlayer* a_Player = ((cPlayer*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cPlugin__OnPlayerSpawn'", NULL);
+#endif
+ {
+ self->cPlugin__OnPlayerSpawn(a_Player);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'cPlugin__OnPlayerSpawn'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cPlugin__OnPlayerJoin of class Lua__cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPlugin_cPlugin__OnPlayerJoin00
+static int tolua_AllToLua_Lua__cPlugin_cPlugin__OnPlayerJoin00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPlugin",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPlugin* self = (Lua__cPlugin*) tolua_tousertype(tolua_S,1,0);
+ cPlayer* a_Player = ((cPlayer*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cPlugin__OnPlayerJoin'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->cPlugin__OnPlayerJoin(a_Player);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'cPlugin__OnPlayerJoin'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cPlugin__OnPlayerMove of class Lua__cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPlugin_cPlugin__OnPlayerMove00
+static int tolua_AllToLua_Lua__cPlugin_cPlugin__OnPlayerMove00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPlugin",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPlugin* self = (Lua__cPlugin*) tolua_tousertype(tolua_S,1,0);
+ cPlayer* a_Player = ((cPlayer*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cPlugin__OnPlayerMove'", NULL);
+#endif
+ {
+ self->cPlugin__OnPlayerMove(a_Player);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'cPlugin__OnPlayerMove'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cPlugin__OnTakeDamage of class Lua__cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPlugin_cPlugin__OnTakeDamage00
+static int tolua_AllToLua_Lua__cPlugin_cPlugin__OnTakeDamage00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPlugin",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPawn",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,3,"TakeDamageInfo",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPlugin* self = (Lua__cPlugin*) tolua_tousertype(tolua_S,1,0);
+ cPawn* a_Pawn = ((cPawn*) tolua_tousertype(tolua_S,2,0));
+ TakeDamageInfo* a_TakeDamageInfo = ((TakeDamageInfo*) tolua_tousertype(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cPlugin__OnTakeDamage'", NULL);
+#endif
+ {
+ self->cPlugin__OnTakeDamage(a_Pawn,a_TakeDamageInfo);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'cPlugin__OnTakeDamage'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cPlugin__OnKilled of class Lua__cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPlugin_cPlugin__OnKilled00
+static int tolua_AllToLua_Lua__cPlugin_cPlugin__OnKilled00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPlugin",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPawn",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,3,"cEntity",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPlugin* self = (Lua__cPlugin*) tolua_tousertype(tolua_S,1,0);
+ cPawn* a_Killed = ((cPawn*) tolua_tousertype(tolua_S,2,0));
+ cEntity* a_Killer = ((cEntity*) tolua_tousertype(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cPlugin__OnKilled'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->cPlugin__OnKilled(a_Killed,a_Killer);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'cPlugin__OnKilled'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class Lua__cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPlugin_new00
+static int tolua_AllToLua_Lua__cPlugin_new00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Lua__cPlugin",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ {
+ Lua__cPlugin* tolua_ret = (Lua__cPlugin*) Mtolua_new((Lua__cPlugin)());
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Lua__cPlugin");
+ }
+ }
+ 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 Lua__cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPlugin_new00_local
+static int tolua_AllToLua_Lua__cPlugin_new00_local(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Lua__cPlugin",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ {
+ Lua__cPlugin* tolua_ret = (Lua__cPlugin*) Mtolua_new((Lua__cPlugin)());
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Lua__cPlugin");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: delete of class Lua__cPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPlugin_delete00
+static int tolua_AllToLua_Lua__cPlugin_delete00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPlugin",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPlugin* self = (Lua__cPlugin*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
+#endif
+ Mtolua_delete(self);
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+/* function to release collected object via destructor */
+#ifdef __cplusplus
+
+static int tolua_collect_Lua__cPlugin (lua_State* tolua_S)
+{
+ Lua__cPlugin* self = (Lua__cPlugin*) tolua_tousertype(tolua_S,1,0);
+ delete self;
+ return 0;
+}
+#endif
+
+/* method: GetFileName of class cPlugin_Lua */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPlugin_Lua_GetFileName00
+static int tolua_AllToLua_cPlugin_Lua_GetFileName00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPlugin_Lua",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPlugin_Lua* self = (cPlugin_Lua*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetFileName'", NULL);
+#endif
+ {
+ std::string tolua_ret = (std::string) self->GetFileName();
+ tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetFileName'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetServer of class cServer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cServer_GetServer00
+static int tolua_AllToLua_cServer_GetServer00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cServer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ {
+ cServer* tolua_ret = (cServer*) cServer::GetServer();
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cServer");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetServer'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: ServerCommand of class cServer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cServer_ServerCommand00
+static int tolua_AllToLua_cServer_ServerCommand00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cServer",0,&tolua_err) ||
+ !tolua_isstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cServer* self = (cServer*) tolua_tousertype(tolua_S,1,0);
+ const char* a_Cmd = ((const char*) tolua_tostring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ServerCommand'", NULL);
+#endif
+ {
+ self->ServerCommand(a_Cmd);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'ServerCommand'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SendMessage of class cServer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cServer_SendMessage00
+static int tolua_AllToLua_cServer_SendMessage00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cServer",0,&tolua_err) ||
+ !tolua_isstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,3,"cPlayer",1,&tolua_err) ||
+ !tolua_isboolean(tolua_S,4,1,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cServer* self = (cServer*) tolua_tousertype(tolua_S,1,0);
+ const char* a_Message = ((const char*) tolua_tostring(tolua_S,2,0));
+ cPlayer* a_Player = ((cPlayer*) tolua_tousertype(tolua_S,3,0));
+ bool a_bExclude = ((bool) tolua_toboolean(tolua_S,4,false));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendMessage'", NULL);
+#endif
+ {
+ self->SendMessage(a_Message,a_Player,a_bExclude);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SendMessage'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetWorld of class cWorld */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetWorld00
+static int tolua_AllToLua_cWorld_GetWorld00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cWorld",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ {
+ cWorld* tolua_ret = (cWorld*) cWorld::GetWorld();
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cWorld");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetWorld'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetTime of class cWorld */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetTime00
+static int tolua_AllToLua_cWorld_GetTime00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cWorld",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ {
+ float tolua_ret = (float) cWorld::GetTime();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetTime'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetWorldTime of class cWorld */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetWorldTime00
+static int tolua_AllToLua_cWorld_SetWorldTime00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWorld* self = (cWorld*) tolua_tousertype(tolua_S,1,0);
+ long long a_WorldTime = ((long long) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetWorldTime'", NULL);
+#endif
+ {
+ self->SetWorldTime(a_WorldTime);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetWorldTime'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetHeight of class cWorld */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetHeight00
+static int tolua_AllToLua_cWorld_GetHeight00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWorld* self = (cWorld*) tolua_tousertype(tolua_S,1,0);
+ int a_X = ((int) tolua_tonumber(tolua_S,2,0));
+ int a_Z = ((int) tolua_tonumber(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetHeight'", NULL);
+#endif
+ {
+ char tolua_ret = (char) self->GetHeight(a_X,a_Z);
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetHeight'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetNumPlayers of class cWorld */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetNumPlayers00
+static int tolua_AllToLua_cWorld_GetNumPlayers00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWorld* self = (cWorld*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetNumPlayers'", NULL);
+#endif
+ {
+ unsigned int tolua_ret = (unsigned int) self->GetNumPlayers();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetNumPlayers'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetPlayer of class cWorld */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetPlayer00
+static int tolua_AllToLua_cWorld_GetPlayer00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
+ !tolua_isstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWorld* self = (cWorld*) tolua_tousertype(tolua_S,1,0);
+ const char* a_PlayerName = ((const char*) tolua_tostring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPlayer'", NULL);
+#endif
+ {
+ cPlayer* tolua_ret = (cPlayer*) self->GetPlayer(a_PlayerName);
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cPlayer");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetPlayer'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetEntity of class cWorld */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetEntity00
+static int tolua_AllToLua_cWorld_GetEntity00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWorld* self = (cWorld*) tolua_tousertype(tolua_S,1,0);
+ int a_UniqueID = ((int) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEntity'", NULL);
+#endif
+ {
+ cEntity* tolua_ret = (cEntity*) self->GetEntity(a_UniqueID);
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cEntity");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetEntity'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetBlock of class cWorld */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetBlock00
+static int tolua_AllToLua_cWorld_SetBlock00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,7,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWorld* self = (cWorld*) tolua_tousertype(tolua_S,1,0);
+ int a_X = ((int) tolua_tonumber(tolua_S,2,0));
+ int a_Y = ((int) tolua_tonumber(tolua_S,3,0));
+ int a_Z = ((int) tolua_tonumber(tolua_S,4,0));
+ char a_BlockType = ((char) tolua_tonumber(tolua_S,5,0));
+ char a_BlockMeta = ((char) tolua_tonumber(tolua_S,6,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetBlock'", NULL);
+#endif
+ {
+ self->SetBlock(a_X,a_Y,a_Z,a_BlockType,a_BlockMeta);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetBlock'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: FastSetBlock of class cWorld */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_FastSetBlock00
+static int tolua_AllToLua_cWorld_FastSetBlock00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,6,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,7,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWorld* self = (cWorld*) tolua_tousertype(tolua_S,1,0);
+ int a_X = ((int) tolua_tonumber(tolua_S,2,0));
+ int a_Y = ((int) tolua_tonumber(tolua_S,3,0));
+ int a_Z = ((int) tolua_tonumber(tolua_S,4,0));
+ char a_BlockType = ((char) tolua_tonumber(tolua_S,5,0));
+ char a_BlockMeta = ((char) tolua_tonumber(tolua_S,6,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'FastSetBlock'", NULL);
+#endif
+ {
+ self->FastSetBlock(a_X,a_Y,a_Z,a_BlockType,a_BlockMeta);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'FastSetBlock'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetBlock of class cWorld */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetBlock00
+static int tolua_AllToLua_cWorld_GetBlock00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWorld* self = (cWorld*) tolua_tousertype(tolua_S,1,0);
+ int a_X = ((int) tolua_tonumber(tolua_S,2,0));
+ int a_Y = ((int) tolua_tonumber(tolua_S,3,0));
+ int a_Z = ((int) tolua_tonumber(tolua_S,4,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetBlock'", NULL);
+#endif
+ {
+ char tolua_ret = (char) self->GetBlock(a_X,a_Y,a_Z);
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetBlock'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetBlockMeta of class cWorld */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetBlockMeta00
+static int tolua_AllToLua_cWorld_GetBlockMeta00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWorld* self = (cWorld*) tolua_tousertype(tolua_S,1,0);
+ int a_X = ((int) tolua_tonumber(tolua_S,2,0));
+ int a_Y = ((int) tolua_tonumber(tolua_S,3,0));
+ int a_Z = ((int) tolua_tonumber(tolua_S,4,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetBlockMeta'", NULL);
+#endif
+ {
+ char tolua_ret = (char) self->GetBlockMeta(a_X,a_Y,a_Z);
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetBlockMeta'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetBlockMeta of class cWorld */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SetBlockMeta00
+static int tolua_AllToLua_cWorld_SetBlockMeta00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,5,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,6,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWorld* self = (cWorld*) tolua_tousertype(tolua_S,1,0);
+ int a_X = ((int) tolua_tonumber(tolua_S,2,0));
+ int a_Y = ((int) tolua_tonumber(tolua_S,3,0));
+ int a_Z = ((int) tolua_tonumber(tolua_S,4,0));
+ char a_MetaData = ((char) tolua_tonumber(tolua_S,5,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetBlockMeta'", NULL);
+#endif
+ {
+ self->SetBlockMeta(a_X,a_Y,a_Z,a_MetaData);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetBlockMeta'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: DigBlock of class cWorld */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_DigBlock00
+static int tolua_AllToLua_cWorld_DigBlock00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"cItem",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,6,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWorld* self = (cWorld*) tolua_tousertype(tolua_S,1,0);
+ int a_X = ((int) tolua_tonumber(tolua_S,2,0));
+ int a_Y = ((int) tolua_tonumber(tolua_S,3,0));
+ int a_Z = ((int) tolua_tonumber(tolua_S,4,0));
+ cItem* a_PickupItem = ((cItem*) tolua_tousertype(tolua_S,5,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'DigBlock'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->DigBlock(a_X,a_Y,a_Z,*a_PickupItem);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'DigBlock'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SendBlockTo of class cWorld */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_SendBlockTo00
+static int tolua_AllToLua_cWorld_SendBlockTo00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,5,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,6,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWorld* self = (cWorld*) tolua_tousertype(tolua_S,1,0);
+ int a_X = ((int) tolua_tonumber(tolua_S,2,0));
+ int a_Y = ((int) tolua_tonumber(tolua_S,3,0));
+ int a_Z = ((int) tolua_tonumber(tolua_S,4,0));
+ cPlayer* a_Player = ((cPlayer*) tolua_tousertype(tolua_S,5,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendBlockTo'", NULL);
+#endif
+ {
+ self->SendBlockTo(a_X,a_Y,a_Z,a_Player);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SendBlockTo'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetSpawnX of class cWorld */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetSpawnX00
+static int tolua_AllToLua_cWorld_GetSpawnX00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWorld* self = (cWorld*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSpawnX'", NULL);
+#endif
+ {
+ const double tolua_ret = (const double) self->GetSpawnX();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetSpawnX'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetSpawnY of class cWorld */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetSpawnY00
+static int tolua_AllToLua_cWorld_GetSpawnY00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWorld* self = (cWorld*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSpawnY'", NULL);
+#endif
+ {
+ const double tolua_ret = (const double) self->GetSpawnY();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetSpawnY'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetSpawnZ of class cWorld */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetSpawnZ00
+static int tolua_AllToLua_cWorld_GetSpawnZ00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWorld* self = (cWorld*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSpawnZ'", NULL);
+#endif
+ {
+ const double tolua_ret = (const double) self->GetSpawnZ();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetSpawnZ'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetBlockEntity of class cWorld */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetBlockEntity00
+static int tolua_AllToLua_cWorld_GetBlockEntity00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWorld* self = (cWorld*) tolua_tousertype(tolua_S,1,0);
+ int a_X = ((int) tolua_tonumber(tolua_S,2,0));
+ int a_Y = ((int) tolua_tonumber(tolua_S,3,0));
+ int a_Z = ((int) tolua_tonumber(tolua_S,4,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetBlockEntity'", NULL);
+#endif
+ {
+ cBlockEntity* tolua_ret = (cBlockEntity*) self->GetBlockEntity(a_X,a_Y,a_Z);
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cBlockEntity");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetBlockEntity'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GrowTree of class cWorld */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GrowTree00
+static int tolua_AllToLua_cWorld_GrowTree00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWorld* self = (cWorld*) tolua_tousertype(tolua_S,1,0);
+ int a_X = ((int) tolua_tonumber(tolua_S,2,0));
+ int a_Y = ((int) tolua_tonumber(tolua_S,3,0));
+ int a_Z = ((int) tolua_tonumber(tolua_S,4,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GrowTree'", NULL);
+#endif
+ {
+ self->GrowTree(a_X,a_Y,a_Z);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GrowTree'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetWorldSeed of class cWorld */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWorld_GetWorldSeed00
+static int tolua_AllToLua_cWorld_GetWorldSeed00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cWorld",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWorld* self = (cWorld*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetWorldSeed'", NULL);
+#endif
+ {
+ unsigned int tolua_ret = (unsigned int) self->GetWorldSeed();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetWorldSeed'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Clear of class cInventory */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_Clear00
+static int tolua_AllToLua_cInventory_Clear00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cInventory* self = (cInventory*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Clear'", NULL);
+#endif
+ {
+ self->Clear();
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Clear'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: AddItem of class cInventory */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_AddItem00
+static int tolua_AllToLua_cInventory_AddItem00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cItem",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cInventory* self = (cInventory*) tolua_tousertype(tolua_S,1,0);
+ cItem* a_Item = ((cItem*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddItem'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->AddItem(*a_Item);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'AddItem'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: RemoveItem of class cInventory */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_RemoveItem00
+static int tolua_AllToLua_cInventory_RemoveItem00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cItem",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cInventory* self = (cInventory*) tolua_tousertype(tolua_S,1,0);
+ cItem* a_Item = ((cItem*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'RemoveItem'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->RemoveItem(*a_Item);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'RemoveItem'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetSlot of class cInventory */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_GetSlot00
+static int tolua_AllToLua_cInventory_GetSlot00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cInventory* self = (cInventory*) tolua_tousertype(tolua_S,1,0);
+ int a_SlotNum = ((int) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetSlot'", NULL);
+#endif
+ {
+ cItem* tolua_ret = (cItem*) self->GetSlot(a_SlotNum);
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cItem");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetSlot'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetFromHotBar of class cInventory */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_GetFromHotBar00
+static int tolua_AllToLua_cInventory_GetFromHotBar00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cInventory* self = (cInventory*) tolua_tousertype(tolua_S,1,0);
+ int a_SlotNum = ((int) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetFromHotBar'", NULL);
+#endif
+ {
+ cItem* tolua_ret = (cItem*) self->GetFromHotBar(a_SlotNum);
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cItem");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetFromHotBar'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetEquippedItem of class cInventory */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_GetEquippedItem00
+static int tolua_AllToLua_cInventory_GetEquippedItem00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cInventory* self = (cInventory*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetEquippedItem'", NULL);
+#endif
+ {
+ cItem& tolua_ret = (cItem&) self->GetEquippedItem();
+ tolua_pushusertype(tolua_S,(void*)&tolua_ret,"cItem");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetEquippedItem'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetEquippedSlot of class cInventory */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_SetEquippedSlot00
+static int tolua_AllToLua_cInventory_SetEquippedSlot00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cInventory* self = (cInventory*) tolua_tousertype(tolua_S,1,0);
+ int a_SlotNum = ((int) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetEquippedSlot'", NULL);
+#endif
+ {
+ self->SetEquippedSlot(a_SlotNum);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetEquippedSlot'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SendSlot of class cInventory */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cInventory_SendSlot00
+static int tolua_AllToLua_cInventory_SendSlot00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cInventory",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cInventory* self = (cInventory*) tolua_tousertype(tolua_S,1,0);
+ int a_SlotNum = ((int) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendSlot'", NULL);
+#endif
+ {
+ self->SendSlot(a_SlotNum);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SendSlot'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class cItem */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_new00
+static int tolua_AllToLua_cItem_new00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cItem",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ ENUM_ITEM_ID a_ItemID = ((ENUM_ITEM_ID) (int) tolua_tonumber(tolua_S,2,E_ITEM_EMPTY));
+ char a_ItemCount = ((char) tolua_tonumber(tolua_S,3,0));
+ short a_ItemHealth = ((short) tolua_tonumber(tolua_S,4,0));
+ {
+ cItem* tolua_ret = (cItem*) Mtolua_new((cItem)(a_ItemID,a_ItemCount,a_ItemHealth));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cItem");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new_local of class cItem */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_new00_local
+static int tolua_AllToLua_cItem_new00_local(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cItem",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,1,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ ENUM_ITEM_ID a_ItemID = ((ENUM_ITEM_ID) (int) tolua_tonumber(tolua_S,2,E_ITEM_EMPTY));
+ char a_ItemCount = ((char) tolua_tonumber(tolua_S,3,0));
+ short a_ItemHealth = ((short) tolua_tonumber(tolua_S,4,0));
+ {
+ cItem* tolua_ret = (cItem*) Mtolua_new((cItem)(a_ItemID,a_ItemCount,a_ItemHealth));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cItem");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Empty of class cItem */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_Empty00
+static int tolua_AllToLua_cItem_Empty00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cItem",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cItem* self = (cItem*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Empty'", NULL);
+#endif
+ {
+ self->Empty();
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Empty'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: IsEmpty of class cItem */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_IsEmpty00
+static int tolua_AllToLua_cItem_IsEmpty00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cItem",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cItem* self = (cItem*) 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: Equals of class cItem */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_Equals00
+static int tolua_AllToLua_cItem_Equals00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cItem",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cItem",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cItem* self = (cItem*) tolua_tousertype(tolua_S,1,0);
+ cItem* a_Item = ((cItem*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Equals'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->Equals(*a_Item);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Equals'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: m_ItemID of class cItem */
+#ifndef TOLUA_DISABLE_tolua_get_cItem_m_ItemID
+static int tolua_get_cItem_m_ItemID(lua_State* tolua_S)
+{
+ cItem* self = (cItem*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_ItemID'",NULL);
+#endif
+ tolua_pushnumber(tolua_S,(lua_Number)self->m_ItemID);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: m_ItemID of class cItem */
+#ifndef TOLUA_DISABLE_tolua_set_cItem_m_ItemID
+static int tolua_set_cItem_m_ItemID(lua_State* tolua_S)
+{
+ cItem* self = (cItem*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_ItemID'",NULL);
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->m_ItemID = ((ENUM_ITEM_ID) (int) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: m_ItemCount of class cItem */
+#ifndef TOLUA_DISABLE_tolua_get_cItem_m_ItemCount
+static int tolua_get_cItem_m_ItemCount(lua_State* tolua_S)
+{
+ cItem* self = (cItem*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_ItemCount'",NULL);
+#endif
+ tolua_pushnumber(tolua_S,(lua_Number)self->m_ItemCount);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: m_ItemCount of class cItem */
+#ifndef TOLUA_DISABLE_tolua_set_cItem_m_ItemCount
+static int tolua_set_cItem_m_ItemCount(lua_State* tolua_S)
+{
+ cItem* self = (cItem*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_ItemCount'",NULL);
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->m_ItemCount = ((char) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: m_ItemHealth of class cItem */
+#ifndef TOLUA_DISABLE_tolua_get_cItem_m_ItemHealth
+static int tolua_get_cItem_m_ItemHealth(lua_State* tolua_S)
+{
+ cItem* self = (cItem*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_ItemHealth'",NULL);
+#endif
+ tolua_pushnumber(tolua_S,(lua_Number)self->m_ItemHealth);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: m_ItemHealth of class cItem */
+#ifndef TOLUA_DISABLE_tolua_set_cItem_m_ItemHealth
+static int tolua_set_cItem_m_ItemHealth(lua_State* tolua_S)
+{
+ cItem* self = (cItem*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_ItemHealth'",NULL);
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->m_ItemHealth = ((short) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: Method of class HTTPRequest */
+#ifndef TOLUA_DISABLE_tolua_get_HTTPRequest_Method
+static int tolua_get_HTTPRequest_Method(lua_State* tolua_S)
+{
+ HTTPRequest* self = (HTTPRequest*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Method'",NULL);
+#endif
+ tolua_pushcppstring(tolua_S,(const char*)self->Method);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: Method of class HTTPRequest */
+#ifndef TOLUA_DISABLE_tolua_set_HTTPRequest_Method
+static int tolua_set_HTTPRequest_Method(lua_State* tolua_S)
+{
+ HTTPRequest* self = (HTTPRequest*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Method'",NULL);
+ if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->Method = ((std::string) tolua_tocppstring(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: Path of class HTTPRequest */
+#ifndef TOLUA_DISABLE_tolua_get_HTTPRequest_Path
+static int tolua_get_HTTPRequest_Path(lua_State* tolua_S)
+{
+ HTTPRequest* self = (HTTPRequest*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Path'",NULL);
+#endif
+ tolua_pushcppstring(tolua_S,(const char*)self->Path);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: Path of class HTTPRequest */
+#ifndef TOLUA_DISABLE_tolua_set_HTTPRequest_Path
+static int tolua_set_HTTPRequest_Path(lua_State* tolua_S)
+{
+ HTTPRequest* self = (HTTPRequest*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Path'",NULL);
+ if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->Path = ((std::string) tolua_tocppstring(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: Params of class HTTPRequest */
+#ifndef TOLUA_DISABLE_tolua_get_HTTPRequest_Params_ptr
+static int tolua_get_HTTPRequest_Params_ptr(lua_State* tolua_S)
+{
+ HTTPRequest* self = (HTTPRequest*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Params'",NULL);
+#endif
+ tolua_pushusertype(tolua_S,(void*)self->Params,"cStringMap");
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: Params of class HTTPRequest */
+#ifndef TOLUA_DISABLE_tolua_set_HTTPRequest_Params_ptr
+static int tolua_set_HTTPRequest_Params_ptr(lua_State* tolua_S)
+{
+ HTTPRequest* self = (HTTPRequest*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Params'",NULL);
+ if (!tolua_isusertype(tolua_S,2,"cStringMap",0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->Params = ((cStringMap*) tolua_tousertype(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: Username of class HTTPRequest */
+#ifndef TOLUA_DISABLE_tolua_get_HTTPRequest_Username
+static int tolua_get_HTTPRequest_Username(lua_State* tolua_S)
+{
+ HTTPRequest* self = (HTTPRequest*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Username'",NULL);
+#endif
+ tolua_pushcppstring(tolua_S,(const char*)self->Username);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: Username of class HTTPRequest */
+#ifndef TOLUA_DISABLE_tolua_set_HTTPRequest_Username
+static int tolua_set_HTTPRequest_Username(lua_State* tolua_S)
+{
+ HTTPRequest* self = (HTTPRequest*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'Username'",NULL);
+ if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->Username = ((std::string) tolua_tocppstring(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: delete of class cWebPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWebPlugin_delete00
+static int tolua_AllToLua_cWebPlugin_delete00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cWebPlugin",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWebPlugin* self = (cWebPlugin*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
+#endif
+ Mtolua_delete(self);
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetName of class cWebPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWebPlugin_SetName00
+static int tolua_AllToLua_cWebPlugin_SetName00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cWebPlugin",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWebPlugin* self = (cWebPlugin*) tolua_tousertype(tolua_S,1,0);
+ std::string a_Name = ((std::string) tolua_tocppstring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetName'", NULL);
+#endif
+ {
+ self->SetName(a_Name);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetName'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetName of class cWebPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWebPlugin_GetName00
+static int tolua_AllToLua_cWebPlugin_GetName00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cWebPlugin",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWebPlugin* self = (cWebPlugin*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetName'", NULL);
+#endif
+ {
+ std::string tolua_ret = (std::string) self->GetName();
+ tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetName'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: HandleRequest of class cWebPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWebPlugin_HandleRequest00
+static int tolua_AllToLua_cWebPlugin_HandleRequest00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cWebPlugin",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"HTTPRequest",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWebPlugin* self = (cWebPlugin*) tolua_tousertype(tolua_S,1,0);
+ HTTPRequest* a_Request = ((HTTPRequest*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HandleRequest'", NULL);
+#endif
+ {
+ std::string tolua_ret = (std::string) self->HandleRequest(a_Request);
+ tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'HandleRequest'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Initialize of class cWebPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cWebPlugin_Initialize00
+static int tolua_AllToLua_cWebPlugin_Initialize00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cWebPlugin",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWebPlugin* self = (cWebPlugin*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Initialize'", NULL);
+#endif
+ {
+ self->Initialize();
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Initialize'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+ class Lua__cWebPlugin : public cWebPlugin, public ToluaBase {
+public:
+ std::string HandleRequest( HTTPRequest* a_Request) {
+ if (push_method("HandleRequest", tolua_AllToLua_cWebPlugin_HandleRequest00)) {
+ tolua_pushusertype(lua_state, (void*)a_Request, "HTTPRequest");
+ ToluaBase::dbcall(lua_state, 2, 1);
+ std::string tolua_ret = ( std::string )tolua_tocppstring(lua_state, -1, 0);
+ lua_pop(lua_state, 1);
+ return tolua_ret;
+ } else {
+ if (lua_state)
+ LOG("pure-virtual method cWebPlugin::HandleRequest not implemented.");
+ else {
+ LOG("pure-virtual method cWebPlugin::HandleRequest called with no lua_state. Aborting");
+ ::abort();
+ };
+ return "";
+ };
+ };
+ void Initialize( void ) {
+ if (push_method("Initialize", tolua_AllToLua_cWebPlugin_Initialize00)) {
+ ToluaBase::dbcall(lua_state, 1, 0);
+ } else {
+ if (lua_state)
+ LOG("pure-virtual method cWebPlugin::Initialize not implemented.");
+ else {
+ LOG("pure-virtual method cWebPlugin::Initialize called with no lua_state. Aborting");
+ ::abort();
+ };
+ return ( void )0;
+ };
+ };
+
+ Lua__cWebPlugin( lua_State* L): cWebPlugin(L){};
+};
+
+/* method: tolua__set_instance of class Lua__cWebPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cWebPlugin_tolua__set_instance00
+static int tolua_AllToLua_Lua__cWebPlugin_tolua__set_instance00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cWebPlugin",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cWebPlugin* self = (Lua__cWebPlugin*) tolua_tousertype(tolua_S,1,0);
+ lua_State* L = tolua_S;
+ lua_Object lo = ((lua_Object) tolua_tovalue(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'tolua__set_instance'", NULL);
+#endif
+ {
+ self->tolua__set_instance(L,lo);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'tolua__set_instance'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class Lua__cWebPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cWebPlugin_new00
+static int tolua_AllToLua_Lua__cWebPlugin_new00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Lua__cWebPlugin",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ lua_State* L = tolua_S;
+ {
+ Lua__cWebPlugin* tolua_ret = (Lua__cWebPlugin*) Mtolua_new((Lua__cWebPlugin)(L));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Lua__cWebPlugin");
+ }
+ }
+ 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 Lua__cWebPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cWebPlugin_new00_local
+static int tolua_AllToLua_Lua__cWebPlugin_new00_local(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Lua__cWebPlugin",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ lua_State* L = tolua_S;
+ {
+ Lua__cWebPlugin* tolua_ret = (Lua__cWebPlugin*) Mtolua_new((Lua__cWebPlugin)(L));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Lua__cWebPlugin");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: delete of class Lua__cWebPlugin */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cWebPlugin_delete00
+static int tolua_AllToLua_Lua__cWebPlugin_delete00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cWebPlugin",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cWebPlugin* self = (Lua__cWebPlugin*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
+#endif
+ Mtolua_delete(self);
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+/* function to release collected object via destructor */
+#ifdef __cplusplus
+
+static int tolua_collect_Lua__cWebPlugin (lua_State* tolua_S)
+{
+ Lua__cWebPlugin* self = (Lua__cWebPlugin*) tolua_tousertype(tolua_S,1,0);
+ delete self;
+ return 0;
+}
+#endif
+
+/* method: new of class cPickup */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPickup_new00
+static int tolua_AllToLua_cPickup_new00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cPickup",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"const cItem",0,&tolua_err)) ||
+ !tolua_isnumber(tolua_S,6,1,&tolua_err) ||
+ !tolua_isnumber(tolua_S,7,1,&tolua_err) ||
+ !tolua_isnumber(tolua_S,8,1,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,9,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ int a_X = ((int) tolua_tonumber(tolua_S,2,0));
+ int a_Y = ((int) tolua_tonumber(tolua_S,3,0));
+ int a_Z = ((int) tolua_tonumber(tolua_S,4,0));
+ const cItem* a_Item = ((const cItem*) tolua_tousertype(tolua_S,5,0));
+ float a_SpeedX = ((float) tolua_tonumber(tolua_S,6,0.f));
+ float a_SpeedY = ((float) tolua_tonumber(tolua_S,7,0.f));
+ float a_SpeedZ = ((float) tolua_tonumber(tolua_S,8,0.f));
+ {
+ cPickup* tolua_ret = (cPickup*) Mtolua_new((cPickup)(a_X,a_Y,a_Z,*a_Item,a_SpeedX,a_SpeedY,a_SpeedZ));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cPickup");
+ }
+ }
+ 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 cPickup */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPickup_new00_local
+static int tolua_AllToLua_cPickup_new00_local(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cPickup",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"const cItem",0,&tolua_err)) ||
+ !tolua_isnumber(tolua_S,6,1,&tolua_err) ||
+ !tolua_isnumber(tolua_S,7,1,&tolua_err) ||
+ !tolua_isnumber(tolua_S,8,1,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,9,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ int a_X = ((int) tolua_tonumber(tolua_S,2,0));
+ int a_Y = ((int) tolua_tonumber(tolua_S,3,0));
+ int a_Z = ((int) tolua_tonumber(tolua_S,4,0));
+ const cItem* a_Item = ((const cItem*) tolua_tousertype(tolua_S,5,0));
+ float a_SpeedX = ((float) tolua_tonumber(tolua_S,6,0.f));
+ float a_SpeedY = ((float) tolua_tonumber(tolua_S,7,0.f));
+ float a_SpeedZ = ((float) tolua_tonumber(tolua_S,8,0.f));
+ {
+ cPickup* tolua_ret = (cPickup*) Mtolua_new((cPickup)(a_X,a_Y,a_Z,*a_Item,a_SpeedX,a_SpeedY,a_SpeedZ));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cPickup");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class cPickup */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPickup_new01
+static int tolua_AllToLua_cPickup_new01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cPickup",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPacket_PickupSpawn",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ cPacket_PickupSpawn* a_PickupSpawnPacket = ((cPacket_PickupSpawn*) tolua_tousertype(tolua_S,2,0));
+ {
+ cPickup* tolua_ret = (cPickup*) Mtolua_new((cPickup)(a_PickupSpawnPacket));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cPickup");
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_cPickup_new00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new_local of class cPickup */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPickup_new01_local
+static int tolua_AllToLua_cPickup_new01_local(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cPickup",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPacket_PickupSpawn",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ cPacket_PickupSpawn* a_PickupSpawnPacket = ((cPacket_PickupSpawn*) tolua_tousertype(tolua_S,2,0));
+ {
+ cPickup* tolua_ret = (cPickup*) Mtolua_new((cPickup)(a_PickupSpawnPacket));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cPickup");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_cPickup_new00_local(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: delete of class cPickup */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPickup_delete00
+static int tolua_AllToLua_cPickup_delete00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPickup",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPickup* self = (cPickup*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
+#endif
+ Mtolua_delete(self);
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetItem of class cPickup */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPickup_GetItem00
+static int tolua_AllToLua_cPickup_GetItem00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPickup",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPickup* self = (cPickup*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetItem'", NULL);
+#endif
+ {
+ cItem* tolua_ret = (cItem*) self->GetItem();
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cItem");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetItem'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: CollectedBy of class cPickup */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPickup_CollectedBy00
+static int tolua_AllToLua_cPickup_CollectedBy00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cPickup",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cPickup* self = (cPickup*) tolua_tousertype(tolua_S,1,0);
+ cPlayer* a_Dest = ((cPlayer*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CollectedBy'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->CollectedBy(a_Dest);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'CollectedBy'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+ class Lua__cPickup : public cPickup, public ToluaBase {
+public:
+ bool CollectedBy( cPlayer* a_Dest) {
+ if (push_method("CollectedBy", tolua_AllToLua_cPickup_CollectedBy00)) {
+ tolua_pushusertype(lua_state, (void*)a_Dest, "cPlayer");
+ ToluaBase::dbcall(lua_state, 2, 1);
+ bool tolua_ret = ( bool )tolua_toboolean(lua_state, -1, 0);
+ lua_pop(lua_state, 1);
+ return tolua_ret;
+ } else {
+ return ( bool ) cPickup:: CollectedBy(a_Dest);
+ };
+ };
+ void Initialize( void ) {
+ if (push_method("Initialize", tolua_AllToLua_cEntity_Initialize00)) {
+ ToluaBase::dbcall(lua_state, 1, 0);
+ } else {
+ return ( void ) cPickup:: Initialize();
+ };
+ };
+ unsigned int GetEntityType( void ) {
+ if (push_method("GetEntityType", tolua_AllToLua_cEntity_GetEntityType00)) {
+ ToluaBase::dbcall(lua_state, 1, 1);
+ unsigned int tolua_ret = (unsigned int )tolua_tonumber(lua_state, -1, 0);
+ lua_pop(lua_state, 1);
+ return tolua_ret;
+ } else {
+ return (unsigned int ) cPickup:: GetEntityType();
+ };
+ };
+ bool IsA( const char* a_EntityType) {
+ if (push_method("IsA", tolua_AllToLua_cEntity_IsA00)) {
+ tolua_pushstring(lua_state, (const char*)a_EntityType);
+ ToluaBase::dbcall(lua_state, 2, 1);
+ bool tolua_ret = ( bool )tolua_toboolean(lua_state, -1, 0);
+ lua_pop(lua_state, 1);
+ return tolua_ret;
+ } else {
+ return ( bool ) cPickup:: IsA(a_EntityType);
+ };
+ };
+ const char* GetClass( void ) {
+ if (push_method("GetClass", tolua_AllToLua_cEntity_GetClass00)) {
+ ToluaBase::dbcall(lua_state, 1, 1);
+ const char* tolua_ret = ( const char* )tolua_tostring(lua_state, -1, 0);
+ lua_pop(lua_state, 1);
+ return tolua_ret;
+ } else {
+ return ( const char* ) cPickup:: GetClass();
+ };
+ };
+ void Tick( float a_Dt) {
+ if (push_method("Tick", tolua_AllToLua_cEntity_Tick00)) {
+ tolua_pushnumber(lua_state, (lua_Number)a_Dt);
+ ToluaBase::dbcall(lua_state, 2, 0);
+ } else {
+ if (lua_state)
+ LOG("pure-virtual method cPickup::Tick not implemented.");
+ else {
+ LOG("pure-virtual method cPickup::Tick called with no lua_state. Aborting");
+ ::abort();
+ };
+ return ( void )0;
+ };
+ };
+ void SpawnOn( cClientHandle* a_Target) {
+ if (push_method("SpawnOn", tolua_AllToLua_cEntity_SpawnOn00)) {
+ tolua_pushusertype(lua_state, (void*)a_Target, "cClientHandle");
+ ToluaBase::dbcall(lua_state, 2, 0);
+ } else {
+ if (lua_state)
+ LOG("pure-virtual method cPickup::SpawnOn not implemented.");
+ else {
+ LOG("pure-virtual method cPickup::SpawnOn called with no lua_state. Aborting");
+ ::abort();
+ };
+ return ( void )0;
+ };
+ };
+
+ bool cPickup__CollectedBy( cPlayer* a_Dest) {
+ return ( bool )cPickup::CollectedBy(a_Dest);
+ };
+ void cPickup__Initialize( void ) {
+ return ( void )cPickup::Initialize();
+ };
+ unsigned int cPickup__GetEntityType( void ) {
+ return (unsigned int )cPickup::GetEntityType();
+ };
+ bool cPickup__IsA( const char* a_EntityType) {
+ return ( bool )cPickup::IsA(a_EntityType);
+ };
+ const char* cPickup__GetClass( void ) {
+ return ( const char* )cPickup::GetClass();
+ };
+ Lua__cPickup( int a_X, int a_Y, int a_Z, const cItem& a_Item, float a_SpeedX = 0.f, float a_SpeedY = 0.f, float a_SpeedZ = 0.f): cPickup(a_X,a_Y,a_Z,a_Item,a_SpeedX,a_SpeedY,a_SpeedZ){};
+ Lua__cPickup( cPacket_PickupSpawn* a_PickupSpawnPacket): cPickup(a_PickupSpawnPacket){};
+};
+
+/* method: tolua__set_instance of class Lua__cPickup */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPickup_tolua__set_instance00
+static int tolua_AllToLua_Lua__cPickup_tolua__set_instance00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPickup",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPickup* self = (Lua__cPickup*) tolua_tousertype(tolua_S,1,0);
+ lua_State* L = tolua_S;
+ lua_Object lo = ((lua_Object) tolua_tovalue(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'tolua__set_instance'", NULL);
+#endif
+ {
+ self->tolua__set_instance(L,lo);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'tolua__set_instance'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cPickup__CollectedBy of class Lua__cPickup */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPickup_cPickup__CollectedBy00
+static int tolua_AllToLua_Lua__cPickup_cPickup__CollectedBy00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPickup",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPlayer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPickup* self = (Lua__cPickup*) tolua_tousertype(tolua_S,1,0);
+ cPlayer* a_Dest = ((cPlayer*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cPickup__CollectedBy'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->cPickup__CollectedBy(a_Dest);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'cPickup__CollectedBy'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class Lua__cPickup */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPickup_new00
+static int tolua_AllToLua_Lua__cPickup_new00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Lua__cPickup",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"cItem",0,&tolua_err)) ||
+ !tolua_isnumber(tolua_S,6,1,&tolua_err) ||
+ !tolua_isnumber(tolua_S,7,1,&tolua_err) ||
+ !tolua_isnumber(tolua_S,8,1,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,9,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ int a_X = ((int) tolua_tonumber(tolua_S,2,0));
+ int a_Y = ((int) tolua_tonumber(tolua_S,3,0));
+ int a_Z = ((int) tolua_tonumber(tolua_S,4,0));
+ const cItem* a_Item = ((const cItem*) tolua_tousertype(tolua_S,5,0));
+ float a_SpeedX = ((float) tolua_tonumber(tolua_S,6,0.f));
+ float a_SpeedY = ((float) tolua_tonumber(tolua_S,7,0.f));
+ float a_SpeedZ = ((float) tolua_tonumber(tolua_S,8,0.f));
+ {
+ Lua__cPickup* tolua_ret = (Lua__cPickup*) Mtolua_new((Lua__cPickup)(a_X,a_Y,a_Z,*a_Item,a_SpeedX,a_SpeedY,a_SpeedZ));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Lua__cPickup");
+ }
+ }
+ 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 Lua__cPickup */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPickup_new00_local
+static int tolua_AllToLua_Lua__cPickup_new00_local(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Lua__cPickup",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,5,&tolua_err) || !tolua_isusertype(tolua_S,5,"cItem",0,&tolua_err)) ||
+ !tolua_isnumber(tolua_S,6,1,&tolua_err) ||
+ !tolua_isnumber(tolua_S,7,1,&tolua_err) ||
+ !tolua_isnumber(tolua_S,8,1,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,9,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ int a_X = ((int) tolua_tonumber(tolua_S,2,0));
+ int a_Y = ((int) tolua_tonumber(tolua_S,3,0));
+ int a_Z = ((int) tolua_tonumber(tolua_S,4,0));
+ const cItem* a_Item = ((const cItem*) tolua_tousertype(tolua_S,5,0));
+ float a_SpeedX = ((float) tolua_tonumber(tolua_S,6,0.f));
+ float a_SpeedY = ((float) tolua_tonumber(tolua_S,7,0.f));
+ float a_SpeedZ = ((float) tolua_tonumber(tolua_S,8,0.f));
+ {
+ Lua__cPickup* tolua_ret = (Lua__cPickup*) Mtolua_new((Lua__cPickup)(a_X,a_Y,a_Z,*a_Item,a_SpeedX,a_SpeedY,a_SpeedZ));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Lua__cPickup");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class Lua__cPickup */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPickup_new01
+static int tolua_AllToLua_Lua__cPickup_new01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Lua__cPickup",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPacket_PickupSpawn",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ cPacket_PickupSpawn* a_PickupSpawnPacket = ((cPacket_PickupSpawn*) tolua_tousertype(tolua_S,2,0));
+ {
+ Lua__cPickup* tolua_ret = (Lua__cPickup*) Mtolua_new((Lua__cPickup)(a_PickupSpawnPacket));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Lua__cPickup");
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Lua__cPickup_new00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new_local of class Lua__cPickup */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPickup_new01_local
+static int tolua_AllToLua_Lua__cPickup_new01_local(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Lua__cPickup",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cPacket_PickupSpawn",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ cPacket_PickupSpawn* a_PickupSpawnPacket = ((cPacket_PickupSpawn*) tolua_tousertype(tolua_S,2,0));
+ {
+ Lua__cPickup* tolua_ret = (Lua__cPickup*) Mtolua_new((Lua__cPickup)(a_PickupSpawnPacket));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Lua__cPickup");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Lua__cPickup_new00_local(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: delete of class Lua__cPickup */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPickup_delete00
+static int tolua_AllToLua_Lua__cPickup_delete00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPickup",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPickup* self = (Lua__cPickup*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
+#endif
+ Mtolua_delete(self);
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+/* function to release collected object via destructor */
+#ifdef __cplusplus
+
+static int tolua_collect_Lua__cPickup (lua_State* tolua_S)
+{
+ Lua__cPickup* self = (Lua__cPickup*) tolua_tousertype(tolua_S,1,0);
+ delete self;
+ return 0;
+}
+#endif
+
+/* method: Get of class cRoot */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_Get00
+static int tolua_AllToLua_cRoot_Get00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cRoot",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ {
+ cRoot* tolua_ret = (cRoot*) cRoot::Get();
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cRoot");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Get'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetServer of class cRoot */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_GetServer00
+static int tolua_AllToLua_cRoot_GetServer00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cRoot* self = (cRoot*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetServer'", NULL);
+#endif
+ {
+ cServer* tolua_ret = (cServer*) self->GetServer();
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cServer");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetServer'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetWorld of class cRoot */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_GetWorld00
+static int tolua_AllToLua_cRoot_GetWorld00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cRoot* self = (cRoot*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetWorld'", NULL);
+#endif
+ {
+ cWorld* tolua_ret = (cWorld*) self->GetWorld();
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cWorld");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetWorld'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetGroupManager of class cRoot */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_GetGroupManager00
+static int tolua_AllToLua_cRoot_GetGroupManager00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cRoot* self = (cRoot*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetGroupManager'", NULL);
+#endif
+ {
+ cGroupManager* tolua_ret = (cGroupManager*) self->GetGroupManager();
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cGroupManager");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetGroupManager'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetRecipeChecker of class cRoot */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_GetRecipeChecker00
+static int tolua_AllToLua_cRoot_GetRecipeChecker00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cRoot* self = (cRoot*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetRecipeChecker'", NULL);
+#endif
+ {
+ cRecipeChecker* tolua_ret = (cRecipeChecker*) self->GetRecipeChecker();
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cRecipeChecker");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetRecipeChecker'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetFurnaceRecipe of class cRoot */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_GetFurnaceRecipe00
+static int tolua_AllToLua_cRoot_GetFurnaceRecipe00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cRoot* self = (cRoot*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetFurnaceRecipe'", NULL);
+#endif
+ {
+ cFurnaceRecipe* tolua_ret = (cFurnaceRecipe*) self->GetFurnaceRecipe();
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cFurnaceRecipe");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetFurnaceRecipe'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetWebAdmin of class cRoot */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_GetWebAdmin00
+static int tolua_AllToLua_cRoot_GetWebAdmin00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cRoot* self = (cRoot*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetWebAdmin'", NULL);
+#endif
+ {
+ cWebAdmin* tolua_ret = (cWebAdmin*) self->GetWebAdmin();
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cWebAdmin");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetWebAdmin'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetPluginManager of class cRoot */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_GetPluginManager00
+static int tolua_AllToLua_cRoot_GetPluginManager00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cRoot* self = (cRoot*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPluginManager'", NULL);
+#endif
+ {
+ cPluginManager* tolua_ret = (cPluginManager*) self->GetPluginManager();
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cPluginManager");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetPluginManager'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: ServerCommand of class cRoot */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cRoot_ServerCommand00
+static int tolua_AllToLua_cRoot_ServerCommand00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cRoot",0,&tolua_err) ||
+ !tolua_isstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cRoot* self = (cRoot*) tolua_tousertype(tolua_S,1,0);
+ const char* a_Cmd = ((const char*) tolua_tostring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ServerCommand'", NULL);
+#endif
+ {
+ self->ServerCommand(a_Cmd);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'ServerCommand'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: delete of class cTCPLink */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cTCPLink_delete00
+static int tolua_AllToLua_cTCPLink_delete00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cTCPLink",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cTCPLink* self = (cTCPLink*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
+#endif
+ Mtolua_delete(self);
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Connect of class cTCPLink */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cTCPLink_Connect00
+static int tolua_AllToLua_cTCPLink_Connect00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cTCPLink",0,&tolua_err) ||
+ !tolua_isstring(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
+ {
+ cTCPLink* self = (cTCPLink*) tolua_tousertype(tolua_S,1,0);
+ const char* a_Address = ((const char*) tolua_tostring(tolua_S,2,0));
+ unsigned int a_Port = ((unsigned int) tolua_tonumber(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Connect'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->Connect(a_Address,a_Port);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Connect'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Send of class cTCPLink */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cTCPLink_Send00
+static int tolua_AllToLua_cTCPLink_Send00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cTCPLink",0,&tolua_err) ||
+ !tolua_isstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,1,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cTCPLink* self = (cTCPLink*) tolua_tousertype(tolua_S,1,0);
+ char* a_Data = ((char*) tolua_tostring(tolua_S,2,0));
+ unsigned int a_Size = ((unsigned int) tolua_tonumber(tolua_S,3,0));
+ int a_Flags = ((int) tolua_tonumber(tolua_S,4,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Send'", NULL);
+#endif
+ {
+ int tolua_ret = (int) self->Send(a_Data,a_Size,a_Flags);
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Send'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SendMessage of class cTCPLink */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cTCPLink_SendMessage00
+static int tolua_AllToLua_cTCPLink_SendMessage00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cTCPLink",0,&tolua_err) ||
+ !tolua_isstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cTCPLink* self = (cTCPLink*) tolua_tousertype(tolua_S,1,0);
+ const char* a_Message = ((const char*) tolua_tostring(tolua_S,2,0));
+ int a_Flags = ((int) tolua_tonumber(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SendMessage'", NULL);
+#endif
+ {
+ int tolua_ret = (int) self->SendMessage(a_Message,a_Flags);
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SendMessage'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: CloseSocket of class cTCPLink */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cTCPLink_CloseSocket00
+static int tolua_AllToLua_cTCPLink_CloseSocket00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cTCPLink",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cTCPLink* self = (cTCPLink*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'CloseSocket'", NULL);
+#endif
+ {
+ self->CloseSocket();
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'CloseSocket'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+ class Lua__cTCPLink : public cTCPLink, public ToluaBase {
+public:
+ void ReceivedData( char* a_Data, int a_Size) {
+ if (push_method("ReceivedData", NULL)) {
+ tolua_pushstring(lua_state, (const char*)a_Data);
+ tolua_pushnumber(lua_state, (lua_Number)a_Size);
+ ToluaBase::dbcall(lua_state, 3, 0);
+ } else {
+ if (lua_state)
+ LOG("pure-virtual method cTCPLink::ReceivedData not implemented.");
+ else {
+ LOG("pure-virtual method cTCPLink::ReceivedData called with no lua_state. Aborting");
+ ::abort();
+ };
+ return ( void )0;
+ };
+ };
+
+ Lua__cTCPLink( void ): cTCPLink(){};
+};
+
+/* method: tolua__set_instance of class Lua__cTCPLink */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cTCPLink_tolua__set_instance00
+static int tolua_AllToLua_Lua__cTCPLink_tolua__set_instance00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cTCPLink",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cTCPLink* self = (Lua__cTCPLink*) tolua_tousertype(tolua_S,1,0);
+ lua_State* L = tolua_S;
+ lua_Object lo = ((lua_Object) tolua_tovalue(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'tolua__set_instance'", NULL);
+#endif
+ {
+ self->tolua__set_instance(L,lo);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'tolua__set_instance'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class Lua__cTCPLink */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cTCPLink_new00
+static int tolua_AllToLua_Lua__cTCPLink_new00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Lua__cTCPLink",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ {
+ Lua__cTCPLink* tolua_ret = (Lua__cTCPLink*) Mtolua_new((Lua__cTCPLink)());
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Lua__cTCPLink");
+ }
+ }
+ 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 Lua__cTCPLink */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cTCPLink_new00_local
+static int tolua_AllToLua_Lua__cTCPLink_new00_local(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Lua__cTCPLink",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ {
+ Lua__cTCPLink* tolua_ret = (Lua__cTCPLink*) Mtolua_new((Lua__cTCPLink)());
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Lua__cTCPLink");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: delete of class Lua__cTCPLink */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cTCPLink_delete00
+static int tolua_AllToLua_Lua__cTCPLink_delete00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cTCPLink",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cTCPLink* self = (Lua__cTCPLink*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
+#endif
+ Mtolua_delete(self);
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+/* function to release collected object via destructor */
+#ifdef __cplusplus
+
+static int tolua_collect_Lua__cTCPLink (lua_State* tolua_S)
+{
+ Lua__cTCPLink* self = (Lua__cTCPLink*) tolua_tousertype(tolua_S,1,0);
+ delete self;
+ return 0;
+}
+#endif
+
+/* method: new of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_new00
+static int tolua_AllToLua_Vector3f_new00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3f",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3d",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3d* v = ((const Vector3d*) tolua_tousertype(tolua_S,2,0));
+ {
+ Vector3f* tolua_ret = (Vector3f*) Mtolua_new((Vector3f)(*v));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3f");
+ }
+ }
+ 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 Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_new00_local
+static int tolua_AllToLua_Vector3f_new00_local(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3f",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3d",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3d* v = ((const Vector3d*) tolua_tousertype(tolua_S,2,0));
+ {
+ Vector3f* tolua_ret = (Vector3f*) Mtolua_new((Vector3f)(*v));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3f");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_new01
+static int tolua_AllToLua_Vector3f_new01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3f",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"const Vector3d",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const Vector3d* v = ((const Vector3d*) tolua_tousertype(tolua_S,2,0));
+ {
+ Vector3f* tolua_ret = (Vector3f*) Mtolua_new((Vector3f)(v));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3f");
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3f_new00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new_local of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_new01_local
+static int tolua_AllToLua_Vector3f_new01_local(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3f",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"const Vector3d",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const Vector3d* v = ((const Vector3d*) tolua_tousertype(tolua_S,2,0));
+ {
+ Vector3f* tolua_ret = (Vector3f*) Mtolua_new((Vector3f)(v));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3f");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3f_new00_local(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_new02
+static int tolua_AllToLua_Vector3f_new02(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3f",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3i",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const Vector3i* v = ((const Vector3i*) tolua_tousertype(tolua_S,2,0));
+ {
+ Vector3f* tolua_ret = (Vector3f*) Mtolua_new((Vector3f)(*v));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3f");
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3f_new01(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new_local of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_new02_local
+static int tolua_AllToLua_Vector3f_new02_local(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3f",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3i",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const Vector3i* v = ((const Vector3i*) tolua_tousertype(tolua_S,2,0));
+ {
+ Vector3f* tolua_ret = (Vector3f*) Mtolua_new((Vector3f)(*v));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3f");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3f_new01_local(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_new03
+static int tolua_AllToLua_Vector3f_new03(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3f",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"const Vector3i",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const Vector3i* v = ((const Vector3i*) tolua_tousertype(tolua_S,2,0));
+ {
+ Vector3f* tolua_ret = (Vector3f*) Mtolua_new((Vector3f)(v));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3f");
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3f_new02(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new_local of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_new03_local
+static int tolua_AllToLua_Vector3f_new03_local(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3f",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"const Vector3i",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const Vector3i* v = ((const Vector3i*) tolua_tousertype(tolua_S,2,0));
+ {
+ Vector3f* tolua_ret = (Vector3f*) Mtolua_new((Vector3f)(v));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3f");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3f_new02_local(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_new04
+static int tolua_AllToLua_Vector3f_new04(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3f",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ {
+ Vector3f* tolua_ret = (Vector3f*) Mtolua_new((Vector3f)());
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3f");
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3f_new03(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new_local of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_new04_local
+static int tolua_AllToLua_Vector3f_new04_local(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3f",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ {
+ Vector3f* tolua_ret = (Vector3f*) Mtolua_new((Vector3f)());
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3f");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3f_new03_local(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_new05
+static int tolua_AllToLua_Vector3f_new05(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3f",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ float a_x = ((float) tolua_tonumber(tolua_S,2,0));
+ float a_y = ((float) tolua_tonumber(tolua_S,3,0));
+ float a_z = ((float) tolua_tonumber(tolua_S,4,0));
+ {
+ Vector3f* tolua_ret = (Vector3f*) Mtolua_new((Vector3f)(a_x,a_y,a_z));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3f");
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3f_new04(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new_local of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_new05_local
+static int tolua_AllToLua_Vector3f_new05_local(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3f",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ float a_x = ((float) tolua_tonumber(tolua_S,2,0));
+ float a_y = ((float) tolua_tonumber(tolua_S,3,0));
+ float a_z = ((float) tolua_tonumber(tolua_S,4,0));
+ {
+ Vector3f* tolua_ret = (Vector3f*) Mtolua_new((Vector3f)(a_x,a_y,a_z));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3f");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3f_new04_local(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Set of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_Set00
+static int tolua_AllToLua_Vector3f_Set00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Vector3f",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
+ {
+ Vector3f* self = (Vector3f*) tolua_tousertype(tolua_S,1,0);
+ float a_x = ((float) tolua_tonumber(tolua_S,2,0));
+ float a_y = ((float) tolua_tonumber(tolua_S,3,0));
+ float a_z = ((float) tolua_tonumber(tolua_S,4,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Set'", NULL);
+#endif
+ {
+ self->Set(a_x,a_y,a_z);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Set'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Normalize of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_Normalize00
+static int tolua_AllToLua_Vector3f_Normalize00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Vector3f",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Vector3f* self = (Vector3f*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Normalize'", NULL);
+#endif
+ {
+ self->Normalize();
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Normalize'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: NormalizeCopy of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_NormalizeCopy00
+static int tolua_AllToLua_Vector3f_NormalizeCopy00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3f",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3f* self = (const Vector3f*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NormalizeCopy'", NULL);
+#endif
+ {
+ Vector3f tolua_ret = (Vector3f) self->NormalizeCopy();
+ {
+#ifdef __cplusplus
+ void* tolua_obj = Mtolua_new((Vector3f)(tolua_ret));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3f");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#else
+ void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3f));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3f");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#endif
+ }
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'NormalizeCopy'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: NormalizeCopy of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_NormalizeCopy01
+static int tolua_AllToLua_Vector3f_NormalizeCopy01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3f",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3f",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const Vector3f* self = (const Vector3f*) tolua_tousertype(tolua_S,1,0);
+ Vector3f* a_V = ((Vector3f*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NormalizeCopy'", NULL);
+#endif
+ {
+ self->NormalizeCopy(*a_V);
+ }
+ }
+ return 0;
+tolua_lerror:
+ return tolua_AllToLua_Vector3f_NormalizeCopy00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Length of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_Length00
+static int tolua_AllToLua_Vector3f_Length00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3f",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3f* self = (const Vector3f*) 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: SqrLength of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_SqrLength00
+static int tolua_AllToLua_Vector3f_SqrLength00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3f",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3f* self = (const Vector3f*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SqrLength'", NULL);
+#endif
+ {
+ float tolua_ret = (float) self->SqrLength();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SqrLength'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Dot of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_Dot00
+static int tolua_AllToLua_Vector3f_Dot00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3f",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3f",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3f* self = (const Vector3f*) tolua_tousertype(tolua_S,1,0);
+ const Vector3f* a_V = ((const Vector3f*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Dot'", NULL);
+#endif
+ {
+ float tolua_ret = (float) self->Dot(*a_V);
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Dot'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Cross of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_Cross00
+static int tolua_AllToLua_Vector3f_Cross00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3f",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3f",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3f* self = (const Vector3f*) tolua_tousertype(tolua_S,1,0);
+ const Vector3f* v = ((const Vector3f*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Cross'", NULL);
+#endif
+ {
+ Vector3f tolua_ret = (Vector3f) self->Cross(*v);
+ {
+#ifdef __cplusplus
+ void* tolua_obj = Mtolua_new((Vector3f)(tolua_ret));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3f");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#else
+ void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3f));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3f");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#endif
+ }
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Cross'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Equals of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f_Equals00
+static int tolua_AllToLua_Vector3f_Equals00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3f",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3f",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3f* self = (const Vector3f*) tolua_tousertype(tolua_S,1,0);
+ const Vector3f* v = ((const Vector3f*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Equals'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->Equals(*v);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Equals'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: operator+ of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f__add00
+static int tolua_AllToLua_Vector3f__add00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3f",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3f",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3f* self = (const Vector3f*) tolua_tousertype(tolua_S,1,0);
+ const Vector3f* v2 = ((const Vector3f*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'", NULL);
+#endif
+ {
+ Vector3f tolua_ret = (Vector3f) self->operator+(*v2);
+ {
+#ifdef __cplusplus
+ void* tolua_obj = Mtolua_new((Vector3f)(tolua_ret));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3f");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#else
+ void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3f));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3f");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#endif
+ }
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function '.add'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: operator+ of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f__add01
+static int tolua_AllToLua_Vector3f__add01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3f",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"const Vector3f",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const Vector3f* self = (const Vector3f*) tolua_tousertype(tolua_S,1,0);
+ const Vector3f* v2 = ((const Vector3f*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'", NULL);
+#endif
+ {
+ Vector3f tolua_ret = (Vector3f) self->operator+(v2);
+ {
+#ifdef __cplusplus
+ void* tolua_obj = Mtolua_new((Vector3f)(tolua_ret));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3f");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#else
+ void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3f));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3f");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#endif
+ }
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3f__add00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: operator- of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f__sub00
+static int tolua_AllToLua_Vector3f__sub00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3f",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3f",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3f* self = (const Vector3f*) tolua_tousertype(tolua_S,1,0);
+ const Vector3f* v2 = ((const Vector3f*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'", NULL);
+#endif
+ {
+ Vector3f tolua_ret = (Vector3f) self->operator-(*v2);
+ {
+#ifdef __cplusplus
+ void* tolua_obj = Mtolua_new((Vector3f)(tolua_ret));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3f");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#else
+ void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3f));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3f");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#endif
+ }
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function '.sub'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: operator- of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f__sub01
+static int tolua_AllToLua_Vector3f__sub01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3f",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"const Vector3f",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const Vector3f* self = (const Vector3f*) tolua_tousertype(tolua_S,1,0);
+ const Vector3f* v2 = ((const Vector3f*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'", NULL);
+#endif
+ {
+ Vector3f tolua_ret = (Vector3f) self->operator-(v2);
+ {
+#ifdef __cplusplus
+ void* tolua_obj = Mtolua_new((Vector3f)(tolua_ret));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3f");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#else
+ void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3f));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3f");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#endif
+ }
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3f__sub00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: operator* of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f__mul00
+static int tolua_AllToLua_Vector3f__mul00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3f",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3f* self = (const Vector3f*) tolua_tousertype(tolua_S,1,0);
+ const float f = ((const float) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'", NULL);
+#endif
+ {
+ Vector3f tolua_ret = (Vector3f) self->operator*(f);
+ {
+#ifdef __cplusplus
+ void* tolua_obj = Mtolua_new((Vector3f)(tolua_ret));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3f");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#else
+ void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3f));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3f");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#endif
+ }
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function '.mul'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: operator* of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3f__mul01
+static int tolua_AllToLua_Vector3f__mul01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3f",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3f",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const Vector3f* self = (const Vector3f*) tolua_tousertype(tolua_S,1,0);
+ const Vector3f* v2 = ((const Vector3f*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'", NULL);
+#endif
+ {
+ Vector3f tolua_ret = (Vector3f) self->operator*(*v2);
+ {
+#ifdef __cplusplus
+ void* tolua_obj = Mtolua_new((Vector3f)(tolua_ret));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3f");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#else
+ void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3f));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3f");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#endif
+ }
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3f__mul00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: x of class Vector3f */
+#ifndef TOLUA_DISABLE_tolua_get_Vector3f_x
+static int tolua_get_Vector3f_x(lua_State* tolua_S)
+{
+ Vector3f* self = (Vector3f*) 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 Vector3f */
+#ifndef TOLUA_DISABLE_tolua_set_Vector3f_x
+static int tolua_set_Vector3f_x(lua_State* tolua_S)
+{
+ Vector3f* self = (Vector3f*) 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 Vector3f */
+#ifndef TOLUA_DISABLE_tolua_get_Vector3f_y
+static int tolua_get_Vector3f_y(lua_State* tolua_S)
+{
+ Vector3f* self = (Vector3f*) 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 Vector3f */
+#ifndef TOLUA_DISABLE_tolua_set_Vector3f_y
+static int tolua_set_Vector3f_y(lua_State* tolua_S)
+{
+ Vector3f* self = (Vector3f*) 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 Vector3f */
+#ifndef TOLUA_DISABLE_tolua_get_Vector3f_z
+static int tolua_get_Vector3f_z(lua_State* tolua_S)
+{
+ Vector3f* self = (Vector3f*) 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 Vector3f */
+#ifndef TOLUA_DISABLE_tolua_set_Vector3f_z
+static int tolua_set_Vector3f_z(lua_State* tolua_S)
+{
+ Vector3f* self = (Vector3f*) 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: new of class Vector3d */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_new00
+static int tolua_AllToLua_Vector3d_new00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3d",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3f",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3f* v = ((const Vector3f*) tolua_tousertype(tolua_S,2,0));
+ {
+ Vector3d* tolua_ret = (Vector3d*) Mtolua_new((Vector3d)(*v));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3d");
+ }
+ }
+ 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 Vector3d */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_new00_local
+static int tolua_AllToLua_Vector3d_new00_local(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3d",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3f",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3f* v = ((const Vector3f*) tolua_tousertype(tolua_S,2,0));
+ {
+ Vector3d* tolua_ret = (Vector3d*) Mtolua_new((Vector3d)(*v));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3d");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class Vector3d */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_new01
+static int tolua_AllToLua_Vector3d_new01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3d",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"const Vector3f",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const Vector3f* v = ((const Vector3f*) tolua_tousertype(tolua_S,2,0));
+ {
+ Vector3d* tolua_ret = (Vector3d*) Mtolua_new((Vector3d)(v));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3d");
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3d_new00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new_local of class Vector3d */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_new01_local
+static int tolua_AllToLua_Vector3d_new01_local(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3d",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"const Vector3f",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const Vector3f* v = ((const Vector3f*) tolua_tousertype(tolua_S,2,0));
+ {
+ Vector3d* tolua_ret = (Vector3d*) Mtolua_new((Vector3d)(v));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3d");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3d_new00_local(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class Vector3d */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_new02
+static int tolua_AllToLua_Vector3d_new02(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3d",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ {
+ Vector3d* tolua_ret = (Vector3d*) Mtolua_new((Vector3d)());
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3d");
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3d_new01(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new_local of class Vector3d */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_new02_local
+static int tolua_AllToLua_Vector3d_new02_local(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3d",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ {
+ Vector3d* tolua_ret = (Vector3d*) Mtolua_new((Vector3d)());
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3d");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3d_new01_local(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class Vector3d */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_new03
+static int tolua_AllToLua_Vector3d_new03(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3d",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ double a_x = ((double) tolua_tonumber(tolua_S,2,0));
+ double a_y = ((double) tolua_tonumber(tolua_S,3,0));
+ double a_z = ((double) tolua_tonumber(tolua_S,4,0));
+ {
+ Vector3d* tolua_ret = (Vector3d*) Mtolua_new((Vector3d)(a_x,a_y,a_z));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3d");
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3d_new02(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new_local of class Vector3d */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_new03_local
+static int tolua_AllToLua_Vector3d_new03_local(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3d",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ double a_x = ((double) tolua_tonumber(tolua_S,2,0));
+ double a_y = ((double) tolua_tonumber(tolua_S,3,0));
+ double a_z = ((double) tolua_tonumber(tolua_S,4,0));
+ {
+ Vector3d* tolua_ret = (Vector3d*) Mtolua_new((Vector3d)(a_x,a_y,a_z));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3d");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3d_new02_local(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Set of class Vector3d */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_Set00
+static int tolua_AllToLua_Vector3d_Set00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Vector3d",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
+ {
+ Vector3d* self = (Vector3d*) tolua_tousertype(tolua_S,1,0);
+ double a_x = ((double) tolua_tonumber(tolua_S,2,0));
+ double a_y = ((double) tolua_tonumber(tolua_S,3,0));
+ double a_z = ((double) tolua_tonumber(tolua_S,4,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Set'", NULL);
+#endif
+ {
+ self->Set(a_x,a_y,a_z);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Set'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Normalize of class Vector3d */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_Normalize00
+static int tolua_AllToLua_Vector3d_Normalize00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Vector3d",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Vector3d* self = (Vector3d*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Normalize'", NULL);
+#endif
+ {
+ self->Normalize();
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Normalize'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: NormalizeCopy of class Vector3d */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_NormalizeCopy00
+static int tolua_AllToLua_Vector3d_NormalizeCopy00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Vector3d",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Vector3d* self = (Vector3d*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NormalizeCopy'", NULL);
+#endif
+ {
+ Vector3d tolua_ret = (Vector3d) self->NormalizeCopy();
+ {
+#ifdef __cplusplus
+ void* tolua_obj = Mtolua_new((Vector3d)(tolua_ret));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#else
+ void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3d));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#endif
+ }
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'NormalizeCopy'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: NormalizeCopy of class Vector3d */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_NormalizeCopy01
+static int tolua_AllToLua_Vector3d_NormalizeCopy01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Vector3d",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3d",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ Vector3d* self = (Vector3d*) tolua_tousertype(tolua_S,1,0);
+ Vector3d* a_V = ((Vector3d*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'NormalizeCopy'", NULL);
+#endif
+ {
+ self->NormalizeCopy(*a_V);
+ }
+ }
+ return 0;
+tolua_lerror:
+ return tolua_AllToLua_Vector3d_NormalizeCopy00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Length of class Vector3d */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_Length00
+static int tolua_AllToLua_Vector3d_Length00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3d",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3d* self = (const Vector3d*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Length'", NULL);
+#endif
+ {
+ double tolua_ret = (double) self->Length();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Length'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SqrLength of class Vector3d */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_SqrLength00
+static int tolua_AllToLua_Vector3d_SqrLength00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3d",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3d* self = (const Vector3d*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SqrLength'", NULL);
+#endif
+ {
+ double tolua_ret = (double) self->SqrLength();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SqrLength'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Dot of class Vector3d */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_Dot00
+static int tolua_AllToLua_Vector3d_Dot00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3d",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3d",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3d* self = (const Vector3d*) tolua_tousertype(tolua_S,1,0);
+ const Vector3d* a_V = ((const Vector3d*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Dot'", NULL);
+#endif
+ {
+ double tolua_ret = (double) self->Dot(*a_V);
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Dot'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Cross of class Vector3d */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d_Cross00
+static int tolua_AllToLua_Vector3d_Cross00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3d",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3d",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3d* self = (const Vector3d*) tolua_tousertype(tolua_S,1,0);
+ const Vector3d* v = ((const Vector3d*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Cross'", NULL);
+#endif
+ {
+ Vector3d tolua_ret = (Vector3d) self->Cross(*v);
+ {
+#ifdef __cplusplus
+ void* tolua_obj = Mtolua_new((Vector3d)(tolua_ret));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#else
+ void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3d));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#endif
+ }
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Cross'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: operator+ of class Vector3d */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d__add00
+static int tolua_AllToLua_Vector3d__add00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3d",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3d",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3d* self = (const Vector3d*) tolua_tousertype(tolua_S,1,0);
+ const Vector3d* v2 = ((const Vector3d*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'", NULL);
+#endif
+ {
+ Vector3d tolua_ret = (Vector3d) self->operator+(*v2);
+ {
+#ifdef __cplusplus
+ void* tolua_obj = Mtolua_new((Vector3d)(tolua_ret));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#else
+ void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3d));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#endif
+ }
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function '.add'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: operator+ of class Vector3d */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d__add01
+static int tolua_AllToLua_Vector3d__add01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3d",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"const Vector3d",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const Vector3d* self = (const Vector3d*) tolua_tousertype(tolua_S,1,0);
+ const Vector3d* v2 = ((const Vector3d*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator+'", NULL);
+#endif
+ {
+ Vector3d tolua_ret = (Vector3d) self->operator+(v2);
+ {
+#ifdef __cplusplus
+ void* tolua_obj = Mtolua_new((Vector3d)(tolua_ret));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#else
+ void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3d));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#endif
+ }
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3d__add00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: operator- of class Vector3d */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d__sub00
+static int tolua_AllToLua_Vector3d__sub00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3d",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3d",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3d* self = (const Vector3d*) tolua_tousertype(tolua_S,1,0);
+ const Vector3d* v2 = ((const Vector3d*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'", NULL);
+#endif
+ {
+ Vector3d tolua_ret = (Vector3d) self->operator-(*v2);
+ {
+#ifdef __cplusplus
+ void* tolua_obj = Mtolua_new((Vector3d)(tolua_ret));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#else
+ void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3d));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#endif
+ }
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function '.sub'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: operator- of class Vector3d */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d__sub01
+static int tolua_AllToLua_Vector3d__sub01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3d",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"const Vector3d",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const Vector3d* self = (const Vector3d*) tolua_tousertype(tolua_S,1,0);
+ const Vector3d* v2 = ((const Vector3d*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator-'", NULL);
+#endif
+ {
+ Vector3d tolua_ret = (Vector3d) self->operator-(v2);
+ {
+#ifdef __cplusplus
+ void* tolua_obj = Mtolua_new((Vector3d)(tolua_ret));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#else
+ void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3d));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#endif
+ }
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3d__sub00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: operator* of class Vector3d */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d__mul00
+static int tolua_AllToLua_Vector3d__mul00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3d",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3d* self = (const Vector3d*) tolua_tousertype(tolua_S,1,0);
+ const double f = ((const double) tolua_tonumber(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'", NULL);
+#endif
+ {
+ Vector3d tolua_ret = (Vector3d) self->operator*(f);
+ {
+#ifdef __cplusplus
+ void* tolua_obj = Mtolua_new((Vector3d)(tolua_ret));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#else
+ void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3d));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#endif
+ }
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function '.mul'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: operator* of class Vector3d */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3d__mul01
+static int tolua_AllToLua_Vector3d__mul01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3d",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3d",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const Vector3d* self = (const Vector3d*) tolua_tousertype(tolua_S,1,0);
+ const Vector3d* v2 = ((const Vector3d*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'operator*'", NULL);
+#endif
+ {
+ Vector3d tolua_ret = (Vector3d) self->operator*(*v2);
+ {
+#ifdef __cplusplus
+ void* tolua_obj = Mtolua_new((Vector3d)(tolua_ret));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#else
+ void* tolua_obj = tolua_copy(tolua_S,(void*)&tolua_ret,sizeof(Vector3d));
+ tolua_pushusertype(tolua_S,tolua_obj,"Vector3d");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+#endif
+ }
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3d__mul00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: x of class Vector3d */
+#ifndef TOLUA_DISABLE_tolua_get_Vector3d_x
+static int tolua_get_Vector3d_x(lua_State* tolua_S)
+{
+ Vector3d* self = (Vector3d*) 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 Vector3d */
+#ifndef TOLUA_DISABLE_tolua_set_Vector3d_x
+static int tolua_set_Vector3d_x(lua_State* tolua_S)
+{
+ Vector3d* self = (Vector3d*) 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 = ((double) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: y of class Vector3d */
+#ifndef TOLUA_DISABLE_tolua_get_Vector3d_y
+static int tolua_get_Vector3d_y(lua_State* tolua_S)
+{
+ Vector3d* self = (Vector3d*) 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 Vector3d */
+#ifndef TOLUA_DISABLE_tolua_set_Vector3d_y
+static int tolua_set_Vector3d_y(lua_State* tolua_S)
+{
+ Vector3d* self = (Vector3d*) 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 = ((double) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: z of class Vector3d */
+#ifndef TOLUA_DISABLE_tolua_get_Vector3d_z
+static int tolua_get_Vector3d_z(lua_State* tolua_S)
+{
+ Vector3d* self = (Vector3d*) 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 Vector3d */
+#ifndef TOLUA_DISABLE_tolua_set_Vector3d_z
+static int tolua_set_Vector3d_z(lua_State* tolua_S)
+{
+ Vector3d* self = (Vector3d*) 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 = ((double) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class Vector3i */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_new00
+static int tolua_AllToLua_Vector3i_new00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3i",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3d",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3d* v = ((const Vector3d*) tolua_tousertype(tolua_S,2,0));
+ {
+ Vector3i* tolua_ret = (Vector3i*) Mtolua_new((Vector3i)(*v));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3i");
+ }
+ }
+ 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 Vector3i */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_new00_local
+static int tolua_AllToLua_Vector3i_new00_local(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3i",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3d",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3d* v = ((const Vector3d*) tolua_tousertype(tolua_S,2,0));
+ {
+ Vector3i* tolua_ret = (Vector3i*) Mtolua_new((Vector3i)(*v));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3i");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class Vector3i */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_new01
+static int tolua_AllToLua_Vector3i_new01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3i",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ {
+ Vector3i* tolua_ret = (Vector3i*) Mtolua_new((Vector3i)());
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3i");
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3i_new00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new_local of class Vector3i */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_new01_local
+static int tolua_AllToLua_Vector3i_new01_local(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3i",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ {
+ Vector3i* tolua_ret = (Vector3i*) Mtolua_new((Vector3i)());
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3i");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3i_new00_local(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class Vector3i */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_new02
+static int tolua_AllToLua_Vector3i_new02(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3i",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ int a_x = ((int) tolua_tonumber(tolua_S,2,0));
+ int a_y = ((int) tolua_tonumber(tolua_S,3,0));
+ int a_z = ((int) tolua_tonumber(tolua_S,4,0));
+ {
+ Vector3i* tolua_ret = (Vector3i*) Mtolua_new((Vector3i)(a_x,a_y,a_z));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3i");
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3i_new01(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new_local of class Vector3i */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_new02_local
+static int tolua_AllToLua_Vector3i_new02_local(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Vector3i",0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ int a_x = ((int) tolua_tonumber(tolua_S,2,0));
+ int a_y = ((int) tolua_tonumber(tolua_S,3,0));
+ int a_z = ((int) tolua_tonumber(tolua_S,4,0));
+ {
+ Vector3i* tolua_ret = (Vector3i*) Mtolua_new((Vector3i)(a_x,a_y,a_z));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Vector3i");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3i_new01_local(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Set of class Vector3i */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_Set00
+static int tolua_AllToLua_Vector3i_Set00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Vector3i",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
+ {
+ Vector3i* self = (Vector3i*) tolua_tousertype(tolua_S,1,0);
+ int a_x = ((int) tolua_tonumber(tolua_S,2,0));
+ int a_y = ((int) tolua_tonumber(tolua_S,3,0));
+ int a_z = ((int) tolua_tonumber(tolua_S,4,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Set'", NULL);
+#endif
+ {
+ self->Set(a_x,a_y,a_z);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Set'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Length of class Vector3i */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_Length00
+static int tolua_AllToLua_Vector3i_Length00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3i",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3i* self = (const Vector3i*) 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: SqrLength of class Vector3i */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_SqrLength00
+static int tolua_AllToLua_Vector3i_SqrLength00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3i",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3i* self = (const Vector3i*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SqrLength'", NULL);
+#endif
+ {
+ int tolua_ret = (int) self->SqrLength();
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SqrLength'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Equals of class Vector3i */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_Equals00
+static int tolua_AllToLua_Vector3i_Equals00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3i",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3i",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const Vector3i* self = (const Vector3i*) tolua_tousertype(tolua_S,1,0);
+ const Vector3i* v = ((const Vector3i*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Equals'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->Equals(*v);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Equals'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Equals of class Vector3i */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Vector3i_Equals01
+static int tolua_AllToLua_Vector3i_Equals01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const Vector3i",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"const Vector3i",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const Vector3i* self = (const Vector3i*) tolua_tousertype(tolua_S,1,0);
+ const Vector3i* v = ((const Vector3i*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Equals'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->Equals(v);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_Vector3i_Equals00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: x of class Vector3i */
+#ifndef TOLUA_DISABLE_tolua_get_Vector3i_x
+static int tolua_get_Vector3i_x(lua_State* tolua_S)
+{
+ Vector3i* self = (Vector3i*) 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 Vector3i */
+#ifndef TOLUA_DISABLE_tolua_set_Vector3i_x
+static int tolua_set_Vector3i_x(lua_State* tolua_S)
+{
+ Vector3i* self = (Vector3i*) 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 = ((int) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: y of class Vector3i */
+#ifndef TOLUA_DISABLE_tolua_get_Vector3i_y
+static int tolua_get_Vector3i_y(lua_State* tolua_S)
+{
+ Vector3i* self = (Vector3i*) 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 Vector3i */
+#ifndef TOLUA_DISABLE_tolua_set_Vector3i_y
+static int tolua_set_Vector3i_y(lua_State* tolua_S)
+{
+ Vector3i* self = (Vector3i*) 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 = ((int) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: z of class Vector3i */
+#ifndef TOLUA_DISABLE_tolua_get_Vector3i_z
+static int tolua_get_Vector3i_z(lua_State* tolua_S)
+{
+ Vector3i* self = (Vector3i*) 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 Vector3i */
+#ifndef TOLUA_DISABLE_tolua_set_Vector3i_z
+static int tolua_set_Vector3i_z(lua_State* tolua_S)
+{
+ Vector3i* self = (Vector3i*) 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 = ((int) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class cCuboid */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_new00
+static int tolua_AllToLua_cCuboid_new00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cCuboid",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ {
+ cCuboid* tolua_ret = (cCuboid*) Mtolua_new((cCuboid)());
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cCuboid");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new_local of class cCuboid */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_new00_local
+static int tolua_AllToLua_cCuboid_new00_local(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cCuboid",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ {
+ cCuboid* tolua_ret = (cCuboid*) Mtolua_new((cCuboid)());
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cCuboid");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class cCuboid */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_new01
+static int tolua_AllToLua_cCuboid_new01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cCuboid",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cCuboid",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const cCuboid* a_Cuboid = ((const cCuboid*) tolua_tousertype(tolua_S,2,0));
+ {
+ cCuboid* tolua_ret = (cCuboid*) Mtolua_new((cCuboid)(*a_Cuboid));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cCuboid");
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_cCuboid_new00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new_local of class cCuboid */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_new01_local
+static int tolua_AllToLua_cCuboid_new01_local(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cCuboid",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const cCuboid",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const cCuboid* a_Cuboid = ((const cCuboid*) tolua_tousertype(tolua_S,2,0));
+ {
+ cCuboid* tolua_ret = (cCuboid*) Mtolua_new((cCuboid)(*a_Cuboid));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cCuboid");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_cCuboid_new00_local(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class cCuboid */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_new02
+static int tolua_AllToLua_cCuboid_new02(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cCuboid",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3i",0,&tolua_err)) ||
+ (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const Vector3i",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const Vector3i* a_p1 = ((const Vector3i*) tolua_tousertype(tolua_S,2,0));
+ const Vector3i* a_p2 = ((const Vector3i*) tolua_tousertype(tolua_S,3,0));
+ {
+ cCuboid* tolua_ret = (cCuboid*) Mtolua_new((cCuboid)(*a_p1,*a_p2));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cCuboid");
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_cCuboid_new01(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new_local of class cCuboid */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_new02_local
+static int tolua_AllToLua_cCuboid_new02_local(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cCuboid",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3i",0,&tolua_err)) ||
+ (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const Vector3i",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const Vector3i* a_p1 = ((const Vector3i*) tolua_tousertype(tolua_S,2,0));
+ const Vector3i* a_p2 = ((const Vector3i*) tolua_tousertype(tolua_S,3,0));
+ {
+ cCuboid* tolua_ret = (cCuboid*) Mtolua_new((cCuboid)(*a_p1,*a_p2));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cCuboid");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_cCuboid_new01_local(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: p1 of class cCuboid */
+#ifndef TOLUA_DISABLE_tolua_get_cCuboid_p1
+static int tolua_get_cCuboid_p1(lua_State* tolua_S)
+{
+ cCuboid* self = (cCuboid*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'p1'",NULL);
+#endif
+ tolua_pushusertype(tolua_S,(void*)&self->p1,"Vector3i");
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: p1 of class cCuboid */
+#ifndef TOLUA_DISABLE_tolua_set_cCuboid_p1
+static int tolua_set_cCuboid_p1(lua_State* tolua_S)
+{
+ cCuboid* self = (cCuboid*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'p1'",NULL);
+ if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3i",0,&tolua_err)))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->p1 = *((Vector3i*) tolua_tousertype(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: p2 of class cCuboid */
+#ifndef TOLUA_DISABLE_tolua_get_cCuboid_p2
+static int tolua_get_cCuboid_p2(lua_State* tolua_S)
+{
+ cCuboid* self = (cCuboid*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'p2'",NULL);
+#endif
+ tolua_pushusertype(tolua_S,(void*)&self->p2,"Vector3i");
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: p2 of class cCuboid */
+#ifndef TOLUA_DISABLE_tolua_set_cCuboid_p2
+static int tolua_set_cCuboid_p2(lua_State* tolua_S)
+{
+ cCuboid* self = (cCuboid*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'p2'",NULL);
+ if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"Vector3i",0,&tolua_err)))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->p2 = *((Vector3i*) tolua_tousertype(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Sort of class cCuboid */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_Sort00
+static int tolua_AllToLua_cCuboid_Sort00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cCuboid",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cCuboid* self = (cCuboid*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Sort'", NULL);
+#endif
+ {
+ self->Sort();
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Sort'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: IsInside of class cCuboid */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_IsInside00
+static int tolua_AllToLua_cCuboid_IsInside00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cCuboid",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3i",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const cCuboid* self = (const cCuboid*) tolua_tousertype(tolua_S,1,0);
+ const Vector3i* v = ((const Vector3i*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsInside'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->IsInside(*v);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'IsInside'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: IsInside of class cCuboid */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cCuboid_IsInside01
+static int tolua_AllToLua_cCuboid_IsInside01(lua_State* tolua_S)
+{
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cCuboid",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3d",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+ {
+ const cCuboid* self = (const cCuboid*) tolua_tousertype(tolua_S,1,0);
+ const Vector3d* v = ((const Vector3d*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IsInside'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->IsInside(*v);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+tolua_lerror:
+ return tolua_AllToLua_cCuboid_IsInside00(tolua_S);
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class cMCLogger */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cMCLogger_new00
+static int tolua_AllToLua_cMCLogger_new00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cMCLogger",0,&tolua_err) ||
+ !tolua_isstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ char* a_File = ((char*) tolua_tostring(tolua_S,2,0));
+ {
+ cMCLogger* tolua_ret = (cMCLogger*) Mtolua_new((cMCLogger)(a_File));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cMCLogger");
+ }
+ }
+ 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 cMCLogger */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cMCLogger_new00_local
+static int tolua_AllToLua_cMCLogger_new00_local(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cMCLogger",0,&tolua_err) ||
+ !tolua_isstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ char* a_File = ((char*) tolua_tostring(tolua_S,2,0));
+ {
+ cMCLogger* tolua_ret = (cMCLogger*) Mtolua_new((cMCLogger)(a_File));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cMCLogger");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: delete of class cMCLogger */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cMCLogger_delete00
+static int tolua_AllToLua_cMCLogger_delete00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cMCLogger",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cMCLogger* self = (cMCLogger*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
+#endif
+ Mtolua_delete(self);
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: LogSimple of class cMCLogger */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cMCLogger_LogSimple00
+static int tolua_AllToLua_cMCLogger_LogSimple00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cMCLogger",0,&tolua_err) ||
+ !tolua_isstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnumber(tolua_S,3,1,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cMCLogger* self = (cMCLogger*) tolua_tousertype(tolua_S,1,0);
+ const char* a_Text = ((const char*) tolua_tostring(tolua_S,2,0));
+ int a_LogType = ((int) tolua_tonumber(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'LogSimple'", NULL);
+#endif
+ {
+ self->LogSimple(a_Text,a_LogType);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'LogSimple'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class cTracer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cTracer_new00
+static int tolua_AllToLua_cTracer_new00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cTracer",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cWorld",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWorld* a_World = ((cWorld*) tolua_tousertype(tolua_S,2,0));
+ {
+ cTracer* tolua_ret = (cTracer*) Mtolua_new((cTracer)(a_World));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cTracer");
+ }
+ }
+ 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 cTracer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cTracer_new00_local
+static int tolua_AllToLua_cTracer_new00_local(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cTracer",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cWorld",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cWorld* a_World = ((cWorld*) tolua_tousertype(tolua_S,2,0));
+ {
+ cTracer* tolua_ret = (cTracer*) Mtolua_new((cTracer)(a_World));
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cTracer");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: delete of class cTracer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cTracer_delete00
+static int tolua_AllToLua_cTracer_delete00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cTracer",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cTracer* self = (cTracer*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'delete'", NULL);
+#endif
+ Mtolua_delete(self);
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'delete'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Trace of class cTracer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cTracer_Trace00
+static int tolua_AllToLua_cTracer_Trace00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cTracer",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3f",0,&tolua_err)) ||
+ (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const Vector3f",0,&tolua_err)) ||
+ !tolua_isnumber(tolua_S,4,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,5,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cTracer* self = (cTracer*) tolua_tousertype(tolua_S,1,0);
+ const Vector3f* a_Start = ((const Vector3f*) tolua_tousertype(tolua_S,2,0));
+ const Vector3f* a_Direction = ((const Vector3f*) tolua_tousertype(tolua_S,3,0));
+ int a_Distance = ((int) tolua_tonumber(tolua_S,4,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Trace'", NULL);
+#endif
+ {
+ int tolua_ret = (int) self->Trace(*a_Start,*a_Direction,a_Distance);
+ tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Trace'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetValues of class cTracer */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cTracer_SetValues00
+static int tolua_AllToLua_cTracer_SetValues00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cTracer",0,&tolua_err) ||
+ (tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"const Vector3f",0,&tolua_err)) ||
+ (tolua_isvaluenil(tolua_S,3,&tolua_err) || !tolua_isusertype(tolua_S,3,"const Vector3f",0,&tolua_err)) ||
+ !tolua_isnoobj(tolua_S,4,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cTracer* self = (cTracer*) tolua_tousertype(tolua_S,1,0);
+ const Vector3f* a_Start = ((const Vector3f*) tolua_tousertype(tolua_S,2,0));
+ const Vector3f* a_Direction = ((const Vector3f*) tolua_tousertype(tolua_S,3,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetValues'", NULL);
+#endif
+ {
+ self->SetValues(*a_Start,*a_Direction);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetValues'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: BlockHitPosition of class cTracer */
+#ifndef TOLUA_DISABLE_tolua_get_cTracer_BlockHitPosition_ptr
+static int tolua_get_cTracer_BlockHitPosition_ptr(lua_State* tolua_S)
+{
+ cTracer* self = (cTracer*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'BlockHitPosition'",NULL);
+#endif
+ tolua_pushusertype(tolua_S,(void*)self->BlockHitPosition,"Vector3f");
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: BlockHitPosition of class cTracer */
+#ifndef TOLUA_DISABLE_tolua_set_cTracer_BlockHitPosition_ptr
+static int tolua_set_cTracer_BlockHitPosition_ptr(lua_State* tolua_S)
+{
+ cTracer* self = (cTracer*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'BlockHitPosition'",NULL);
+ if (!tolua_isusertype(tolua_S,2,"Vector3f",0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->BlockHitPosition = ((Vector3f*) tolua_tousertype(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: HitNormal of class cTracer */
+#ifndef TOLUA_DISABLE_tolua_get_cTracer_HitNormal_ptr
+static int tolua_get_cTracer_HitNormal_ptr(lua_State* tolua_S)
+{
+ cTracer* self = (cTracer*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'HitNormal'",NULL);
+#endif
+ tolua_pushusertype(tolua_S,(void*)self->HitNormal,"Vector3f");
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: HitNormal of class cTracer */
+#ifndef TOLUA_DISABLE_tolua_set_cTracer_HitNormal_ptr
+static int tolua_set_cTracer_HitNormal_ptr(lua_State* tolua_S)
+{
+ cTracer* self = (cTracer*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'HitNormal'",NULL);
+ if (!tolua_isusertype(tolua_S,2,"Vector3f",0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->HitNormal = ((Vector3f*) tolua_tousertype(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: RealHit of class cTracer */
+#ifndef TOLUA_DISABLE_tolua_get_cTracer_RealHit_ptr
+static int tolua_get_cTracer_RealHit_ptr(lua_State* tolua_S)
+{
+ cTracer* self = (cTracer*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'RealHit'",NULL);
+#endif
+ tolua_pushusertype(tolua_S,(void*)self->RealHit,"Vector3f");
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: RealHit of class cTracer */
+#ifndef TOLUA_DISABLE_tolua_set_cTracer_RealHit_ptr
+static int tolua_set_cTracer_RealHit_ptr(lua_State* tolua_S)
+{
+ cTracer* self = (cTracer*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'RealHit'",NULL);
+ if (!tolua_isusertype(tolua_S,2,"Vector3f",0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->RealHit = ((Vector3f*) tolua_tousertype(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetName of class cGroup */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cGroup_SetName00
+static int tolua_AllToLua_cGroup_SetName00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cGroup",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cGroup* self = (cGroup*) tolua_tousertype(tolua_S,1,0);
+ std::string a_Name = ((std::string) tolua_tocppstring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetName'", NULL);
+#endif
+ {
+ self->SetName(a_Name);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetName'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetName of class cGroup */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cGroup_GetName00
+static int tolua_AllToLua_cGroup_GetName00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cGroup",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const cGroup* self = (const cGroup*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetName'", NULL);
+#endif
+ {
+ const std::string tolua_ret = (const std::string) self->GetName();
+ tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetName'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: SetColor of class cGroup */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cGroup_SetColor00
+static int tolua_AllToLua_cGroup_SetColor00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cGroup",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cGroup* self = (cGroup*) tolua_tousertype(tolua_S,1,0);
+ std::string a_Color = ((std::string) tolua_tocppstring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetColor'", NULL);
+#endif
+ {
+ self->SetColor(a_Color);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'SetColor'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: AddCommand of class cGroup */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cGroup_AddCommand00
+static int tolua_AllToLua_cGroup_AddCommand00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cGroup",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cGroup* self = (cGroup*) tolua_tousertype(tolua_S,1,0);
+ std::string a_Command = ((std::string) tolua_tocppstring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddCommand'", NULL);
+#endif
+ {
+ self->AddCommand(a_Command);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'AddCommand'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: AddPermission of class cGroup */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cGroup_AddPermission00
+static int tolua_AllToLua_cGroup_AddPermission00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cGroup",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cGroup* self = (cGroup*) tolua_tousertype(tolua_S,1,0);
+ std::string a_Permission = ((std::string) tolua_tocppstring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddPermission'", NULL);
+#endif
+ {
+ self->AddPermission(a_Permission);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'AddPermission'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: InheritFrom of class cGroup */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cGroup_InheritFrom00
+static int tolua_AllToLua_cGroup_InheritFrom00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cGroup",0,&tolua_err) ||
+ !tolua_isusertype(tolua_S,2,"cGroup",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cGroup* self = (cGroup*) tolua_tousertype(tolua_S,1,0);
+ cGroup* a_Group = ((cGroup*) tolua_tousertype(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'InheritFrom'", NULL);
+#endif
+ {
+ self->InheritFrom(a_Group);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'InheritFrom'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: HasCommand of class cGroup */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cGroup_HasCommand00
+static int tolua_AllToLua_cGroup_HasCommand00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"cGroup",0,&tolua_err) ||
+ !tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ cGroup* self = (cGroup*) tolua_tousertype(tolua_S,1,0);
+ std::string a_Command = ((std::string) tolua_tocppstring(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'HasCommand'", NULL);
+#endif
+ {
+ bool tolua_ret = (bool) self->HasCommand(a_Command);
+ tolua_pushboolean(tolua_S,(bool)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'HasCommand'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: GetColor of class cGroup */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cGroup_GetColor00
+static int tolua_AllToLua_cGroup_GetColor00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cGroup",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const cGroup* self = (const cGroup*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetColor'", NULL);
+#endif
+ {
+ std::string tolua_ret = (std::string) self->GetColor();
+ tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'GetColor'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: m_ProtocolVersion of class cPacket_Login */
+#ifndef TOLUA_DISABLE_tolua_get_cPacket_Login_m_ProtocolVersion
+static int tolua_get_cPacket_Login_m_ProtocolVersion(lua_State* tolua_S)
+{
+ cPacket_Login* self = (cPacket_Login*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_ProtocolVersion'",NULL);
+#endif
+ tolua_pushnumber(tolua_S,(lua_Number)self->m_ProtocolVersion);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: m_ProtocolVersion of class cPacket_Login */
+#ifndef TOLUA_DISABLE_tolua_set_cPacket_Login_m_ProtocolVersion
+static int tolua_set_cPacket_Login_m_ProtocolVersion(lua_State* tolua_S)
+{
+ cPacket_Login* self = (cPacket_Login*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_ProtocolVersion'",NULL);
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->m_ProtocolVersion = ((int) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: m_Username of class cPacket_Login */
+#ifndef TOLUA_DISABLE_tolua_get_cPacket_Login_m_Username
+static int tolua_get_cPacket_Login_m_Username(lua_State* tolua_S)
+{
+ cPacket_Login* self = (cPacket_Login*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_Username'",NULL);
+#endif
+ tolua_pushcppstring(tolua_S,(const char*)self->m_Username);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: m_Username of class cPacket_Login */
+#ifndef TOLUA_DISABLE_tolua_set_cPacket_Login_m_Username
+static int tolua_set_cPacket_Login_m_Username(lua_State* tolua_S)
+{
+ cPacket_Login* self = (cPacket_Login*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_Username'",NULL);
+ if (!tolua_iscppstring(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->m_Username = ((std::string) tolua_tocppstring(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: m_MapSeed of class cPacket_Login */
+#ifndef TOLUA_DISABLE_tolua_get_cPacket_Login_m_MapSeed
+static int tolua_get_cPacket_Login_m_MapSeed(lua_State* tolua_S)
+{
+ cPacket_Login* self = (cPacket_Login*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_MapSeed'",NULL);
+#endif
+ tolua_pushnumber(tolua_S,(lua_Number)self->m_MapSeed);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: m_MapSeed of class cPacket_Login */
+#ifndef TOLUA_DISABLE_tolua_set_cPacket_Login_m_MapSeed
+static int tolua_set_cPacket_Login_m_MapSeed(lua_State* tolua_S)
+{
+ cPacket_Login* self = (cPacket_Login*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_MapSeed'",NULL);
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->m_MapSeed = ((long long) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: m_Dimension of class cPacket_Login */
+#ifndef TOLUA_DISABLE_tolua_get_cPacket_Login_m_Dimension
+static int tolua_get_cPacket_Login_m_Dimension(lua_State* tolua_S)
+{
+ cPacket_Login* self = (cPacket_Login*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_Dimension'",NULL);
+#endif
+ tolua_pushnumber(tolua_S,(lua_Number)self->m_Dimension);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: m_Dimension of class cPacket_Login */
+#ifndef TOLUA_DISABLE_tolua_set_cPacket_Login_m_Dimension
+static int tolua_set_cPacket_Login_m_Dimension(lua_State* tolua_S)
+{
+ cPacket_Login* self = (cPacket_Login*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_Dimension'",NULL);
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->m_Dimension = ((char) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class cPacket_BlockDig */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPacket_BlockDig_new00
+static int tolua_AllToLua_cPacket_BlockDig_new00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cPacket_BlockDig",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ {
+ cPacket_BlockDig* tolua_ret = (cPacket_BlockDig*) Mtolua_new((cPacket_BlockDig)());
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cPacket_BlockDig");
+ }
+ }
+ 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 cPacket_BlockDig */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPacket_BlockDig_new00_local
+static int tolua_AllToLua_cPacket_BlockDig_new00_local(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"cPacket_BlockDig",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ {
+ cPacket_BlockDig* tolua_ret = (cPacket_BlockDig*) Mtolua_new((cPacket_BlockDig)());
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cPacket_BlockDig");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: Clone of class cPacket_BlockDig */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_cPacket_BlockDig_Clone00
+static int tolua_AllToLua_cPacket_BlockDig_Clone00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"const cPacket_BlockDig",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ const cPacket_BlockDig* self = (const cPacket_BlockDig*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'Clone'", NULL);
+#endif
+ {
+ cPacket* tolua_ret = (cPacket*) self->Clone();
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cPacket");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'Clone'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: m_Status of class cPacket_BlockDig */
+#ifndef TOLUA_DISABLE_tolua_get_cPacket_BlockDig_m_Status
+static int tolua_get_cPacket_BlockDig_m_Status(lua_State* tolua_S)
+{
+ cPacket_BlockDig* self = (cPacket_BlockDig*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_Status'",NULL);
+#endif
+ tolua_pushnumber(tolua_S,(lua_Number)self->m_Status);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: m_Status of class cPacket_BlockDig */
+#ifndef TOLUA_DISABLE_tolua_set_cPacket_BlockDig_m_Status
+static int tolua_set_cPacket_BlockDig_m_Status(lua_State* tolua_S)
+{
+ cPacket_BlockDig* self = (cPacket_BlockDig*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_Status'",NULL);
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->m_Status = ((char) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: m_PosX of class cPacket_BlockDig */
+#ifndef TOLUA_DISABLE_tolua_get_cPacket_BlockDig_m_PosX
+static int tolua_get_cPacket_BlockDig_m_PosX(lua_State* tolua_S)
+{
+ cPacket_BlockDig* self = (cPacket_BlockDig*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_PosX'",NULL);
+#endif
+ tolua_pushnumber(tolua_S,(lua_Number)self->m_PosX);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: m_PosX of class cPacket_BlockDig */
+#ifndef TOLUA_DISABLE_tolua_set_cPacket_BlockDig_m_PosX
+static int tolua_set_cPacket_BlockDig_m_PosX(lua_State* tolua_S)
+{
+ cPacket_BlockDig* self = (cPacket_BlockDig*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_PosX'",NULL);
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->m_PosX = ((int) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: m_PosY of class cPacket_BlockDig */
+#ifndef TOLUA_DISABLE_tolua_get_cPacket_BlockDig_m_PosY
+static int tolua_get_cPacket_BlockDig_m_PosY(lua_State* tolua_S)
+{
+ cPacket_BlockDig* self = (cPacket_BlockDig*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_PosY'",NULL);
+#endif
+ tolua_pushnumber(tolua_S,(lua_Number)self->m_PosY);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: m_PosY of class cPacket_BlockDig */
+#ifndef TOLUA_DISABLE_tolua_set_cPacket_BlockDig_m_PosY
+static int tolua_set_cPacket_BlockDig_m_PosY(lua_State* tolua_S)
+{
+ cPacket_BlockDig* self = (cPacket_BlockDig*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_PosY'",NULL);
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->m_PosY = ((char) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: m_PosZ of class cPacket_BlockDig */
+#ifndef TOLUA_DISABLE_tolua_get_cPacket_BlockDig_m_PosZ
+static int tolua_get_cPacket_BlockDig_m_PosZ(lua_State* tolua_S)
+{
+ cPacket_BlockDig* self = (cPacket_BlockDig*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_PosZ'",NULL);
+#endif
+ tolua_pushnumber(tolua_S,(lua_Number)self->m_PosZ);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: m_PosZ of class cPacket_BlockDig */
+#ifndef TOLUA_DISABLE_tolua_set_cPacket_BlockDig_m_PosZ
+static int tolua_set_cPacket_BlockDig_m_PosZ(lua_State* tolua_S)
+{
+ cPacket_BlockDig* self = (cPacket_BlockDig*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_PosZ'",NULL);
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->m_PosZ = ((int) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: m_Direction of class cPacket_BlockDig */
+#ifndef TOLUA_DISABLE_tolua_get_cPacket_BlockDig_m_Direction
+static int tolua_get_cPacket_BlockDig_m_Direction(lua_State* tolua_S)
+{
+ cPacket_BlockDig* self = (cPacket_BlockDig*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_Direction'",NULL);
+#endif
+ tolua_pushnumber(tolua_S,(lua_Number)self->m_Direction);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: m_Direction of class cPacket_BlockDig */
+#ifndef TOLUA_DISABLE_tolua_set_cPacket_BlockDig_m_Direction
+static int tolua_set_cPacket_BlockDig_m_Direction(lua_State* tolua_S)
+{
+ cPacket_BlockDig* self = (cPacket_BlockDig*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_Direction'",NULL);
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->m_Direction = ((char) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+ class Lua__cPacket_BlockDig : public cPacket_BlockDig, public ToluaBase {
+public:
+ cPacket* Clone( void )const {
+ if (push_method("Clone", tolua_AllToLua_cPacket_BlockDig_Clone00)) {
+ ToluaBase::dbcall(lua_state, 1, 1);
+ cPacket* tolua_ret = ( cPacket* )tolua_tousertype(lua_state, -1, 0);
+ lua_pop(lua_state, 1);
+ return tolua_ret;
+ } else {
+ return ( cPacket* ) cPacket_BlockDig:: Clone();
+ };
+ };
+
+ cPacket* cPacket_BlockDig__Clone( void ) {
+ return ( cPacket* )cPacket_BlockDig::Clone();
+ };
+ Lua__cPacket_BlockDig( void ): cPacket_BlockDig(){};
+};
+
+/* method: tolua__set_instance of class Lua__cPacket_BlockDig */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPacket_BlockDig_tolua__set_instance00
+static int tolua_AllToLua_Lua__cPacket_BlockDig_tolua__set_instance00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPacket_BlockDig",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,3,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPacket_BlockDig* self = (Lua__cPacket_BlockDig*) tolua_tousertype(tolua_S,1,0);
+ lua_State* L = tolua_S;
+ lua_Object lo = ((lua_Object) tolua_tovalue(tolua_S,2,0));
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'tolua__set_instance'", NULL);
+#endif
+ {
+ self->tolua__set_instance(L,lo);
+ }
+ }
+ return 0;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'tolua__set_instance'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: cPacket_BlockDig__Clone of class Lua__cPacket_BlockDig */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPacket_BlockDig_cPacket_BlockDig__Clone00
+static int tolua_AllToLua_Lua__cPacket_BlockDig_cPacket_BlockDig__Clone00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertype(tolua_S,1,"Lua__cPacket_BlockDig",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ Lua__cPacket_BlockDig* self = (Lua__cPacket_BlockDig*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in function 'cPacket_BlockDig__Clone'", NULL);
+#endif
+ {
+ cPacket* tolua_ret = (cPacket*) self->cPacket_BlockDig__Clone();
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"cPacket");
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'cPacket_BlockDig__Clone'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* method: new of class Lua__cPacket_BlockDig */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPacket_BlockDig_new00
+static int tolua_AllToLua_Lua__cPacket_BlockDig_new00(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Lua__cPacket_BlockDig",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ {
+ Lua__cPacket_BlockDig* tolua_ret = (Lua__cPacket_BlockDig*) Mtolua_new((Lua__cPacket_BlockDig)());
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Lua__cPacket_BlockDig");
+ }
+ }
+ 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 Lua__cPacket_BlockDig */
+#ifndef TOLUA_DISABLE_tolua_AllToLua_Lua__cPacket_BlockDig_new00_local
+static int tolua_AllToLua_Lua__cPacket_BlockDig_new00_local(lua_State* tolua_S)
+{
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (
+ !tolua_isusertable(tolua_S,1,"Lua__cPacket_BlockDig",0,&tolua_err) ||
+ !tolua_isnoobj(tolua_S,2,&tolua_err)
+ )
+ goto tolua_lerror;
+ else
+#endif
+ {
+ {
+ Lua__cPacket_BlockDig* tolua_ret = (Lua__cPacket_BlockDig*) Mtolua_new((Lua__cPacket_BlockDig)());
+ tolua_pushusertype(tolua_S,(void*)tolua_ret,"Lua__cPacket_BlockDig");
+ tolua_register_gc(tolua_S,lua_gettop(tolua_S));
+ }
+ }
+ return 1;
+#ifndef TOLUA_RELEASE
+ tolua_lerror:
+ tolua_error(tolua_S,"#ferror in function 'new'.",&tolua_err);
+ return 0;
+#endif
+}
+#endif //#ifndef TOLUA_DISABLE
+
+
+/* function to release collected object via destructor */
+#ifdef __cplusplus
+
+static int tolua_collect_Lua__cPacket_BlockDig (lua_State* tolua_S)
+{
+ Lua__cPacket_BlockDig* self = (Lua__cPacket_BlockDig*) tolua_tousertype(tolua_S,1,0);
+ delete self;
+ return 0;
+}
+#endif
+
+/* get function: m_PosX of class cPacket_BlockPlace */
+#ifndef TOLUA_DISABLE_tolua_get_cPacket_BlockPlace_m_PosX
+static int tolua_get_cPacket_BlockPlace_m_PosX(lua_State* tolua_S)
+{
+ cPacket_BlockPlace* self = (cPacket_BlockPlace*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_PosX'",NULL);
+#endif
+ tolua_pushnumber(tolua_S,(lua_Number)self->m_PosX);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: m_PosX of class cPacket_BlockPlace */
+#ifndef TOLUA_DISABLE_tolua_set_cPacket_BlockPlace_m_PosX
+static int tolua_set_cPacket_BlockPlace_m_PosX(lua_State* tolua_S)
+{
+ cPacket_BlockPlace* self = (cPacket_BlockPlace*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_PosX'",NULL);
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->m_PosX = ((int) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: m_PosY of class cPacket_BlockPlace */
+#ifndef TOLUA_DISABLE_tolua_get_cPacket_BlockPlace_m_PosY
+static int tolua_get_cPacket_BlockPlace_m_PosY(lua_State* tolua_S)
+{
+ cPacket_BlockPlace* self = (cPacket_BlockPlace*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_PosY'",NULL);
+#endif
+ tolua_pushnumber(tolua_S,(lua_Number)self->m_PosY);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: m_PosY of class cPacket_BlockPlace */
+#ifndef TOLUA_DISABLE_tolua_set_cPacket_BlockPlace_m_PosY
+static int tolua_set_cPacket_BlockPlace_m_PosY(lua_State* tolua_S)
+{
+ cPacket_BlockPlace* self = (cPacket_BlockPlace*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_PosY'",NULL);
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->m_PosY = ((char) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: m_PosZ of class cPacket_BlockPlace */
+#ifndef TOLUA_DISABLE_tolua_get_cPacket_BlockPlace_m_PosZ
+static int tolua_get_cPacket_BlockPlace_m_PosZ(lua_State* tolua_S)
+{
+ cPacket_BlockPlace* self = (cPacket_BlockPlace*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_PosZ'",NULL);
+#endif
+ tolua_pushnumber(tolua_S,(lua_Number)self->m_PosZ);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: m_PosZ of class cPacket_BlockPlace */
+#ifndef TOLUA_DISABLE_tolua_set_cPacket_BlockPlace_m_PosZ
+static int tolua_set_cPacket_BlockPlace_m_PosZ(lua_State* tolua_S)
+{
+ cPacket_BlockPlace* self = (cPacket_BlockPlace*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_PosZ'",NULL);
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->m_PosZ = ((int) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: m_Direction of class cPacket_BlockPlace */
+#ifndef TOLUA_DISABLE_tolua_get_cPacket_BlockPlace_m_Direction
+static int tolua_get_cPacket_BlockPlace_m_Direction(lua_State* tolua_S)
+{
+ cPacket_BlockPlace* self = (cPacket_BlockPlace*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_Direction'",NULL);
+#endif
+ tolua_pushnumber(tolua_S,(lua_Number)self->m_Direction);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: m_Direction of class cPacket_BlockPlace */
+#ifndef TOLUA_DISABLE_tolua_set_cPacket_BlockPlace_m_Direction
+static int tolua_set_cPacket_BlockPlace_m_Direction(lua_State* tolua_S)
+{
+ cPacket_BlockPlace* self = (cPacket_BlockPlace*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_Direction'",NULL);
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->m_Direction = ((char) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: m_ItemType of class cPacket_BlockPlace */
+#ifndef TOLUA_DISABLE_tolua_get_cPacket_BlockPlace_m_ItemType
+static int tolua_get_cPacket_BlockPlace_m_ItemType(lua_State* tolua_S)
+{
+ cPacket_BlockPlace* self = (cPacket_BlockPlace*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_ItemType'",NULL);
+#endif
+ tolua_pushnumber(tolua_S,(lua_Number)self->m_ItemType);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: m_ItemType of class cPacket_BlockPlace */
+#ifndef TOLUA_DISABLE_tolua_set_cPacket_BlockPlace_m_ItemType
+static int tolua_set_cPacket_BlockPlace_m_ItemType(lua_State* tolua_S)
+{
+ cPacket_BlockPlace* self = (cPacket_BlockPlace*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_ItemType'",NULL);
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->m_ItemType = ((short) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: m_Count of class cPacket_BlockPlace */
+#ifndef TOLUA_DISABLE_tolua_get_cPacket_BlockPlace_m_Count
+static int tolua_get_cPacket_BlockPlace_m_Count(lua_State* tolua_S)
+{
+ cPacket_BlockPlace* self = (cPacket_BlockPlace*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_Count'",NULL);
+#endif
+ tolua_pushnumber(tolua_S,(lua_Number)self->m_Count);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: m_Count of class cPacket_BlockPlace */
+#ifndef TOLUA_DISABLE_tolua_set_cPacket_BlockPlace_m_Count
+static int tolua_set_cPacket_BlockPlace_m_Count(lua_State* tolua_S)
+{
+ cPacket_BlockPlace* self = (cPacket_BlockPlace*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_Count'",NULL);
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->m_Count = ((char) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* get function: m_Uses of class cPacket_BlockPlace */
+#ifndef TOLUA_DISABLE_tolua_get_cPacket_BlockPlace_m_Uses
+static int tolua_get_cPacket_BlockPlace_m_Uses(lua_State* tolua_S)
+{
+ cPacket_BlockPlace* self = (cPacket_BlockPlace*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_Uses'",NULL);
+#endif
+ tolua_pushnumber(tolua_S,(lua_Number)self->m_Uses);
+ return 1;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* set function: m_Uses of class cPacket_BlockPlace */
+#ifndef TOLUA_DISABLE_tolua_set_cPacket_BlockPlace_m_Uses
+static int tolua_set_cPacket_BlockPlace_m_Uses(lua_State* tolua_S)
+{
+ cPacket_BlockPlace* self = (cPacket_BlockPlace*) tolua_tousertype(tolua_S,1,0);
+#ifndef TOLUA_RELEASE
+ tolua_Error tolua_err;
+ if (!self) tolua_error(tolua_S,"invalid 'self' in accessing variable 'm_Uses'",NULL);
+ if (!tolua_isnumber(tolua_S,2,0,&tolua_err))
+ tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
+#endif
+ self->m_Uses = ((short) tolua_tonumber(tolua_S,2,0))
+;
+ return 0;
+}
+#endif //#ifndef TOLUA_DISABLE
+
+/* Open function */
+TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S)
+{
+ tolua_open(tolua_S);
+ tolua_reg_types(tolua_S);
+ tolua_module(tolua_S,NULL,1);
+ tolua_beginmodule(tolua_S,NULL);
+ tolua_cclass(tolua_S,"cTorch","cTorch","",NULL);
+ tolua_beginmodule(tolua_S,"cTorch");
+ tolua_function(tolua_S,"DirectionToMetaData",tolua_AllToLua_cTorch_DirectionToMetaData00);
+ tolua_function(tolua_S,"MetaDataToDirection",tolua_AllToLua_cTorch_MetaDataToDirection00);
+ tolua_endmodule(tolua_S);
+ tolua_cclass(tolua_S,"cStairs","cStairs","",NULL);
+ tolua_beginmodule(tolua_S,"cStairs");
+ tolua_function(tolua_S,"RotationToMetaData",tolua_AllToLua_cStairs_RotationToMetaData00);
+ tolua_endmodule(tolua_S);
+ tolua_cclass(tolua_S,"cLadder","cLadder","",NULL);
+ tolua_beginmodule(tolua_S,"cLadder");
+ tolua_function(tolua_S,"DirectionToMetaData",tolua_AllToLua_cLadder_DirectionToMetaData00);
+ tolua_function(tolua_S,"MetaDataToDirection",tolua_AllToLua_cLadder_MetaDataToDirection00);
+ tolua_endmodule(tolua_S);
+ #ifdef __cplusplus
+ tolua_cclass(tolua_S,"cIniFile","cIniFile","",tolua_collect_cIniFile);
+ #else
+ tolua_cclass(tolua_S,"cIniFile","cIniFile","",NULL);
+ #endif
+ tolua_beginmodule(tolua_S,"cIniFile");
+ tolua_function(tolua_S,"new",tolua_AllToLua_cIniFile_new00);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_cIniFile_new00_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_cIniFile_new00_local);
+ tolua_function(tolua_S,"CaseSensitive",tolua_AllToLua_cIniFile_CaseSensitive00);
+ tolua_function(tolua_S,"CaseInsensitive",tolua_AllToLua_cIniFile_CaseInsensitive00);
+ tolua_function(tolua_S,"Path",tolua_AllToLua_cIniFile_Path00);
+ tolua_function(tolua_S,"Path",tolua_AllToLua_cIniFile_Path01);
+ tolua_function(tolua_S,"SetPath",tolua_AllToLua_cIniFile_SetPath00);
+ tolua_function(tolua_S,"ReadFile",tolua_AllToLua_cIniFile_ReadFile00);
+ tolua_function(tolua_S,"WriteFile",tolua_AllToLua_cIniFile_WriteFile00);
+ tolua_function(tolua_S,"Erase",tolua_AllToLua_cIniFile_Erase00);
+ tolua_function(tolua_S,"Clear",tolua_AllToLua_cIniFile_Clear00);
+ tolua_function(tolua_S,"Reset",tolua_AllToLua_cIniFile_Reset00);
+ tolua_function(tolua_S,"FindKey",tolua_AllToLua_cIniFile_FindKey00);
+ tolua_function(tolua_S,"FindValue",tolua_AllToLua_cIniFile_FindValue00);
+ tolua_function(tolua_S,"NumKeys",tolua_AllToLua_cIniFile_NumKeys00);
+ tolua_function(tolua_S,"GetNumKeys",tolua_AllToLua_cIniFile_GetNumKeys00);
+ tolua_function(tolua_S,"AddKeyName",tolua_AllToLua_cIniFile_AddKeyName00);
+ tolua_function(tolua_S,"KeyName",tolua_AllToLua_cIniFile_KeyName00);
+ tolua_function(tolua_S,"GetKeyName",tolua_AllToLua_cIniFile_GetKeyName00);
+ tolua_function(tolua_S,"NumValues",tolua_AllToLua_cIniFile_NumValues00);
+ tolua_function(tolua_S,"GetNumValues",tolua_AllToLua_cIniFile_GetNumValues00);
+ tolua_function(tolua_S,"NumValues",tolua_AllToLua_cIniFile_NumValues01);
+ tolua_function(tolua_S,"GetNumValues",tolua_AllToLua_cIniFile_GetNumValues01);
+ tolua_function(tolua_S,"ValueName",tolua_AllToLua_cIniFile_ValueName00);
+ tolua_function(tolua_S,"GetValueName",tolua_AllToLua_cIniFile_GetValueName00);
+ tolua_function(tolua_S,"ValueName",tolua_AllToLua_cIniFile_ValueName01);
+ tolua_function(tolua_S,"GetValueName",tolua_AllToLua_cIniFile_GetValueName01);
+ tolua_function(tolua_S,"GetValue",tolua_AllToLua_cIniFile_GetValue00);
+ tolua_function(tolua_S,"GetValue",tolua_AllToLua_cIniFile_GetValue01);
+ tolua_function(tolua_S,"GetValue",tolua_AllToLua_cIniFile_GetValue02);
+ tolua_function(tolua_S,"GetValue",tolua_AllToLua_cIniFile_GetValue03);
+ tolua_function(tolua_S,"GetValueI",tolua_AllToLua_cIniFile_GetValueI00);
+ tolua_function(tolua_S,"GetValueB",tolua_AllToLua_cIniFile_GetValueB00);
+ tolua_function(tolua_S,"GetValueF",tolua_AllToLua_cIniFile_GetValueF00);
+ tolua_function(tolua_S,"SetValue",tolua_AllToLua_cIniFile_SetValue00);
+ tolua_function(tolua_S,"SetValue",tolua_AllToLua_cIniFile_SetValue01);
+ tolua_function(tolua_S,"SetValueI",tolua_AllToLua_cIniFile_SetValueI00);
+ tolua_function(tolua_S,"SetValueB",tolua_AllToLua_cIniFile_SetValueB00);
+ tolua_function(tolua_S,"SetValueF",tolua_AllToLua_cIniFile_SetValueF00);
+ tolua_function(tolua_S,"DeleteValue",tolua_AllToLua_cIniFile_DeleteValue00);
+ tolua_function(tolua_S,"DeleteKey",tolua_AllToLua_cIniFile_DeleteKey00);
+ tolua_function(tolua_S,"NumHeaderComments",tolua_AllToLua_cIniFile_NumHeaderComments00);
+ tolua_function(tolua_S,"HeaderComment",tolua_AllToLua_cIniFile_HeaderComment00);
+ tolua_function(tolua_S,"HeaderComment",tolua_AllToLua_cIniFile_HeaderComment01);
+ tolua_function(tolua_S,"DeleteHeaderComment",tolua_AllToLua_cIniFile_DeleteHeaderComment00);
+ tolua_function(tolua_S,"DeleteHeaderComments",tolua_AllToLua_cIniFile_DeleteHeaderComments00);
+ tolua_function(tolua_S,"NumKeyComments",tolua_AllToLua_cIniFile_NumKeyComments00);
+ tolua_function(tolua_S,"NumKeyComments",tolua_AllToLua_cIniFile_NumKeyComments01);
+ tolua_function(tolua_S,"KeyComment",tolua_AllToLua_cIniFile_KeyComment00);
+ tolua_function(tolua_S,"KeyComment",tolua_AllToLua_cIniFile_KeyComment01);
+ tolua_function(tolua_S,"KeyComment",tolua_AllToLua_cIniFile_KeyComment02);
+ tolua_function(tolua_S,"KeyComment",tolua_AllToLua_cIniFile_KeyComment03);
+ tolua_function(tolua_S,"DeleteKeyComment",tolua_AllToLua_cIniFile_DeleteKeyComment00);
+ tolua_function(tolua_S,"DeleteKeyComment",tolua_AllToLua_cIniFile_DeleteKeyComment01);
+ tolua_function(tolua_S,"DeleteKeyComments",tolua_AllToLua_cIniFile_DeleteKeyComments00);
+ tolua_function(tolua_S,"DeleteKeyComments",tolua_AllToLua_cIniFile_DeleteKeyComments01);
+ tolua_endmodule(tolua_S);
+ tolua_constant(tolua_S,"E_BLOCK_AIR",E_BLOCK_AIR);
+ tolua_constant(tolua_S,"E_BLOCK_STONE",E_BLOCK_STONE);
+ tolua_constant(tolua_S,"E_BLOCK_GRASS",E_BLOCK_GRASS);
+ tolua_constant(tolua_S,"E_BLOCK_DIRT",E_BLOCK_DIRT);
+ tolua_constant(tolua_S,"E_BLOCK_COBBLESTONE",E_BLOCK_COBBLESTONE);
+ tolua_constant(tolua_S,"E_BLOCK_WOOD",E_BLOCK_WOOD);
+ tolua_constant(tolua_S,"E_BLOCK_SAPLING",E_BLOCK_SAPLING);
+ tolua_constant(tolua_S,"E_BLOCK_BEDROCK",E_BLOCK_BEDROCK);
+ tolua_constant(tolua_S,"E_BLOCK_WATER",E_BLOCK_WATER);
+ tolua_constant(tolua_S,"E_BLOCK_STATIONARY_WATER",E_BLOCK_STATIONARY_WATER);
+ tolua_constant(tolua_S,"E_BLOCK_LAVA",E_BLOCK_LAVA);
+ tolua_constant(tolua_S,"E_BLOCK_STATIONARY_LAVA",E_BLOCK_STATIONARY_LAVA);
+ tolua_constant(tolua_S,"E_BLOCK_SAND",E_BLOCK_SAND);
+ tolua_constant(tolua_S,"E_BLOCK_GRAVEL",E_BLOCK_GRAVEL);
+ tolua_constant(tolua_S,"E_BLOCK_GOLD_ORE",E_BLOCK_GOLD_ORE);
+ tolua_constant(tolua_S,"E_BLOCK_IRON_ORE",E_BLOCK_IRON_ORE);
+ tolua_constant(tolua_S,"E_BLOCK_COAL_ORE",E_BLOCK_COAL_ORE);
+ tolua_constant(tolua_S,"E_BLOCK_LOG",E_BLOCK_LOG);
+ tolua_constant(tolua_S,"E_BLOCK_LEAVES",E_BLOCK_LEAVES);
+ tolua_constant(tolua_S,"E_BLOCK_SPONGE",E_BLOCK_SPONGE);
+ tolua_constant(tolua_S,"E_BLOCK_GLASS",E_BLOCK_GLASS);
+ tolua_constant(tolua_S,"E_BLOCK_WHITE_CLOTH",E_BLOCK_WHITE_CLOTH);
+ tolua_constant(tolua_S,"E_BLOCK_YELLOW_FLOWER",E_BLOCK_YELLOW_FLOWER);
+ tolua_constant(tolua_S,"E_BLOCK_RED_ROSE",E_BLOCK_RED_ROSE);
+ tolua_constant(tolua_S,"E_BLOCK_BROWN_MUSHROOM",E_BLOCK_BROWN_MUSHROOM);
+ tolua_constant(tolua_S,"E_BLOCK_RED_MUSHROOM",E_BLOCK_RED_MUSHROOM);
+ tolua_constant(tolua_S,"E_BLOCK_GOLD_BLOCK",E_BLOCK_GOLD_BLOCK);
+ tolua_constant(tolua_S,"E_BLOCK_IRON_BLOCK",E_BLOCK_IRON_BLOCK);
+ tolua_constant(tolua_S,"E_BLOCK_DOUBLE_STEP",E_BLOCK_DOUBLE_STEP);
+ tolua_constant(tolua_S,"E_BLOCK_STEP",E_BLOCK_STEP);
+ tolua_constant(tolua_S,"E_BLOCK_BRICK",E_BLOCK_BRICK);
+ tolua_constant(tolua_S,"E_BLOCK_TNT",E_BLOCK_TNT);
+ tolua_constant(tolua_S,"E_BLOCK_BOOKCASE",E_BLOCK_BOOKCASE);
+ tolua_constant(tolua_S,"E_BLOCK_MOSSY_COBBLESTONE",E_BLOCK_MOSSY_COBBLESTONE);
+ tolua_constant(tolua_S,"E_BLOCK_OBSIDIAN",E_BLOCK_OBSIDIAN);
+ tolua_constant(tolua_S,"E_BLOCK_TORCH",E_BLOCK_TORCH);
+ tolua_constant(tolua_S,"E_BLOCK_FIRE",E_BLOCK_FIRE);
+ tolua_constant(tolua_S,"E_BLOCK_MOB_SPAWNER",E_BLOCK_MOB_SPAWNER);
+ tolua_constant(tolua_S,"E_BLOCK_WOODEN_STAIRS",E_BLOCK_WOODEN_STAIRS);
+ tolua_constant(tolua_S,"E_BLOCK_CHEST",E_BLOCK_CHEST);
+ tolua_constant(tolua_S,"E_BLOCK_REDSTONE_WIRE",E_BLOCK_REDSTONE_WIRE);
+ tolua_constant(tolua_S,"E_BLOCK_DIAMOND_ORE",E_BLOCK_DIAMOND_ORE);
+ tolua_constant(tolua_S,"E_BLOCK_DIAMOND_BLOCK",E_BLOCK_DIAMOND_BLOCK);
+ tolua_constant(tolua_S,"E_BLOCK_WORKBENCH",E_BLOCK_WORKBENCH);
+ tolua_constant(tolua_S,"E_BLOCK_CROPS",E_BLOCK_CROPS);
+ tolua_constant(tolua_S,"E_BLOCK_SOIL",E_BLOCK_SOIL);
+ tolua_constant(tolua_S,"E_BLOCK_FURNACE",E_BLOCK_FURNACE);
+ tolua_constant(tolua_S,"E_BLOCK_BURNING_FURNACE",E_BLOCK_BURNING_FURNACE);
+ tolua_constant(tolua_S,"E_BLOCK_SIGN_POST",E_BLOCK_SIGN_POST);
+ tolua_constant(tolua_S,"E_BLOCK_WOODEN_DOOR",E_BLOCK_WOODEN_DOOR);
+ tolua_constant(tolua_S,"E_BLOCK_LADDER",E_BLOCK_LADDER);
+ tolua_constant(tolua_S,"E_BLOCK_MINECART_TRACKS",E_BLOCK_MINECART_TRACKS);
+ tolua_constant(tolua_S,"E_BLOCK_COBBLESTONE_STAIRS",E_BLOCK_COBBLESTONE_STAIRS);
+ tolua_constant(tolua_S,"E_BLOCK_WALLSIGN",E_BLOCK_WALLSIGN);
+ tolua_constant(tolua_S,"E_BLOCK_LEVER",E_BLOCK_LEVER);
+ tolua_constant(tolua_S,"E_BLOCK_STONE_PRESSURE_PLATE",E_BLOCK_STONE_PRESSURE_PLATE);
+ tolua_constant(tolua_S,"E_BLOCK_IRON_DOOR",E_BLOCK_IRON_DOOR);
+ tolua_constant(tolua_S,"E_BLOCK_WOODEN_PRESSURE_PLATE",E_BLOCK_WOODEN_PRESSURE_PLATE);
+ tolua_constant(tolua_S,"E_BLOCK_REDSTONE_ORE",E_BLOCK_REDSTONE_ORE);
+ tolua_constant(tolua_S,"E_BLOCK_REDSTONE_ORE_GLOWING",E_BLOCK_REDSTONE_ORE_GLOWING);
+ tolua_constant(tolua_S,"E_BLOCK_REDSTONE_TORCH_ON",E_BLOCK_REDSTONE_TORCH_ON);
+ tolua_constant(tolua_S,"E_BLOCK_REDSTONE_TORCH_OFF",E_BLOCK_REDSTONE_TORCH_OFF);
+ tolua_constant(tolua_S,"E_BLOCK_SNOW",E_BLOCK_SNOW);
+ tolua_constant(tolua_S,"E_BLOCK_ICE",E_BLOCK_ICE);
+ tolua_constant(tolua_S,"E_BLOCK_SNOW_BLOCK",E_BLOCK_SNOW_BLOCK);
+ tolua_constant(tolua_S,"E_BLOCK_CACTUS",E_BLOCK_CACTUS);
+ tolua_constant(tolua_S,"E_BLOCK_CLAY",E_BLOCK_CLAY);
+ tolua_constant(tolua_S,"E_BLOCK_REEDS",E_BLOCK_REEDS);
+ tolua_constant(tolua_S,"E_BLOCK_BLOODSTONE",E_BLOCK_BLOODSTONE);
+ tolua_constant(tolua_S,"E_BLOCK_SOULSAND",E_BLOCK_SOULSAND);
+ tolua_constant(tolua_S,"E_BLOCK_GLOWSTONE",E_BLOCK_GLOWSTONE);
+ tolua_constant(tolua_S,"E_BLOCK_PORT",E_BLOCK_PORT);
+ tolua_constant(tolua_S,"E_BLOCK_JACK_O_LANTERN",E_BLOCK_JACK_O_LANTERN);
+ tolua_constant(tolua_S,"E_BLOCK_CAKE",E_BLOCK_CAKE);
+ tolua_constant(tolua_S,"E_BLOCK_REDSTONE_REPEATER_OFF",E_BLOCK_REDSTONE_REPEATER_OFF);
+ tolua_constant(tolua_S,"E_BLOCK_REDSTONE_REPEATER_ON",E_BLOCK_REDSTONE_REPEATER_ON);
+ tolua_constant(tolua_S,"E_BLOCK_LOCKED_CHEST",E_BLOCK_LOCKED_CHEST);
+ tolua_constant(tolua_S,"E_BLOCK_TRAPDOOR",E_BLOCK_TRAPDOOR);
+ tolua_constant(tolua_S,"E_ITEM_EMPTY",E_ITEM_EMPTY);
+ tolua_constant(tolua_S,"E_ITEM_STONE",E_ITEM_STONE);
+ tolua_constant(tolua_S,"E_ITEM_GRASS",E_ITEM_GRASS);
+ tolua_constant(tolua_S,"E_ITEM_DIRT",E_ITEM_DIRT);
+ tolua_constant(tolua_S,"E_ITEM_COBBLESTONE",E_ITEM_COBBLESTONE);
+ tolua_constant(tolua_S,"E_ITEM_WOOD",E_ITEM_WOOD);
+ tolua_constant(tolua_S,"E_ITEM_SAPLING",E_ITEM_SAPLING);
+ tolua_constant(tolua_S,"E_ITEM_BEDROCK",E_ITEM_BEDROCK);
+ tolua_constant(tolua_S,"E_ITEM_WATER",E_ITEM_WATER);
+ tolua_constant(tolua_S,"E_ITEM_STATIONARY_WATER",E_ITEM_STATIONARY_WATER);
+ tolua_constant(tolua_S,"E_ITEM_LAVA",E_ITEM_LAVA);
+ tolua_constant(tolua_S,"E_ITEM_STATIONARY_LAVA",E_ITEM_STATIONARY_LAVA);
+ tolua_constant(tolua_S,"E_ITEM_SAND",E_ITEM_SAND);
+ tolua_constant(tolua_S,"E_ITEM_GRAVEL",E_ITEM_GRAVEL);
+ tolua_constant(tolua_S,"E_ITEM_GOLD_ORE",E_ITEM_GOLD_ORE);
+ tolua_constant(tolua_S,"E_ITEM_IRON_ORE",E_ITEM_IRON_ORE);
+ tolua_constant(tolua_S,"E_ITEM_COAL_ORE",E_ITEM_COAL_ORE);
+ tolua_constant(tolua_S,"E_ITEM_LOG",E_ITEM_LOG);
+ tolua_constant(tolua_S,"E_ITEM_LEAVES",E_ITEM_LEAVES);
+ tolua_constant(tolua_S,"E_ITEM_GOLD_BLOCK",E_ITEM_GOLD_BLOCK);
+ tolua_constant(tolua_S,"E_ITEM_IRON_BLOCK",E_ITEM_IRON_BLOCK);
+ tolua_constant(tolua_S,"E_ITEM_DIAMOND_BLOCK",E_ITEM_DIAMOND_BLOCK);
+ tolua_constant(tolua_S,"E_ITEM_FLINT_AND_STEEL",E_ITEM_FLINT_AND_STEEL);
+ tolua_constant(tolua_S,"E_ITEM_APPLE",E_ITEM_APPLE);
+ tolua_constant(tolua_S,"E_ITEM_BOW",E_ITEM_BOW);
+ tolua_constant(tolua_S,"E_ITEM_ARROW",E_ITEM_ARROW);
+ tolua_constant(tolua_S,"E_ITEM_COAL",E_ITEM_COAL);
+ tolua_constant(tolua_S,"E_ITEM_DIAMOND",E_ITEM_DIAMOND);
+ tolua_constant(tolua_S,"E_ITEM_IRON",E_ITEM_IRON);
+ tolua_constant(tolua_S,"E_ITEM_GOLD",E_ITEM_GOLD);
+ tolua_constant(tolua_S,"E_ITEM_MUSHROOM_SOUP",E_ITEM_MUSHROOM_SOUP);
+ tolua_constant(tolua_S,"E_ITEM_GOLD_SWORD",E_ITEM_GOLD_SWORD);
+ tolua_constant(tolua_S,"E_ITEM_GOLD_SHOVEL",E_ITEM_GOLD_SHOVEL);
+ tolua_constant(tolua_S,"E_ITEM_GOLD_PICKAXE",E_ITEM_GOLD_PICKAXE);
+ tolua_constant(tolua_S,"E_ITEM_GOLD_AXE",E_ITEM_GOLD_AXE);
+ tolua_constant(tolua_S,"E_ITEM_STRING",E_ITEM_STRING);
+ tolua_constant(tolua_S,"E_ITEM_FEATHER",E_ITEM_FEATHER);
+ tolua_constant(tolua_S,"E_ITEM_BREAD",E_ITEM_BREAD);
+ tolua_constant(tolua_S,"E_ITEM_RAW_MEAT",E_ITEM_RAW_MEAT);
+ tolua_constant(tolua_S,"E_ITEM_COOKED_MEAT",E_ITEM_COOKED_MEAT);
+ tolua_constant(tolua_S,"E_ITEM_GOLDEN_APPLE",E_ITEM_GOLDEN_APPLE);
+ tolua_constant(tolua_S,"E_ITEM_SIGN",E_ITEM_SIGN);
+ tolua_constant(tolua_S,"E_ITEM_MILK",E_ITEM_MILK);
+ tolua_constant(tolua_S,"E_ITEM_EGG",E_ITEM_EGG);
+ tolua_constant(tolua_S,"E_ITEM_COMPASS",E_ITEM_COMPASS);
+ tolua_constant(tolua_S,"E_ITEM_FISHING_ROD",E_ITEM_FISHING_ROD);
+ tolua_constant(tolua_S,"E_ITEM_CLOCK",E_ITEM_CLOCK);
+ tolua_constant(tolua_S,"E_ITEM_GLOWSTONE_DUST",E_ITEM_GLOWSTONE_DUST);
+ tolua_constant(tolua_S,"E_ITEM_RAW_FISH",E_ITEM_RAW_FISH);
+ tolua_constant(tolua_S,"E_ITEM_COOKED_FISH",E_ITEM_COOKED_FISH);
+ tolua_constant(tolua_S,"E_ITEM_CAKE",E_ITEM_CAKE);
+ tolua_constant(tolua_S,"E_KEEP_ALIVE",E_KEEP_ALIVE);
+ tolua_constant(tolua_S,"E_LOGIN",E_LOGIN);
+ tolua_constant(tolua_S,"E_HANDSHAKE",E_HANDSHAKE);
+ tolua_constant(tolua_S,"E_CHAT",E_CHAT);
+ tolua_constant(tolua_S,"E_UPDATE_TIME",E_UPDATE_TIME);
+ tolua_constant(tolua_S,"E_ENTITY_EQUIPMENT",E_ENTITY_EQUIPMENT);
+ tolua_constant(tolua_S,"E_USE_ENTITY",E_USE_ENTITY);
+ tolua_constant(tolua_S,"E_UPDATE_HEALTH",E_UPDATE_HEALTH);
+ tolua_constant(tolua_S,"E_RESPAWN",E_RESPAWN);
+ tolua_constant(tolua_S,"E_FLYING",E_FLYING);
+ tolua_constant(tolua_S,"E_PLAYERPOS",E_PLAYERPOS);
+ tolua_constant(tolua_S,"E_PLAYERLOOK",E_PLAYERLOOK);
+ tolua_constant(tolua_S,"E_PLAYERMOVELOOK",E_PLAYERMOVELOOK);
+ tolua_constant(tolua_S,"E_BLOCK_DIG",E_BLOCK_DIG);
+ tolua_constant(tolua_S,"E_BLOCK_PLACE",E_BLOCK_PLACE);
+ tolua_constant(tolua_S,"E_ITEM_SWITCH",E_ITEM_SWITCH);
+ tolua_constant(tolua_S,"E_ADD_TO_INV",E_ADD_TO_INV);
+ tolua_constant(tolua_S,"E_ANIMATION",E_ANIMATION);
+ tolua_constant(tolua_S,"E_PACKET_13",E_PACKET_13);
+ tolua_constant(tolua_S,"E_NAMED_ENTITY_SPAWN",E_NAMED_ENTITY_SPAWN);
+ tolua_constant(tolua_S,"E_PICKUP_SPAWN",E_PICKUP_SPAWN);
+ tolua_constant(tolua_S,"E_COLLECT_ITEM",E_COLLECT_ITEM);
+ tolua_constant(tolua_S,"E_ADD_VEHICLE",E_ADD_VEHICLE);
+ tolua_constant(tolua_S,"E_SPAWN_MOB",E_SPAWN_MOB);
+ tolua_constant(tolua_S,"E_DESTROY_ENT",E_DESTROY_ENT);
+ tolua_constant(tolua_S,"E_ENTITY",E_ENTITY);
+ tolua_constant(tolua_S,"E_REL_ENT_MOVE",E_REL_ENT_MOVE);
+ tolua_constant(tolua_S,"E_ENT_LOOK",E_ENT_LOOK);
+ tolua_constant(tolua_S,"E_REL_ENT_MOVE_LOOK",E_REL_ENT_MOVE_LOOK);
+ tolua_constant(tolua_S,"E_ENT_TELEPORT",E_ENT_TELEPORT);
+ tolua_constant(tolua_S,"E_ENT_STATUS",E_ENT_STATUS);
+ tolua_constant(tolua_S,"E_METADATA",E_METADATA);
+ tolua_constant(tolua_S,"E_PRE_CHUNK",E_PRE_CHUNK);
+ tolua_constant(tolua_S,"E_MAP_CHUNK",E_MAP_CHUNK);
+ tolua_constant(tolua_S,"E_MULTI_BLOCK",E_MULTI_BLOCK);
+ tolua_constant(tolua_S,"E_BLOCK_CHANGE",E_BLOCK_CHANGE);
+ tolua_constant(tolua_S,"E_WINDOW_OPEN",E_WINDOW_OPEN);
+ tolua_constant(tolua_S,"E_WINDOW_CLOSE",E_WINDOW_CLOSE);
+ tolua_constant(tolua_S,"E_WINDOW_CLICK",E_WINDOW_CLICK);
+ tolua_constant(tolua_S,"E_INVENTORY_SLOT",E_INVENTORY_SLOT);
+ tolua_constant(tolua_S,"E_INVENTORY_WHOLE",E_INVENTORY_WHOLE);
+ tolua_constant(tolua_S,"E_INVENTORY_PROGRESS",E_INVENTORY_PROGRESS);
+ tolua_constant(tolua_S,"E_UPDATE_SIGN",E_UPDATE_SIGN);
+ tolua_constant(tolua_S,"E_DISCONNECT",E_DISCONNECT);
+ tolua_array(tolua_S,"g_BlockLightValue",tolua_get_AllToLua_g_BlockLightValue,tolua_set_AllToLua_g_BlockLightValue);
+ tolua_array(tolua_S,"g_BlockSpreadLightFalloff",tolua_get_AllToLua_g_BlockSpreadLightFalloff,tolua_set_AllToLua_g_BlockSpreadLightFalloff);
+ tolua_array(tolua_S,"g_BlockTransparent",tolua_get_AllToLua_g_BlockTransparent,tolua_set_AllToLua_g_BlockTransparent);
+ tolua_array(tolua_S,"g_BlockOneHitDig",tolua_get_AllToLua_g_BlockOneHitDig,tolua_set_AllToLua_g_BlockOneHitDig);
+ tolua_function(tolua_S,"IsValidBlock",tolua_AllToLua_IsValidBlock00);
+ tolua_function(tolua_S,"isValidItem",tolua_AllToLua_isValidItem00);
+ tolua_function(tolua_S,"AddDirection",tolua_AllToLua_AddDirection00);
+ tolua_function(tolua_S,"GetTime",tolua_AllToLua_GetTime00);
+ tolua_function(tolua_S,"GetChar",tolua_AllToLua_GetChar00);
+ tolua_cclass(tolua_S,"cStringMap","cStringMap","",NULL);
+ tolua_beginmodule(tolua_S,"cStringMap");
+ tolua_function(tolua_S,"clear",tolua_AllToLua_cStringMap_clear00);
+ tolua_function(tolua_S,"size",tolua_AllToLua_cStringMap_size00);
+ tolua_function(tolua_S,"get",tolua_AllToLua_cStringMap_get00);
+ tolua_endmodule(tolua_S);
+ tolua_cclass(tolua_S,"cChatColor","cChatColor","",NULL);
+ tolua_beginmodule(tolua_S,"cChatColor");
+ tolua_variable(tolua_S,"Color",tolua_get_cChatColor_Color,NULL);
+ tolua_variable(tolua_S,"Black",tolua_get_cChatColor_Black,NULL);
+ tolua_variable(tolua_S,"Navy",tolua_get_cChatColor_Navy,NULL);
+ tolua_variable(tolua_S,"Green",tolua_get_cChatColor_Green,NULL);
+ tolua_variable(tolua_S,"Blue",tolua_get_cChatColor_Blue,NULL);
+ tolua_variable(tolua_S,"Red",tolua_get_cChatColor_Red,NULL);
+ tolua_variable(tolua_S,"Purple",tolua_get_cChatColor_Purple,NULL);
+ tolua_variable(tolua_S,"Gold",tolua_get_cChatColor_Gold,NULL);
+ tolua_variable(tolua_S,"LightGray",tolua_get_cChatColor_LightGray,NULL);
+ tolua_variable(tolua_S,"Gray",tolua_get_cChatColor_Gray,NULL);
+ tolua_variable(tolua_S,"DarkPurple",tolua_get_cChatColor_DarkPurple,NULL);
+ tolua_variable(tolua_S,"LightGreen",tolua_get_cChatColor_LightGreen,NULL);
+ tolua_variable(tolua_S,"LightBlue",tolua_get_cChatColor_LightBlue,NULL);
+ tolua_variable(tolua_S,"Rose",tolua_get_cChatColor_Rose,NULL);
+ tolua_variable(tolua_S,"LightPurple",tolua_get_cChatColor_LightPurple,NULL);
+ tolua_variable(tolua_S,"Yellow",tolua_get_cChatColor_Yellow,NULL);
+ tolua_variable(tolua_S,"White",tolua_get_cChatColor_White,NULL);
+ tolua_function(tolua_S,"MakeColor",tolua_AllToLua_cChatColor_MakeColor00);
+ tolua_endmodule(tolua_S);
+ tolua_cclass(tolua_S,"cClientHandle","cClientHandle","",NULL);
+ tolua_beginmodule(tolua_S,"cClientHandle");
+ tolua_function(tolua_S,"GetPlayer",tolua_AllToLua_cClientHandle_GetPlayer00);
+ tolua_function(tolua_S,"Kick",tolua_AllToLua_cClientHandle_Kick00);
+ tolua_endmodule(tolua_S);
+ #ifdef __cplusplus
+ tolua_cclass(tolua_S,"cEntity","cEntity","",tolua_collect_cEntity);
+ #else
+ tolua_cclass(tolua_S,"cEntity","cEntity","",NULL);
+ #endif
+ tolua_beginmodule(tolua_S,"cEntity");
+ tolua_function(tolua_S,"delete",tolua_AllToLua_cEntity_delete00);
+ tolua_function(tolua_S,"Initialize",tolua_AllToLua_cEntity_Initialize00);
+ tolua_constant(tolua_S,"E_ENTITY",cEntity::E_ENTITY);
+ tolua_constant(tolua_S,"E_PLAYER",cEntity::E_PLAYER);
+ tolua_constant(tolua_S,"E_PICKUP",cEntity::E_PICKUP);
+ tolua_function(tolua_S,"GetEntityType",tolua_AllToLua_cEntity_GetEntityType00);
+ tolua_function(tolua_S,"IsA",tolua_AllToLua_cEntity_IsA00);
+ tolua_function(tolua_S,"GetClass",tolua_AllToLua_cEntity_GetClass00);
+ tolua_function(tolua_S,"GetPosition",tolua_AllToLua_cEntity_GetPosition00);
+ tolua_function(tolua_S,"GetPosX",tolua_AllToLua_cEntity_GetPosX00);
+ tolua_function(tolua_S,"GetPosY",tolua_AllToLua_cEntity_GetPosY00);
+ tolua_function(tolua_S,"GetPosZ",tolua_AllToLua_cEntity_GetPosZ00);
+ tolua_function(tolua_S,"GetRot",tolua_AllToLua_cEntity_GetRot00);
+ tolua_function(tolua_S,"GetRotation",tolua_AllToLua_cEntity_GetRotation00);
+ tolua_function(tolua_S,"GetPitch",tolua_AllToLua_cEntity_GetPitch00);
+ tolua_function(tolua_S,"GetRoll",tolua_AllToLua_cEntity_GetRoll00);
+ tolua_function(tolua_S,"GetLookVector",tolua_AllToLua_cEntity_GetLookVector00);
+ tolua_function(tolua_S,"SetPosX",tolua_AllToLua_cEntity_SetPosX00);
+ tolua_function(tolua_S,"SetPosY",tolua_AllToLua_cEntity_SetPosY00);
+ tolua_function(tolua_S,"SetPosZ",tolua_AllToLua_cEntity_SetPosZ00);
+ tolua_function(tolua_S,"SetPosition",tolua_AllToLua_cEntity_SetPosition00);
+ tolua_function(tolua_S,"SetPosition",tolua_AllToLua_cEntity_SetPosition01);
+ tolua_function(tolua_S,"SetRot",tolua_AllToLua_cEntity_SetRot00);
+ tolua_function(tolua_S,"SetRotation",tolua_AllToLua_cEntity_SetRotation00);
+ tolua_function(tolua_S,"SetPitch",tolua_AllToLua_cEntity_SetPitch00);
+ tolua_function(tolua_S,"SetRoll",tolua_AllToLua_cEntity_SetRoll00);
+ tolua_function(tolua_S,"GetUniqueID",tolua_AllToLua_cEntity_GetUniqueID00);
+ tolua_function(tolua_S,"IsDestroyed",tolua_AllToLua_cEntity_IsDestroyed00);
+ tolua_function(tolua_S,"Destroy",tolua_AllToLua_cEntity_Destroy00);
+ tolua_function(tolua_S,"Tick",tolua_AllToLua_cEntity_Tick00);
+ tolua_function(tolua_S,"SpawnOn",tolua_AllToLua_cEntity_SpawnOn00);
+ tolua_endmodule(tolua_S);
+ #ifdef __cplusplus
+ tolua_cclass(tolua_S,"Lua__cEntity","Lua__cEntity","cEntity",tolua_collect_Lua__cEntity);
+ #else
+ tolua_cclass(tolua_S,"Lua__cEntity","Lua__cEntity","cEntity",NULL);
+ #endif
+ tolua_beginmodule(tolua_S,"Lua__cEntity");
+ tolua_function(tolua_S,"tolua__set_instance",tolua_AllToLua_Lua__cEntity_tolua__set_instance00);
+ tolua_function(tolua_S,"cEntity__Initialize",tolua_AllToLua_Lua__cEntity_cEntity__Initialize00);
+ tolua_function(tolua_S,"cEntity__GetEntityType",tolua_AllToLua_Lua__cEntity_cEntity__GetEntityType00);
+ tolua_function(tolua_S,"cEntity__IsA",tolua_AllToLua_Lua__cEntity_cEntity__IsA00);
+ tolua_function(tolua_S,"cEntity__GetClass",tolua_AllToLua_Lua__cEntity_cEntity__GetClass00);
+ tolua_function(tolua_S,"new",tolua_AllToLua_Lua__cEntity_new00);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_Lua__cEntity_new00_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_Lua__cEntity_new00_local);
+ tolua_function(tolua_S,"delete",tolua_AllToLua_Lua__cEntity_delete00);
+ tolua_endmodule(tolua_S);
+ tolua_cclass(tolua_S,"TakeDamageInfo","TakeDamageInfo","",NULL);
+ tolua_beginmodule(tolua_S,"TakeDamageInfo");
+ tolua_variable(tolua_S,"Damage",tolua_get_TakeDamageInfo_Damage,tolua_set_TakeDamageInfo_Damage);
+ tolua_variable(tolua_S,"Instigator",tolua_get_TakeDamageInfo_Instigator_ptr,tolua_set_TakeDamageInfo_Instigator_ptr);
+ tolua_endmodule(tolua_S);
+ tolua_cclass(tolua_S,"cPawn","cPawn","cEntity",NULL);
+ tolua_beginmodule(tolua_S,"cPawn");
+ tolua_function(tolua_S,"TeleportTo",tolua_AllToLua_cPawn_TeleportTo00);
+ tolua_function(tolua_S,"TeleportTo",tolua_AllToLua_cPawn_TeleportTo01);
+ tolua_function(tolua_S,"Heal",tolua_AllToLua_cPawn_Heal00);
+ tolua_function(tolua_S,"TakeDamage",tolua_AllToLua_cPawn_TakeDamage00);
+ tolua_function(tolua_S,"KilledBy",tolua_AllToLua_cPawn_KilledBy00);
+ tolua_function(tolua_S,"GetHealth",tolua_AllToLua_cPawn_GetHealth00);
+ tolua_endmodule(tolua_S);
+ tolua_cclass(tolua_S,"Lua__cPawn","Lua__cPawn","cPawn",NULL);
+ tolua_beginmodule(tolua_S,"Lua__cPawn");
+ tolua_function(tolua_S,"tolua__set_instance",tolua_AllToLua_Lua__cPawn_tolua__set_instance00);
+ tolua_function(tolua_S,"cPawn__TeleportTo",tolua_AllToLua_Lua__cPawn_cPawn__TeleportTo00);
+ tolua_function(tolua_S,"cPawn__TeleportTo",tolua_AllToLua_Lua__cPawn_cPawn__TeleportTo01);
+ tolua_function(tolua_S,"cPawn__TakeDamage",tolua_AllToLua_Lua__cPawn_cPawn__TakeDamage00);
+ tolua_function(tolua_S,"cPawn__KilledBy",tolua_AllToLua_Lua__cPawn_cPawn__KilledBy00);
+ tolua_endmodule(tolua_S);
+ tolua_cclass(tolua_S,"cPlayer","cPlayer","cPawn",NULL);
+ tolua_beginmodule(tolua_S,"cPlayer");
+ tolua_function(tolua_S,"GetEyeHeight",tolua_AllToLua_cPlayer_GetEyeHeight00);
+ tolua_function(tolua_S,"GetEyePosition",tolua_AllToLua_cPlayer_GetEyePosition00);
+ tolua_function(tolua_S,"GetFlying",tolua_AllToLua_cPlayer_GetFlying00);
+ tolua_function(tolua_S,"GetStance",tolua_AllToLua_cPlayer_GetStance00);
+ tolua_function(tolua_S,"GetInventory",tolua_AllToLua_cPlayer_GetInventory00);
+ tolua_function(tolua_S,"TeleportTo",tolua_AllToLua_cPlayer_TeleportTo00);
+ tolua_function(tolua_S,"TeleportTo",tolua_AllToLua_cPlayer_TeleportTo01);
+ tolua_function(tolua_S,"MoveTo",tolua_AllToLua_cPlayer_MoveTo00);
+ tolua_function(tolua_S,"GetClientHandle",tolua_AllToLua_cPlayer_GetClientHandle00);
+ tolua_function(tolua_S,"SendMessage",tolua_AllToLua_cPlayer_SendMessage00);
+ tolua_function(tolua_S,"GetName",tolua_AllToLua_cPlayer_GetName00);
+ tolua_function(tolua_S,"SetName",tolua_AllToLua_cPlayer_SetName00);
+ tolua_function(tolua_S,"AddToGroup",tolua_AllToLua_cPlayer_AddToGroup00);
+ tolua_function(tolua_S,"CanUseCommand",tolua_AllToLua_cPlayer_CanUseCommand00);
+ tolua_function(tolua_S,"HasPermission",tolua_AllToLua_cPlayer_HasPermission00);
+ tolua_function(tolua_S,"IsInGroup",tolua_AllToLua_cPlayer_IsInGroup00);
+ tolua_function(tolua_S,"GetColor",tolua_AllToLua_cPlayer_GetColor00);
+ tolua_function(tolua_S,"TossItem",tolua_AllToLua_cPlayer_TossItem00);
+ tolua_function(tolua_S,"Heal",tolua_AllToLua_cPlayer_Heal00);
+ tolua_function(tolua_S,"TakeDamage",tolua_AllToLua_cPlayer_TakeDamage00);
+ tolua_function(tolua_S,"KilledBy",tolua_AllToLua_cPlayer_KilledBy00);
+ tolua_function(tolua_S,"Respawn",tolua_AllToLua_cPlayer_Respawn00);
+ tolua_function(tolua_S,"SetVisible",tolua_AllToLua_cPlayer_SetVisible00);
+ tolua_function(tolua_S,"IsVisible",tolua_AllToLua_cPlayer_IsVisible00);
+ tolua_endmodule(tolua_S);
+ tolua_cclass(tolua_S,"Lua__cPlayer","Lua__cPlayer","cPlayer",NULL);
+ tolua_beginmodule(tolua_S,"Lua__cPlayer");
+ tolua_function(tolua_S,"tolua__set_instance",tolua_AllToLua_Lua__cPlayer_tolua__set_instance00);
+ tolua_function(tolua_S,"cPlayer__TeleportTo",tolua_AllToLua_Lua__cPlayer_cPlayer__TeleportTo00);
+ tolua_function(tolua_S,"cPlayer__TeleportTo",tolua_AllToLua_Lua__cPlayer_cPlayer__TeleportTo01);
+ tolua_function(tolua_S,"cPlayer__MoveTo",tolua_AllToLua_Lua__cPlayer_cPlayer__MoveTo00);
+ tolua_endmodule(tolua_S);
+ tolua_cclass(tolua_S,"cPluginManager","cPluginManager","",NULL);
+ tolua_beginmodule(tolua_S,"cPluginManager");
+ tolua_constant(tolua_S,"E_PLUGIN_TICK",cPluginManager::E_PLUGIN_TICK);
+ tolua_constant(tolua_S,"E_PLUGIN_CHAT",cPluginManager::E_PLUGIN_CHAT);
+ tolua_constant(tolua_S,"E_PLUGIN_COLLECT_ITEM",cPluginManager::E_PLUGIN_COLLECT_ITEM);
+ tolua_constant(tolua_S,"E_PLUGIN_BLOCK_DIG",cPluginManager::E_PLUGIN_BLOCK_DIG);
+ tolua_constant(tolua_S,"E_PLUGIN_BLOCK_PLACE",cPluginManager::E_PLUGIN_BLOCK_PLACE);
+ tolua_constant(tolua_S,"E_PLUGIN_DISCONNECT",cPluginManager::E_PLUGIN_DISCONNECT);
+ tolua_constant(tolua_S,"E_PLUGIN_HANDSHAKE",cPluginManager::E_PLUGIN_HANDSHAKE);
+ tolua_constant(tolua_S,"E_PLUGIN_LOGIN",cPluginManager::E_PLUGIN_LOGIN);
+ tolua_constant(tolua_S,"E_PLUGIN_PLAYER_SPAWN",cPluginManager::E_PLUGIN_PLAYER_SPAWN);
+ tolua_constant(tolua_S,"E_PLUGIN_PLAYER_JOIN",cPluginManager::E_PLUGIN_PLAYER_JOIN);
+ tolua_constant(tolua_S,"E_PLUGIN_PLAYER_MOVE",cPluginManager::E_PLUGIN_PLAYER_MOVE);
+ tolua_constant(tolua_S,"E_PLUGIN_TAKE_DAMAGE",cPluginManager::E_PLUGIN_TAKE_DAMAGE);
+ tolua_constant(tolua_S,"E_PLUGIN_KILLED",cPluginManager::E_PLUGIN_KILLED);
+ tolua_function(tolua_S,"GetPluginManager",tolua_AllToLua_cPluginManager_GetPluginManager00);
+ tolua_function(tolua_S,"GetPlugin",tolua_AllToLua_cPluginManager_GetPlugin00);
+ tolua_function(tolua_S,"ReloadPlugins",tolua_AllToLua_cPluginManager_ReloadPlugins00);
+ tolua_function(tolua_S,"AddPlugin",tolua_AllToLua_cPluginManager_AddPlugin00);
+ tolua_function(tolua_S,"AddHook",tolua_AllToLua_cPluginManager_AddHook00);
+ tolua_function(tolua_S,"GetNumPlugins",tolua_AllToLua_cPluginManager_GetNumPlugins00);
+ tolua_function(tolua_S,"RemovePlugin",tolua_AllToLua_cPluginManager_RemovePlugin00);
+ tolua_function(tolua_S,"RemoveLuaPlugin",tolua_AllToLua_cPluginManager_RemoveLuaPlugin00);
+ tolua_function(tolua_S,"GetLuaPlugin",tolua_AllToLua_cPluginManager_GetLuaPlugin00);
+ tolua_endmodule(tolua_S);
+ #ifdef __cplusplus
+ tolua_cclass(tolua_S,"cPlugin","cPlugin","",tolua_collect_cPlugin);
+ #else
+ tolua_cclass(tolua_S,"cPlugin","cPlugin","",NULL);
+ #endif
+ tolua_beginmodule(tolua_S,"cPlugin");
+ tolua_function(tolua_S,"delete",tolua_AllToLua_cPlugin_delete00);
+ tolua_function(tolua_S,"OnDisable",tolua_AllToLua_cPlugin_OnDisable00);
+ tolua_function(tolua_S,"Initialize",tolua_AllToLua_cPlugin_Initialize00);
+ tolua_function(tolua_S,"Tick",tolua_AllToLua_cPlugin_Tick00);
+ tolua_function(tolua_S,"OnCollectItem",tolua_AllToLua_cPlugin_OnCollectItem00);
+ tolua_function(tolua_S,"OnDisconnect",tolua_AllToLua_cPlugin_OnDisconnect00);
+ tolua_function(tolua_S,"OnBlockPlace",tolua_AllToLua_cPlugin_OnBlockPlace00);
+ tolua_function(tolua_S,"OnBlockDig",tolua_AllToLua_cPlugin_OnBlockDig00);
+ tolua_function(tolua_S,"OnChat",tolua_AllToLua_cPlugin_OnChat00);
+ tolua_function(tolua_S,"OnLogin",tolua_AllToLua_cPlugin_OnLogin00);
+ tolua_function(tolua_S,"OnPlayerSpawn",tolua_AllToLua_cPlugin_OnPlayerSpawn00);
+ tolua_function(tolua_S,"OnPlayerJoin",tolua_AllToLua_cPlugin_OnPlayerJoin00);
+ tolua_function(tolua_S,"OnPlayerMove",tolua_AllToLua_cPlugin_OnPlayerMove00);
+ tolua_function(tolua_S,"OnTakeDamage",tolua_AllToLua_cPlugin_OnTakeDamage00);
+ tolua_function(tolua_S,"OnKilled",tolua_AllToLua_cPlugin_OnKilled00);
+ tolua_function(tolua_S,"GetName",tolua_AllToLua_cPlugin_GetName00);
+ tolua_function(tolua_S,"SetName",tolua_AllToLua_cPlugin_SetName00);
+ tolua_function(tolua_S,"GetVersion",tolua_AllToLua_cPlugin_GetVersion00);
+ tolua_function(tolua_S,"SetVersion",tolua_AllToLua_cPlugin_SetVersion00);
+ tolua_cclass(tolua_S,"CommandStruct","cPlugin::CommandStruct","",NULL);
+ tolua_beginmodule(tolua_S,"CommandStruct");
+ tolua_variable(tolua_S,"Command",tolua_get_cPlugin__CommandStruct_Command,tolua_set_cPlugin__CommandStruct_Command);
+ tolua_variable(tolua_S,"Description",tolua_get_cPlugin__CommandStruct_Description,tolua_set_cPlugin__CommandStruct_Description);
+ tolua_variable(tolua_S,"Permission",tolua_get_cPlugin__CommandStruct_Permission,tolua_set_cPlugin__CommandStruct_Permission);
+ tolua_endmodule(tolua_S);
+ tolua_function(tolua_S,"AddCommand",tolua_AllToLua_cPlugin_AddCommand00);
+ tolua_endmodule(tolua_S);
+ #ifdef __cplusplus
+ tolua_cclass(tolua_S,"Lua__cPlugin","Lua__cPlugin","cPlugin",tolua_collect_Lua__cPlugin);
+ #else
+ tolua_cclass(tolua_S,"Lua__cPlugin","Lua__cPlugin","cPlugin",NULL);
+ #endif
+ tolua_beginmodule(tolua_S,"Lua__cPlugin");
+ tolua_function(tolua_S,"tolua__set_instance",tolua_AllToLua_Lua__cPlugin_tolua__set_instance00);
+ tolua_function(tolua_S,"cPlugin__OnDisable",tolua_AllToLua_Lua__cPlugin_cPlugin__OnDisable00);
+ tolua_function(tolua_S,"cPlugin__Tick",tolua_AllToLua_Lua__cPlugin_cPlugin__Tick00);
+ tolua_function(tolua_S,"cPlugin__OnCollectItem",tolua_AllToLua_Lua__cPlugin_cPlugin__OnCollectItem00);
+ tolua_function(tolua_S,"cPlugin__OnDisconnect",tolua_AllToLua_Lua__cPlugin_cPlugin__OnDisconnect00);
+ tolua_function(tolua_S,"cPlugin__OnBlockPlace",tolua_AllToLua_Lua__cPlugin_cPlugin__OnBlockPlace00);
+ tolua_function(tolua_S,"cPlugin__OnBlockDig",tolua_AllToLua_Lua__cPlugin_cPlugin__OnBlockDig00);
+ tolua_function(tolua_S,"cPlugin__OnChat",tolua_AllToLua_Lua__cPlugin_cPlugin__OnChat00);
+ tolua_function(tolua_S,"cPlugin__OnLogin",tolua_AllToLua_Lua__cPlugin_cPlugin__OnLogin00);
+ tolua_function(tolua_S,"cPlugin__OnPlayerSpawn",tolua_AllToLua_Lua__cPlugin_cPlugin__OnPlayerSpawn00);
+ tolua_function(tolua_S,"cPlugin__OnPlayerJoin",tolua_AllToLua_Lua__cPlugin_cPlugin__OnPlayerJoin00);
+ tolua_function(tolua_S,"cPlugin__OnPlayerMove",tolua_AllToLua_Lua__cPlugin_cPlugin__OnPlayerMove00);
+ tolua_function(tolua_S,"cPlugin__OnTakeDamage",tolua_AllToLua_Lua__cPlugin_cPlugin__OnTakeDamage00);
+ tolua_function(tolua_S,"cPlugin__OnKilled",tolua_AllToLua_Lua__cPlugin_cPlugin__OnKilled00);
+ tolua_function(tolua_S,"new",tolua_AllToLua_Lua__cPlugin_new00);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_Lua__cPlugin_new00_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_Lua__cPlugin_new00_local);
+ tolua_function(tolua_S,"delete",tolua_AllToLua_Lua__cPlugin_delete00);
+ tolua_endmodule(tolua_S);
+ tolua_cclass(tolua_S,"cPlugin_Lua","cPlugin_Lua","",NULL);
+ tolua_beginmodule(tolua_S,"cPlugin_Lua");
+ tolua_function(tolua_S,"GetFileName",tolua_AllToLua_cPlugin_Lua_GetFileName00);
+ tolua_endmodule(tolua_S);
+ tolua_cclass(tolua_S,"cServer","cServer","",NULL);
+ tolua_beginmodule(tolua_S,"cServer");
+ tolua_function(tolua_S,"GetServer",tolua_AllToLua_cServer_GetServer00);
+ tolua_function(tolua_S,"ServerCommand",tolua_AllToLua_cServer_ServerCommand00);
+ tolua_function(tolua_S,"SendMessage",tolua_AllToLua_cServer_SendMessage00);
+ tolua_endmodule(tolua_S);
+ tolua_cclass(tolua_S,"cWorld","cWorld","",NULL);
+ tolua_beginmodule(tolua_S,"cWorld");
+ tolua_function(tolua_S,"GetWorld",tolua_AllToLua_cWorld_GetWorld00);
+ tolua_function(tolua_S,"GetTime",tolua_AllToLua_cWorld_GetTime00);
+ tolua_function(tolua_S,"SetWorldTime",tolua_AllToLua_cWorld_SetWorldTime00);
+ tolua_function(tolua_S,"GetHeight",tolua_AllToLua_cWorld_GetHeight00);
+ tolua_function(tolua_S,"GetNumPlayers",tolua_AllToLua_cWorld_GetNumPlayers00);
+ tolua_function(tolua_S,"GetPlayer",tolua_AllToLua_cWorld_GetPlayer00);
+ tolua_function(tolua_S,"GetEntity",tolua_AllToLua_cWorld_GetEntity00);
+ tolua_function(tolua_S,"SetBlock",tolua_AllToLua_cWorld_SetBlock00);
+ tolua_function(tolua_S,"FastSetBlock",tolua_AllToLua_cWorld_FastSetBlock00);
+ tolua_function(tolua_S,"GetBlock",tolua_AllToLua_cWorld_GetBlock00);
+ tolua_function(tolua_S,"GetBlockMeta",tolua_AllToLua_cWorld_GetBlockMeta00);
+ tolua_function(tolua_S,"SetBlockMeta",tolua_AllToLua_cWorld_SetBlockMeta00);
+ tolua_function(tolua_S,"DigBlock",tolua_AllToLua_cWorld_DigBlock00);
+ tolua_function(tolua_S,"SendBlockTo",tolua_AllToLua_cWorld_SendBlockTo00);
+ tolua_function(tolua_S,"GetSpawnX",tolua_AllToLua_cWorld_GetSpawnX00);
+ tolua_function(tolua_S,"GetSpawnY",tolua_AllToLua_cWorld_GetSpawnY00);
+ tolua_function(tolua_S,"GetSpawnZ",tolua_AllToLua_cWorld_GetSpawnZ00);
+ tolua_function(tolua_S,"GetBlockEntity",tolua_AllToLua_cWorld_GetBlockEntity00);
+ tolua_function(tolua_S,"GrowTree",tolua_AllToLua_cWorld_GrowTree00);
+ tolua_function(tolua_S,"GetWorldSeed",tolua_AllToLua_cWorld_GetWorldSeed00);
+ tolua_endmodule(tolua_S);
+ tolua_cclass(tolua_S,"cInventory","cInventory","",NULL);
+ tolua_beginmodule(tolua_S,"cInventory");
+ tolua_function(tolua_S,"Clear",tolua_AllToLua_cInventory_Clear00);
+ tolua_function(tolua_S,"AddItem",tolua_AllToLua_cInventory_AddItem00);
+ tolua_function(tolua_S,"RemoveItem",tolua_AllToLua_cInventory_RemoveItem00);
+ tolua_function(tolua_S,"GetSlot",tolua_AllToLua_cInventory_GetSlot00);
+ tolua_function(tolua_S,"GetFromHotBar",tolua_AllToLua_cInventory_GetFromHotBar00);
+ tolua_function(tolua_S,"GetEquippedItem",tolua_AllToLua_cInventory_GetEquippedItem00);
+ tolua_function(tolua_S,"SetEquippedSlot",tolua_AllToLua_cInventory_SetEquippedSlot00);
+ tolua_function(tolua_S,"SendSlot",tolua_AllToLua_cInventory_SendSlot00);
+ tolua_endmodule(tolua_S);
+ #ifdef __cplusplus
+ tolua_cclass(tolua_S,"cItem","cItem","",tolua_collect_cItem);
+ #else
+ tolua_cclass(tolua_S,"cItem","cItem","",NULL);
+ #endif
+ tolua_beginmodule(tolua_S,"cItem");
+ tolua_function(tolua_S,"new",tolua_AllToLua_cItem_new00);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_cItem_new00_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_cItem_new00_local);
+ tolua_function(tolua_S,"Empty",tolua_AllToLua_cItem_Empty00);
+ tolua_function(tolua_S,"IsEmpty",tolua_AllToLua_cItem_IsEmpty00);
+ tolua_function(tolua_S,"Equals",tolua_AllToLua_cItem_Equals00);
+ tolua_variable(tolua_S,"m_ItemID",tolua_get_cItem_m_ItemID,tolua_set_cItem_m_ItemID);
+ tolua_variable(tolua_S,"m_ItemCount",tolua_get_cItem_m_ItemCount,tolua_set_cItem_m_ItemCount);
+ tolua_variable(tolua_S,"m_ItemHealth",tolua_get_cItem_m_ItemHealth,tolua_set_cItem_m_ItemHealth);
+ tolua_endmodule(tolua_S);
+ tolua_cclass(tolua_S,"HTTPRequest","HTTPRequest","",NULL);
+ tolua_beginmodule(tolua_S,"HTTPRequest");
+ tolua_variable(tolua_S,"Method",tolua_get_HTTPRequest_Method,tolua_set_HTTPRequest_Method);
+ tolua_variable(tolua_S,"Path",tolua_get_HTTPRequest_Path,tolua_set_HTTPRequest_Path);
+ tolua_variable(tolua_S,"Params",tolua_get_HTTPRequest_Params_ptr,tolua_set_HTTPRequest_Params_ptr);
+ tolua_variable(tolua_S,"Username",tolua_get_HTTPRequest_Username,tolua_set_HTTPRequest_Username);
+ tolua_endmodule(tolua_S);
+ #ifdef __cplusplus
+ tolua_cclass(tolua_S,"cWebPlugin","cWebPlugin","",tolua_collect_cWebPlugin);
+ #else
+ tolua_cclass(tolua_S,"cWebPlugin","cWebPlugin","",NULL);
+ #endif
+ tolua_beginmodule(tolua_S,"cWebPlugin");
+ tolua_function(tolua_S,"delete",tolua_AllToLua_cWebPlugin_delete00);
+ tolua_function(tolua_S,"SetName",tolua_AllToLua_cWebPlugin_SetName00);
+ tolua_function(tolua_S,"GetName",tolua_AllToLua_cWebPlugin_GetName00);
+ tolua_function(tolua_S,"HandleRequest",tolua_AllToLua_cWebPlugin_HandleRequest00);
+ tolua_function(tolua_S,"Initialize",tolua_AllToLua_cWebPlugin_Initialize00);
+ tolua_endmodule(tolua_S);
+ #ifdef __cplusplus
+ tolua_cclass(tolua_S,"Lua__cWebPlugin","Lua__cWebPlugin","cWebPlugin",tolua_collect_Lua__cWebPlugin);
+ #else
+ tolua_cclass(tolua_S,"Lua__cWebPlugin","Lua__cWebPlugin","cWebPlugin",NULL);
+ #endif
+ tolua_beginmodule(tolua_S,"Lua__cWebPlugin");
+ tolua_function(tolua_S,"tolua__set_instance",tolua_AllToLua_Lua__cWebPlugin_tolua__set_instance00);
+ tolua_function(tolua_S,"new",tolua_AllToLua_Lua__cWebPlugin_new00);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_Lua__cWebPlugin_new00_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_Lua__cWebPlugin_new00_local);
+ tolua_function(tolua_S,"delete",tolua_AllToLua_Lua__cWebPlugin_delete00);
+ tolua_endmodule(tolua_S);
+ #ifdef __cplusplus
+ tolua_cclass(tolua_S,"cPickup","cPickup","cEntity",tolua_collect_cPickup);
+ #else
+ tolua_cclass(tolua_S,"cPickup","cPickup","cEntity",NULL);
+ #endif
+ tolua_beginmodule(tolua_S,"cPickup");
+ tolua_function(tolua_S,"new",tolua_AllToLua_cPickup_new00);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_cPickup_new00_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_cPickup_new00_local);
+ tolua_function(tolua_S,"new",tolua_AllToLua_cPickup_new01);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_cPickup_new01_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_cPickup_new01_local);
+ tolua_function(tolua_S,"delete",tolua_AllToLua_cPickup_delete00);
+ tolua_function(tolua_S,"GetItem",tolua_AllToLua_cPickup_GetItem00);
+ tolua_function(tolua_S,"CollectedBy",tolua_AllToLua_cPickup_CollectedBy00);
+ tolua_endmodule(tolua_S);
+ #ifdef __cplusplus
+ tolua_cclass(tolua_S,"Lua__cPickup","Lua__cPickup","cPickup",tolua_collect_Lua__cPickup);
+ #else
+ tolua_cclass(tolua_S,"Lua__cPickup","Lua__cPickup","cPickup",NULL);
+ #endif
+ tolua_beginmodule(tolua_S,"Lua__cPickup");
+ tolua_function(tolua_S,"tolua__set_instance",tolua_AllToLua_Lua__cPickup_tolua__set_instance00);
+ tolua_function(tolua_S,"cPickup__CollectedBy",tolua_AllToLua_Lua__cPickup_cPickup__CollectedBy00);
+ tolua_function(tolua_S,"new",tolua_AllToLua_Lua__cPickup_new00);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_Lua__cPickup_new00_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_Lua__cPickup_new00_local);
+ tolua_function(tolua_S,"new",tolua_AllToLua_Lua__cPickup_new01);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_Lua__cPickup_new01_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_Lua__cPickup_new01_local);
+ tolua_function(tolua_S,"delete",tolua_AllToLua_Lua__cPickup_delete00);
+ tolua_endmodule(tolua_S);
+ tolua_cclass(tolua_S,"cRoot","cRoot","",NULL);
+ tolua_beginmodule(tolua_S,"cRoot");
+ tolua_function(tolua_S,"Get",tolua_AllToLua_cRoot_Get00);
+ tolua_function(tolua_S,"GetServer",tolua_AllToLua_cRoot_GetServer00);
+ tolua_function(tolua_S,"GetWorld",tolua_AllToLua_cRoot_GetWorld00);
+ tolua_function(tolua_S,"GetGroupManager",tolua_AllToLua_cRoot_GetGroupManager00);
+ tolua_function(tolua_S,"GetRecipeChecker",tolua_AllToLua_cRoot_GetRecipeChecker00);
+ tolua_function(tolua_S,"GetFurnaceRecipe",tolua_AllToLua_cRoot_GetFurnaceRecipe00);
+ tolua_function(tolua_S,"GetWebAdmin",tolua_AllToLua_cRoot_GetWebAdmin00);
+ tolua_function(tolua_S,"GetPluginManager",tolua_AllToLua_cRoot_GetPluginManager00);
+ tolua_function(tolua_S,"ServerCommand",tolua_AllToLua_cRoot_ServerCommand00);
+ tolua_endmodule(tolua_S);
+ #ifdef __cplusplus
+ tolua_cclass(tolua_S,"cTCPLink","cTCPLink","",tolua_collect_cTCPLink);
+ #else
+ tolua_cclass(tolua_S,"cTCPLink","cTCPLink","",NULL);
+ #endif
+ tolua_beginmodule(tolua_S,"cTCPLink");
+ tolua_function(tolua_S,"delete",tolua_AllToLua_cTCPLink_delete00);
+ tolua_function(tolua_S,"Connect",tolua_AllToLua_cTCPLink_Connect00);
+ tolua_function(tolua_S,"Send",tolua_AllToLua_cTCPLink_Send00);
+ tolua_function(tolua_S,"SendMessage",tolua_AllToLua_cTCPLink_SendMessage00);
+ tolua_function(tolua_S,"CloseSocket",tolua_AllToLua_cTCPLink_CloseSocket00);
+ tolua_endmodule(tolua_S);
+ #ifdef __cplusplus
+ tolua_cclass(tolua_S,"Lua__cTCPLink","Lua__cTCPLink","cTCPLink",tolua_collect_Lua__cTCPLink);
+ #else
+ tolua_cclass(tolua_S,"Lua__cTCPLink","Lua__cTCPLink","cTCPLink",NULL);
+ #endif
+ tolua_beginmodule(tolua_S,"Lua__cTCPLink");
+ tolua_function(tolua_S,"tolua__set_instance",tolua_AllToLua_Lua__cTCPLink_tolua__set_instance00);
+ tolua_function(tolua_S,"new",tolua_AllToLua_Lua__cTCPLink_new00);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_Lua__cTCPLink_new00_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_Lua__cTCPLink_new00_local);
+ tolua_function(tolua_S,"delete",tolua_AllToLua_Lua__cTCPLink_delete00);
+ tolua_endmodule(tolua_S);
+ #ifdef __cplusplus
+ tolua_cclass(tolua_S,"Vector3f","Vector3f","",tolua_collect_Vector3f);
+ #else
+ tolua_cclass(tolua_S,"Vector3f","Vector3f","",NULL);
+ #endif
+ tolua_beginmodule(tolua_S,"Vector3f");
+ tolua_function(tolua_S,"new",tolua_AllToLua_Vector3f_new00);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3f_new00_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_Vector3f_new00_local);
+ tolua_function(tolua_S,"new",tolua_AllToLua_Vector3f_new01);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3f_new01_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_Vector3f_new01_local);
+ tolua_function(tolua_S,"new",tolua_AllToLua_Vector3f_new02);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3f_new02_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_Vector3f_new02_local);
+ tolua_function(tolua_S,"new",tolua_AllToLua_Vector3f_new03);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3f_new03_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_Vector3f_new03_local);
+ tolua_function(tolua_S,"new",tolua_AllToLua_Vector3f_new04);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3f_new04_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_Vector3f_new04_local);
+ tolua_function(tolua_S,"new",tolua_AllToLua_Vector3f_new05);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3f_new05_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_Vector3f_new05_local);
+ tolua_function(tolua_S,"Set",tolua_AllToLua_Vector3f_Set00);
+ tolua_function(tolua_S,"Normalize",tolua_AllToLua_Vector3f_Normalize00);
+ tolua_function(tolua_S,"NormalizeCopy",tolua_AllToLua_Vector3f_NormalizeCopy00);
+ tolua_function(tolua_S,"NormalizeCopy",tolua_AllToLua_Vector3f_NormalizeCopy01);
+ tolua_function(tolua_S,"Length",tolua_AllToLua_Vector3f_Length00);
+ tolua_function(tolua_S,"SqrLength",tolua_AllToLua_Vector3f_SqrLength00);
+ tolua_function(tolua_S,"Dot",tolua_AllToLua_Vector3f_Dot00);
+ tolua_function(tolua_S,"Cross",tolua_AllToLua_Vector3f_Cross00);
+ tolua_function(tolua_S,"Equals",tolua_AllToLua_Vector3f_Equals00);
+ tolua_function(tolua_S,".add",tolua_AllToLua_Vector3f__add00);
+ tolua_function(tolua_S,".add",tolua_AllToLua_Vector3f__add01);
+ tolua_function(tolua_S,".sub",tolua_AllToLua_Vector3f__sub00);
+ tolua_function(tolua_S,".sub",tolua_AllToLua_Vector3f__sub01);
+ tolua_function(tolua_S,".mul",tolua_AllToLua_Vector3f__mul00);
+ tolua_function(tolua_S,".mul",tolua_AllToLua_Vector3f__mul01);
+ tolua_variable(tolua_S,"x",tolua_get_Vector3f_x,tolua_set_Vector3f_x);
+ tolua_variable(tolua_S,"y",tolua_get_Vector3f_y,tolua_set_Vector3f_y);
+ tolua_variable(tolua_S,"z",tolua_get_Vector3f_z,tolua_set_Vector3f_z);
+ tolua_endmodule(tolua_S);
+ #ifdef __cplusplus
+ tolua_cclass(tolua_S,"Vector3d","Vector3d","",tolua_collect_Vector3d);
+ #else
+ tolua_cclass(tolua_S,"Vector3d","Vector3d","",NULL);
+ #endif
+ tolua_beginmodule(tolua_S,"Vector3d");
+ tolua_function(tolua_S,"new",tolua_AllToLua_Vector3d_new00);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3d_new00_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_Vector3d_new00_local);
+ tolua_function(tolua_S,"new",tolua_AllToLua_Vector3d_new01);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3d_new01_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_Vector3d_new01_local);
+ tolua_function(tolua_S,"new",tolua_AllToLua_Vector3d_new02);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3d_new02_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_Vector3d_new02_local);
+ tolua_function(tolua_S,"new",tolua_AllToLua_Vector3d_new03);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3d_new03_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_Vector3d_new03_local);
+ tolua_function(tolua_S,"Set",tolua_AllToLua_Vector3d_Set00);
+ tolua_function(tolua_S,"Normalize",tolua_AllToLua_Vector3d_Normalize00);
+ tolua_function(tolua_S,"NormalizeCopy",tolua_AllToLua_Vector3d_NormalizeCopy00);
+ tolua_function(tolua_S,"NormalizeCopy",tolua_AllToLua_Vector3d_NormalizeCopy01);
+ tolua_function(tolua_S,"Length",tolua_AllToLua_Vector3d_Length00);
+ tolua_function(tolua_S,"SqrLength",tolua_AllToLua_Vector3d_SqrLength00);
+ tolua_function(tolua_S,"Dot",tolua_AllToLua_Vector3d_Dot00);
+ tolua_function(tolua_S,"Cross",tolua_AllToLua_Vector3d_Cross00);
+ tolua_function(tolua_S,".add",tolua_AllToLua_Vector3d__add00);
+ tolua_function(tolua_S,".add",tolua_AllToLua_Vector3d__add01);
+ tolua_function(tolua_S,".sub",tolua_AllToLua_Vector3d__sub00);
+ tolua_function(tolua_S,".sub",tolua_AllToLua_Vector3d__sub01);
+ tolua_function(tolua_S,".mul",tolua_AllToLua_Vector3d__mul00);
+ tolua_function(tolua_S,".mul",tolua_AllToLua_Vector3d__mul01);
+ tolua_variable(tolua_S,"x",tolua_get_Vector3d_x,tolua_set_Vector3d_x);
+ tolua_variable(tolua_S,"y",tolua_get_Vector3d_y,tolua_set_Vector3d_y);
+ tolua_variable(tolua_S,"z",tolua_get_Vector3d_z,tolua_set_Vector3d_z);
+ tolua_endmodule(tolua_S);
+ #ifdef __cplusplus
+ tolua_cclass(tolua_S,"Vector3i","Vector3i","",tolua_collect_Vector3i);
+ #else
+ tolua_cclass(tolua_S,"Vector3i","Vector3i","",NULL);
+ #endif
+ tolua_beginmodule(tolua_S,"Vector3i");
+ tolua_function(tolua_S,"new",tolua_AllToLua_Vector3i_new00);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3i_new00_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_Vector3i_new00_local);
+ tolua_function(tolua_S,"new",tolua_AllToLua_Vector3i_new01);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3i_new01_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_Vector3i_new01_local);
+ tolua_function(tolua_S,"new",tolua_AllToLua_Vector3i_new02);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_Vector3i_new02_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_Vector3i_new02_local);
+ tolua_function(tolua_S,"Set",tolua_AllToLua_Vector3i_Set00);
+ tolua_function(tolua_S,"Length",tolua_AllToLua_Vector3i_Length00);
+ tolua_function(tolua_S,"SqrLength",tolua_AllToLua_Vector3i_SqrLength00);
+ tolua_function(tolua_S,"Equals",tolua_AllToLua_Vector3i_Equals00);
+ tolua_function(tolua_S,"Equals",tolua_AllToLua_Vector3i_Equals01);
+ tolua_variable(tolua_S,"x",tolua_get_Vector3i_x,tolua_set_Vector3i_x);
+ tolua_variable(tolua_S,"y",tolua_get_Vector3i_y,tolua_set_Vector3i_y);
+ tolua_variable(tolua_S,"z",tolua_get_Vector3i_z,tolua_set_Vector3i_z);
+ tolua_endmodule(tolua_S);
+ #ifdef __cplusplus
+ tolua_cclass(tolua_S,"cCuboid","cCuboid","",tolua_collect_cCuboid);
+ #else
+ tolua_cclass(tolua_S,"cCuboid","cCuboid","",NULL);
+ #endif
+ tolua_beginmodule(tolua_S,"cCuboid");
+ tolua_function(tolua_S,"new",tolua_AllToLua_cCuboid_new00);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_cCuboid_new00_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_cCuboid_new00_local);
+ tolua_function(tolua_S,"new",tolua_AllToLua_cCuboid_new01);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_cCuboid_new01_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_cCuboid_new01_local);
+ tolua_function(tolua_S,"new",tolua_AllToLua_cCuboid_new02);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_cCuboid_new02_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_cCuboid_new02_local);
+ tolua_variable(tolua_S,"p1",tolua_get_cCuboid_p1,tolua_set_cCuboid_p1);
+ tolua_variable(tolua_S,"p2",tolua_get_cCuboid_p2,tolua_set_cCuboid_p2);
+ tolua_function(tolua_S,"Sort",tolua_AllToLua_cCuboid_Sort00);
+ tolua_function(tolua_S,"IsInside",tolua_AllToLua_cCuboid_IsInside00);
+ tolua_function(tolua_S,"IsInside",tolua_AllToLua_cCuboid_IsInside01);
+ tolua_endmodule(tolua_S);
+ #ifdef __cplusplus
+ tolua_cclass(tolua_S,"cMCLogger","cMCLogger","",tolua_collect_cMCLogger);
+ #else
+ tolua_cclass(tolua_S,"cMCLogger","cMCLogger","",NULL);
+ #endif
+ tolua_beginmodule(tolua_S,"cMCLogger");
+ tolua_function(tolua_S,"new",tolua_AllToLua_cMCLogger_new00);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_cMCLogger_new00_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_cMCLogger_new00_local);
+ tolua_function(tolua_S,"delete",tolua_AllToLua_cMCLogger_delete00);
+ tolua_function(tolua_S,"LogSimple",tolua_AllToLua_cMCLogger_LogSimple00);
+ tolua_endmodule(tolua_S);
+ #ifdef __cplusplus
+ tolua_cclass(tolua_S,"cTracer","cTracer","",tolua_collect_cTracer);
+ #else
+ tolua_cclass(tolua_S,"cTracer","cTracer","",NULL);
+ #endif
+ tolua_beginmodule(tolua_S,"cTracer");
+ tolua_function(tolua_S,"new",tolua_AllToLua_cTracer_new00);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_cTracer_new00_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_cTracer_new00_local);
+ tolua_function(tolua_S,"delete",tolua_AllToLua_cTracer_delete00);
+ tolua_function(tolua_S,"Trace",tolua_AllToLua_cTracer_Trace00);
+ tolua_function(tolua_S,"SetValues",tolua_AllToLua_cTracer_SetValues00);
+ tolua_variable(tolua_S,"BlockHitPosition",tolua_get_cTracer_BlockHitPosition_ptr,tolua_set_cTracer_BlockHitPosition_ptr);
+ tolua_variable(tolua_S,"HitNormal",tolua_get_cTracer_HitNormal_ptr,tolua_set_cTracer_HitNormal_ptr);
+ tolua_variable(tolua_S,"RealHit",tolua_get_cTracer_RealHit_ptr,tolua_set_cTracer_RealHit_ptr);
+ tolua_endmodule(tolua_S);
+ tolua_cclass(tolua_S,"cGroup","cGroup","",NULL);
+ tolua_beginmodule(tolua_S,"cGroup");
+ tolua_function(tolua_S,"SetName",tolua_AllToLua_cGroup_SetName00);
+ tolua_function(tolua_S,"GetName",tolua_AllToLua_cGroup_GetName00);
+ tolua_function(tolua_S,"SetColor",tolua_AllToLua_cGroup_SetColor00);
+ tolua_function(tolua_S,"AddCommand",tolua_AllToLua_cGroup_AddCommand00);
+ tolua_function(tolua_S,"AddPermission",tolua_AllToLua_cGroup_AddPermission00);
+ tolua_function(tolua_S,"InheritFrom",tolua_AllToLua_cGroup_InheritFrom00);
+ tolua_function(tolua_S,"HasCommand",tolua_AllToLua_cGroup_HasCommand00);
+ tolua_function(tolua_S,"GetColor",tolua_AllToLua_cGroup_GetColor00);
+ tolua_endmodule(tolua_S);
+ tolua_cclass(tolua_S,"cPacket_Login","cPacket_Login","cPacket",NULL);
+ tolua_beginmodule(tolua_S,"cPacket_Login");
+ tolua_variable(tolua_S,"m_ProtocolVersion",tolua_get_cPacket_Login_m_ProtocolVersion,tolua_set_cPacket_Login_m_ProtocolVersion);
+ tolua_variable(tolua_S,"m_Username",tolua_get_cPacket_Login_m_Username,tolua_set_cPacket_Login_m_Username);
+ tolua_variable(tolua_S,"m_MapSeed",tolua_get_cPacket_Login_m_MapSeed,tolua_set_cPacket_Login_m_MapSeed);
+ tolua_variable(tolua_S,"m_Dimension",tolua_get_cPacket_Login_m_Dimension,tolua_set_cPacket_Login_m_Dimension);
+ tolua_endmodule(tolua_S);
+ #ifdef __cplusplus
+ tolua_cclass(tolua_S,"cPacket_BlockDig","cPacket_BlockDig","cPacket",tolua_collect_cPacket_BlockDig);
+ #else
+ tolua_cclass(tolua_S,"cPacket_BlockDig","cPacket_BlockDig","cPacket",NULL);
+ #endif
+ tolua_beginmodule(tolua_S,"cPacket_BlockDig");
+ tolua_function(tolua_S,"new",tolua_AllToLua_cPacket_BlockDig_new00);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_cPacket_BlockDig_new00_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_cPacket_BlockDig_new00_local);
+ tolua_function(tolua_S,"Clone",tolua_AllToLua_cPacket_BlockDig_Clone00);
+ tolua_variable(tolua_S,"m_Status",tolua_get_cPacket_BlockDig_m_Status,tolua_set_cPacket_BlockDig_m_Status);
+ tolua_variable(tolua_S,"m_PosX",tolua_get_cPacket_BlockDig_m_PosX,tolua_set_cPacket_BlockDig_m_PosX);
+ tolua_variable(tolua_S,"m_PosY",tolua_get_cPacket_BlockDig_m_PosY,tolua_set_cPacket_BlockDig_m_PosY);
+ tolua_variable(tolua_S,"m_PosZ",tolua_get_cPacket_BlockDig_m_PosZ,tolua_set_cPacket_BlockDig_m_PosZ);
+ tolua_variable(tolua_S,"m_Direction",tolua_get_cPacket_BlockDig_m_Direction,tolua_set_cPacket_BlockDig_m_Direction);
+ tolua_endmodule(tolua_S);
+ #ifdef __cplusplus
+ tolua_cclass(tolua_S,"Lua__cPacket_BlockDig","Lua__cPacket_BlockDig","cPacket_BlockDig",tolua_collect_Lua__cPacket_BlockDig);
+ #else
+ tolua_cclass(tolua_S,"Lua__cPacket_BlockDig","Lua__cPacket_BlockDig","cPacket_BlockDig",NULL);
+ #endif
+ tolua_beginmodule(tolua_S,"Lua__cPacket_BlockDig");
+ tolua_function(tolua_S,"tolua__set_instance",tolua_AllToLua_Lua__cPacket_BlockDig_tolua__set_instance00);
+ tolua_function(tolua_S,"cPacket_BlockDig__Clone",tolua_AllToLua_Lua__cPacket_BlockDig_cPacket_BlockDig__Clone00);
+ tolua_function(tolua_S,"new",tolua_AllToLua_Lua__cPacket_BlockDig_new00);
+ tolua_function(tolua_S,"new_local",tolua_AllToLua_Lua__cPacket_BlockDig_new00_local);
+ tolua_function(tolua_S,".call",tolua_AllToLua_Lua__cPacket_BlockDig_new00_local);
+ tolua_endmodule(tolua_S);
+ tolua_cclass(tolua_S,"cPacket_BlockPlace","cPacket_BlockPlace","cPacket",NULL);
+ tolua_beginmodule(tolua_S,"cPacket_BlockPlace");
+ tolua_variable(tolua_S,"m_PosX",tolua_get_cPacket_BlockPlace_m_PosX,tolua_set_cPacket_BlockPlace_m_PosX);
+ tolua_variable(tolua_S,"m_PosY",tolua_get_cPacket_BlockPlace_m_PosY,tolua_set_cPacket_BlockPlace_m_PosY);
+ tolua_variable(tolua_S,"m_PosZ",tolua_get_cPacket_BlockPlace_m_PosZ,tolua_set_cPacket_BlockPlace_m_PosZ);
+ tolua_variable(tolua_S,"m_Direction",tolua_get_cPacket_BlockPlace_m_Direction,tolua_set_cPacket_BlockPlace_m_Direction);
+ tolua_variable(tolua_S,"m_ItemType",tolua_get_cPacket_BlockPlace_m_ItemType,tolua_set_cPacket_BlockPlace_m_ItemType);
+ tolua_variable(tolua_S,"m_Count",tolua_get_cPacket_BlockPlace_m_Count,tolua_set_cPacket_BlockPlace_m_Count);
+ tolua_variable(tolua_S,"m_Uses",tolua_get_cPacket_BlockPlace_m_Uses,tolua_set_cPacket_BlockPlace_m_Uses);
+ tolua_endmodule(tolua_S);
+ tolua_endmodule(tolua_S);
+ return 1;
+}
+
+
+#if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
+ TOLUA_API int luaopen_AllToLua (lua_State* tolua_S) {
+ return tolua_AllToLua_open(tolua_S);
+};
+#endif
+
diff --git a/source/Bindings.h b/source/Bindings.h new file mode 100644 index 000000000..4fb3dfa9e --- /dev/null +++ b/source/Bindings.h @@ -0,0 +1,8 @@ +/*
+** Lua binding: AllToLua
+** Generated automatically by tolua++-1.0.92 on 07/15/11 01:36:28.
+*/
+
+/* Exported function */
+TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S);
+
diff --git a/source/BlockID.h b/source/BlockID.h new file mode 100644 index 000000000..3304e3b99 --- /dev/null +++ b/source/BlockID.h @@ -0,0 +1,151 @@ +#pragma once
+
+//tolua_begin
+enum ENUM_BLOCK_ID
+{
+ E_BLOCK_AIR = 0,
+ E_BLOCK_STONE = 1,
+ E_BLOCK_GRASS = 2,
+ E_BLOCK_DIRT = 3,
+ E_BLOCK_COBBLESTONE = 4,
+ E_BLOCK_WOOD = 5,
+ E_BLOCK_SAPLING = 6,
+ E_BLOCK_BEDROCK = 7,
+ E_BLOCK_WATER = 8,
+ E_BLOCK_STATIONARY_WATER = 9,
+ E_BLOCK_LAVA = 10,
+ E_BLOCK_STATIONARY_LAVA = 11,
+ E_BLOCK_SAND = 12,
+ E_BLOCK_GRAVEL = 13,
+ E_BLOCK_GOLD_ORE = 14,
+ E_BLOCK_IRON_ORE = 15,
+ E_BLOCK_COAL_ORE = 16,
+ E_BLOCK_LOG = 17,
+ E_BLOCK_LEAVES = 18,
+ E_BLOCK_SPONGE = 19,
+ E_BLOCK_GLASS = 20,
+ E_BLOCK_WHITE_CLOTH = 35,
+ E_BLOCK_YELLOW_FLOWER = 37,
+ E_BLOCK_RED_ROSE = 38,
+ E_BLOCK_BROWN_MUSHROOM = 39,
+ E_BLOCK_RED_MUSHROOM = 40,
+ E_BLOCK_GOLD_BLOCK = 41,
+ E_BLOCK_IRON_BLOCK = 42,
+ E_BLOCK_DOUBLE_STEP = 43,
+ E_BLOCK_STEP = 44,
+ E_BLOCK_BRICK = 45,
+ E_BLOCK_TNT = 46,
+ E_BLOCK_BOOKCASE = 47,
+ E_BLOCK_MOSSY_COBBLESTONE = 48,
+ E_BLOCK_OBSIDIAN = 49,
+ E_BLOCK_TORCH = 50,
+ E_BLOCK_FIRE = 51,
+ E_BLOCK_MOB_SPAWNER = 52,
+ E_BLOCK_WOODEN_STAIRS = 53,
+ E_BLOCK_CHEST = 54,
+ E_BLOCK_REDSTONE_WIRE = 55,
+ E_BLOCK_DIAMOND_ORE = 56,
+ E_BLOCK_DIAMOND_BLOCK = 57,
+ E_BLOCK_WORKBENCH = 58,
+ E_BLOCK_CROPS = 59,
+ E_BLOCK_SOIL = 60,
+ E_BLOCK_FURNACE = 61,
+ E_BLOCK_BURNING_FURNACE = 62,
+ E_BLOCK_SIGN_POST = 63,
+ E_BLOCK_WOODEN_DOOR = 64,
+ E_BLOCK_LADDER = 65,
+ E_BLOCK_MINECART_TRACKS = 66,
+ E_BLOCK_COBBLESTONE_STAIRS = 67,
+ E_BLOCK_WALLSIGN = 68,
+ E_BLOCK_LEVER = 69,
+ E_BLOCK_STONE_PRESSURE_PLATE = 70,
+ E_BLOCK_IRON_DOOR = 71,
+ E_BLOCK_WOODEN_PRESSURE_PLATE = 72,
+ E_BLOCK_REDSTONE_ORE = 73,
+ E_BLOCK_REDSTONE_ORE_GLOWING = 74,
+ E_BLOCK_REDSTONE_TORCH_ON = 75,
+ E_BLOCK_REDSTONE_TORCH_OFF = 76,
+
+ E_BLOCK_SNOW = 78,
+ E_BLOCK_ICE = 79,
+ E_BLOCK_SNOW_BLOCK = 80,
+ E_BLOCK_CACTUS = 81,
+ E_BLOCK_CLAY = 82,
+ E_BLOCK_REEDS = 83,
+
+ E_BLOCK_BLOODSTONE = 87,
+ E_BLOCK_SOULSAND = 88,
+ E_BLOCK_GLOWSTONE = 89,
+ E_BLOCK_PORT = 90,
+ E_BLOCK_JACK_O_LANTERN = 91,
+ E_BLOCK_CAKE = 92,
+ E_BLOCK_REDSTONE_REPEATER_OFF = 93,
+ E_BLOCK_REDSTONE_REPEATER_ON = 94,
+ E_BLOCK_LOCKED_CHEST = 95,
+ E_BLOCK_TRAPDOOR = 96,
+};
+//tolua_end
+
+//tolua_begin
+enum ENUM_ITEM_ID
+{
+ E_ITEM_EMPTY = -1,
+ E_ITEM_STONE = 1,
+ E_ITEM_GRASS = 2,
+ E_ITEM_DIRT = 3,
+ E_ITEM_COBBLESTONE = 4,
+ E_ITEM_WOOD = 5,
+ E_ITEM_SAPLING = 6,
+ E_ITEM_BEDROCK = 7,
+ E_ITEM_WATER = 8,
+ E_ITEM_STATIONARY_WATER = 9,
+ E_ITEM_LAVA = 10,
+ E_ITEM_STATIONARY_LAVA = 11,
+ E_ITEM_SAND = 12,
+ E_ITEM_GRAVEL = 13,
+ E_ITEM_GOLD_ORE = 14,
+ E_ITEM_IRON_ORE = 15,
+ E_ITEM_COAL_ORE = 16,
+ E_ITEM_LOG = 17,
+ E_ITEM_LEAVES = 18,
+ E_ITEM_GOLD_BLOCK = 41,
+ E_ITEM_IRON_BLOCK = 42,
+ E_ITEM_DIAMOND_BLOCK = 57,
+ E_ITEM_FLINT_AND_STEEL = 259,
+ E_ITEM_APPLE = 260,
+ E_ITEM_BOW = 261,
+ E_ITEM_ARROW = 262,
+ E_ITEM_COAL = 263,
+ E_ITEM_DIAMOND = 264,
+ E_ITEM_IRON = 265,
+ E_ITEM_GOLD = 266,
+
+ E_ITEM_MUSHROOM_SOUP = 282,
+ E_ITEM_GOLD_SWORD = 283,
+ E_ITEM_GOLD_SHOVEL = 284,
+ E_ITEM_GOLD_PICKAXE = 285,
+ E_ITEM_GOLD_AXE = 286,
+ E_ITEM_STRING = 287,
+ E_ITEM_FEATHER = 288,
+
+ E_ITEM_BREAD = 297,
+
+ E_ITEM_RAW_MEAT = 319,
+ E_ITEM_COOKED_MEAT = 320,
+
+ E_ITEM_GOLDEN_APPLE = 322,
+ E_ITEM_SIGN = 323,
+
+ E_ITEM_MILK = 335,
+
+ E_ITEM_EGG = 344,
+ E_ITEM_COMPASS = 345,
+ E_ITEM_FISHING_ROD = 346,
+ E_ITEM_CLOCK = 347,
+ E_ITEM_GLOWSTONE_DUST = 348,
+ E_ITEM_RAW_FISH = 349,
+ E_ITEM_COOKED_FISH = 350,
+
+ E_ITEM_CAKE = 354,
+};
+//tolua_end
\ No newline at end of file diff --git a/source/Defines.h b/source/Defines.h new file mode 100644 index 000000000..1b176208c --- /dev/null +++ b/source/Defines.h @@ -0,0 +1,129 @@ +#pragma once
+
+#include "MemoryLeak.h"
+
+//tolua_begin
+// emissive blocks
+extern char g_BlockLightValue[];
+// whether blocks allow spreading
+extern char g_BlockSpreadLightFalloff[];
+// whether blocks are transparent (light can shine though)
+extern bool g_BlockTransparent[];
+// one hit break blocks
+extern bool g_BlockOneHitDig[];
+//tolua_end
+
+//--DO NOT DELETE THIS COMMENT-- //tolua_export
+
+inline bool IsValidBlock( int a_BlockID ) //tolua_export
+{ //tolua_export
+ if( a_BlockID > -1 &&
+ a_BlockID <= 96 &&
+ a_BlockID != 29 &&
+ a_BlockID != 33 &&
+ a_BlockID != 34 &&
+ a_BlockID != 36 )
+ {
+ return true;
+ }
+ return false;
+} //tolua_export
+
+inline bool isValidItem( int a_ItemID ) //tolua_export
+{ //tolua_export
+ if( (a_ItemID >= 256 && a_ItemID <= 358)
+ || (a_ItemID == 2256 || a_ItemID == 2257) )
+ {
+ return true;
+ }
+
+ if( a_ItemID == 0 )
+ return false;
+
+ return IsValidBlock( a_ItemID );
+} //tolua_export
+
+inline void AddDirection( int & a_X, char & a_Y, int & a_Z, char a_Direction, bool a_bInverse = false ) //tolua_export
+{//tolua_export
+ if( !a_bInverse )
+ {
+ switch( a_Direction )
+ {
+ case 0:
+ a_Y--;
+ break;
+ case 1:
+ a_Y++;
+ break;
+ case 2:
+ a_Z--;
+ break;
+ case 3:
+ a_Z++;
+ break;
+ case 4:
+ a_X--;
+ break;
+ case 5:
+ a_X++;
+ break;
+ };
+ }
+ else
+ {
+ switch( a_Direction ) // other way around
+ {
+ case 0:
+ a_Y++;
+ break;
+ case 1:
+ a_Y--;
+ break;
+ case 2:
+ a_Z++;
+ break;
+ case 3:
+ a_Z--;
+ break;
+ case 4:
+ a_X++;
+ break;
+ case 5:
+ a_X--;
+ break;
+ };
+ }
+}//tolua_export
+
+#include <math.h>
+#define PI 3.14159265358979323846264338327950288419716939937510582097494459072381640628620899862803482534211706798f
+#define MIN(a,b) (((a)>(b))?(b):(a))
+#define MAX(a,b) (((a)>(b))?(a):(b))
+inline void EulerToVector( float a_Pan, float a_Pitch, float & a_X, float & a_Y, float & a_Z )
+{
+// a_X = sinf ( a_Pan / 180 * PI ) * cosf ( a_Pitch / 180 * PI );
+// a_Y = -sinf ( a_Pitch / 180 * PI );
+// a_Z = -cosf ( a_Pan / 180 * PI ) * cosf ( a_Pitch / 180 * PI );
+a_X = cos(a_Pan / 180 * PI)*cos(a_Pitch / 180 * PI);
+a_Y = sin(a_Pan / 180 * PI)*cos(a_Pitch / 180 * PI);
+a_Z = sin(a_Pitch / 180 * PI);
+}
+
+inline void VectorToEuler( float a_X, float a_Y, float a_Z, float & a_Pan, float & a_Pitch )
+{
+ if( a_X != 0 )
+ a_Pan = atan2( a_Z, a_X ) * 180 / PI - 90;
+ else
+ a_Pan = 0;
+ a_Pitch = atan2(a_Y, sqrtf((a_X * a_X) + (a_Z * a_Z))) * 180 / PI;
+}
+
+inline float GetSignf( float a_Val )
+{
+ return (a_Val < 0.f)?-1.f:1.f;
+}
+
+inline float GetSpecialSignf( float a_Val )
+{
+ return (a_Val <= 0.f)?-1.f:1.f;
+}
diff --git a/source/Endianness.h b/source/Endianness.h new file mode 100644 index 000000000..9e62c48c4 --- /dev/null +++ b/source/Endianness.h @@ -0,0 +1,51 @@ +#pragma once
+
+#include <string>
+#ifdef _WIN32
+#include <WinSock.h>
+#else
+#include <sys/socket.h>
+#include <netinet/in.h>
+#endif
+
+// Changes endianness
+inline unsigned long long HostToNetwork8( void* a_Value )
+{
+ unsigned long long __HostToNetwork8;
+ memcpy( &__HostToNetwork8, a_Value, sizeof( __HostToNetwork8 ) );
+ __HostToNetwork8 = (( ( (unsigned long long)htonl((u_long)__HostToNetwork8) ) << 32) + htonl(__HostToNetwork8 >> 32));
+ return __HostToNetwork8;
+}
+
+inline unsigned int HostToNetwork4( void* a_Value )
+{
+ unsigned int __HostToNetwork4;
+ memcpy( &__HostToNetwork4, a_Value, sizeof( __HostToNetwork4 ) );
+ __HostToNetwork4 = ntohl( __HostToNetwork4 );
+ return __HostToNetwork4;
+}
+
+inline double NetworkToHostDouble8( void* a_Value )
+{
+#define ntohll(x) ((((unsigned long long)ntohl((u_long)x)) << 32) + ntohl(x >> 32))
+ unsigned long long buf = 0;//(*(unsigned long long*)a_Value);
+ memcpy( &buf, a_Value, 8 );
+ buf = ntohll(buf);
+ double x;
+ memcpy(&x, &buf, sizeof(double));
+ return x;
+}
+
+inline long long NetworkToHostLong8( void* a_Value )
+{
+ unsigned long long buf = *(unsigned long long*)a_Value;
+ buf = ntohll(buf);
+ return *reinterpret_cast<long long *>(&buf);
+}
+
+inline float NetworkToHostFloat4( void* a_Value )
+{
+ u_long buf = *(u_long*)a_Value;
+ buf = ntohl( buf );
+ return *(float*)reinterpret_cast<float *>(&buf);
+}
\ No newline at end of file diff --git a/source/FileDefine.h b/source/FileDefine.h new file mode 100644 index 000000000..826d6dd75 --- /dev/null +++ b/source/FileDefine.h @@ -0,0 +1,21 @@ +#pragma once
+
+// So we don't have to include fstream :P
+#ifdef _WIN32
+#ifndef _FILE_DEFINED
+struct _iobuf {
+ char *_ptr;
+ int _cnt;
+ char *_base;
+ int _flag;
+ int _file;
+ int _charbuf;
+ int _bufsiz;
+ char *_tmpfname;
+};
+typedef struct _iobuf FILE;
+#define _FILE_DEFINED
+#endif
+#else
+#include <stdio.h>
+#endif
\ No newline at end of file diff --git a/source/LuaFunctions.h b/source/LuaFunctions.h new file mode 100644 index 000000000..04de7784f --- /dev/null +++ b/source/LuaFunctions.h @@ -0,0 +1,17 @@ +#pragma once
+
+#include "cMCLogger.h"
+#include <time.h>
+// tolua_begin
+
+unsigned int GetTime()
+{
+ return (unsigned int)time(0);
+}
+
+std::string GetChar( std::string & a_Str, unsigned int a_Idx )
+{
+ return std::string(1, a_Str[ a_Idx ]);
+}
+
+// tolua_end
diff --git a/source/MCSocket.h b/source/MCSocket.h new file mode 100644 index 000000000..554a5f35b --- /dev/null +++ b/source/MCSocket.h @@ -0,0 +1,41 @@ +#pragma once + +#ifdef _WIN32 + +#include <winsock2.h> +#define socklen_t int +#ifdef SendMessage +#undef SendMessage +#endif +#else + +// Linux threads http://www.yolinux.com/TUTORIALS/LinuxTutorialPosixThreads.html + +#include <netdb.h> +#include <sys/socket.h> +#include <netinet/in.h> +#include <arpa/inet.h> +#include <pthread.h> +#include <unistd.h> +#define SOCKET int +typedef void *HANDLE; +#define CRITICAL_SECTION pthread_mutex_t +#define SD_BOTH (2) +#define closesocket(x) (shutdown(x, SD_BOTH), close(x)) +#define SOCKET_ERROR SO_ERROR +#define EnterCriticalSection(x) pthread_mutex_lock(x) +#define LeaveCriticalSection(x) pthread_mutex_unlock(x) +#define InitializeCriticalSection(x) pthread_mutex_init(x, NULL) +#define DeleteCriticalSection(x) (x) +#define sprintf_s(x, y, ...) sprintf(x, __VA_ARGS__) + +#endif + +inline bool IsSocketError( int a_ReturnedValue ) +{ + #ifdef _WIN32 + return (a_ReturnedValue == SOCKET_ERROR || a_ReturnedValue == 0); + #else + return (a_ReturnedValue <= 0); + #endif +} diff --git a/source/ManualBindings.cpp b/source/ManualBindings.cpp new file mode 100644 index 000000000..728320f11 --- /dev/null +++ b/source/ManualBindings.cpp @@ -0,0 +1,229 @@ +#include "ManualBindings.h"
+#include "tolua++.h"
+#include "cMCLogger.h"
+
+#include "cRoot.h"
+#include "cWorld.h"
+#include "cPlugin.h"
+#include "cPluginManager.h"
+#include "cLuaCommandBinder.h"
+#include "cPlayer.h"
+#include "md5/md5.h"
+
+extern std::vector<std::string> StringSplit(std::string str, std::string delim);
+
+/****************************
+ * Lua bound functions with special return types
+ **/
+
+static int tolua_StringSplit(lua_State* tolua_S)
+{
+ std::string str = ((std::string) tolua_tocppstring(tolua_S,1,0));
+ std::string delim = ((std::string) tolua_tocppstring(tolua_S,2,0));
+
+ std::vector<std::string> Split = StringSplit( str, delim );
+
+ lua_createtable(tolua_S, Split.size(), 0);
+ int newTable = lua_gettop(tolua_S);
+ int index = 1;
+ std::vector<std::string>::const_iterator iter = Split.begin();
+ while(iter != Split.end()) {
+ tolua_pushstring( tolua_S, (*iter).c_str() );
+ lua_rawseti(tolua_S, newTable, index);
+ ++iter;
+ ++index;
+ }
+ return 1;
+}
+
+static int tolua_LOG(lua_State* tolua_S)
+{
+ const char* str = tolua_tocppstring(tolua_S,1,0);
+ cMCLogger::GetInstance()->LogSimple( str, 0 );
+ return 0;
+}
+
+static int tolua_LOGINFO(lua_State* tolua_S)
+{
+ const char* str = tolua_tocppstring(tolua_S,1,0);
+ cMCLogger::GetInstance()->LogSimple( str, 1 );
+ return 0;
+}
+
+static int tolua_LOGWARN(lua_State* tolua_S)
+{
+ const char* str = tolua_tocppstring(tolua_S,1,0);
+ cMCLogger::GetInstance()->LogSimple( str, 2 );
+ return 0;
+}
+
+static int tolua_LOGERROR(lua_State* tolua_S)
+{
+ const char* str = tolua_tocppstring(tolua_S,1,0);
+ cMCLogger::GetInstance()->LogSimple( str, 3 );
+ return 0;
+}
+
+static int tolua_cWorld_GetAllPlayers(lua_State* tolua_S)
+{
+ cWorld* self = (cWorld*) tolua_tousertype(tolua_S,1,0);
+ lua_State* L = tolua_S;
+
+ self->GetAllPlayers(L);
+
+ return 1;
+}
+
+static int tolua_cPlugin_GetCommands(lua_State* tolua_S)
+{
+ cPlugin* self = (cPlugin*) tolua_tousertype(tolua_S,1,0);
+
+ const std::vector< cPlugin::CommandStruct > & AllCommands = self->GetCommands();
+
+ lua_createtable(tolua_S, AllCommands.size(), 0);
+ int newTable = lua_gettop(tolua_S);
+ int index = 1;
+ std::vector< cPlugin::CommandStruct >::const_iterator iter = AllCommands.begin();
+ while(iter != AllCommands.end())
+ {
+ const cPlugin::CommandStruct & CS = *iter;
+ tolua_pushusertype( tolua_S, (void*)&CS, "const cPlugin::CommandStruct" );
+ lua_rawseti(tolua_S, newTable, index);
+ ++iter;
+ ++index;
+ }
+ return 1;
+}
+
+static int tolua_cPluginManager_GetAllPlugins(lua_State* tolua_S)
+{
+ cPluginManager* self = (cPluginManager*) tolua_tousertype(tolua_S,1,0);
+
+ const cPluginManager::PluginList & AllPlugins = self->GetAllPlugins();
+
+ lua_createtable(tolua_S, AllPlugins.size(), 0);
+ int newTable = lua_gettop(tolua_S);
+ int index = 1;
+ cPluginManager::PluginList::const_iterator iter = AllPlugins.begin();
+ while(iter != AllPlugins.end())
+ {
+ const cPlugin* Plugin = *iter;
+ tolua_pushusertype( tolua_S, (void*)Plugin, "const cPlugin" );
+ lua_rawseti(tolua_S, newTable, index);
+ ++iter;
+ ++index;
+ }
+ return 1;
+}
+
+static int tolua_cPlayer_GetGroups(lua_State* tolua_S)
+{
+ cPlayer* self = (cPlayer*) tolua_tousertype(tolua_S,1,0);
+
+ const cPlayer::GroupList & AllGroups = self->GetGroups();
+
+ lua_createtable(tolua_S, AllGroups.size(), 0);
+ int newTable = lua_gettop(tolua_S);
+ int index = 1;
+ cPlayer::GroupList::const_iterator iter = AllGroups.begin();
+ while(iter != AllGroups.end())
+ {
+ const cGroup* Group = *iter;
+ tolua_pushusertype( tolua_S, (void*)Group, "const cGroup" );
+ lua_rawseti(tolua_S, newTable, index);
+ ++iter;
+ ++index;
+ }
+ return 1;
+}
+
+static int tolua_cPlugin_BindCommand(lua_State* tolua_S)
+{
+ cPlugin* self = (cPlugin*) tolua_tousertype(tolua_S,1,0);
+ cPluginManager* PluginManager = cRoot::Get()->GetPluginManager();
+ cLuaCommandBinder* CommandBinder = PluginManager->GetLuaCommandBinder();
+
+ tolua_Error tolua_err;
+ tolua_err.array = 0;
+ tolua_err.index = 0;
+ tolua_err.type = 0;
+
+ std::string Permission = "";
+ std::string Command = "";
+ int Reference = LUA_REFNIL;
+
+ if( tolua_isstring( tolua_S, 2, 0, &tolua_err ) &&
+ lua_isfunction( tolua_S, 3 ) )
+ {
+ Reference = luaL_ref(tolua_S, LUA_REGISTRYINDEX);
+ Command = ((std::string) tolua_tocppstring(tolua_S,2,0));
+ }
+ else if( tolua_isstring( tolua_S, 2, 0, &tolua_err ) &&
+ tolua_isstring( tolua_S, 3, 0, &tolua_err ) &&
+ lua_isfunction( tolua_S, 4 ) )
+ {
+ Reference = luaL_ref(tolua_S, LUA_REGISTRYINDEX);
+ Command = ((std::string) tolua_tocppstring(tolua_S,2,0));
+ Permission = ((std::string) tolua_tocppstring(tolua_S,3,0));
+ }
+ else
+ {
+ if( tolua_err.type == 0 )
+ {
+ tolua_err.type = "function";
+ }
+ tolua_error(tolua_S,"#ferror in function 'BindCommand'.",&tolua_err);
+ return 0;
+ }
+
+ if( Reference != LUA_REFNIL )
+ {
+ if( !CommandBinder->BindCommand( Command, Permission, self, tolua_S, Reference ) )
+ {
+ luaL_unref( tolua_S, LUA_REGISTRYINDEX, Reference );
+ }
+ }
+ else
+ {
+ LOGERROR("ERROR: cPlugin:BindCommand invalid function reference in 2nd argument (Command: \"%s\")", Command.c_str() );
+ }
+
+ return 0;
+}
+
+static int tolua_md5(lua_State* tolua_S)
+{
+ std::string SourceString = tolua_tostring(tolua_S, 1, 0);
+ std::string CryptedString = md5( SourceString );
+ tolua_pushstring( tolua_S, CryptedString.c_str() );
+ return 1;
+}
+
+void ManualBindings::Bind( lua_State* tolua_S )
+{
+ tolua_beginmodule(tolua_S,NULL);
+ tolua_function(tolua_S,"StringSplit",tolua_StringSplit);
+ tolua_function(tolua_S,"LOG",tolua_LOG);
+ tolua_function(tolua_S,"LOGINFO",tolua_LOGINFO);
+ tolua_function(tolua_S,"LOGWARN",tolua_LOGWARN);
+ tolua_function(tolua_S,"LOGERROR",tolua_LOGERROR);
+ tolua_function(tolua_S,"Log",tolua_LOG); // Deprecated
+
+ tolua_beginmodule(tolua_S,"cWorld");
+ tolua_function(tolua_S,"GetAllPlayers",tolua_cWorld_GetAllPlayers);
+ tolua_endmodule(tolua_S);
+ tolua_beginmodule(tolua_S,"cPlugin");
+ tolua_function(tolua_S,"GetCommands",tolua_cPlugin_GetCommands);
+ tolua_function(tolua_S,"BindCommand",tolua_cPlugin_BindCommand);
+ tolua_endmodule(tolua_S);
+ tolua_beginmodule(tolua_S,"cPluginManager");
+ tolua_function(tolua_S,"GetAllPlugins",tolua_cPluginManager_GetAllPlugins);
+ tolua_endmodule(tolua_S);
+ tolua_beginmodule(tolua_S,"cPlayer");
+ tolua_function(tolua_S,"GetGroups",tolua_cPlayer_GetGroups);
+ tolua_endmodule(tolua_S);
+
+ tolua_function(tolua_S,"md5",tolua_md5);
+
+ tolua_endmodule(tolua_S);
+}
diff --git a/source/ManualBindings.h b/source/ManualBindings.h new file mode 100644 index 000000000..147a1362d --- /dev/null +++ b/source/ManualBindings.h @@ -0,0 +1,8 @@ +#pragma once
+
+struct lua_State;
+class ManualBindings
+{
+public:
+ static void Bind( lua_State* tolua_S );
+};
\ No newline at end of file diff --git a/source/Matrix4f.cpp b/source/Matrix4f.cpp new file mode 100644 index 000000000..e69de29bb --- /dev/null +++ b/source/Matrix4f.cpp diff --git a/source/Matrix4f.h b/source/Matrix4f.h new file mode 100644 index 000000000..8d92f6e44 --- /dev/null +++ b/source/Matrix4f.h @@ -0,0 +1,111 @@ +#pragma once
+
+#define _USE_MATH_DEFINES
+#include <math.h>
+#include "Vector3f.h"
+
+class Matrix4f
+{
+public:
+ enum
+ {
+ TX=3,
+ TY=7,
+ TZ=11,
+ D0=0, D1=5, D2=10, D3=15,
+ SX=D0, SY=D1, SZ=D2,
+ W=D3
+ };
+ Matrix4f() { Identity(); }
+ float& operator [] ( int a_N ) { return cell[a_N]; }
+ void Identity()
+ {
+ cell[1] = cell[2] = cell[TX] = cell[4] = cell[6] = cell[TY] =
+ cell[8] = cell[9] = cell[TZ] = cell[12] = cell[13] = cell[14] = 0;
+ cell[D0] = cell[D1] = cell[D2] = cell[W] = 1;
+ }
+ void Init( Vector3f a_Pos, float a_RX, float a_RY, float a_RZ )
+ {
+ Matrix4f t;
+ t.RotateX( a_RZ );
+ RotateY( a_RY );
+ Concatenate( t );
+ t.RotateZ( a_RX );
+ Concatenate( t );
+ Translate( a_Pos );
+ }
+ void RotateX( float a_RX )
+ {
+ float sx = (float)sin( a_RX * M_PI / 180 );
+ float cx = (float)cos( a_RX * M_PI / 180 );
+ Identity();
+ cell[5] = cx, cell[6] = sx, cell[9] = -sx, cell[10] = cx;
+ }
+ void RotateY( float a_RY )
+ {
+ float sy = (float)sin( a_RY * M_PI / 180 );
+ float cy = (float)cos( a_RY * M_PI / 180 );
+ Identity ();
+ cell[0] = cy, cell[2] = -sy, cell[8] = sy, cell[10] = cy;
+ }
+ void RotateZ( float a_RZ )
+ {
+ float sz = (float)sin( a_RZ * M_PI / 180 );
+ float cz = (float)cos( a_RZ * M_PI / 180 );
+ Identity ();
+ cell[0] = cz, cell[1] = sz, cell[4] = -sz, cell[5] = cz;
+ }
+ void Translate( Vector3f a_Pos ) { cell[TX] += a_Pos.x; cell[TY] += a_Pos.y; cell[TZ] += a_Pos.z; }
+ void SetTranslation( Vector3f a_Pos ) { cell[TX] = a_Pos.x; cell[TY] = a_Pos.y; cell[TZ] = a_Pos.z; }
+ void Concatenate( const Matrix4f& m2 )
+ {
+ Matrix4f res;
+ int c;
+ for ( c = 0; c < 4; c++ ) for ( int r = 0; r < 4; r++ )
+ res.cell[r * 4 + c] = cell[r * 4] * m2.cell[c] +
+ cell[r * 4 + 1] * m2.cell[c + 4] +
+ cell[r * 4 + 2] * m2.cell[c + 8] +
+ cell[r * 4 + 3] * m2.cell[c + 12];
+ for ( c = 0; c < 16; c++ ) cell[c] = res.cell[c];
+ }
+ Vector3f Transform( const Vector3f& v ) const
+ {
+ float x = cell[0] * v.x + cell[1] * v.y + cell[2] * v.z + cell[3];
+ float y = cell[4] * v.x + cell[5] * v.y + cell[6] * v.z + cell[7];
+ float z = cell[8] * v.x + cell[9] * v.y + cell[10] * v.z + cell[11];
+ return Vector3f( x, y, z );
+ }
+ void Invert()
+ {
+ Matrix4f t;
+ int h, i;
+ float tx = -cell[3], ty = -cell[7], tz = -cell[11];
+ for ( h = 0; h < 3; h++ ) for ( int v = 0; v < 3; v++ ) t.cell[h + v * 4] = cell[v + h * 4];
+ for ( i = 0; i < 11; i++ ) cell[i] = t.cell[i];
+ cell[3] = tx * cell[0] + ty * cell[1] + tz * cell[2];
+ cell[7] = tx * cell[4] + ty * cell[5] + tz * cell[6];
+ cell[11] = tx * cell[8] + ty * cell[9] + tz * cell[10];
+ }
+ Vector3f GetXColumn() { return Vector3f( cell[0], cell[1], cell[2] ); }
+ Vector3f GetYColumn() { return Vector3f( cell[4], cell[5], cell[6] ); }
+ Vector3f GetZColumn() { return Vector3f( cell[8], cell[9], cell[10] ); }
+ void SetXColumn( const Vector3f & a_X )
+ {
+ cell[0] = a_X.x;
+ cell[1] = a_X.y;
+ cell[2] = a_X.z;
+ }
+ void SetYColumn( const Vector3f & a_Y )
+ {
+ cell[4] = a_Y.x;
+ cell[5] = a_Y.y;
+ cell[6] = a_Y.z;
+ }
+ void SetZColumn( const Vector3f & a_Z )
+ {
+ cell[8] = a_Z.x;
+ cell[9] = a_Z.y;
+ cell[10] = a_Z.z;
+ }
+ float cell[16];
+}; diff --git a/source/MemoryLeak.h b/source/MemoryLeak.h new file mode 100644 index 000000000..6ac06a302 --- /dev/null +++ b/source/MemoryLeak.h @@ -0,0 +1,18 @@ +#pragma once
+
+#ifdef _WIN32
+
+#ifdef _DEBUG
+
+#define _CRTDBG_MAP_ALLOC
+#include <stdlib.h>
+#include <crtdbg.h>
+
+#ifndef DEBUG_NEW
+#define DEBUG_NEW new(_NORMAL_BLOCK, __FILE__, __LINE__)
+#define new DEBUG_NEW
+#endif
+
+#endif
+
+#endif
diff --git a/source/PacketID.h b/source/PacketID.h new file mode 100644 index 000000000..6a5611ae0 --- /dev/null +++ b/source/PacketID.h @@ -0,0 +1,52 @@ +#pragma once
+
+//tolua_begin
+enum ENUM_PACKET_ID
+{
+ E_KEEP_ALIVE = 0x00,
+ E_LOGIN = 0x01,
+ E_HANDSHAKE = 0x02,
+ E_CHAT = 0x03,
+ E_UPDATE_TIME = 0x04,
+ E_ENTITY_EQUIPMENT = 0x05,
+ E_USE_ENTITY = 0x07,
+ E_UPDATE_HEALTH = 0x08,
+ E_RESPAWN = 0x09,
+ E_FLYING = 0x0a,
+ E_PLAYERPOS = 0x0b,
+ E_PLAYERLOOK = 0x0c,
+ E_PLAYERMOVELOOK= 0x0d,
+ E_BLOCK_DIG = 0x0e,
+ E_BLOCK_PLACE = 0x0f,
+ E_ITEM_SWITCH = 0x10,
+ E_ADD_TO_INV = 0x11,
+ E_ANIMATION = 0x12,
+ E_PACKET_13 = 0x13,
+ E_NAMED_ENTITY_SPAWN = 0x14,
+ E_PICKUP_SPAWN = 0x15,
+ E_COLLECT_ITEM = 0x16,
+ E_ADD_VEHICLE = 0x17,
+ E_SPAWN_MOB = 0x18,
+ E_DESTROY_ENT = 0x1d,
+ E_ENTITY = 0x1e,
+ E_REL_ENT_MOVE = 0x1f,
+ E_ENT_LOOK = 0x20,
+ E_REL_ENT_MOVE_LOOK = 0x21,
+ E_ENT_TELEPORT = 0x22,
+ E_ENT_STATUS = 0x26,
+ E_METADATA = 0x28,
+ E_PRE_CHUNK = 0x32,
+ E_MAP_CHUNK = 0x33,
+ E_MULTI_BLOCK = 0x34,
+ E_BLOCK_CHANGE = 0x35,
+ E_WINDOW_OPEN = 0x64,
+ E_WINDOW_CLOSE = 0x65,
+ E_WINDOW_CLICK = 0x66,
+ E_INVENTORY_SLOT = 0x67,
+ E_INVENTORY_WHOLE = 0x68,
+ E_INVENTORY_PROGRESS= 0x69,
+ E_UPDATE_SIGN = 0x82,
+ E_PING = 0xfe,
+ E_DISCONNECT = 0xff,
+};
+//tolua_end
\ No newline at end of file diff --git a/source/Vector3d.cpp b/source/Vector3d.cpp new file mode 100644 index 000000000..b2c47972a --- /dev/null +++ b/source/Vector3d.cpp @@ -0,0 +1,16 @@ +#include "Vector3d.h"
+#include "Vector3f.h"
+
+Vector3d::Vector3d(const Vector3f & v )
+ : x( v.x )
+ , y( v.y )
+ , z( v.z )
+{
+}
+
+Vector3d::Vector3d(const Vector3f * v )
+ : x( v->x )
+ , y( v->y )
+ , z( v->z )
+{
+}
\ No newline at end of file diff --git a/source/Vector3d.h b/source/Vector3d.h new file mode 100644 index 000000000..84b04fce7 --- /dev/null +++ b/source/Vector3d.h @@ -0,0 +1,40 @@ +#pragma once
+
+#include <math.h>
+
+class Vector3f;
+class Vector3d //tolua_export
+{ //tolua_export
+public: //tolua_export
+ // convert from float
+ Vector3d(const Vector3f & v ); //tolua_export
+ Vector3d(const Vector3f * v ); //tolua_export
+
+ Vector3d() : x(0), y(0), z(0) {} //tolua_export
+ Vector3d(double a_x, double a_y, double a_z) : x(a_x), y(a_y), z(a_z) {} //tolua_export
+
+ inline void Set(double a_x, double a_y, double a_z) { x = a_x, y = a_y, z = a_z; } //tolua_export
+ inline void Normalize() { double l = 1.0f / Length(); x *= l; y *= l; z *= l; } //tolua_export
+ inline Vector3d NormalizeCopy() { double l = 1.0f / Length(); return Vector3d( x * l, y * l, z * l ); } //tolua_export
+ inline void NormalizeCopy(Vector3d & a_V) { double l = 1.0f / Length(); a_V.Set(x*l, y*l, z*l ); } //tolua_export
+ inline double Length() const { return (double)sqrt( x * x + y * y + z * z ); } //tolua_export
+ inline double SqrLength() const { return x * x + y * y + z * z; } //tolua_export
+ inline double Dot( const Vector3d & a_V ) const { return x * a_V.x + y * a_V.y + z * a_V.z; } //tolua_export
+ inline Vector3d Cross( const Vector3d & v ) const { return Vector3d( y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x ); } //tolua_export
+
+ void operator += ( const Vector3d& a_V ) { x += a_V.x; y += a_V.y; z += a_V.z; }
+ void operator += ( Vector3d* a_V ) { x += a_V->x; y += a_V->y; z += a_V->z; }
+ void operator -= ( const Vector3d& a_V ) { x -= a_V.x; y -= a_V.y; z -= a_V.z; }
+ void operator -= ( Vector3d* a_V ) { x -= a_V->x; y -= a_V->y; z -= a_V->z; }
+ void operator *= ( double a_f ) { x *= a_f; y *= a_f; z *= a_f; }
+
+ Vector3d operator + ( const Vector3d& v2 ) const { return Vector3d( x + v2.x, y + v2.y, z + v2.z ); } //tolua_export
+ Vector3d operator + ( const Vector3d* v2 ) const { return Vector3d( x + v2->x, y + v2->y, z + v2->z ); } //tolua_export
+ Vector3d operator - ( const Vector3d& v2 ) const { return Vector3d( x - v2.x, y - v2.y, z - v2.z ); } //tolua_export
+ Vector3d operator - ( const Vector3d* v2 ) const { return Vector3d( x - v2->x, y - v2->y, z - v2->z ); } //tolua_export
+ Vector3d operator * ( const double f ) const { return Vector3d( x * f, y * f, z * f ); } //tolua_export
+ Vector3d operator * ( const Vector3d& v2 ) const { return Vector3d( x * v2.x, y * v2.y, z * v2.z ); } //tolua_export
+
+ double x, y, z; //tolua_export
+
+};//tolua_export
\ No newline at end of file diff --git a/source/Vector3f.cpp b/source/Vector3f.cpp new file mode 100644 index 000000000..bc73a8070 --- /dev/null +++ b/source/Vector3f.cpp @@ -0,0 +1,31 @@ +#include "Vector3f.h"
+#include "Vector3d.h"
+#include "Vector3i.h"
+
+Vector3f::Vector3f( const Vector3d & v )
+ : x( (float)v.x )
+ , y( (float)v.y )
+ , z( (float)v.z )
+{
+}
+
+Vector3f::Vector3f( const Vector3d * v )
+ : x( (float)v->x )
+ , y( (float)v->y )
+ , z( (float)v->z )
+{
+}
+
+Vector3f::Vector3f( const Vector3i & v )
+ : x( (float)v.x )
+ , y( (float)v.y )
+ , z( (float)v.z )
+{
+}
+
+Vector3f::Vector3f( const Vector3i * v )
+ : x( (float)v->x )
+ , y( (float)v->y )
+ , z( (float)v->z )
+{
+}
\ No newline at end of file diff --git a/source/Vector3f.h b/source/Vector3f.h new file mode 100644 index 000000000..ed1a6ef07 --- /dev/null +++ b/source/Vector3f.h @@ -0,0 +1,47 @@ +#pragma once
+
+#include <math.h>
+
+class Vector3i;
+class Vector3d;
+class Vector3f //tolua_export
+{ //tolua_export
+public: //tolua_export
+ Vector3f( const Vector3d & v ); //tolua_export
+ Vector3f( const Vector3d * v ); //tolua_export
+ Vector3f( const Vector3i & v ); //tolua_export
+ Vector3f( const Vector3i * v ); //tolua_export
+
+
+ Vector3f() : x(0), y(0), z(0) {} //tolua_export
+ Vector3f(float a_x, float a_y, float a_z) : x(a_x), y(a_y), z(a_z) {} //tolua_export
+
+ inline void Set(float a_x, float a_y, float a_z) { x = a_x, y = a_y, z = a_z; } //tolua_export
+ inline void Normalize() { float l = 1.0f / Length(); x *= l; y *= l; z *= l; } //tolua_export
+ inline Vector3f NormalizeCopy() const { float l = 1.0f / Length(); return Vector3f( x * l, y * l, z * l ); }//tolua_export
+ inline void NormalizeCopy(Vector3f & a_V) const { float l = 1.0f / Length(); a_V.Set(x*l, y*l, z*l ); } //tolua_export
+ inline float Length() const { return (float)sqrtf( x * x + y * y + z * z ); } //tolua_export
+ inline float SqrLength() const { return x * x + y * y + z * z; } //tolua_export
+ inline float Dot( const Vector3f & a_V ) const { return x * a_V.x + y * a_V.y + z * a_V.z; } //tolua_export
+ inline Vector3f Cross( const Vector3f & v ) const { return Vector3f( y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x ); } //tolua_export
+
+ inline bool Equals( const Vector3f & v ) const { return (x == v.x && y == v.y && z == v.z ); } //tolua_export
+
+ void operator += ( const Vector3f& a_V ) { x += a_V.x; y += a_V.y; z += a_V.z; }
+ void operator += ( Vector3f* a_V ) { x += a_V->x; y += a_V->y; z += a_V->z; }
+ void operator -= ( const Vector3f& a_V ) { x -= a_V.x; y -= a_V.y; z -= a_V.z; }
+ void operator -= ( Vector3f* a_V ) { x -= a_V->x; y -= a_V->y; z -= a_V->z; }
+ void operator *= ( float a_f ) { x *= a_f; y *= a_f; z *= a_f; }
+ void operator *= ( Vector3f* a_V ) { x *= a_V->x; y *= a_V->y; z *= a_V->z; }
+ void operator *= ( const Vector3f& a_V ) { x *= a_V.x; y *= a_V.y; z *= a_V.z; }
+
+ Vector3f operator + ( const Vector3f& v2 ) const { return Vector3f( x + v2.x, y + v2.y, z + v2.z ); } //tolua_export
+ Vector3f operator + ( const Vector3f* v2 ) const { return Vector3f( x + v2->x, y + v2->y, z + v2->z ); } //tolua_export
+ Vector3f operator - ( const Vector3f& v2 ) const { return Vector3f( x - v2.x, y - v2.y, z - v2.z ); } //tolua_export
+ Vector3f operator - ( const Vector3f* v2 ) const { return Vector3f( x - v2->x, y - v2->y, z - v2->z ); } //tolua_export
+ Vector3f operator * ( const float f ) const { return Vector3f( x * f, y * f, z * f ); } //tolua_export
+ Vector3f operator * ( const Vector3f& v2 ) const { return Vector3f( x * v2.x, y * v2.y, z * v2.z ); } //tolua_export
+
+ float x, y, z; //tolua_export
+
+};//tolua_export
\ No newline at end of file diff --git a/source/Vector3i.cpp b/source/Vector3i.cpp new file mode 100644 index 000000000..6a163a7e8 --- /dev/null +++ b/source/Vector3i.cpp @@ -0,0 +1,9 @@ +#include "Vector3i.h"
+#include "Vector3d.h"
+
+Vector3i::Vector3i( const Vector3d & v )
+ : x( (int)v.x )
+ , y( (int)v.y )
+ , z( (int)v.z )
+{
+}
\ No newline at end of file diff --git a/source/Vector3i.h b/source/Vector3i.h new file mode 100644 index 000000000..676e7ba21 --- /dev/null +++ b/source/Vector3i.h @@ -0,0 +1,37 @@ +#pragma once
+
+#include <math.h>
+
+class Vector3d;
+class Vector3i //tolua_export
+{ //tolua_export
+public: //tolua_export
+ Vector3i( const Vector3d & v ); //tolua_export
+
+ Vector3i() : x(0), y(0), z(0) {} //tolua_export
+ Vector3i(int a_x, int a_y, int a_z) : x(a_x), y(a_y), z(a_z) {} //tolua_export
+
+ inline void Set(int a_x, int a_y, int a_z) { x = a_x, y = a_y, z = a_z; } //tolua_export
+ inline float Length() const { return sqrtf( (float)( x * x + y * y + z * z) ); } //tolua_export
+ inline int SqrLength() const { return x * x + y * y + z * z; } //tolua_export
+
+ inline bool Equals( const Vector3i & v ) const { return (x == v.x && y == v.y && z == v.z ); } //tolua_export
+ inline bool Equals( const Vector3i * v ) const { return (x == v->x && y == v->y && z == v->z ); } //tolua_export
+
+ void operator += ( const Vector3i& a_V ) { x += a_V.x; y += a_V.y; z += a_V.z; }
+ void operator += ( Vector3i* a_V ) { x += a_V->x; y += a_V->y; z += a_V->z; }
+ void operator -= ( const Vector3i& a_V ) { x -= a_V.x; y -= a_V.y; z -= a_V.z; }
+ void operator -= ( Vector3i* a_V ) { x -= a_V->x; y -= a_V->y; z -= a_V->z; }
+ void operator *= ( int a_f ) { x *= a_f; y *= a_f; z *= a_f; }
+
+ friend Vector3i operator + ( const Vector3i& v1, const Vector3i& v2 ) { return Vector3i( v1.x + v2.x, v1.y + v2.y, v1.z + v2.z ); }
+ friend Vector3i operator + ( const Vector3i& v1, Vector3i* v2 ) { return Vector3i( v1.x + v2->x, v1.y + v2->y, v1.z + v2->z ); }
+ friend Vector3i operator - ( const Vector3i& v1, const Vector3i& v2 ) { return Vector3i( v1.x - v2.x, v1.y - v2.y, v1.z - v2.z ); }
+ friend Vector3i operator - ( const Vector3i& v1, Vector3i* v2 ) { return Vector3i( v1.x - v2->x, v1.y - v2->y, v1.z - v2->z ); }
+ friend Vector3i operator - ( const Vector3i* v1, Vector3i& v2 ) { return Vector3i( v1->x - v2.x, v1->y - v2.y, v1->z - v2.z ); }
+ friend Vector3i operator * ( const Vector3i& v, const int f ) { return Vector3i( v.x * f, v.y * f, v.z * f ); }
+ friend Vector3i operator * ( const Vector3i& v1, const Vector3i& v2 ) { return Vector3i( v1.x * v2.x, v1.y * v2.y, v1.z * v2.z ); }
+ friend Vector3i operator * ( const int f, const Vector3i& v ) { return Vector3i( v.x * f, v.y * f, v.z * f ); }
+
+ int x, y, z; //tolua_export
+}; //tolua_export
\ No newline at end of file diff --git a/source/cAuthenticator.cpp b/source/cAuthenticator.cpp new file mode 100644 index 000000000..bce7f942f --- /dev/null +++ b/source/cAuthenticator.cpp @@ -0,0 +1,194 @@ +#include "cAuthenticator.h"
+#include "cBlockingTCPLink.h"
+#include "cMCLogger.h"
+
+#include "../iniFile/iniFile.h"
+#ifndef _WIN32
+#include <cstring>
+#endif
+
+#include <string>
+#include <sstream>
+
+extern void ReplaceString( std::string & a_HayStack, const std::string & a_Needle, const std::string & a_ReplaceWith );
+
+cAuthenticator::cAuthenticator()
+{
+}
+
+cAuthenticator::~cAuthenticator()
+{
+}
+
+bool cAuthenticator::Authenticate( const char* a_PlayerName, const char* a_ServerID )
+{
+ // Default values
+ std::string Server = "www.minecraft.net";
+ std::string Address = "/game/checkserver.jsp?user=%USERNAME%&serverId=%SERVERID%";
+ bool bAuthenticate = true;
+
+ // Read custom values from INI
+ cIniFile IniFile("settings.ini");
+ if( IniFile.ReadFile() )
+ {
+ std::string tServer = IniFile.GetValue("Authentication", "Server");
+ std::string tAddress = IniFile.GetValue("Authentication", "Address");
+ bAuthenticate = IniFile.GetValueB("Authentication", "Authenticate", true);
+ bool bSave = false;
+ if( tServer.length() == 0 )
+ {
+ IniFile.SetValue("Authentication", "Server", Server, true );
+ bSave = true;
+ }
+ else
+ Server = tServer;
+ if( tAddress.length() == 0 )
+ {
+ IniFile.SetValue("Authentication", "Address", Address, true );
+ bSave = true;
+ }
+ else
+ Address = tAddress;
+
+ if( bSave )
+ {
+ IniFile.SetValueB("Authentication", "Authenticate", bAuthenticate, true );
+ IniFile.WriteFile();
+ }
+ }
+
+ if( !bAuthenticate ) // If we don't want to authenticate.. just return true
+ {
+ return true;
+ }
+
+ ReplaceString( Address, "%USERNAME%", a_PlayerName );
+ ReplaceString( Address, "%SERVERID%", a_ServerID );
+
+
+ cBlockingTCPLink TCPLink;
+ if( TCPLink.Connect( Server.c_str(), 80 ) )
+ {
+ //TCPLink.SendMessage( std::string( "GET /game/checkserver.jsp?user=" + std::string(a_PlayerName) + "&serverId=" + std::string(a_ServerID) + " HTTP/1.0\r\n\r\n" ).c_str() );
+ TCPLink.SendMessage( std::string( "GET " + Address + " HTTP/1.0\r\n\r\n" ).c_str() );
+ //LOGINFO("Successfully connected to mc.net");
+ std::string Received = TCPLink.ReceiveData();
+ //LOGINFO("Received data: %s", Received.c_str() );
+ return ParseReceived( Received.c_str(), &TCPLink );
+ }
+ else
+ {
+ LOGERROR("Could not connect to %s to verify player name! (%s)", Server.c_str(), a_PlayerName );
+ return false;
+ }
+}
+
+bool cAuthenticator::ParseReceived( const char* a_Data, cBlockingTCPLink* a_TCPLink )
+{
+ std::stringstream ss(a_Data);
+
+ std::string temp;
+ ss >> temp;
+ //LOGINFO("tmp: %s", temp.c_str() );
+
+ bool bRedirect = false;
+ bool bOK = false;
+
+ if( temp.compare("HTTP/1.1") == 0 || temp.compare("HTTP/1.0") == 0 )
+ {
+ int code;
+ ss >> code;
+ if( code == 302 )
+ {
+ // redirect blabla
+ LOGINFO("Need to redirect!");
+ bRedirect = true;
+ }
+ else if( code == 200 )
+ {
+ LOGINFO("Got 200 OK :D");
+ bOK = true;
+ }
+ }
+ else
+ return false;
+
+ if( bRedirect )
+ {
+ std::string Location;
+ // Search for "Location:"
+ bool bFoundLocation = false;
+ while( !bFoundLocation && ss.good() )
+ {
+ char c = 0;
+ while( c != '\n' )
+ {
+ ss.get( c );
+ }
+ std::string Name;
+ ss >> Name;
+ if( Name.compare("Location:") == 0 )
+ {
+ bFoundLocation = true;
+ ss >> Location;
+ }
+ }
+ if( !bFoundLocation )
+ {
+ LOGERROR("Could not find location");
+ return false;
+ }
+
+ Location = Location.substr( strlen("http://"), std::string::npos ); // Strip http://
+ std::string Server = Location.substr( 0, Location.find( "/" ) ); // Only leave server address
+ Location = Location.substr( Server.length(), std::string::npos );
+ //LOGINFO("Got location: (%s)", Location.c_str() );
+ //LOGINFO("Got server addr: (%s)", Server.c_str() );
+ a_TCPLink->CloseSocket();
+ if( a_TCPLink->Connect( Server.c_str(), 80 ) )
+ {
+ LOGINFO("Successfully connected to %s", Server.c_str() );
+ a_TCPLink->SendMessage( ( std::string("GET ") + Location + " HTTP/1.0\r\n\r\n").c_str() );
+ std::string Received = a_TCPLink->ReceiveData();
+ //LOGINFO("Received data: %s", Received.c_str() );
+ return ParseReceived( Received.c_str(), a_TCPLink );
+ }
+ else
+ {
+ LOGERROR("Could not connect to %s to verify player name!", Server.c_str() );
+ }
+ }
+ else if( bOK )
+ {
+ // Header says OK, so receive the rest.
+
+ // Go past header, double \n means end of headers
+ char c = 0;
+ while( ss.good() )
+ {
+ while( c != '\n' )
+ {
+ ss.get( c );
+ }
+ ss.get( c );
+ if( c == '\n' || c == '\r' || ss.peek() == '\r' || ss.peek() == '\n' )
+ break;
+ }
+ if( !ss.good() ) return false;
+
+ std::string Result;
+ ss >> Result;
+ LOGINFO("Got result: %s", Result.c_str() );
+ if( Result.compare("YES") == 0 )
+ {
+ LOGINFO("Result was \"YES\", so player is authenticated!");
+ return true;
+ }
+ else
+ {
+ LOGINFO("Result was \"%s\", so player is NOT authenticated!", Result.c_str() );
+ return false;
+ }
+ }
+ return false;
+}
diff --git a/source/cAuthenticator.h b/source/cAuthenticator.h new file mode 100644 index 000000000..dada1ce43 --- /dev/null +++ b/source/cAuthenticator.h @@ -0,0 +1,13 @@ +#pragma once
+
+class cBlockingTCPLink;
+class cAuthenticator
+{
+public:
+ cAuthenticator();
+ ~cAuthenticator();
+
+ bool Authenticate( const char* a_PlayerName, const char* a_ServerID );
+private:
+ bool ParseReceived( const char* a_Data, cBlockingTCPLink* a_TCPLink );
+};
\ No newline at end of file diff --git a/source/cBlockEntity.h b/source/cBlockEntity.h new file mode 100644 index 000000000..75c864cec --- /dev/null +++ b/source/cBlockEntity.h @@ -0,0 +1,34 @@ +#pragma once
+
+#ifndef _WIN32
+#include "BlockID.h"
+#else
+enum ENUM_BLOCK_ID;
+#endif
+
+class cClientHandle;
+class cPlayer;
+class cBlockEntity
+{
+protected:
+ cBlockEntity(ENUM_BLOCK_ID a_BlockType, int a_X, int a_Y, int a_Z) : m_PosX( a_X ), m_PosY( a_Y ), m_PosZ( a_Z ), m_BlockType( a_BlockType ) {}
+public:
+ virtual ~cBlockEntity() {};
+ virtual void Destroy() {};
+
+ int GetPosX() { return m_PosX; }
+ int GetPosY() { return m_PosY; }
+ int GetPosZ() { return m_PosZ; }
+
+ ENUM_BLOCK_ID GetBlockType() { return m_BlockType; }
+
+ virtual void UsedBy( cPlayer & a_Player ) = 0;
+ virtual void SendTo( cClientHandle* a_Client ) { (void)a_Client; }
+
+protected:
+ int m_PosX; // Position in block coordinates
+ int m_PosY;
+ int m_PosZ;
+
+ ENUM_BLOCK_ID m_BlockType;
+};
diff --git a/source/cBlockToPickup.cpp b/source/cBlockToPickup.cpp new file mode 100644 index 000000000..3638740a3 --- /dev/null +++ b/source/cBlockToPickup.cpp @@ -0,0 +1,37 @@ +#include "cBlockToPickup.h"
+#include "BlockID.h"
+
+ENUM_ITEM_ID cBlockToPickup::ToPickup( unsigned char a_BlockID, ENUM_ITEM_ID a_UsedItemID )
+{
+ (void)a_UsedItemID;
+
+ switch( a_BlockID )
+ {
+ case E_BLOCK_AIR:
+ return E_ITEM_EMPTY;
+ case E_BLOCK_STONE:
+ return E_ITEM_COBBLESTONE;
+ case E_BLOCK_GRASS:
+ return E_ITEM_DIRT;
+ case E_BLOCK_DIRT:
+ return E_ITEM_DIRT;
+ case E_BLOCK_LOG:
+ return E_ITEM_LOG;
+ case E_BLOCK_COAL_ORE:
+ return E_ITEM_COAL;
+ case E_BLOCK_DIAMOND_ORE:
+ return E_ITEM_DIAMOND;
+ case E_BLOCK_IRON_BLOCK:
+ return E_ITEM_IRON_BLOCK;
+ case E_BLOCK_DIAMOND_BLOCK:
+ return E_ITEM_DIAMOND_BLOCK;
+ case E_BLOCK_GOLD_BLOCK:
+ return E_ITEM_GOLD_BLOCK;
+ case E_BLOCK_SIGN_POST:
+ case E_BLOCK_WALLSIGN:
+ return E_ITEM_SIGN;
+ default:
+ return (ENUM_ITEM_ID)a_BlockID;
+ }
+ return E_ITEM_EMPTY;
+}
diff --git a/source/cBlockToPickup.h b/source/cBlockToPickup.h new file mode 100644 index 000000000..8eb74c5ae --- /dev/null +++ b/source/cBlockToPickup.h @@ -0,0 +1,13 @@ +#pragma once
+
+#ifndef _WIN32
+#include "BlockID.h"
+#else
+enum ENUM_ITEM_ID;
+#endif
+
+class cBlockToPickup
+{
+public:
+ static ENUM_ITEM_ID ToPickup( unsigned char a_BlockID, ENUM_ITEM_ID a_UsedItemID );
+};
diff --git a/source/cBlockingTCPLink.cpp b/source/cBlockingTCPLink.cpp new file mode 100644 index 000000000..a87809857 --- /dev/null +++ b/source/cBlockingTCPLink.cpp @@ -0,0 +1,137 @@ +#include "cBlockingTCPLink.h"
+#include "packets/cPacket.h"
+#include <string>
+
+#include "cMCLogger.h"
+
+#ifndef _WIN32
+#include <cstring>
+#include <errno.h>
+#endif
+
+#ifdef _WIN32
+#define MSG_NOSIGNAL (0)
+#endif
+#ifdef __MACH__
+#define MSG_NOSIGNAL (0)
+#endif
+
+cBlockingTCPLink::cBlockingTCPLink()
+ : m_Socket( 0 )
+{
+}
+
+cBlockingTCPLink::~cBlockingTCPLink()
+{
+ CloseSocket();
+}
+
+void cBlockingTCPLink::CloseSocket()
+{
+ if( m_Socket )
+ {
+ closesocket( m_Socket );
+ m_Socket = 0;
+ }
+}
+
+bool cBlockingTCPLink::Connect( const char* a_Address, unsigned int a_Port )
+{
+ if( m_Socket )
+ {
+ LOGWARN("WARNING: cTCPLink Connect() called while still connected. ALWAYS disconnect before re-connecting!");
+ }
+
+ struct hostent *hp;
+ unsigned int addr;
+ struct sockaddr_in server;
+
+#ifdef _WIN32
+ WSADATA wsaData;
+ int wsaret=WSAStartup(/*0x101*/ MAKEWORD(2, 2),&wsaData);
+
+ if(wsaret!=0)
+ {
+ LOGERROR("cTCPLink: WSAStartup returned error");
+ return false;
+ }
+#endif
+
+ m_Socket=socket(AF_INET,SOCK_STREAM,0);
+#ifdef _WIN32
+ if( m_Socket==INVALID_SOCKET )
+#else
+ if( m_Socket < 0 )
+#endif
+ {
+ LOGERROR("cTCPLink: Invalid socket");
+ m_Socket = 0;
+ return false;
+ }
+
+
+ addr=inet_addr( a_Address );
+ hp=gethostbyaddr((char*)&addr,sizeof(addr),AF_INET);
+ if(hp==NULL)
+ {
+ //LOGWARN("cTCPLink: gethostbyaddr returned NULL");
+ hp = gethostbyname( a_Address );
+ if( hp == NULL )
+ {
+ LOGWARN("cTCPLink: Could not resolve %s", a_Address);
+ CloseSocket();
+ return false;
+ }
+ }
+
+ server.sin_addr.s_addr=*((unsigned long*)hp->h_addr);
+ server.sin_family=AF_INET;
+ server.sin_port=htons( (unsigned short)a_Port );
+ if( connect( m_Socket, (struct sockaddr*)&server, sizeof(server) ) )
+ {
+ LOGWARN("cTCPLink: No response from server (%i)", errno);
+ CloseSocket();
+ return false;
+ }
+
+ return true;
+}
+
+int cBlockingTCPLink::Send( char* a_Data, unsigned int a_Size, int a_Flags /* = 0 */ )
+{
+ if( !m_Socket )
+ {
+ LOGWARN("cBlockingTCPLink: Trying to send data without a valid connection!");
+ return -1;
+ }
+ return cPacket::SendData( m_Socket, a_Data, a_Size, a_Flags );
+}
+
+int cBlockingTCPLink::SendMessage( const char* a_Message, int a_Flags /* = 0 */ )
+{
+ if( !m_Socket )
+ {
+ LOGWARN("cBlockingTCPLink: Trying to send message without a valid connection!");
+ return -1;
+ }
+ return cPacket::SendData( m_Socket, a_Message, strlen(a_Message), a_Flags );
+}
+
+std::string cBlockingTCPLink::ReceiveData()
+{
+ if( !m_Socket ) return "";
+
+ int Received = 0;
+ char Buffer[256];
+ std::string Data;
+ while( (Received = recv(m_Socket, Buffer, 256, 0) ) > 0 )
+ {
+ //LOGINFO("Recv: %i", Received);
+ //LOG("%s", Buffer );
+ Data.append( Buffer, Received );
+ memset( Buffer, 0, 256 );
+ }
+
+ //LOGINFO("Received returned: %i", Received );
+ return Data;
+}
diff --git a/source/cBlockingTCPLink.h b/source/cBlockingTCPLink.h new file mode 100644 index 000000000..535137c3e --- /dev/null +++ b/source/cBlockingTCPLink.h @@ -0,0 +1,21 @@ +#pragma once
+
+#include "cSocket.h"
+#include <string>
+
+class cEvent;
+class cBlockingTCPLink //tolua_export
+{ //tolua_export
+public: //tolua_export
+ cBlockingTCPLink(); //tolua_export
+ ~cBlockingTCPLink(); //tolua_export
+
+ bool Connect( const char* a_Address, unsigned int a_Port ); //tolua_export
+ int Send( char* a_Data, unsigned int a_Size, int a_Flags = 0 ); //tolua_export
+ int SendMessage( const char* a_Message, int a_Flags = 0 ); //tolua_export
+ void CloseSocket(); //tolua_export
+ std::string ReceiveData(); //tolua_export
+protected:
+
+ cSocket m_Socket;
+}; //tolua_export
diff --git a/source/cChatColor.cpp b/source/cChatColor.cpp new file mode 100644 index 000000000..a0f7813c5 --- /dev/null +++ b/source/cChatColor.cpp @@ -0,0 +1,25 @@ +#include "cChatColor.h"
+
+const std::string cChatColor::Color = "§";
+const std::string cChatColor::Delimiter = "\xa7";
+const std::string cChatColor::Black = cChatColor::Color + "0";
+const std::string cChatColor::Navy = cChatColor::Color + "1";
+const std::string cChatColor::Green = cChatColor::Color + "2";
+const std::string cChatColor::Blue = cChatColor::Color + "3";
+const std::string cChatColor::Red = cChatColor::Color + "4";
+const std::string cChatColor::Purple = cChatColor::Color + "5";
+const std::string cChatColor::Gold = cChatColor::Color + "6";
+const std::string cChatColor::LightGray = cChatColor::Color + "7";
+const std::string cChatColor::Gray = cChatColor::Color + "8";
+const std::string cChatColor::DarkPurple = cChatColor::Color + "9";
+const std::string cChatColor::LightGreen = cChatColor::Color + "a";
+const std::string cChatColor::LightBlue = cChatColor::Color + "b";
+const std::string cChatColor::Rose = cChatColor::Color + "c";
+const std::string cChatColor::LightPurple = cChatColor::Color + "d";
+const std::string cChatColor::Yellow = cChatColor::Color + "e";
+const std::string cChatColor::White = cChatColor::Color + "f";
+
+const std::string cChatColor::MakeColor( char a_Color )
+{
+ return cChatColor::Color + a_Color;
+}
\ No newline at end of file diff --git a/source/cChatColor.h b/source/cChatColor.h new file mode 100644 index 000000000..217a0afc3 --- /dev/null +++ b/source/cChatColor.h @@ -0,0 +1,32 @@ +#pragma once
+
+#include <string>
+
+// tolua_begin
+class cChatColor
+{
+public:
+ static const std::string Color;
+ static const std::string Delimiter;
+
+ static const std::string Black;
+ static const std::string Navy;
+ static const std::string Green;
+ static const std::string Blue;
+ static const std::string Red;
+ static const std::string Purple;
+ static const std::string Gold;
+ static const std::string LightGray;
+ static const std::string Gray;
+ static const std::string DarkPurple;
+ static const std::string LightGreen;
+ static const std::string LightBlue;
+ static const std::string Rose;
+ static const std::string LightPurple;
+ static const std::string Yellow;
+ static const std::string White;
+
+ static const std::string MakeColor( char a_Color );
+};
+
+// tolua_end
\ No newline at end of file diff --git a/source/cChestEntity.cpp b/source/cChestEntity.cpp new file mode 100644 index 000000000..f76848879 --- /dev/null +++ b/source/cChestEntity.cpp @@ -0,0 +1,185 @@ +#include "cChestEntity.h"
+#include "cItem.h"
+#include <string>
+#include "cClientHandle.h"
+#include "cMCLogger.h"
+#include "cPlayer.h"
+#include "cWindow.h"
+#include "cPickup.h"
+#include "cMCLogger.h"
+
+#include <json/json.h>
+
+cChestEntity::cChestEntity(int a_X, int a_Y, int a_Z)
+ : cBlockEntity( E_BLOCK_CHEST, a_X, a_Y, a_Z )
+{
+ m_Content = new cItem[ c_ChestHeight*c_ChestWidth ];
+}
+
+cChestEntity::~cChestEntity()
+{
+ if( GetWindow() )
+ {
+ GetWindow()->OwnerDestroyed();
+ }
+
+ if( m_Content )
+ {
+ delete [] m_Content;
+ }
+}
+
+void cChestEntity::Destroy()
+{
+ // Drop items
+ for( int i = 0; i < c_ChestHeight*c_ChestWidth; ++i )
+ {
+ if( !m_Content[i].IsEmpty() )
+ {
+ cPickup* Pickup = new cPickup( m_PosX*32 + 16, m_PosY*32 + 16, m_PosZ*32 + 16, m_Content[i], 0, 1.f, 0 );
+ Pickup->Initialize();
+ m_Content[i].Empty();
+ }
+ }
+}
+
+cItem * cChestEntity::GetSlot( int a_Slot )
+{
+ if( a_Slot > -1 && a_Slot < c_ChestHeight*c_ChestWidth )
+ {
+ return &m_Content[ a_Slot ];
+ }
+ return 0;
+}
+
+void cChestEntity::SetSlot( int a_Slot, cItem & a_Item )
+{
+ if( a_Slot > -1 && a_Slot < c_ChestHeight*c_ChestWidth )
+ {
+ m_Content[a_Slot] = a_Item;
+ }
+}
+
+void cChestEntity::WriteToFile(FILE* a_File)
+{
+ fwrite( &m_BlockType, sizeof( ENUM_BLOCK_ID ), 1, a_File );
+ fwrite( &m_PosX, sizeof( int ), 1, a_File );
+ fwrite( &m_PosY, sizeof( int ), 1, a_File );
+ fwrite( &m_PosZ, sizeof( int ), 1, a_File );
+
+ unsigned int NumSlots = c_ChestHeight*c_ChestWidth;
+ fwrite( &NumSlots, sizeof(unsigned int), 1, a_File );
+ for(unsigned int i = 0; i < NumSlots; i++)
+ {
+ cItem* Item = GetSlot( i );
+ if( Item )
+ {
+ fwrite( &Item->m_ItemID, sizeof(Item->m_ItemID), 1, a_File );
+ fwrite( &Item->m_ItemCount, sizeof(Item->m_ItemCount), 1, a_File );
+ fwrite( &Item->m_ItemHealth, sizeof(Item->m_ItemHealth), 1, a_File );
+ }
+ }
+}
+
+bool cChestEntity::LoadFromFile(FILE* a_File)
+{
+ if( fread( &m_PosX, sizeof(int), 1, a_File) != 1 ) { LOGERROR("ERROR READING CHEST FROM FILE"); return false; }
+ if( fread( &m_PosY, sizeof(int), 1, a_File) != 1 ) { LOGERROR("ERROR READING CHEST FROM FILE"); return false; }
+ if( fread( &m_PosZ, sizeof(int), 1, a_File) != 1 ) { LOGERROR("ERROR READING CHEST FROM FILE"); return false; }
+
+ unsigned int NumSlots = 0;
+ if( fread( &NumSlots, sizeof(unsigned int), 1, a_File) != 1 ) { LOGERROR("ERROR READING CHEST FROM FILE"); return false; }
+ for(unsigned int i = 0; i < NumSlots; i++)
+ {
+ cItem Item;
+ if( fread( &Item.m_ItemID, sizeof(Item.m_ItemID), 1, a_File) != 1 ) { LOGERROR("ERROR READING CHEST FROM FILE"); return false; }
+ if( fread( &Item.m_ItemCount, sizeof(Item.m_ItemCount), 1, a_File) != 1 ) { LOGERROR("ERROR READING CHEST FROM FILE"); return false; }
+ if( fread( &Item.m_ItemHealth, sizeof(Item.m_ItemHealth), 1, a_File)!= 1 ) { LOGERROR("ERROR READING CHEST FROM FILE"); return false; }
+ SetSlot( i, Item );
+ }
+ return true;
+}
+
+bool cChestEntity::LoadFromJson( const Json::Value& a_Value )
+{
+ m_PosX = a_Value.get("x", 0).asInt();
+ m_PosY = a_Value.get("y", 0).asInt();
+ m_PosZ = a_Value.get("z", 0).asInt();
+
+ Json::Value AllSlots = a_Value.get("Slots", 0);
+ int SlotIdx = 0;
+ for( Json::Value::iterator itr = AllSlots.begin(); itr != AllSlots.end(); ++itr )
+ {
+ Json::Value & Slot = *itr;
+ cItem Item;
+ Item.m_ItemID = (ENUM_ITEM_ID)Slot.get("ID", -1 ).asInt();
+ if( Item.m_ItemID > 0 )
+ {
+ Item.m_ItemCount = (char)Slot.get("Count", -1 ).asInt();
+ Item.m_ItemHealth = (short)Slot.get("Health", -1 ).asInt();
+ }
+ SetSlot( SlotIdx, Item );
+ SlotIdx++;
+ }
+ return true;
+}
+
+void cChestEntity::SaveToJson( Json::Value& a_Value )
+{
+ a_Value["x"] = m_PosX;
+ a_Value["y"] = m_PosY;
+ a_Value["z"] = m_PosZ;
+
+ unsigned int NumSlots = c_ChestHeight*c_ChestWidth;
+ Json::Value AllSlots;
+ for(unsigned int i = 0; i < NumSlots; i++)
+ {
+ Json::Value Slot;
+ cItem* Item = GetSlot( i );
+ if( Item )
+ {
+ Slot["ID"] = Item->m_ItemID;
+ if( Item->m_ItemID > 0 )
+ {
+ Slot["Count"] = Item->m_ItemCount;
+ Slot["Health"] = Item->m_ItemHealth;
+ }
+ }
+ AllSlots.append( Slot );
+ }
+ a_Value["Slots"] = AllSlots;
+}
+
+void cChestEntity::SendTo( cClientHandle* a_Client, cServer* a_Server )
+{
+ (void)a_Client;
+ (void)a_Server;
+ return;
+}
+
+void cChestEntity::UsedBy( cPlayer & a_Player )
+{
+ LOG("Used a chest");
+// m_Content[0].m_ItemCount = 1;
+// m_Content[0].m_ItemID = E_ITEM_STONE;
+// m_Content[0].m_ItemHealth = 0;
+
+ if( !GetWindow() )
+ {
+ cWindow* Window = new cWindow( this, true );
+ Window->SetSlots( m_Content, c_ChestHeight*c_ChestWidth );
+ Window->SetWindowID( 1 );
+ Window->SetWindowType( 0 );
+ Window->SetWindowTitle("UberChest");
+ OpenWindow( Window );
+ }
+ if( GetWindow() )
+ {
+ if( a_Player.GetWindow() != GetWindow() )
+ {
+ a_Player.OpenWindow( GetWindow() );
+
+ GetWindow()->SendWholeWindow( a_Player.GetClientHandle() );
+ }
+ }
+}
diff --git a/source/cChestEntity.h b/source/cChestEntity.h new file mode 100644 index 000000000..5170b168d --- /dev/null +++ b/source/cChestEntity.h @@ -0,0 +1,42 @@ +#pragma once
+
+#include "cBlockEntity.h"
+#include "cWindowOwner.h"
+#include "FileDefine.h"
+
+namespace Json
+{
+ class Value;
+};
+
+class cClientHandle;
+class cServer;
+class cItem;
+class cNBTData;
+class cChestEntity : public cBlockEntity, public cWindowOwner
+{
+public:
+ cChestEntity(int a_X, int a_Y, int a_Z);
+ virtual ~cChestEntity();
+ virtual void Destroy();
+
+ void HandleData( cNBTData* a_NBTData );
+
+ cItem * GetSlot( int a_Slot );
+ void SetSlot( int a_Slot, cItem & a_Item );
+
+ void WriteToFile(FILE* a_File);
+ bool LoadFromFile(FILE* a_File);
+
+ bool LoadFromJson( const Json::Value& a_Value );
+ void SaveToJson( Json::Value& a_Value );
+
+ void SendTo( cClientHandle* a_Client, cServer* a_Server );
+
+ virtual void UsedBy( cPlayer & a_Player );
+
+ static const int c_ChestWidth = 9;
+ static const int c_ChestHeight = 3;
+private:
+ cItem* m_Content;
+};
\ No newline at end of file diff --git a/source/cChicken.cpp b/source/cChicken.cpp new file mode 100644 index 000000000..ed420f256 --- /dev/null +++ b/source/cChicken.cpp @@ -0,0 +1,90 @@ +#include "cChicken.h"
+
+#include "Vector3f.h"
+#include "Vector3d.h"
+
+#include "Defines.h"
+
+#include "cRoot.h"
+#include "cWorld.h"
+#include "cPickup.h"
+#include "cItem.h"
+
+#include "cMCLogger.h"
+
+#ifndef _WIN32
+#include <stdlib.h> // rand()
+#include <cstring>
+#endif
+
+#include <string>
+
+
+
+cChicken::cChicken()
+ : m_ChaseTime( 999999 )
+
+{
+ //LOG("SPAWNING A CHICKEN!!!!!!!!!!!!!!!!!!!!!");
+ m_EMPersonality = PASSIVE;
+ m_MobType = 93;
+ GetMonsterConfig("Chicken");
+}
+
+cChicken::~cChicken()
+{
+}
+
+bool cChicken::IsA( const char* a_EntityType )
+{
+ //LOG("IsA( cChicken ) : %s", a_EntityType);
+ if( strcmp( a_EntityType, "cChicken" ) == 0 ) return true;
+ return cMonster::IsA( a_EntityType );
+}
+
+void cChicken::Tick(float a_Dt)
+{
+ cMonster::Tick(a_Dt);
+}
+
+void cChicken::KilledBy( cEntity* a_Killer )
+{
+ if( (rand() % 5) == 0 )
+ {
+ cPickup* Pickup = new cPickup( (int)(m_Pos->x*32), (int)(m_Pos->y*32), (int)(m_Pos->z*32), cItem( E_ITEM_EGG, 1 ) );
+ Pickup->Initialize();
+ }
+ if( (rand() % 1) == 0 )
+ {
+ cPickup* Pickup = new cPickup( (int)(m_Pos->x*32), (int)(m_Pos->y*32), (int)(m_Pos->z*32), cItem( E_ITEM_FEATHER, 1 ) );
+ Pickup->Initialize();
+ }
+ cMonster::KilledBy( a_Killer );
+}
+
+//What to do if in Idle State
+void cChicken::InStateIdle(float a_Dt) {
+ cMonster::InStateIdle(a_Dt);
+}
+
+//What to do if in Chasing State
+void cChicken::InStateChasing(float a_Dt) {
+ cMonster::InStateChasing(a_Dt);
+ m_ChaseTime += a_Dt;
+ if( m_Target )
+ {
+ Vector3f Pos = Vector3f( m_Pos );
+ Vector3f Their = Vector3f( m_Target->GetPosition() );
+ if( (Their - Pos).Length() <= m_AttackRange) {
+ cMonster::Attack(a_Dt);
+ }
+ MoveToPosition( Their + Vector3f(0, 0.65f, 0) );
+ } else if( m_ChaseTime > 5.f ) {
+ m_ChaseTime = 0;
+ m_EMState = IDLE;
+ }
+}
+
+void cChicken::InStateEscaping(float a_Dt) {
+ cMonster::InStateEscaping(a_Dt);
+}
diff --git a/source/cChicken.h b/source/cChicken.h new file mode 100644 index 000000000..9da836587 --- /dev/null +++ b/source/cChicken.h @@ -0,0 +1,21 @@ +#pragma once
+
+#include "cMonster.h"
+
+class cChicken : public cMonster
+{
+public:
+ cChicken();
+ ~cChicken(); + + virtual bool IsA( const char* a_EntityType );
+
+ virtual void Tick(float a_Dt);
+ virtual void KilledBy( cEntity* a_Killer );
+ virtual void InStateIdle(float a_Dt);
+ virtual void InStateChasing(float a_Dt);
+ virtual void InStateEscaping(float a_Dt);
+ //float m_ChaseTime;
+protected:
+ float m_ChaseTime;
+}; diff --git a/source/cChunk.cpp b/source/cChunk.cpp new file mode 100644 index 000000000..c6d0fb3b3 --- /dev/null +++ b/source/cChunk.cpp @@ -0,0 +1,1388 @@ +#ifndef _WIN32
+#include <cstring>
+#include <cstdlib>
+#include <stdio.h>
+#include <sys/stat.h> // for mkdir
+#include <sys/types.h>
+#endif
+#include "cChunk.h"
+#include "cWorld.h"
+#include "cClientHandle.h"
+#include "cServer.h"
+#include "zlib.h"
+#include "Defines.h"
+#include <string> // memset
+#include "cChestEntity.h"
+#include "cFurnaceEntity.h"
+#include "cSignEntity.h"
+#include "cMCLogger.h"
+#include "cTorch.h"
+#include "cLadder.h"
+#include "cPickup.h"
+#include "cItem.h"
+#include "cNoise.h"
+#include "cRoot.h"
+
+#include "cGenSettings.h"
+
+#include "packets/cPacket_DestroyEntity.h"
+#include "packets/cPacket_PreChunk.h"
+#include "packets/cPacket_BlockChange.h"
+#include "packets/cPacket_MapChunk.h"
+#include "packets/cPacket_MultiBlock.h"
+
+#include <json/json.h>
+
+#include <list>
+#include <vector>
+#include <map>
+
+extern bool g_bWaterPhysics;
+
+
+typedef std::list< cFurnaceEntity* > FurnaceEntityList;
+typedef std::list< cClientHandle* > ClientHandleList;
+typedef std::list< cBlockEntity* > BlockEntityList;
+typedef std::list< cEntity* > EntityList;
+struct cChunk::sChunkState
+{
+ std::map< unsigned int, int > m_ToTickBlocks;
+ FurnaceEntityList m_TickBlockEntities;
+ std::vector< unsigned int > m_PendingSendBlocks;
+ ClientHandleList m_LoadedByClient;
+ ClientHandleList m_UnloadQuery;
+ BlockEntityList m_BlockEntities;
+ EntityList m_Entities;
+};
+
+cChunk::~cChunk()
+{
+ //LOG("~cChunk() %i %i %i", m_PosX, m_PosY, m_PosZ );
+ for( std::list<cBlockEntity*>::iterator itr = m_pState->m_BlockEntities.begin(); itr != m_pState->m_BlockEntities.end(); ++itr)
+ {
+ delete *itr;
+ }
+ m_pState->m_BlockEntities.clear();
+
+ LockEntities();
+ for( EntityList::iterator itr = m_pState->m_Entities.begin(); itr != m_pState->m_Entities.end(); ++itr)
+ {
+ if( (*itr)->GetEntityType() != cEntity::E_PLAYER )
+ {
+ cRoot::Get()->GetWorld()->AddToRemoveEntityQueue( **itr ); // World also destroys the entity
+ }
+ }
+ m_pState->m_Entities.clear();
+ UnlockEntities();
+
+ if( m_EntitiesCriticalSection )
+ {
+ DeleteCriticalSection( (CRITICAL_SECTION*)m_EntitiesCriticalSection );
+ delete (CRITICAL_SECTION*)m_EntitiesCriticalSection;
+ m_EntitiesCriticalSection = 0;
+ }
+ delete m_pState;
+}
+
+cChunk::cChunk(int a_X, int a_Y, int a_Z)
+ : m_pState( new sChunkState )
+ , m_bCalculateLighting( false )
+ , m_bCalculateHeightmap( false )
+ , m_PosX( a_X )
+ , m_PosY( a_Y )
+ , m_PosZ( a_Z )
+ , m_BlockType( m_BlockData ) // Offset the pointers
+ , m_BlockMeta( m_BlockType + c_NumBlocks )
+ , m_BlockLight( m_BlockMeta + c_NumBlocks/2 )
+ , m_BlockSkyLight( m_BlockLight + c_NumBlocks/2 )
+ , m_BlockTickNum( 0 )
+ , m_BlockTickX( 0 )
+ , m_BlockTickY( 0 )
+ , m_BlockTickZ( 0 )
+ , m_EntitiesCriticalSection( 0 )
+{
+ //LOG("cChunk::cChunk(%i, %i, %i)", a_X, a_Y, a_Z);
+ m_EntitiesCriticalSection = new CRITICAL_SECTION;
+ InitializeCriticalSection( (CRITICAL_SECTION*)m_EntitiesCriticalSection );
+}
+
+void cChunk::Initialize()
+{
+ if( !LoadFromDisk() )
+ {
+ // Clear memory
+ memset( m_BlockData, 0x00, c_BlockDataSize );
+
+// LARGE_INTEGER TicksPerSecond;
+// QueryPerformanceFrequency( &TicksPerSecond );
+
+ GenerateTerrain();
+
+// LARGE_INTEGER start;
+// QueryPerformanceCounter( &start );
+
+ CalculateHeightmap();
+ CalculateLighting();
+
+// LARGE_INTEGER end;
+// QueryPerformanceCounter( &end );
+// double Time = double( end.QuadPart - start.QuadPart ) / double( TicksPerSecond.QuadPart / 1000 );
+// LOG("Calculated light in %f ms", Time );
+
+ CreateBlockEntities();
+ }
+ else
+ {
+ //LOGINFO("Successfully loaded from disk");
+ CalculateHeightmap();
+ }
+}
+
+void cChunk::Tick(float a_Dt)
+{
+ if( m_bCalculateLighting )
+ CalculateLighting();
+ if( m_bCalculateHeightmap )
+ CalculateHeightmap();
+
+ unsigned int PendingSendBlocks = m_pState->m_PendingSendBlocks.size();
+ if( PendingSendBlocks > 1 )
+ {
+ cPacket_MultiBlock MultiBlock;
+ MultiBlock.m_ChunkX = m_PosX;
+ MultiBlock.m_ChunkZ = m_PosZ;
+ MultiBlock.m_NumBlocks = (short)PendingSendBlocks;
+ MultiBlock.m_BlockCoordinates = new unsigned short[PendingSendBlocks];
+ MultiBlock.m_BlockTypes = new char[PendingSendBlocks];
+ MultiBlock.m_BlockMetas = new char[PendingSendBlocks];
+ //LOG("Sending multiblock packet for %i blocks", PendingSendBlocks );
+ for( unsigned int i = 0; i < PendingSendBlocks; i++)
+ {
+ unsigned int index = m_pState->m_PendingSendBlocks[i];
+ unsigned int Y = index % 128;
+ unsigned int Z = (index / 128) % 16;
+ unsigned int X = (index / (128*16));
+
+ MultiBlock.m_BlockCoordinates[i] = (Z&0xf) | (X&0xf)<<4 | (Y&0xff)<<8;
+ //LOG("X: %i Y: %i Z: %i Combo: 0x%04x", X, Y, Z, MultiBlock.m_BlockCoordinates[i] );
+ MultiBlock.m_BlockTypes[i] = m_BlockType[index];
+ MultiBlock.m_BlockMetas[i] = GetLight( m_BlockMeta, index );
+ }
+ m_pState->m_PendingSendBlocks.clear();
+ PendingSendBlocks = m_pState->m_PendingSendBlocks.size();
+ Broadcast( MultiBlock );
+ }
+ if( PendingSendBlocks > 0 )
+ {
+ for( unsigned int i = 0; i < PendingSendBlocks; i++)
+ {
+ unsigned int index = m_pState->m_PendingSendBlocks[i];
+ int Y = index % 128;
+ int Z = (index / 128) % 16;
+ int X = (index / (128*16));
+
+ cPacket_BlockChange BlockChange;
+ BlockChange.m_PosX = X + m_PosX*16;
+ BlockChange.m_PosY = (char)(Y + m_PosY*128);
+ BlockChange.m_PosZ = Z + m_PosZ*16;
+ BlockChange.m_BlockType = m_BlockType[index];
+ BlockChange.m_BlockMeta = GetLight( m_BlockMeta, index );
+ Broadcast( BlockChange );
+ }
+ m_pState->m_PendingSendBlocks.clear();
+ }
+
+ while( !m_pState->m_UnloadQuery.empty() )
+ {
+ cPacket_PreChunk UnloadPacket;
+ UnloadPacket.m_PosX = GetPosX();
+ UnloadPacket.m_PosZ = GetPosZ();
+ UnloadPacket.m_bLoad = false; // Unload
+ (*m_pState->m_UnloadQuery.begin())->Send( UnloadPacket );
+ m_pState->m_UnloadQuery.remove( *m_pState->m_UnloadQuery.begin() );
+ }
+
+ std::map< unsigned int, int > ToTickBlocks = m_pState->m_ToTickBlocks;
+ unsigned int NumTickBlocks = ToTickBlocks.size();
+ if( NumTickBlocks > 0 ) LOG("To tick: %i", NumTickBlocks );
+ m_pState->m_ToTickBlocks.clear();
+ for( std::map< unsigned int, int>::iterator itr = ToTickBlocks.begin(); itr != ToTickBlocks.end(); ++itr )
+ {
+ if( (*itr).second < 0 ) continue;
+ unsigned int index = (*itr).first;
+ int Y = index % 128;
+ int Z = (index / 128) % 16;
+ int X = (index / (128*16));
+
+ char BlockID = GetBlock( index );
+ switch( BlockID )
+ {
+ case E_BLOCK_REEDS:
+ case E_BLOCK_WOODEN_PRESSURE_PLATE:
+ case E_BLOCK_STONE_PRESSURE_PLATE:
+ case E_BLOCK_MINECART_TRACKS:
+ case E_BLOCK_SIGN_POST:
+ case E_BLOCK_CROPS:
+ case E_BLOCK_SAPLING:
+ case E_BLOCK_YELLOW_FLOWER:
+ case E_BLOCK_RED_ROSE:
+ case E_BLOCK_RED_MUSHROOM:
+ case E_BLOCK_BROWN_MUSHROOM:
+ case E_BLOCK_REDSTONE_WIRE: // Stuff that drops when block below is destroyed
+ {
+ if( GetBlock( X, Y-1, Z ) == E_BLOCK_AIR )
+ {
+ SetBlock( X, Y, Z, 0, 0 );
+ cPickup* Pickup = new cPickup( (X+m_PosX*16) * 32 + 16, (Y+m_PosY*128) * 32 + 16, (Z+m_PosZ*16) * 32 + 16, cItem( (ENUM_ITEM_ID)BlockID, 1 ) );
+ Pickup->Initialize();
+ }
+ }
+ break;
+ case E_BLOCK_REDSTONE_TORCH_OFF:
+ case E_BLOCK_REDSTONE_TORCH_ON:
+ case E_BLOCK_TORCH:
+ {
+ char Dir = cTorch::MetaDataToDirection( GetLight( m_BlockMeta, X, Y, Z ) );
+ LOG("MetaData: %i", Dir );
+ int XX = X + m_PosX*16;
+ char YY = (char)Y;
+ int ZZ = Z + m_PosZ*16;
+ AddDirection( XX, YY, ZZ, Dir, true );
+ cWorld* World = cRoot::Get()->GetWorld();
+ if( World->GetBlock( XX, YY, ZZ ) == E_BLOCK_AIR )
+ {
+ SetBlock( X, Y, Z, 0, 0 );
+ cPickup* Pickup = new cPickup( (X+m_PosX*16) * 32 + 16, (Y+m_PosY*128) * 32 + 16, (Z+m_PosZ*16) * 32 + 16, cItem( (ENUM_ITEM_ID)BlockID, 1 ) );
+ Pickup->Initialize();
+ }
+ }
+ break;
+ case E_BLOCK_LADDER:
+ {
+ char Dir = cLadder::MetaDataToDirection( GetLight( m_BlockMeta, X, Y, Z ) );
+ int XX = X + m_PosX*16;
+ char YY = (char)Y;
+ int ZZ = Z + m_PosZ*16;
+ AddDirection( XX, YY, ZZ, Dir, true );
+ cWorld* World = cRoot::Get()->GetWorld();
+ if( World->GetBlock( XX, YY, ZZ ) == E_BLOCK_AIR )
+ {
+ SetBlock( X, Y, Z, 0, 0 );
+ cPickup* Pickup = new cPickup( (X+m_PosX*16) * 32 + 16, (Y+m_PosY*128) * 32 + 16, (Z+m_PosZ*16) * 32 + 16, cItem( (ENUM_ITEM_ID)BlockID, 1 ) );
+ Pickup->Initialize();
+ }
+ }
+ break;
+ case E_BLOCK_STATIONARY_WATER:
+ case E_BLOCK_WATER:
+
+ break;
+ case E_BLOCK_GRAVEL:
+ case E_BLOCK_SAND:
+ {
+ char BottomBlock = GetBlock( X, Y-1, Z );
+ if( BottomBlock == E_BLOCK_AIR || BottomBlock == E_BLOCK_WATER || BottomBlock == E_BLOCK_STATIONARY_WATER || BottomBlock == E_BLOCK_LAVA || BottomBlock == E_BLOCK_STATIONARY_LAVA )
+ {
+ SetBlock( X, Y, Z, 0, 0 );
+ SetBlock( X, Y-1, Z, BlockID, 0 );
+ }
+ }
+ break;
+ default:
+ break;
+ };
+ }
+
+ // Tick dem blocks
+ int RandomX = rand();
+ int RandomY = rand();
+ int RandomZ = rand();
+
+ for(int i = 0; i < 50; i++)
+ {
+ m_BlockTickX = (m_BlockTickX + RandomX) % 16;
+ m_BlockTickY = (m_BlockTickY + RandomY) % 128;
+ m_BlockTickZ = (m_BlockTickZ + RandomZ) % 16;
+
+ //LOG("%03i %03i %03i", m_BlockTickX, m_BlockTickY, m_BlockTickZ);
+
+ if( m_BlockTickY > m_HeightMap[ m_BlockTickX + m_BlockTickZ*16 ] ) continue; // It's all air up here
+
+ //m_BlockTickNum = (m_BlockTickNum + 1 ) % c_NumBlocks;
+ unsigned int Index = MakeIndex( m_BlockTickX, m_BlockTickY, m_BlockTickZ );
+ char ID = m_BlockType[Index];
+ switch( ID )
+ {
+ case E_BLOCK_DIRT:
+ {
+ char AboveBlock = GetBlock( Index+1 );
+ if( AboveBlock == 0 && GetLight( m_BlockSkyLight, Index ) > 0xf/2 ) // Half lit
+ {
+ FastSetBlock( m_BlockTickX, m_BlockTickY, m_BlockTickZ, E_BLOCK_GRASS, GetLight( m_BlockMeta, Index ) );
+ }
+ }
+ break;
+ case E_BLOCK_GRASS:
+ {
+ char AboveBlock = GetBlock( Index+1 );
+ if( AboveBlock != 0 )
+ {
+ FastSetBlock( m_BlockTickX, m_BlockTickY, m_BlockTickZ, E_BLOCK_DIRT, GetLight( m_BlockMeta, Index ) );
+ }
+ }
+ break;
+ case E_BLOCK_SAPLING:
+ {
+ FastSetBlock( m_BlockTickX, m_BlockTickY, m_BlockTickZ, E_BLOCK_AIR, GetLight( m_BlockMeta, Index ) );
+ cRoot::Get()->GetWorld()->GrowTree( m_BlockTickX + m_PosX*16, m_BlockTickY, m_BlockTickZ + m_PosZ*16 );
+ }
+ default:
+ break;
+ }
+ }
+
+ // Tick block entities (furnace)
+ std::list< cFurnaceEntity* > TickBlockEntites = m_pState->m_TickBlockEntities; // Dangerous stuff, better make a copy.
+ for( std::list< cFurnaceEntity* >::iterator itr = TickBlockEntites.begin(); itr != TickBlockEntites.end(); ++itr )
+ {
+ if( !(*itr)->Tick( a_Dt ) ) // Remove from list
+ {
+ m_pState->m_TickBlockEntities.remove( *itr );
+ }
+ }
+}
+
+char cChunk::GetHeight( int a_X, int a_Z )
+{
+ if( a_X >= 0 && a_X < 16 && a_Z >= 0 && a_Z < 16 )
+ return m_HeightMap[a_X + a_Z*16];
+ return 0;
+}
+
+void cChunk::CreateBlockEntities()
+{
+ for(int x = 0; x < 16; x++)
+ {
+ for(int z = 0; z < 16; z++)
+ {
+ for(int y = 0; y < 128; y++)
+ {
+ ENUM_BLOCK_ID BlockType = (ENUM_BLOCK_ID)m_BlockData[ MakeIndex( x, y, z ) ];
+ switch( BlockType )
+ {
+ case E_BLOCK_CHEST:
+ {
+ m_pState->m_BlockEntities.push_back( new cChestEntity( x + m_PosX*16, y + m_PosY*128, z + m_PosZ*16 ) );
+ }
+ break;
+ case E_BLOCK_FURNACE:
+ {
+ m_pState->m_BlockEntities.push_back( new cFurnaceEntity( x + m_PosX*16, y + m_PosY*128, z + m_PosZ*16 ) );
+ }
+ break;
+ case E_BLOCK_SIGN_POST:
+ case E_BLOCK_WALLSIGN:
+ {
+ m_pState->m_BlockEntities.push_back( new cSignEntity( BlockType, x + m_PosX*16, y + m_PosY*128, z + m_PosZ*16 ) );
+ }
+ break;
+ default:
+ {
+ }
+ break;
+ }
+ }
+ }
+ }
+}
+
+unsigned int cChunk::MakeIndex(int x, int y, int z )
+{
+ if( x < 16 && x > -1 && y < 128 && y > -1 && z < 16 && z > -1 )
+ return y + (z * 128) + (x * 128 * 16);
+ return 0;
+}
+
+char cChunk::GetLight(char* a_Buffer, int a_BlockIdx)
+{
+ if( a_BlockIdx > -1 && a_BlockIdx < c_NumBlocks )
+ {
+ const int cindex = (a_BlockIdx/2);
+ if( (a_BlockIdx & 1) == 0 )
+ { // First half byte
+ return (a_Buffer[cindex] & 0x0f);
+ }
+ else
+ {
+ return ((a_Buffer[cindex] & 0xf0) >> 4);
+ }
+ }
+ return 0;
+}
+
+char cChunk::GetLight(char* a_Buffer, int x, int y, int z)
+{
+ if( x < 16 && x > -1 && y < 128 && y > -1 && z < 16 && z > -1 )
+ {
+ const int cindex = (y/2) + (z * 64) + (x * 64 * 16);
+ if( (y & 1) == 0 )
+ { // First half byte
+ return (a_Buffer[cindex] & 0x0f);
+ }
+ else
+ {
+ return ((a_Buffer[cindex] & 0xf0) >> 4);
+ }
+ }
+ return 0;
+}
+
+void cChunk::SetLight(char* a_Buffer, int a_BlockIdx, char a_Light)
+{
+ if( a_BlockIdx > -1 && a_BlockIdx < c_NumBlocks )
+ {
+ const int cindex = (a_BlockIdx/2);
+ if( (a_BlockIdx & 1) == 0 )
+ { // First half byte
+ a_Buffer[cindex] &= 0xf0; // Set first half to 0
+ a_Buffer[cindex] |= (a_Light) & 0x0f;
+ }
+ else
+ {
+ a_Buffer[cindex] &= 0x0f; // Set second half to 0
+ a_Buffer[cindex] |= (a_Light << 4) & 0xf0;
+ }
+ }
+}
+
+void cChunk::SetLight(char* a_Buffer, int x, int y, int z, char light)
+{
+ if( x < 16 && x > -1 && y < 128 && y > -1 && z < 16 && z > -1 )
+ {
+ int cindex = (y/2) + (z * 64) + (x * 64 * 16);
+ if( (y & 1) == 0 )
+ { // First half byte
+ a_Buffer[cindex] &= 0xf0; // Set first half to 0
+ a_Buffer[cindex] |= (light) & 0x0f;
+ }
+ else
+ {
+ a_Buffer[cindex] &= 0x0f; // Set second half to 0
+ a_Buffer[cindex] |= (light << 4) & 0xf0;
+ }
+ }
+}
+
+inline void cChunk::SpreadLightOfBlock(char* a_LightBuffer, int a_X, int a_Y, int a_Z, char a_Falloff)
+{
+ unsigned char CurrentLight = GetLight( a_LightBuffer, a_X, a_Y, a_Z );
+ SetLight( a_LightBuffer, a_X-1, a_Y, a_Z, MAX(GetLight( a_LightBuffer, a_X-1, a_Y, a_Z ), MAX(0,CurrentLight-a_Falloff) ) );
+ SetLight( a_LightBuffer, a_X+1, a_Y, a_Z, MAX(GetLight( a_LightBuffer, a_X+1, a_Y, a_Z ), MAX(0,CurrentLight-a_Falloff) ) );
+ SetLight( a_LightBuffer, a_X, a_Y-1, a_Z, MAX(GetLight( a_LightBuffer, a_X, a_Y-1, a_Z ), MAX(0,CurrentLight-a_Falloff) ) );
+ SetLight( a_LightBuffer, a_X, a_Y+1, a_Z, MAX(GetLight( a_LightBuffer, a_X, a_Y+1, a_Z ), MAX(0,CurrentLight-a_Falloff) ) );
+ SetLight( a_LightBuffer, a_X, a_Y, a_Z-1, MAX(GetLight( a_LightBuffer, a_X, a_Y, a_Z-1 ), MAX(0,CurrentLight-a_Falloff) ) );
+ SetLight( a_LightBuffer, a_X, a_Y, a_Z+1, MAX(GetLight( a_LightBuffer, a_X, a_Y, a_Z+1 ), MAX(0,CurrentLight-a_Falloff) ) );
+}
+
+inline void cChunk::SpreadLightOfBlockX(char* a_LightBuffer, int a_X, int a_Y, int a_Z)
+{
+ unsigned char CurrentLight = GetLight( a_LightBuffer, a_X, a_Y, a_Z );
+ SetLight( a_LightBuffer, a_X-1, a_Y, a_Z, MAX(GetLight( a_LightBuffer, a_X-1, a_Y, a_Z ), CurrentLight-1) );
+ SetLight( a_LightBuffer, a_X+1, a_Y, a_Z, MAX(GetLight( a_LightBuffer, a_X+1, a_Y, a_Z ), CurrentLight-1) );
+}
+
+inline void cChunk::SpreadLightOfBlockY(char* a_LightBuffer, int a_X, int a_Y, int a_Z)
+{
+ unsigned char CurrentLight = GetLight( a_LightBuffer, a_X, a_Y, a_Z );
+ SetLight( a_LightBuffer, a_X, a_Y-1, a_Z, MAX(GetLight( a_LightBuffer, a_X, a_Y-1, a_Z ), CurrentLight-1) );
+ SetLight( a_LightBuffer, a_X, a_Y+1, a_Z, MAX(GetLight( a_LightBuffer, a_X, a_Y+1, a_Z ), CurrentLight-1) );
+}
+
+inline void cChunk::SpreadLightOfBlockZ(char* a_LightBuffer, int a_X, int a_Y, int a_Z)
+{
+ unsigned char CurrentLight = GetLight( a_LightBuffer, a_X, a_Y, a_Z );
+ SetLight( a_LightBuffer, a_X, a_Y, a_Z-1, MAX(GetLight( a_LightBuffer, a_X, a_Y, a_Z-1 ), CurrentLight-1) );
+ SetLight( a_LightBuffer, a_X, a_Y, a_Z+1, MAX(GetLight( a_LightBuffer, a_X, a_Y, a_Z+1 ), CurrentLight-1) );
+}
+
+void cChunk::CalculateHeightmap()
+{
+ m_bCalculateHeightmap = false;
+ for(int x = 0; x < 16; x++)
+ {
+ for(int z = 0; z < 16; z++)
+ {
+ for(int y = 127; y > -1; y--)
+ {
+ int index = MakeIndex( x, y, z );
+ if(m_BlockData[index] != E_BLOCK_AIR)
+ {
+ m_HeightMap[x + z*16] = (char)y;
+ break;
+ }
+ }
+ }
+ }
+}
+
+void cChunk::CalculateLighting()
+{
+ // Calculate sunlight
+ memset(m_BlockSkyLight, 0xff, c_NumBlocks/2 ); // Set all to fully lit, so everything above HeightMap is lit
+ for(int x = 0; x < 16; x++)
+ {
+ for(int z = 0; z < 16; z++)
+ {
+ char sunlight = 0xf;
+ for(int y = m_HeightMap[x + z*16]; y > -1; y--)
+ {
+ int index = y + (z * 128) + (x * 128 * 16);
+
+ if( g_BlockTransparent[ (int)m_BlockData[index] ] == false )
+ {
+ sunlight = 0x0;
+ }
+ SetLight( m_BlockSkyLight, x, y, z, sunlight );
+ }
+ }
+ }
+
+ // Calculate blocklights
+ for(int x = 0; x < 16; x++)
+ {
+ for(int z = 0; z < 16; z++)
+ {
+ int MaxHeight = m_HeightMap[x + z*16];
+ for(int y = 0; y < MaxHeight; y++)
+ {
+ char BlockID = GetBlock(x, y, z);
+ SetLight( m_BlockLight, x, y, z, g_BlockLightValue[(int)BlockID] );
+ }
+ }
+ }
+
+ SpreadLight(m_BlockSkyLight);
+ SpreadLight(m_BlockLight);
+
+ // Stop it from calculating again :P
+ m_bCalculateLighting = false;
+}
+
+void cChunk::SpreadLight(char* a_LightBuffer)
+{
+ // Spread the sunlight
+ for(int x = 0; x < 16; x++) for(int z = 0; z < 16; z++) for(int y = 0; y < 128; y++)
+ {
+ int index = y + (z * 128) + (x * 128 * 16);
+ if( g_BlockSpreadLightFalloff[ m_BlockData[index] ] > 0 )
+ {
+ SpreadLightOfBlock(a_LightBuffer, x, y, z, g_BlockSpreadLightFalloff[ m_BlockData[index] ]);
+ }
+ }
+
+ for(int x = 15; x > -1; x--) for(int z = 15; z > -1; z--) for(int y = 127; y > -1; y--)
+ {
+ int index = y + (z * 128) + (x * 128 * 16);
+ if( g_BlockSpreadLightFalloff[ m_BlockData[index] ] > 0 )
+ {
+ SpreadLightOfBlock(a_LightBuffer, x, y, z, g_BlockSpreadLightFalloff[ m_BlockData[index] ]);
+ }
+ }
+
+ bool bCalcLeft, bCalcRight, bCalcFront, bCalcBack;
+ bCalcLeft = bCalcRight = bCalcFront = bCalcBack = false;
+ // Spread to neighbour chunks X-axis
+ cChunk* LeftChunk = cRoot::Get()->GetWorld()->GetChunkUnreliable( m_PosX-1, m_PosY, m_PosZ );
+ cChunk* RightChunk = cRoot::Get()->GetWorld()->GetChunkUnreliable( m_PosX+1, m_PosY, m_PosZ );
+ char* LeftSky = 0, *RightSky = 0;
+ if(LeftChunk) LeftSky = (a_LightBuffer==m_BlockSkyLight)?LeftChunk->pGetSkyLight():LeftChunk->pGetLight();
+ if(RightChunk) RightSky = (a_LightBuffer==m_BlockSkyLight)?RightChunk->pGetSkyLight():RightChunk->pGetLight();
+ for(int z = 0; z < 16; z++) for(int y = 0; y < 128; y++)
+ {
+ if( LeftChunk )
+ {
+ int index = y + (z * 128) + (0 * 128 * 16);
+ if( g_BlockSpreadLightFalloff[ m_BlockData[index] ] > 0 )
+ {
+ char CurrentLight = GetLight( a_LightBuffer, 0, y, z );
+ char LeftLight = GetLight( LeftSky, 15, y, z );
+ if( LeftLight < CurrentLight-g_BlockSpreadLightFalloff[ m_BlockData[index] ] )
+ {
+ SetLight( LeftSky, 15, y, z, MAX(0, CurrentLight-g_BlockSpreadLightFalloff[ m_BlockData[index] ]) );
+ bCalcLeft = true;
+ }
+ }
+ }
+ if( RightChunk )
+ {
+ int index = y + (z * 128) + (15 * 128 * 16);
+ if( g_BlockSpreadLightFalloff[ m_BlockData[index] ] > 0 )
+ {
+ char CurrentLight = GetLight( a_LightBuffer, 15, y, z );
+ char RightLight = GetLight( RightSky, 0, y, z );
+ if( RightLight < CurrentLight-g_BlockSpreadLightFalloff[ m_BlockData[index] ] )
+ {
+ SetLight( RightSky, 0, y, z, MAX(0, CurrentLight-g_BlockSpreadLightFalloff[ m_BlockData[index] ]) );
+ bCalcRight = true;
+ }
+ }
+ }
+ }
+
+ // Spread to neighbour chunks Z-axis
+ cChunk* FrontChunk = cRoot::Get()->GetWorld()->GetChunkUnreliable( m_PosX, m_PosY, m_PosZ-1 );
+ cChunk* BackChunk = cRoot::Get()->GetWorld()->GetChunkUnreliable( m_PosX, m_PosY, m_PosZ+1 );
+ char* FrontSky = 0, *BackSky = 0;
+ if(FrontChunk) FrontSky = (a_LightBuffer==m_BlockSkyLight)?FrontChunk->pGetSkyLight():FrontChunk->pGetLight();
+ if(BackChunk) BackSky = (a_LightBuffer==m_BlockSkyLight)?BackChunk->pGetSkyLight():BackChunk->pGetLight();
+ for(int x = 0; x < 16; x++) for(int y = 0; y < 128; y++)
+ {
+ if( FrontChunk )
+ {
+ int index = y + (0 * 128) + (x * 128 * 16);
+ if( g_BlockSpreadLightFalloff[ m_BlockData[index] ] > 0 )
+ {
+ char CurrentLight = GetLight( a_LightBuffer, x, y, 0 );
+ char FrontLight = GetLight( FrontSky, x, y, 15 );
+ if( FrontLight < CurrentLight-g_BlockSpreadLightFalloff[ m_BlockData[index] ] )
+ {
+ SetLight( FrontSky, x, y, 15, MAX(0, CurrentLight-g_BlockSpreadLightFalloff[ m_BlockData[index] ]) );
+ bCalcFront = true;
+ }
+ }
+ }
+ if( BackChunk )
+ {
+ int index = y + (15 * 128) + (x * 128 * 16);
+ if( g_BlockSpreadLightFalloff[ m_BlockData[index] ] > 0 )
+ {
+ char CurrentLight = GetLight( a_LightBuffer, x, y, 15 );
+ char BackLight = GetLight( BackSky, x, y, 0 );
+ if( BackLight < CurrentLight-g_BlockSpreadLightFalloff[ m_BlockData[index] ] )
+ {
+ SetLight( BackSky, x, y, 0, MAX(0, CurrentLight-g_BlockSpreadLightFalloff[ m_BlockData[index] ]) );
+ bCalcBack = true;
+ }
+ }
+ }
+ }
+
+ if( bCalcLeft ) cRoot::Get()->GetWorld()->ReSpreadLighting( LeftChunk );
+ if( bCalcRight ) cRoot::Get()->GetWorld()->ReSpreadLighting( RightChunk );
+ if( bCalcFront ) cRoot::Get()->GetWorld()->ReSpreadLighting( FrontChunk );
+ if( bCalcBack ) cRoot::Get()->GetWorld()->ReSpreadLighting( BackChunk );
+}
+
+float GetNoise( float x, float y, cNoise & a_Noise )
+{
+ float oct1 = a_Noise.CubicNoise2D( x*cGenSettings::HeightFreq1, y*cGenSettings::HeightFreq1 )*cGenSettings::HeightAmp1;
+ float oct2 = a_Noise.CubicNoise2D( x*cGenSettings::HeightFreq2, y*cGenSettings::HeightFreq2 )*cGenSettings::HeightAmp2;
+ float oct3 = a_Noise.CubicNoise2D( x*cGenSettings::HeightFreq3, y*cGenSettings::HeightFreq3 )*cGenSettings::HeightAmp3;
+
+ float height = a_Noise.CubicNoise2D( x*0.1f, y*0.1f )*2;
+
+ float flatness = ((a_Noise.CubicNoise2D( x*0.5f, y*0.5f ) + 1.f ) * 0.5f) * 1.1f; // 0 ... 1.5
+ flatness *= flatness * flatness;
+
+ return (oct1 + oct2 + oct3) * flatness + height;
+}
+
+#define PI_2 (1.57079633)
+float GetMarbleNoise( float x, float y, float z, cNoise & a_Noise )
+{
+ float oct1 = (a_Noise.CubicNoise3D( x*0.1f, y*0.1f, z*0.1f ))*4;
+
+ oct1 = oct1 * oct1 * oct1;
+ if( oct1 < 0.f ) oct1 = PI_2;
+ if( oct1 > PI_2 ) oct1 = PI_2;
+
+ return oct1;
+}
+
+float GetOreNoise( float x, float y, float z, cNoise & a_Noise )
+{
+ float oct1 = a_Noise.CubicNoise3D( x*0.1f, y*0.1f, z*0.1f );
+ float oct2 = a_Noise.CubicNoise3D( x*0.05f, y*0.5f, z*0.05f );
+
+ oct2 *= oct2;
+ oct1 = (1 - (oct1 * oct1 *100)) * oct2;
+ //if( oct1 < 0.5f ) oct1 = 0;
+ //else oct1 = 1.f;
+
+ return oct1;
+}
+
+void cChunk::GenerateTerrain()
+{
+
+
+ const ENUM_BLOCK_ID GrassID = E_BLOCK_GRASS;
+ const ENUM_BLOCK_ID DirtID = E_BLOCK_DIRT;
+ const ENUM_BLOCK_ID StoneID = E_BLOCK_STONE;
+ const ENUM_BLOCK_ID SandID = E_BLOCK_SAND;
+ const ENUM_BLOCK_ID CaveID = E_BLOCK_AIR;
+ const ENUM_BLOCK_ID LavaID = E_BLOCK_STATIONARY_LAVA;
+ const ENUM_BLOCK_ID CoalID = E_BLOCK_COAL_ORE;
+ const ENUM_BLOCK_ID IronID = E_BLOCK_IRON_ORE;
+ const ENUM_BLOCK_ID GoldID = E_BLOCK_GOLD_ORE;
+ const ENUM_BLOCK_ID DiamondID = E_BLOCK_DIAMOND_ORE;
+ const ENUM_BLOCK_ID RedID = E_BLOCK_REDSTONE_ORE;
+
+ /*
+ const ENUM_BLOCK_ID GrassID = E_BLOCK_AIR;
+ const ENUM_BLOCK_ID DirtID = E_BLOCK_AIR;
+ const ENUM_BLOCK_ID StoneID = E_BLOCK_AIR;
+ const ENUM_BLOCK_ID SandID = E_BLOCK_AIR;
+ const ENUM_BLOCK_ID CaveID = E_BLOCK_AIR;
+ const ENUM_BLOCK_ID LavaID = E_BLOCK_AIR;
+ const ENUM_BLOCK_ID CoalID = E_BLOCK_COAL_ORE;
+ const ENUM_BLOCK_ID IronID = E_BLOCK_IRON_ORE;
+ const ENUM_BLOCK_ID GoldID = E_BLOCK_GOLD_ORE;
+ const ENUM_BLOCK_ID DiamondID = E_BLOCK_DIAMOND_ORE;
+ const ENUM_BLOCK_ID RedID = E_BLOCK_REDSTONE_ORE;
+ */
+
+ cNoise m_Noise( cRoot::Get()->GetWorld()->GetWorldSeed() );
+ for(int z = 0; z < 16; z++)
+ {
+ const float zz = (float)(m_PosZ*16 + z);
+ for(int x = 0; x < 16; x++)
+ {
+ // Place bedrock on bottom layer
+ m_BlockType[ MakeIndex(x, 0, z) ] = E_BLOCK_BEDROCK;
+
+ const float xx = (float)(m_PosX*16 + x);
+
+ int Height = (int)(GetNoise( xx*0.05f, zz*0.05f, m_Noise )*16);
+ const int Lower = 64;
+ if( Height+Lower > 127 ) Height = 127-Lower;
+ const int Top = Lower+Height;
+ const float WaveNoise = 1;//m_Noise.CubicNoise2D( xx*0.01f, zz*0.01f ) + 0.5f;
+ for( int y = 1; y < Top; ++y )
+ {
+ const float yy = (float)y;
+ // V prevent caves from getting too close to the surface
+ if( (Top - y > (WaveNoise*2) ) && cosf(GetMarbleNoise( xx, yy*0.5f, zz, m_Noise )) * fabs( cosf( yy*0.2f + WaveNoise*2 )*0.75f + WaveNoise ) > 0.5f )
+ {
+ if( y > 4 )
+ {
+ m_BlockType[ MakeIndex(x, y, z) ] = CaveID;
+ if( z > 0 ) m_BlockType[ MakeIndex(x, y, z-1) ] = CaveID;
+ if( z < 15 ) m_BlockType[ MakeIndex(x, y, z+1) ] = CaveID;
+ if( x > 0 ) m_BlockType[ MakeIndex(x-1, y, z) ] = CaveID;
+ if( x < 15 ) m_BlockType[ MakeIndex(x+1, y, z) ] = CaveID;
+ }
+ else
+ {
+ m_BlockType[ MakeIndex(x, y, z) ] = LavaID;
+ }
+ }
+ else if( y < 61 && Top - y < 3 )
+ m_BlockType[ MakeIndex(x, y, z) ] = SandID;
+ else if( Top - y > ((WaveNoise+1.5f)*1.5f) ) // rock and ores between 1.5 .. 4.5 deep
+ {
+ if( GetOreNoise( xx, yy, zz, m_Noise ) > 0.5f )
+ m_BlockType[ MakeIndex(x, y, z) ] = CoalID;
+ else if( GetOreNoise( xx, yy+100.f, zz, m_Noise ) > 0.6f )
+ m_BlockType[ MakeIndex(x, y, z) ] = IronID;
+ else if( yy < 20 && GetOreNoise( xx*1.5f, yy+300.f, zz*1.5f, m_Noise ) > 0.6f )
+ m_BlockType[ MakeIndex(x, y, z) ] = RedID;
+ else if( yy < 30 && GetOreNoise( xx*2, yy+200.f, zz*2, m_Noise ) > 0.75f )
+ m_BlockType[ MakeIndex(x, y, z) ] = DiamondID;
+ else if( yy < 40 && GetOreNoise( xx*2, yy+100.f, zz*2, m_Noise ) > 0.75f )
+ m_BlockType[ MakeIndex(x, y, z) ] = GoldID;
+ else
+ m_BlockType[ MakeIndex(x, y, z) ] = StoneID;
+ }
+ else
+ m_BlockType[ MakeIndex(x, y, z) ] = DirtID;
+ }
+ for( int y = Lower+Height; y < 60; ++y )
+ {
+ m_BlockType[ MakeIndex(x, y, z) ] = E_BLOCK_STATIONARY_WATER;
+ }
+ }
+ }
+
+ for(int z = 0; z < 16; z++) for(int x = 0; x < 16; x++)
+ {
+ // Find top most Y
+ int TopY = -1;
+ for(int y = 127; y > 0; y--)
+ {
+ int index = MakeIndex( x, y, z );
+ if( m_BlockType[index] != E_BLOCK_AIR )
+ {
+ TopY = y;
+ break;
+ }
+ }
+ if( TopY > 0 )
+ {
+ // Change top dirt into grass
+ int index = MakeIndex( x, TopY, z );
+ if( m_BlockType[index] == DirtID )
+ {
+ m_BlockType[ index ] = (char)GrassID;
+ }
+
+
+ // Plant sum trees
+ {
+ int xx = x + m_PosX*16;
+// int yy = TopY;
+ int zz = z + m_PosZ*16;
+
+ float val1 = m_Noise.CubicNoise2D( xx*0.1f, zz*0.1f );
+ float val2 = m_Noise.CubicNoise2D( xx*0.01f, zz*0.01f );
+ if( m_BlockType[index] == SandID )
+ {
+ if( (val1 + val2 > 0.f) && (rand()%128) > 124 && m_BlockType[index] == E_BLOCK_SAND )
+ {
+ m_BlockType[ MakeIndex(x, TopY+1, z) ] = E_BLOCK_CACTUS;
+ if( (rand() & 3) == 3 )
+ {
+ m_BlockType[ MakeIndex(x, TopY+2, z) ] = E_BLOCK_CACTUS;
+ }
+ continue;
+ }
+ }
+ else if( m_BlockType[index] == GrassID )
+ {
+ float val3 = m_Noise.CubicNoise2D( xx*0.01f+10, zz*0.01f+10 );
+ float val4 = m_Noise.CubicNoise2D( xx*0.05f+20, zz*0.05f+20 );
+ if( val1 + val2 > 0.2f && (rand()%128) > 124 )
+ cRoot::Get()->GetWorld()->GrowTree( xx, TopY, zz );
+ else if( val3 > 0.2f && (rand()%128) > 124 )
+ m_BlockType[ MakeIndex(x, TopY+1, z) ] = E_BLOCK_YELLOW_FLOWER;
+ else if( val4 > 0.2f && (rand()%128) > 124 )
+ m_BlockType[ MakeIndex(x, TopY+1, z) ] = E_BLOCK_RED_ROSE;
+ else if( val1+val2+val3+val4 > 0.2f && (rand()%128) > 124 )
+ m_BlockType[ MakeIndex(x, TopY+1, z) ] = E_BLOCK_RED_MUSHROOM;
+ else if( val1+val2+val3+val4 > 0.2f && (rand()%128) > 124 )
+ m_BlockType[ MakeIndex(x, TopY+1, z) ] = E_BLOCK_BROWN_MUSHROOM;
+ }
+ }
+
+ }
+ }
+}
+
+
+void cChunk::AsyncUnload( cClientHandle* a_Client )
+{
+ m_pState->m_UnloadQuery.remove( a_Client ); // Make sure this client is only in the list once
+ m_pState->m_UnloadQuery.push_back( a_Client );
+}
+
+void cChunk::Send( cClientHandle* a_Client )
+{
+ cPacket_PreChunk PreChunk;
+ PreChunk.m_PosX = m_PosX;
+ PreChunk.m_PosZ = m_PosZ;
+ PreChunk.m_bLoad = true;
+ a_Client->Send( PreChunk );
+ a_Client->Send( cPacket_MapChunk( this ) );
+
+ for( BlockEntityList::iterator itr = m_pState->m_BlockEntities.begin(); itr != m_pState->m_BlockEntities.end(); ++itr )
+ {
+ (*itr)->SendTo( a_Client );
+ }
+}
+
+void cChunk::SetBlock( int a_X, int a_Y, int a_Z, char a_BlockType, char a_BlockMeta )
+{
+ if(a_X < 0 || a_X >= 16 || a_Y < 0 || a_Y >= 128 || a_Z < 0 || a_Z >= 16)
+ {
+ //printf(">>>>>>>>>>>>>>>> CLIPPED SETBLOCK %i %i %i\n", a_X, a_Y, a_Z );
+ return; // Clip
+ }
+
+ int index = a_Y + (a_Z * 128) + (a_X * 128 * 16);
+ char OldBlockMeta = GetLight( m_BlockMeta, index );
+ char OldBlockType = m_BlockType[index];
+ m_BlockType[index] = a_BlockType;
+
+ SetLight( m_BlockMeta, index, a_BlockMeta );
+
+ if( OldBlockType != a_BlockType || OldBlockMeta != a_BlockMeta )
+ {
+ //LOG("Old: %i %i New: %i %i", OldBlockType, OldBlockMeta, a_BlockType, a_BlockMeta );
+ m_pState->m_PendingSendBlocks.push_back( index );
+
+ m_pState->m_ToTickBlocks[ MakeIndex( a_X, a_Y, a_Z ) ]++;
+ m_pState->m_ToTickBlocks[ MakeIndex( a_X+1, a_Y, a_Z ) ]++;
+ m_pState->m_ToTickBlocks[ MakeIndex( a_X-1, a_Y, a_Z ) ]++;
+ m_pState->m_ToTickBlocks[ MakeIndex( a_X, a_Y+1, a_Z ) ]++;
+ m_pState->m_ToTickBlocks[ MakeIndex( a_X, a_Y-1, a_Z ) ]++;
+ m_pState->m_ToTickBlocks[ MakeIndex( a_X, a_Y, a_Z+1 ) ]++;
+ m_pState->m_ToTickBlocks[ MakeIndex( a_X, a_Y, a_Z-1 ) ]++;
+
+ cBlockEntity* BlockEntity = GetBlockEntity( a_X + m_PosX*16, a_Y+m_PosY*128, a_Z+m_PosZ*16 );
+ if( BlockEntity )
+ {
+ BlockEntity->Destroy();
+ RemoveBlockEntity( BlockEntity );
+ delete BlockEntity;
+ }
+ switch( a_BlockType )
+ {
+ case E_BLOCK_CHEST:
+ AddBlockEntity( new cChestEntity( a_X + m_PosX*16, a_Y + m_PosY*128, a_Z + m_PosZ*16 ) );
+ break;
+ case E_BLOCK_FURNACE:
+ AddBlockEntity( new cFurnaceEntity( a_X + m_PosX*16, a_Y + m_PosY*128, a_Z + m_PosZ*16 ) );
+ break;
+ case E_BLOCK_SIGN_POST:
+ case E_BLOCK_WALLSIGN:
+ AddBlockEntity( new cSignEntity( (ENUM_BLOCK_ID)a_BlockType, a_X + m_PosX*16, a_Y + m_PosY*128, a_Z + m_PosZ*16 ) );
+ break;
+ default:
+ break;
+ };
+ }
+
+ CalculateHeightmap();
+ RecalculateLighting();
+}
+
+void cChunk::FastSetBlock( int a_X, int a_Y, int a_Z, char a_BlockType, char a_BlockMeta )
+{
+ if(a_X < 0 || a_X >= 16 || a_Y < 0 || a_Y >= 128 || a_Z < 0 || a_Z >= 16)
+ {
+ //printf(">>>>>>>>>>>>>>>> CLIPPED SETBLOCK %i %i %i\n", a_X, a_Y, a_Z );
+ return; // Clip
+ }
+
+ const int index = a_Y + (a_Z * 128) + (a_X * 128 * 16);
+ const char OldBlock = m_BlockType[index];
+ m_BlockType[index] = a_BlockType;
+ m_pState->m_PendingSendBlocks.push_back( index );
+ SetLight( m_BlockMeta, index, a_BlockMeta );
+
+ // ONLY recalculate lighting if it's nessesary!
+ if( g_BlockLightValue[ OldBlock ] != g_BlockLightValue[ a_BlockType ]
+ || g_BlockSpreadLightFalloff[ OldBlock ] != g_BlockSpreadLightFalloff[ a_BlockType ]
+ || g_BlockTransparent[ OldBlock ] != g_BlockTransparent[ a_BlockType ] )
+ {
+ RecalculateLighting();
+ }
+
+ // Recalculate next tick
+ RecalculateHeightmap();
+}
+
+void cChunk::SendBlockTo( int a_X, int a_Y, int a_Z, cClientHandle* a_Client )
+{
+ if( a_Client == 0 )
+ {
+ m_pState->m_PendingSendBlocks.push_back( MakeIndex( a_X, a_Y, a_Z ) );
+ return;
+ }
+
+ for( std::list< cClientHandle* >::iterator itr = m_pState->m_LoadedByClient.begin(); itr != m_pState->m_LoadedByClient.end(); ++itr )
+ {
+ if( *itr == a_Client )
+ {
+ unsigned int index = MakeIndex( a_X, a_Y, a_Z );
+ cPacket_BlockChange BlockChange;
+ BlockChange.m_PosX = a_X + m_PosX*16;
+ BlockChange.m_PosY = (char)(a_Y + m_PosY*128);
+ BlockChange.m_PosZ = a_Z + m_PosZ*16;
+ BlockChange.m_BlockType = m_BlockType[ index ];
+ BlockChange.m_BlockMeta = GetLight( m_BlockMeta, index );
+ a_Client->Send( BlockChange );
+ break;
+ }
+ }
+}
+
+void cChunk::AddBlockEntity( cBlockEntity* a_BlockEntity )
+{
+ m_pState->m_BlockEntities.push_back( a_BlockEntity );
+}
+
+void cChunk::RemoveBlockEntity( cBlockEntity* a_BlockEntity )
+{
+ m_pState->m_BlockEntities.remove( a_BlockEntity );
+}
+
+void cChunk::AddClient( cClientHandle* a_Client )
+{
+ m_pState->m_LoadedByClient.remove( a_Client );
+ m_pState->m_LoadedByClient.push_back( a_Client );
+
+ LockEntities();
+ for( EntityList::iterator itr = m_pState->m_Entities.begin(); itr != m_pState->m_Entities.end(); ++itr )
+ {
+ LOG("%i %i %i Spawning on %s", m_PosX, m_PosY, m_PosZ, a_Client->GetUsername() );
+ (*itr)->SpawnOn( a_Client );
+ }
+ UnlockEntities();
+}
+
+void cChunk::RemoveClient( cClientHandle* a_Client )
+{
+ m_pState->m_LoadedByClient.remove( a_Client );
+
+ LockEntities();
+ for( EntityList::iterator itr = m_pState->m_Entities.begin(); itr != m_pState->m_Entities.end(); ++itr )
+ {
+ LOG("%i %i %i Destroying on %s", m_PosX, m_PosY, m_PosZ, a_Client->GetUsername() );
+ cPacket_DestroyEntity DestroyEntity( *itr );
+ a_Client->Send( DestroyEntity );
+ }
+ UnlockEntities();
+}
+
+void cChunk::AddEntity( cEntity & a_Entity )
+{
+ LockEntities();
+ m_pState->m_Entities.push_back( &a_Entity );
+ UnlockEntities();
+}
+
+bool cChunk::RemoveEntity( cEntity & a_Entity, cChunk* a_CalledFrom /* = 0 */ )
+{
+ LockEntities();
+ unsigned int SizeBefore = m_pState->m_Entities.size();
+ m_pState->m_Entities.remove( &a_Entity );
+ if( SizeBefore == m_pState->m_Entities.size() )
+ {
+ LOG("WARNING: Entity was not in chunk %i %i %i", m_PosX, m_PosY, m_PosZ );
+ if( !a_CalledFrom )
+ {
+ UnlockEntities();
+ return cRoot::Get()->GetWorld()->RemoveEntityFromChunk( a_Entity, this );
+ }
+ UnlockEntities();
+ return false;
+ }
+ UnlockEntities();
+ return true;
+}
+
+void cChunk::LockEntities()
+{
+ EnterCriticalSection( (CRITICAL_SECTION*)m_EntitiesCriticalSection );
+}
+
+void cChunk::UnlockEntities()
+{
+ LeaveCriticalSection( (CRITICAL_SECTION*)m_EntitiesCriticalSection );
+}
+
+char cChunk::GetBlock( int a_X, int a_Y, int a_Z )
+{
+ if(a_X < 0 || a_X >= 16 || a_Y < 0 || a_Y >= 128 || a_Z < 0 || a_Z >= 16) return 0; // Clip
+
+ int index = a_Y + (a_Z * 128) + (a_X * 128 * 16);
+ return m_BlockType[index];
+}
+
+char cChunk::GetBlock( int a_BlockIdx )
+{
+ if( a_BlockIdx < 0 || a_BlockIdx >= c_NumBlocks ) return 0;
+ return m_BlockType[ a_BlockIdx ];
+}
+
+cBlockEntity* cChunk::GetBlockEntity( int a_X, int a_Y, int a_Z )
+{
+ for( std::list<cBlockEntity*>::iterator itr = m_pState->m_BlockEntities.begin(); itr != m_pState->m_BlockEntities.end(); ++itr)
+ {
+ if( (*itr)->GetPosX() == a_X &&
+ (*itr)->GetPosY() == a_Y &&
+ (*itr)->GetPosZ() == a_Z )
+ {
+ return *itr;
+ }
+ }
+ return 0;
+}
+
+bool cChunk::LoadFromDisk()
+{
+ char SourceFile[128];
+ sprintf_s(SourceFile, 128, "world/X%i_Y%i_Z%i.bin", m_PosX, m_PosY, m_PosZ );
+
+ FILE* f = 0;
+ #ifdef _WIN32
+ if( fopen_s(&f, SourceFile, "rb" ) == 0 ) // no error
+ #else
+ if( (f = fopen(SourceFile, "rb" )) != 0 ) // no error
+ #endif
+ {
+ if( fread( m_BlockData, sizeof(char)*c_BlockDataSize, 1, f) != 1 ) { LOGERROR("ERROR READING FROM FILE %s", SourceFile); fclose(f); return false; }
+
+ // Now load Block Entities
+ ENUM_BLOCK_ID BlockType;
+ while( fread( &BlockType, sizeof(ENUM_BLOCK_ID), 1, f) == 1 )
+ {
+ switch( BlockType )
+ {
+ case E_BLOCK_CHEST:
+ {
+ cChestEntity* ChestEntity = new cChestEntity( 0, 0, 0 );
+ if( !ChestEntity->LoadFromFile( f ) )
+ {
+ LOGERROR("ERROR READING CHEST FROM FILE %s", SourceFile );
+ delete ChestEntity;
+ fclose(f);
+ return false;
+ }
+ m_pState->m_BlockEntities.push_back( ChestEntity );
+ }
+ break;
+ case E_BLOCK_FURNACE:
+ {
+ cFurnaceEntity* FurnaceEntity = new cFurnaceEntity( 0, 0, 0 );
+ if( !FurnaceEntity->LoadFromFile( f ) )
+ {
+ LOGERROR("ERROR READING FURNACE FROM FILE %s", SourceFile );
+ delete FurnaceEntity;
+ fclose(f);
+ return false;
+ }
+ m_pState->m_BlockEntities.push_back( FurnaceEntity );
+ m_pState->m_TickBlockEntities.push_back( FurnaceEntity ); // They need tickin'
+ }
+ break;
+ case E_BLOCK_SIGN_POST:
+ case E_BLOCK_WALLSIGN:
+ {
+ cSignEntity* SignEntity = new cSignEntity(BlockType, 0, 0, 0 );
+ if( !SignEntity->LoadFromFile( f ) )
+ {
+ LOGERROR("ERROR READING SIGN FROM FILE %s", SourceFile );
+ delete SignEntity;
+ fclose(f);
+ return false;
+ }
+ m_pState->m_BlockEntities.push_back( SignEntity );
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+ fclose(f);
+
+ // Delete old format file
+ if( std::remove( SourceFile ) != 0 )
+ LOGERROR("Could not delete file %s", SourceFile );
+ else
+ LOGINFO("Successfully deleted olf format file %s", SourceFile );
+
+ return true;
+ }
+ else
+ {
+ //LOGWARN("COULD NOT OPEN FILE %s\n", SourceFile);
+ return false;
+ }
+}
+
+bool cChunk::SaveToDisk()
+{
+ return true; //no more saving old format!
+
+ char SourceFile[128];
+ sprintf_s(SourceFile, 128, "world/X%i_Y%i_Z%i.bin", m_PosX, m_PosY, m_PosZ );
+
+ #ifdef _WIN32
+ {
+ SECURITY_ATTRIBUTES Attrib;
+ Attrib.nLength = sizeof(SECURITY_ATTRIBUTES);
+ Attrib.lpSecurityDescriptor = NULL;
+ Attrib.bInheritHandle = false;
+ ::CreateDirectory("world", &Attrib);
+ }
+ #else
+ {
+ mkdir("world", S_IRWXU | S_IRWXG | S_IRWXO);
+ }
+ #endif
+
+ FILE* f = 0;
+#ifdef _WIN32
+ if( fopen_s(&f, SourceFile, "wb" ) == 0 ) // no error
+ #else
+ if( (f = fopen(SourceFile, "wb" )) != 0 ) // no error
+ #endif
+ {
+ fwrite( m_BlockData, sizeof(char)*c_BlockDataSize, 1, f );
+
+ // Now write Block Entities
+ for( std::list<cBlockEntity*>::iterator itr = m_pState->m_BlockEntities.begin(); itr != m_pState->m_BlockEntities.end(); ++itr)
+ {
+ cBlockEntity* BlockEntity = *itr;
+ switch( BlockEntity->GetBlockType() )
+ {
+ case E_BLOCK_CHEST:
+ {
+ cChestEntity* ChestEntity = reinterpret_cast< cChestEntity* >( BlockEntity );
+ ChestEntity->WriteToFile( f );
+ }
+ break;
+ case E_BLOCK_FURNACE:
+ {
+ cFurnaceEntity* FurnaceEntity = reinterpret_cast< cFurnaceEntity* >( BlockEntity );
+ FurnaceEntity->WriteToFile( f );
+ }
+ break;
+ case E_BLOCK_SIGN_POST:
+ case E_BLOCK_WALLSIGN:
+ {
+ cSignEntity* SignEntity = reinterpret_cast< cSignEntity* >( BlockEntity );
+ SignEntity->WriteToFile( f );
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+ fclose(f);
+ return true;
+ }
+ else
+ {
+ LOGERROR("ERROR WRITING TO FILE %s", SourceFile);
+ return false;
+ }
+}
+
+void cChunk::Broadcast( const cPacket & a_Packet, cClientHandle* a_Exclude /* = 0 */ ) const
+{
+ for( std::list< cClientHandle* >::const_iterator itr = m_pState->m_LoadedByClient.begin(); itr != m_pState->m_LoadedByClient.end(); ++itr )
+ {
+ if( *itr == a_Exclude ) continue;
+ (*itr)->Send( a_Packet );
+ }
+}
+
+
+void cChunk::LoadFromJson( const Json::Value & a_Value )
+{
+ // Load chests
+ Json::Value AllChests = a_Value.get("Chests", Json::nullValue);
+ if( !AllChests.empty() )
+ {
+ for( Json::Value::iterator itr = AllChests.begin(); itr != AllChests.end(); ++itr )
+ {
+ Json::Value & Chest = *itr;
+ cChestEntity* ChestEntity = new cChestEntity(0,0,0);
+ if( !ChestEntity->LoadFromJson( Chest ) )
+ {
+ LOGERROR("ERROR READING CHEST FROM JSON!" );
+ delete ChestEntity;
+ }
+ else m_pState->m_BlockEntities.push_back( ChestEntity );
+ }
+ }
+
+ // Load furnaces
+ Json::Value AllFurnaces = a_Value.get("Furnaces", Json::nullValue);
+ if( !AllFurnaces.empty() )
+ {
+ for( Json::Value::iterator itr = AllFurnaces.begin(); itr != AllFurnaces.end(); ++itr )
+ {
+ Json::Value & Furnace = *itr;
+ cFurnaceEntity* FurnaceEntity = new cFurnaceEntity(0,0,0);
+ if( !FurnaceEntity->LoadFromJson( Furnace ) )
+ {
+ LOGERROR("ERROR READING FURNACE FROM JSON!" );
+ delete FurnaceEntity;
+ }
+ else m_pState->m_BlockEntities.push_back( FurnaceEntity );
+ }
+ }
+
+ // Load signs
+ Json::Value AllSigns = a_Value.get("Signs", Json::nullValue);
+ if( !AllSigns.empty() )
+ {
+ for( Json::Value::iterator itr = AllSigns.begin(); itr != AllSigns.end(); ++itr )
+ {
+ Json::Value & Sign = *itr;
+ cSignEntity* SignEntity = new cSignEntity( E_BLOCK_SIGN_POST, 0,0,0);
+ if( !SignEntity->LoadFromJson( Sign ) )
+ {
+ LOGERROR("ERROR READING SIGN FROM JSON!" );
+ delete SignEntity;
+ }
+ else m_pState->m_BlockEntities.push_back( SignEntity );
+ }
+ }
+}
+
+void cChunk::SaveToJson( Json::Value & a_Value )
+{
+ Json::Value AllChests;
+ Json::Value AllFurnaces;
+ Json::Value AllSigns;
+ for( std::list<cBlockEntity*>::iterator itr = m_pState->m_BlockEntities.begin(); itr != m_pState->m_BlockEntities.end(); ++itr)
+ {
+ cBlockEntity* BlockEntity = *itr;
+ switch( BlockEntity->GetBlockType() )
+ {
+ case E_BLOCK_CHEST:
+ {
+ cChestEntity* ChestEntity = reinterpret_cast< cChestEntity* >( BlockEntity );
+ Json::Value NewChest;
+ ChestEntity->SaveToJson( NewChest );
+ AllChests.append( NewChest );
+ }
+ break;
+ case E_BLOCK_FURNACE:
+ {
+ cFurnaceEntity* FurnaceEntity = reinterpret_cast< cFurnaceEntity* >( BlockEntity );
+ Json::Value NewFurnace;
+ FurnaceEntity->SaveToJson( NewFurnace );
+ AllFurnaces.append( NewFurnace );
+ }
+ break;
+ case E_BLOCK_SIGN_POST:
+ case E_BLOCK_WALLSIGN:
+ {
+ cSignEntity* SignEntity = reinterpret_cast< cSignEntity* >( BlockEntity );
+ Json::Value NewSign;
+ SignEntity->SaveToJson( NewSign );
+ AllSigns.append( NewSign );
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+ if( !AllChests.empty() )
+ a_Value["Chests"] = AllChests;
+ if( !AllFurnaces.empty() )
+ a_Value["Furnaces"] = AllFurnaces;
+ if( !AllSigns.empty() )
+ a_Value["Signs"] = AllSigns;
+}
+
+EntityList & cChunk::GetEntities()
+{
+ return m_pState->m_Entities;
+}
+
+const ClientHandleList & cChunk::GetClients()
+{
+ return m_pState->m_LoadedByClient;
+}
+
+
+void cChunk::AddTickBlockEntity( cFurnaceEntity* a_Entity )
+{
+ m_pState->m_TickBlockEntities.remove( a_Entity );
+ m_pState->m_TickBlockEntities.push_back( a_Entity );
+}
+
+void cChunk::RemoveTickBlockEntity( cFurnaceEntity* a_Entity )
+{
+ m_pState->m_TickBlockEntities.remove( a_Entity );
+}
\ No newline at end of file diff --git a/source/cChunk.h b/source/cChunk.h new file mode 100644 index 000000000..83c14dcfa --- /dev/null +++ b/source/cChunk.h @@ -0,0 +1,127 @@ +#pragma once
+
+#include <list>
+
+namespace Json
+{
+ class Value;
+};
+
+class cFurnaceEntity;
+class cPacket;
+class cBlockEntity;
+class cEntity;
+class cClientHandle;
+class cServer;
+class cChunk
+{
+public:
+ cChunk(int a_X, int a_Y, int a_Z);
+ ~cChunk();
+
+ void Initialize();
+
+ void Tick(float a_Dt);
+
+ inline int GetPosX() { return m_PosX; }
+ inline int GetPosY() { return m_PosY; }
+ inline int GetPosZ() { return m_PosZ; }
+
+ void Send( cClientHandle* a_Client );
+ void AsyncUnload( cClientHandle* a_Client );
+
+ void SetBlock( int a_X, int a_Y, int a_Z, char a_BlockType, char a_BlockMeta );
+ void FastSetBlock( int a_X, int a_Y, int a_Z, char a_BlockType, char a_BlockMeta );
+ char GetBlock( int a_X, int a_Y, int a_Z );
+ char GetBlock( int a_BlockIdx );
+ cBlockEntity* GetBlockEntity( int a_X, int a_Y, int a_Z );
+ void RemoveBlockEntity( cBlockEntity* a_BlockEntity );
+ void AddBlockEntity( cBlockEntity* a_BlockEntity );
+
+ char GetHeight( int a_X, int a_Z );
+
+ void SendBlockTo( int a_X, int a_Y, int a_Z, cClientHandle* a_Client );
+
+ void AddClient( cClientHandle* a_Client );
+ void RemoveClient( cClientHandle* a_Client );
+
+ std::list< cEntity* > & GetEntities();// { return m_Entities; }
+ void AddEntity( cEntity & a_Entity );
+ bool RemoveEntity( cEntity & a_Entity, cChunk* a_CalledFrom = 0 );
+ void LockEntities();
+ void UnlockEntities();
+
+ const std::list< cClientHandle* > & GetClients();// { return m_LoadedByClient; }
+
+ inline void RecalculateLighting() { m_bCalculateLighting = true; } // Recalculate lighting next tick
+ inline void RecalculateHeightmap() { m_bCalculateHeightmap = true; } // Recalculate heightmap next tick
+ void SpreadLight(char* a_LightBuffer);
+
+ bool SaveToDisk();
+ bool LoadFromDisk();
+
+ // Broadcasts to all clients that have loaded this chunk
+ void Broadcast( const cPacket & a_Packet, cClientHandle* a_Exclude = 0 ) const;
+
+ char* pGetBlockData() { return m_BlockData; }
+ char* pGetType() { return m_BlockType; }
+ char* pGetMeta() { return m_BlockMeta; }
+ char* pGetLight() { return m_BlockLight; }
+ char* pGetSkyLight() { return m_BlockSkyLight; }
+
+ char GetLight(char* a_Buffer, int a_BlockIdx);
+ char GetLight(char* a_Buffer, int x, int y, int z);
+ void SetLight(char* a_Buffer, int a_BlockIdx, char a_Light);
+ void SetLight(char* a_Buffer, int x, int y, int z, char light);
+
+ void AddTickBlockEntity( cFurnaceEntity* a_Entity );
+ //{
+ // m_TickBlockEntities.remove( a_Entity );
+ // m_TickBlockEntities.push_back( a_Entity );
+ //}
+
+ void RemoveTickBlockEntity( cFurnaceEntity* a_Entity );
+ //{
+ // m_TickBlockEntities.remove( a_Entity );
+ //}
+
+ static const int c_NumBlocks = 16*128*16;
+ static const int c_BlockDataSize = c_NumBlocks * 2 + (c_NumBlocks/2); // 2.5 * numblocks
+private:
+ struct sChunkState;
+ sChunkState* m_pState;
+
+ friend class cChunkMap; // So it has access to buffers and shit
+ void LoadFromJson( const Json::Value & a_Value );
+ void SaveToJson( Json::Value & a_Value );
+
+ void GenerateTerrain();
+ void CalculateLighting(); // Recalculate right now
+ void CalculateHeightmap();
+ void SpreadLightOfBlock(char* a_LightBuffer, int a_X, int a_Y, int a_Z, char a_Falloff);
+ void SpreadLightOfBlockX(char* a_LightBuffer, int a_X, int a_Y, int a_Z);
+ void SpreadLightOfBlockY(char* a_LightBuffer, int a_X, int a_Y, int a_Z);
+ void SpreadLightOfBlockZ(char* a_LightBuffer, int a_X, int a_Y, int a_Z);
+
+ void CreateBlockEntities();
+
+ unsigned int MakeIndex(int x, int y, int z );
+
+ bool m_bCalculateLighting;
+ bool m_bCalculateHeightmap;
+
+ int m_PosX, m_PosY, m_PosZ;
+
+ char m_BlockData[c_BlockDataSize]; // Chunk data ready to be compressed and sent
+ char *m_BlockType; // Pointers to an element in m_BlockData
+ char *m_BlockMeta; // += NumBlocks
+ char *m_BlockLight; // += NumBlocks/2
+ char *m_BlockSkyLight; // += NumBlocks/2
+
+ unsigned char m_HeightMap[16*16];
+
+ unsigned int m_BlockTickNum;
+ unsigned int m_BlockTickX, m_BlockTickY, m_BlockTickZ;
+
+ void* m_EntitiesCriticalSection;
+};
\ No newline at end of file diff --git a/source/cChunkLoader.cpp b/source/cChunkLoader.cpp new file mode 100644 index 000000000..a5d07818d --- /dev/null +++ b/source/cChunkLoader.cpp @@ -0,0 +1,364 @@ +#if 0 // ignore all contents of this file
+#include "cChunkLoader.h"
+#include "cChunk.h"
+#include "cMCLogger.h"
+#include "BlockID.h"
+#include "cCriticalSection.h"
+#include "cEvent.h"
+#include "cThread.h"
+#include "cSleep.h"
+
+#include "cChestEntity.h"
+#include "cFurnaceEntity.h"
+#include "cSignEntity.h"
+
+#include <iostream>
+#ifndef _WIN32
+#include <cstring>
+#include <cstdlib>
+#include <stdio.h>
+#include <sys/stat.h> // for mkdir
+#include <sys/types.h>
+#else
+#include <Windows.h>
+#endif
+
+#include <list>
+
+struct ChunkData
+{
+ ChunkData()
+ : x( 0 )
+ , z( 0 )
+ , Data( 0 )
+ , LiveChunk( 0 )
+ {}
+ int x, z;
+ unsigned int DataSize;
+ unsigned int ChunkStart;
+ char* Data;
+ cChunk* LiveChunk;
+};
+
+typedef std::list< ChunkData > ChunkDataList;
+struct cChunkLoader::ChunkPack
+{
+ ChunkDataList AllChunks;
+ int x, y, z;
+};
+
+typedef std::list< cChunkLoader::ChunkPack > ChunkPackList;
+struct cChunkLoader::ChunkPacks
+{
+ ChunkPackList AllPacks;
+};
+
+cChunkLoader::cChunkLoader()
+ : m_bStop( false )
+ , m_CriticalSection( new cCriticalSection() )
+ , m_Event( new cEvent() )
+ , m_ChunkPacks( new ChunkPacks )
+{
+ cThread( SaveThread, this );
+}
+
+cChunkLoader::~cChunkLoader()
+{
+ m_bStop = true;
+ m_Event->Wait();
+ delete m_CriticalSection;
+}
+
+void cChunkLoader::SaveThread( void* a_Param )
+{
+ cChunkLoader* self = (cChunkLoader*)a_Param;
+ while( !self->m_bStop )
+ {
+ cSleep::MilliSleep( 1000 ); // Only check for saving once a second
+ }
+ self->m_Event->Set();
+}
+
+cChunk* cChunkLoader::LoadChunk( int a_X, int a_Y, int a_Z )
+{
+ m_CriticalSection->Lock();
+ cChunk* Chunk = 0;
+
+ Chunk = LoadOldFormat( a_X, a_Y, a_Z );
+ if( Chunk ) { Chunk->CalculateHeightmap(); }
+ else
+ {
+ 1; // load new format()
+ }
+
+ m_CriticalSection->Unlock();
+ return Chunk;
+}
+
+bool cChunkLoader::SaveChunk( const cChunk & a_Chunk )
+{
+ m_CriticalSection->Lock();
+ bool Success = SaveOldFormat( a_Chunk );
+ m_CriticalSection->Unlock();
+
+ return Success;
+}
+
+/**************************************************
+ * Old format stuffs
+ **/
+
+cChunk* cChunkLoader::LoadOldFormat( int a_X, int a_Y, int a_Z )
+{
+ char SourceFile[128];
+ sprintf_s(SourceFile, 128, "world/X%i_Y%i_Z%i.bin", a_X, a_Y, a_Z );
+
+ FILE* f = 0;
+ #ifdef _WIN32
+ if( fopen_s(&f, SourceFile, "rb" ) == 0 ) // no error
+ #else
+ if( (f = fopen(SourceFile, "rb" )) != 0 ) // no error
+ #endif
+ {
+ cChunk* Chunk = new cChunk( a_X, a_Y, a_Z );
+ if( fread( Chunk->m_BlockData, sizeof(char)*cChunk::c_BlockDataSize, 1, f) != 1 ) { LOGERROR("ERROR READING FROM FILE %s", SourceFile); fclose(f); return false; }
+
+ // Now load Block Entities
+ ENUM_BLOCK_ID BlockType;
+ while( fread( &BlockType, sizeof(ENUM_BLOCK_ID), 1, f) == 1 )
+ {
+ switch( BlockType )
+ {
+ case E_BLOCK_CHEST:
+ {
+ cChestEntity* ChestEntity = new cChestEntity( 0, 0, 0 );
+ if( !ChestEntity->LoadFromFile( f ) )
+ {
+ LOGERROR("ERROR READING CHEST FROM FILE %s", SourceFile );
+ delete ChestEntity;
+ fclose(f);
+ return false;
+ }
+ Chunk->m_BlockEntities.push_back( ChestEntity );
+ }
+ break;
+ case E_BLOCK_FURNACE:
+ {
+ cFurnaceEntity* FurnaceEntity = new cFurnaceEntity( 0, 0, 0 );
+ if( !FurnaceEntity->LoadFromFile( f ) )
+ {
+ LOGERROR("ERROR READING FURNACE FROM FILE %s", SourceFile );
+ delete FurnaceEntity;
+ fclose(f);
+ return false;
+ }
+ Chunk->m_BlockEntities.push_back( FurnaceEntity );
+ Chunk->m_TickBlockEntities.push_back( FurnaceEntity ); // They need tickin'
+ }
+ break;
+ case E_BLOCK_SIGN_POST:
+ case E_BLOCK_WALLSIGN:
+ {
+ cSignEntity* SignEntity = new cSignEntity(BlockType, 0, 0, 0 );
+ if( !SignEntity->LoadFromFile( f ) )
+ {
+ LOGERROR("ERROR READING SIGN FROM FILE %s", SourceFile );
+ delete SignEntity;
+ fclose(f);
+ return false;
+ }
+ Chunk->m_BlockEntities.push_back( SignEntity );
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+ fclose(f);
+ return Chunk;
+ }
+ else
+ {
+ return 0;
+ }
+}
+
+bool cChunkLoader::SaveOldFormat( const cChunk & a_Chunk )
+{
+ char SourceFile[128];
+ sprintf_s(SourceFile, 128, "world/X%i_Y%i_Z%i.bin", a_Chunk.m_PosX, a_Chunk.m_PosY, a_Chunk.m_PosZ );
+
+ #ifdef _WIN32
+ {
+ SECURITY_ATTRIBUTES Attrib;
+ Attrib.nLength = sizeof(SECURITY_ATTRIBUTES);
+ Attrib.lpSecurityDescriptor = NULL;
+ Attrib.bInheritHandle = false;
+ ::CreateDirectory("world", &Attrib);
+ }
+ #else
+ {
+ mkdir("world", S_IRWXU | S_IRWXG | S_IRWXO);
+ }
+ #endif
+
+ FILE* f = 0;
+#ifdef _WIN32
+ if( fopen_s(&f, SourceFile, "wb" ) == 0 ) // no error
+ #else
+ if( (f = fopen(SourceFile, "wb" )) != 0 ) // no error
+ #endif
+ {
+ fwrite( a_Chunk.m_BlockData, sizeof(char)*cChunk::c_BlockDataSize, 1, f );
+
+ // Now write Block Entities
+ for( std::list<cBlockEntity*>::const_iterator itr = a_Chunk.m_BlockEntities.begin(); itr != a_Chunk.m_BlockEntities.end(); ++itr)
+ {
+ cBlockEntity* BlockEntity = *itr;
+ switch( BlockEntity->GetBlockType() )
+ {
+ case E_BLOCK_CHEST:
+ {
+ cChestEntity* ChestEntity = reinterpret_cast< cChestEntity* >( BlockEntity );
+ ChestEntity->WriteToFile( f );
+ }
+ break;
+ case E_BLOCK_FURNACE:
+ {
+ cFurnaceEntity* FurnaceEntity = reinterpret_cast< cFurnaceEntity* >( BlockEntity );
+ FurnaceEntity->WriteToFile( f );
+ }
+ break;
+ case E_BLOCK_SIGN_POST:
+ case E_BLOCK_WALLSIGN:
+ {
+ cSignEntity* SignEntity = reinterpret_cast< cSignEntity* >( BlockEntity );
+ SignEntity->WriteToFile( f );
+ }
+ break;
+ default:
+ break;
+ }
+ }
+
+ fclose(f);
+ return true;
+ }
+ else
+ {
+ LOGERROR("ERROR WRITING TO FILE %s", SourceFile);
+ return false;
+ }
+}
+
+
+/******************************************
+ * New format
+ **/
+
+cChunk* cChunkLoader::LoadFormat1( int a_X, int a_Y, int a_Z )
+{
+ int PakX = (int)(floorf((float)a_X / 16.f));
+ int PakY = (int)(floorf((float)a_Y / 16.f));
+ int PakZ = (int)(floorf((float)a_Z / 16.f));
+
+ ChunkPack * Pack = 0;
+ ChunkPackList & PackList = m_ChunkPacks->AllPacks;
+ for( ChunkPackList::iterator itr = PackList.begin(); itr != PackList.end(); ++itr )
+ {
+ if( itr->x == PakX && itr->y == PakY && itr->z == PakZ )
+ {
+ Pack = &(*itr);
+ break;
+ }
+ }
+
+
+ if( !Pack ) // The pack was not in memory, so try to load it from disk
+ {
+ Pack = LoadPak1( PakX, PakY, PakZ ); // Load .pak file from disk
+ if( Pack )
+ {
+ PackList.push_back( *Pack ); // Add it to the loaded list
+ }
+ }
+
+ if( Pack ) // Allright, the pack is in memory
+ {
+ ChunkData * Data = 0;
+ ChunkDataList & ChunkList = Pack->AllChunks;
+ for( ChunkDataList::iterator itr = ChunkList.begin(); itr != ChunkList.end(); ++itr )
+ {
+ if( itr->x == a_X && itr->z == a_Z )
+ {
+ Data = &(*itr);
+ break;
+ }
+ }
+
+ if( !Data ) // Sorry, chunk does not exist (yet)
+ return 0;
+
+ if( Data->LiveChunk ) // This chunk is already loaded and decoded (this should actually never happen)
+ return Data->LiveChunk;
+
+ // Decompress chunk, and return brand new chunk
+
+ // doing it...
+
+ return 0; // actually return the chunk
+ }
+
+ return 0; // .pak file didn't exist
+}
+
+cChunkLoader::ChunkPack* cChunkLoader::LoadPak1( int PakX, int PakY, int PakZ )
+{
+ char SourceFile[128];
+ sprintf_s(SourceFile, 128, "world/X%i_Y%i_Z%i.pak", PakX, PakY, PakZ );
+
+ FILE* f = 0;
+ #ifdef _WIN32
+ if( fopen_s(&f, SourceFile, "rb" ) == 0 ) // no error
+ #else
+ if( (f = fopen(SourceFile, "rb" )) != 0 ) // no error
+ #endif
+ {
+ cChunkLoader::ChunkPack * Pack = new cChunkLoader::ChunkPack;
+ Pack->x = PakX;
+ Pack->y = PakY;
+ Pack->z = PakZ;
+
+ short Version = 0;
+ if( fread( &Version, sizeof( short ), 1, f ) != 1 ) { LOGERROR("Error reading file %s", SourceFile ); return 0; }
+ if( Version != 1 ) { LOGERROR("Wrong pak version! %s", SourceFile ); return 0; }
+ short NumChunks = 0;
+ if( fread( &NumChunks, sizeof( short ), 1, f ) != 1 ) { LOGERROR("Error reading file %s", SourceFile ); return 0; }
+
+ // Load all the headers
+ for( short i = 0; i < NumChunks; ++i )
+ {
+ ChunkData Data;
+ if( fread( &Data.x, sizeof( int ), 1, f ) != 1 ) { LOGERROR("Error reading file %s", SourceFile ); return 0; }
+ if( fread( &Data.z, sizeof( int ), 1, f ) != 1 ) { LOGERROR("Error reading file %s", SourceFile ); return 0; }
+ if( fread( &Data.DataSize, sizeof( unsigned int ), 1, f ) != 1 ) { LOGERROR("Error reading file %s", SourceFile ); return 0; }
+ if( fread( &Data.ChunkStart, sizeof( unsigned int ), 1, f ) != 1 ) { LOGERROR("Error reading file %s", SourceFile ); return 0; }
+ Pack->AllChunks.push_back( Data );
+ }
+
+ // Load all compressed chunk data in the order the headers were loaded
+ ChunkDataList::iterator itr = Pack->AllChunks.begin();
+ for( short i = 0; i < NumChunks; ++i )
+ {
+ itr->Data = new char[ itr->DataSize ];
+ if( fread( itr->Data, sizeof( char ) * itr->DataSize, 1, f ) != 1 ) { LOGERROR("Error reading file %s", SourceFile ); return 0; }
+ ++itr;
+ }
+
+ // And we're done :)
+ return Pack;
+ }
+ return 0;
+}
+#endif
\ No newline at end of file diff --git a/source/cChunkLoader.h b/source/cChunkLoader.h new file mode 100644 index 000000000..5d9be39c5 --- /dev/null +++ b/source/cChunkLoader.h @@ -0,0 +1,32 @@ +#pragma once
+
+class cCriticalSection;
+class cEvent;
+class cChunk;
+class cChunkLoader
+{
+public:
+ cChunkLoader();
+ ~cChunkLoader();
+
+ cChunk* LoadChunk( int a_X, int a_Y, int a_Z );
+ bool SaveChunk( const cChunk & a_Chunk );
+
+ struct ChunkPack;
+private:
+ cChunk* LoadFormat1( int a_X, int a_Y, int a_Z );
+ ChunkPack* LoadPak1( int PakX, int PakY, int PakZ ); // This loads a .pak file from disk and returns it, nothing more
+
+ // Old stuffs
+ cChunk* LoadOldFormat( int a_X, int a_Y, int a_Z );
+ bool SaveOldFormat( const cChunk & a_Chunk );
+
+ static void SaveThread( void* a_Param );
+
+ bool m_bStop;
+ cCriticalSection* m_CriticalSection;
+ cEvent* m_Event;
+
+ struct ChunkPacks; // Defined in .cpp
+ ChunkPacks* m_ChunkPacks;
+};
\ No newline at end of file diff --git a/source/cChunkMap.cpp b/source/cChunkMap.cpp new file mode 100644 index 000000000..5e0e39a9c --- /dev/null +++ b/source/cChunkMap.cpp @@ -0,0 +1,714 @@ +#include "cChunkMap.h"
+#include "cChunk.h"
+#include "cMCLogger.h"
+#include "cWorld.h"
+#include "cRoot.h"
+#include "cMakeDir.h"
+#ifndef _WIN32
+#include <cstring> // memcpy
+#include <cstdlib> // abs
+#endif
+
+#include "zlib.h"
+#include <json/json.h>
+
+#define USE_MEMCPY
+
+#define LAYER_SIZE (32)
+
+cChunkMap::cChunkMap( int a_Width, int a_Height )
+ : m_Nodes( new cChunkNode[ a_Width * a_Height ] )
+ , m_Width( a_Width )
+ , m_Height( a_Height )
+ , m_Layers( 0 )
+ , m_NumLayers( 0 )
+{
+}
+
+cChunkMap::~cChunkMap()
+{
+ delete [] m_Nodes;
+}
+
+cChunkMap::cChunkNode::cChunkNode()
+{
+ m_Size = 0;
+ m_Allocated = 0;
+ m_Chunks = 0;
+}
+
+cChunkMap::cChunkNode::~cChunkNode()
+{
+ if( m_Allocated > 0 )
+ {
+ for( unsigned int i = 0; i < m_Size; ++i )
+ {
+ delete m_Chunks[i];
+ }
+ delete [] m_Chunks;
+ }
+// m_Chunks = 0;
+// m_Allocated = 0;
+// m_Size = 0;
+}
+
+void cChunkMap::cChunkNode::push_back( cChunk* a_Chunk )
+{
+ if( m_Allocated == 0 )
+ {
+ resize( 1 );
+ }
+ if( m_Size >= m_Allocated )
+ {
+ resize( m_Allocated*2 );
+ }
+
+ m_Chunks[ m_Size ] = a_Chunk;
+ m_Size++;
+}
+
+void cChunkMap::cChunkNode::resize( unsigned int a_NewSize )
+{
+ cChunk** TempChunks = new cChunk*[a_NewSize];
+ if( m_Allocated > 0 )
+ {
+#ifdef USE_MEMCPY
+ memcpy( TempChunks, m_Chunks, sizeof( cChunk* ) * m_Size );
+#else
+ for( unsigned int i = 0; i < a_NewSize; ++i )
+ TempChunks[i] = m_Chunks[i];
+#endif
+ delete [] m_Chunks;
+ }
+ m_Chunks = TempChunks;
+ m_Allocated = a_NewSize;
+}
+
+void cChunkMap::cChunkNode::erase( cChunk* a_Chunk )
+{
+ if( m_Size == 0 ) return;
+
+ cChunk** TempChunks = new cChunk*[m_Size];
+ unsigned int TempIdx = 0;
+ for( unsigned int i = 0; i < m_Size; ++i )
+ {
+ if( m_Chunks[i] != a_Chunk )
+ {
+ TempChunks[TempIdx] = m_Chunks[i];
+ TempIdx++;
+ }
+ }
+ delete [] m_Chunks;
+ m_Chunks = 0;
+ if( TempIdx > 0 )
+ {
+ m_Chunks = new cChunk*[ TempIdx ];
+#ifdef USE_MEMCPY
+ memcpy( m_Chunks, TempChunks, sizeof( cChunk* ) * TempIdx );
+#else
+ for( unsigned int i = 0; i < TempIdx; ++i )
+ m_Chunks[i] = TempChunks[i];
+#endif
+ }
+ delete [] TempChunks;
+ m_Allocated = TempIdx;
+ m_Size = TempIdx;
+}
+
+cChunkMap::cChunkData* cChunkMap::cChunkLayer::GetChunk( int a_X, int a_Z )
+{
+ const int LocalX = a_X - m_X * LAYER_SIZE;
+ const int LocalZ = a_Z - m_Z * LAYER_SIZE;
+ //LOG("LocalX:%i LocalZ:%i", LocalX, LocalZ );
+ if( LocalX < LAYER_SIZE && LocalZ < LAYER_SIZE && LocalX > -1 && LocalZ > -1 )
+ return &m_Chunks[ LocalX + LocalZ * LAYER_SIZE ];
+ return 0;
+}
+
+bool cChunkMap::RemoveLayer( cChunkLayer* a_Layer )
+{
+ cChunkLayer* NewLayers = 0;
+ if( m_NumLayers > 1 )
+ NewLayers = new cChunkLayer[m_NumLayers-1];
+
+ int idx = 0;
+ bool bExcludedLayer = false;
+ for( int i = 0; i < m_NumLayers; ++i )
+ {
+ if( &m_Layers[i] != a_Layer )
+ {
+ if( idx < m_NumLayers-1 )
+ {
+ NewLayers[ idx ] = m_Layers[i];
+ idx++;
+ }
+ }
+ else
+ bExcludedLayer = true;
+ }
+
+ if( !bExcludedLayer )
+ {
+ LOGWARN("Could not remove layer, because layer was not found %i %i", a_Layer->m_X, a_Layer->m_Z);
+ delete [] NewLayers;
+ return false;
+ }
+
+ if( m_Layers ) delete [] m_Layers;
+ m_Layers = NewLayers;
+ m_NumLayers--;
+ return true;
+}
+
+cChunkMap::cChunkLayer* cChunkMap::AddLayer( const cChunkLayer & a_Layer )
+{
+ cChunkLayer* TempLayers = new cChunkLayer[m_NumLayers+1];
+ if( m_NumLayers > 0 )
+ {
+ memcpy( TempLayers, m_Layers, sizeof( cChunkLayer ) * m_NumLayers );
+ delete [] m_Layers;
+ }
+ m_Layers = TempLayers;
+
+ m_Layers[m_NumLayers] = a_Layer;
+ cChunkLayer* NewLayer = &m_Layers[m_NumLayers];
+ m_NumLayers++;
+
+ return NewLayer;
+}
+
+void cChunkMap::AddChunk( cChunk* a_Chunk )
+{
+ /* // OLD
+ m_Nodes[ MakeHash( a_Chunk->GetPosX(), a_Chunk->GetPosZ() ) ].push_back( a_Chunk );
+ */
+
+ // NEW
+ const int LayerX = (int)(floorf((float)a_Chunk->GetPosX() / (float)(LAYER_SIZE)));
+ const int LayerZ = (int)(floorf((float)a_Chunk->GetPosZ() / (float)(LAYER_SIZE)));
+ cChunkLayer* FoundLayer = GetLayer( LayerX, LayerZ );
+ if( !FoundLayer )
+ {
+ cChunkLayer NewLayer( LAYER_SIZE*LAYER_SIZE );
+ NewLayer.m_X = LayerX;
+ NewLayer.m_Z = LayerZ;
+ FoundLayer = AddLayer( NewLayer );
+ LOGWARN("Created new layer %i %i (total layers %i)", LayerX, LayerZ, m_NumLayers );
+ }
+
+ //Get local coordinates in layer
+ const int LocalX = a_Chunk->GetPosX() - LayerX * LAYER_SIZE;
+ const int LocalZ = a_Chunk->GetPosZ() - LayerZ * LAYER_SIZE;
+ if( FoundLayer->m_Chunks[ LocalX + LocalZ * LAYER_SIZE ].m_LiveChunk )
+ LOGWARN("WARNING: Added chunk to layer while it was already loaded!");
+ FoundLayer->m_Chunks[ LocalX + LocalZ * LAYER_SIZE ].m_LiveChunk = a_Chunk;
+ FoundLayer->m_NumChunksLoaded++;
+}
+
+void cChunkMap::RemoveChunk( cChunk* a_Chunk )
+{
+ /* // OLD
+ m_Nodes[ MakeHash( a_Chunk->GetPosX(), a_Chunk->GetPosZ() ) ].erase( a_Chunk );
+ */
+
+ // NEW
+ cChunkLayer* Layer = GetLayerForChunk( a_Chunk->GetPosX(), a_Chunk->GetPosZ() );
+ if( Layer )
+ {
+ cChunkData* Data = Layer->GetChunk( a_Chunk->GetPosX(), a_Chunk->GetPosZ() );
+ if( Data->m_LiveChunk )
+ {
+ CompressChunk( Data );
+ Data->m_LiveChunk = 0; // Set live chunk to 0
+ }
+ Layer->m_NumChunksLoaded--;
+ }
+}
+
+void cChunkMap::CompressChunk( cChunkData* a_ChunkData )
+{
+ if( a_ChunkData->m_LiveChunk )
+ {
+ // Delete already present compressed data
+ if( a_ChunkData->m_Compressed ) delete [] a_ChunkData->m_Compressed;
+
+ // Get Json data
+ Json::Value root;
+ std::string JsonData = "";
+ a_ChunkData->m_LiveChunk->SaveToJson( root );
+ if( !root.empty() )
+ {
+ Json::StyledWriter writer; // TODO FIXME: change to FastWriter ? :D
+ JsonData = writer.write( root );
+ }
+
+ unsigned int TotalSize = cChunk::c_BlockDataSize + JsonData.size();
+ uLongf CompressedSize = compressBound( TotalSize );
+ a_ChunkData->m_Compressed = new char[CompressedSize];
+ char* DataSource = a_ChunkData->m_LiveChunk->pGetBlockData();
+ if( JsonData.size() > 0 )
+ {
+ // Move stuff around, so data is aligned in memory
+ DataSource = new char[TotalSize];
+ memcpy( DataSource, a_ChunkData->m_LiveChunk->pGetBlockData(), cChunk::c_BlockDataSize );
+ memcpy( DataSource + cChunk::c_BlockDataSize, JsonData.c_str(), JsonData.size() );
+ }
+
+ int errorcode = compress2( (Bytef*)a_ChunkData->m_Compressed, &CompressedSize, (const Bytef*)DataSource, TotalSize, Z_DEFAULT_COMPRESSION);
+ if( errorcode != Z_OK )
+ {
+ LOGERROR("Error compressing data (%i)", errorcode );
+ }
+
+ a_ChunkData->m_CompressedSize = CompressedSize;
+ a_ChunkData->m_UncompressedSize = TotalSize;
+
+ if( DataSource != a_ChunkData->m_LiveChunk->pGetBlockData() )
+ delete [] DataSource;
+ }
+}
+
+unsigned int cChunkMap::MakeHash( int a_X, int a_Z )
+{
+ const unsigned int HashX = abs( a_X ) % m_Width;
+ const unsigned int HashZ = abs( a_Z ) % m_Height;
+ return HashX + HashZ * m_Width;
+}
+
+cChunkMap::cChunkLayer* cChunkMap::GetLayerForChunk( int a_ChunkX, int a_ChunkZ )
+{
+ const int LayerX = (int)(floorf((float)a_ChunkX / (float)(LAYER_SIZE)));
+ const int LayerZ = (int)(floorf((float)a_ChunkZ / (float)(LAYER_SIZE)));
+ return GetLayer( LayerX, LayerZ );
+}
+
+cChunkMap::cChunkLayer* cChunkMap::GetLayer( int a_LayerX, int a_LayerZ )
+{
+ // Find layer in memory
+ for( int i = 0; i < m_NumLayers; ++i )
+ {
+ if( m_Layers[i].m_X == a_LayerX && m_Layers[i].m_Z == a_LayerZ )
+ {
+ return &m_Layers[i];
+ }
+ }
+
+ // Find layer on disk
+ cChunkLayer* Layer = LoadLayer( a_LayerX, a_LayerZ );
+ if( !Layer ) return 0;
+
+ cChunkLayer* NewLayer = AddLayer( *Layer );
+ delete Layer;
+ return NewLayer;
+}
+
+cChunk* cChunkMap::GetChunk( int a_X, int a_Y, int a_Z )
+{
+ /* // OLD
+ unsigned int Hash = MakeHash( a_X, a_Z );
+ cChunkNode & Node = m_Nodes[ Hash ];
+ cChunk** Chunks = Node.GetChunks();
+ for( unsigned int i = 0; i < Node.size(); ++i )
+ {
+ if( Chunks[i]->GetPosX() == a_X && // Check if we found the right chunk
+ Chunks[i]->GetPosY() == a_Y &&
+ Chunks[i]->GetPosZ() == a_Z )
+ {
+ return Chunks[i];
+ }
+ }
+ */
+
+ // NEW
+ cChunkLayer* Layer = GetLayerForChunk( a_X, a_Z );
+ if( Layer )
+ {
+ cChunkData* Data = Layer->GetChunk( a_X, a_Z );
+ if( Data->m_LiveChunk ) return Data->m_LiveChunk;
+
+ // Decompress cached chunk
+ if( Data->m_Compressed )
+ {
+ uLongf DestSize = Data->m_UncompressedSize;
+ char* BlockData = new char[ DestSize ];
+ int errorcode = uncompress( (Bytef*)BlockData, &DestSize, (Bytef*)Data->m_Compressed, Data->m_CompressedSize );
+ if( Data->m_UncompressedSize != DestSize )
+ {
+ LOGWARN("Lulwtf, expected uncompressed size differs!");
+ delete [] BlockData;
+ }
+ else if( errorcode != Z_OK )
+ {
+ LOGERROR("ERROR: Decompressing chunk data! %i", errorcode );
+ switch( errorcode )
+ {
+ case Z_MEM_ERROR:
+ LOGERROR("Not enough memory");
+ break;
+ case Z_BUF_ERROR:
+ LOGERROR("Not enough room in output buffer");
+ break;
+ case Z_DATA_ERROR:
+ LOGERROR("Input data corrupted or incomplete");
+ break;
+ default:
+ break;
+ };
+
+ delete [] BlockData;
+ }
+ else
+ {
+ cChunk* Chunk = new cChunk(a_X, a_Y, a_Z);
+ memcpy( Chunk->m_BlockData, BlockData, cChunk::c_BlockDataSize );
+ Chunk->CalculateHeightmap();
+ Data->m_LiveChunk = Chunk;
+ Layer->m_NumChunksLoaded++;
+
+ if( DestSize > cChunk::c_BlockDataSize ) // We gots some extra data :D
+ {
+ LOGINFO("Parsing trailing JSON");
+ Json::Value root; // will contains the root value after parsing.
+ Json::Reader reader;
+ if( !reader.parse( BlockData + cChunk::c_BlockDataSize, root, false ) )
+ {
+ LOGERROR("Failed to parse trailing JSON!");
+ }
+ else
+ {
+ //Json::StyledWriter writer;
+ //LOGINFO("Trailing Json:" );
+ //printf("%s", writer.write( root ).c_str() );
+ Chunk->LoadFromJson( root );
+ }
+ }
+
+ delete [] BlockData;
+ delete [] Data->m_Compressed; Data->m_Compressed = 0; Data->m_CompressedSize = 0;
+ return Chunk;
+ }
+
+
+ }
+ }
+
+ return 0;
+}
+
+void cChunkMap::Tick( float a_Dt )
+{
+ /* // OLD
+ for( int i = 0; i < m_Width*m_Height; ++i )
+ {
+ cChunkNode & Node = m_Nodes[ i ];
+ cChunk** Chunks = Node.GetChunks();
+ for( unsigned int i = 0; i < Node.size(); ++i )
+ {
+ Chunks[i]->Tick( a_Dt );
+ }
+ }
+ */
+
+ // NEW
+ for( int l = 0; l < m_NumLayers; ++l )
+ {
+ for( int i = 0; i < LAYER_SIZE*LAYER_SIZE; ++i )
+ {
+ cChunk* Chunk = m_Layers[l].m_Chunks[i].m_LiveChunk;
+ if( Chunk )
+ Chunk->Tick( a_Dt );
+ }
+ }
+}
+
+void cChunkMap::UnloadUnusedChunks()
+{
+ cWorld* World = cRoot::Get()->GetWorld();
+ /* // OLD
+ for( int i = 0; i < m_Width*m_Height; ++i )
+ {
+ cChunkNode & Node = m_Nodes[ i ];
+ cChunk** Chunks = Node.GetChunks();
+ for( unsigned int i = 0; i < Node.size(); ++i )
+ {
+ if( Chunks[i]->GetClients().size() == 0 )
+ {
+ Chunks[i]->SaveToDisk();
+ LOG("Unloading %p", Chunks[i] );
+ World->RemoveSpread( Chunks[i] );
+ cChunk* TheChunk = Chunks[i];
+ RemoveChunk( TheChunk );
+ delete TheChunk;
+ //Node.erase( Chunks[i] );
+ Chunks = Node.GetChunks(); // Chunks pointer is no longer valid, get a new one
+ }
+ }
+ }
+ */
+
+ // NEW
+ for( int l = 0; l < m_NumLayers; ++l )
+ {
+ cChunkLayer & Layer = m_Layers[l];
+ for( int i = 0; i < LAYER_SIZE*LAYER_SIZE; ++i )
+ {
+ cChunk* Chunk = Layer.m_Chunks[i].m_LiveChunk;
+ if( Chunk && Chunk->GetClients().size() == 0 )
+ {
+ Chunk->SaveToDisk();
+ World->RemoveSpread( Chunk );
+ RemoveChunk( Chunk );
+ delete Chunk;
+ }
+ }
+
+ // Unload layers
+ if( Layer.m_NumChunksLoaded == 0 )
+ {
+ SaveLayer( &Layer );
+ for( int i = 0; i < LAYER_SIZE*LAYER_SIZE; ++i ) // Free all chunk data for layer
+ {
+ if( Layer.m_Chunks[i].m_Compressed )
+ delete [] Layer.m_Chunks[i].m_Compressed;
+ if( Layer.m_Chunks[i].m_LiveChunk )
+ delete Layer.m_Chunks[i].m_LiveChunk;
+ }
+ if( RemoveLayer( &Layer ) ) l--;
+ }
+ else if( Layer.m_NumChunksLoaded < 0 )
+ {
+ LOGERROR("WTF! Chunks loaded in layer is %i !!", Layer.m_NumChunksLoaded );
+ }
+ }
+}
+
+bool cChunkMap::RemoveEntityFromChunk( cEntity & a_Entity, cChunk* a_CalledFrom /* = 0 */ )
+{
+ /* // OLD
+ for( int i = 0; i < m_Width*m_Height; ++i )
+ {
+ cChunkNode & Node = m_Nodes[ i ];
+ cChunk** Chunks = Node.GetChunks();
+ for( unsigned int i = 0; i < Node.size(); ++i )
+ {
+ if( Chunks[i] != a_CalledFrom )
+ {
+ if( Chunks[i]->RemoveEntity( a_Entity, a_CalledFrom ) )
+ return true;
+ }
+ }
+ }
+ */
+
+ // NEW
+ for( int i = 0; i < m_NumLayers; ++i )
+ {
+ cChunkLayer & Layer = m_Layers[i];
+ for( int i = 0; i < LAYER_SIZE*LAYER_SIZE; ++i )
+ {
+ cChunk* Chunk = Layer.m_Chunks[i].m_LiveChunk;
+ if( Chunk != a_CalledFrom )
+ {
+ if( Chunk && Chunk->RemoveEntity( a_Entity, a_CalledFrom ) )
+ return true;
+ }
+ }
+ }
+
+ LOG("WARNING: Entity was not found in any chunk!");
+ return false;
+}
+
+void cChunkMap::SaveAllChunks()
+{
+ for( int i = 0; i < m_Width*m_Height; ++i )
+ {
+ cChunkNode & Node = m_Nodes[ i ];
+ cChunk** Chunks = Node.GetChunks();
+ for( unsigned int i = 0; i < Node.size(); ++i )
+ {
+ Chunks[i]->SaveToDisk();
+ }
+ }
+
+ for( int i = 0; i < m_NumLayers; ++i )
+ {
+ SaveLayer( &m_Layers[i] );
+ }
+}
+
+
+
+/********************************
+ * Saving and loading
+ **/
+
+void cChunkMap::SaveLayer( cChunkLayer* a_Layer )
+{
+ cMakeDir::MakeDir("world");
+
+ char SourceFile[128];
+
+ #ifdef _WIN32
+ sprintf_s(SourceFile, 128, "world/X%i_Z%i.pak", a_Layer->m_X, a_Layer->m_Z );
+ #else
+ sprintf(SourceFile, "world/X%i_Z%i.pak", a_Layer->m_X, a_Layer->m_Z );
+ #endif
+
+
+ FILE* f = 0;
+ #ifdef _WIN32
+ if( fopen_s(&f, SourceFile, "wb" ) == 0 ) // no error
+ #else
+ if( (f = fopen(SourceFile, "wb" )) != 0 ) // no error
+ #endif
+ {
+ //---------------
+ // Header
+ char PakVersion = 1;
+ char ChunkVersion = 1;
+ fwrite( &PakVersion, sizeof(PakVersion), 1, f ); // pak version
+ fwrite( &ChunkVersion, sizeof(ChunkVersion), 1, f ); // chunk version
+
+ // Count number of chunks in layer
+ short NumChunks = 0;
+ for( int i = 0; i < LAYER_SIZE*LAYER_SIZE; ++i )
+ {
+ if( a_Layer->m_Chunks[i].m_Compressed || a_Layer->m_Chunks[i].m_LiveChunk )
+ NumChunks++;
+ }
+
+ fwrite( &NumChunks, sizeof( NumChunks ), 1, f );
+ LOG("Num Chunks in layer: %i", NumChunks );
+
+ //---------------
+ // Chunk headers
+ for( int z = 0; z < LAYER_SIZE; ++z )
+ {
+ for( int x = 0; x < LAYER_SIZE; ++x )
+ {
+ cChunkData & Data = a_Layer->m_Chunks[x + z*LAYER_SIZE];
+ CompressChunk( &Data );
+ if( Data.m_Compressed || Data.m_LiveChunk )
+ {
+ int ChunkX = a_Layer->m_X*LAYER_SIZE + x;
+ int ChunkZ = a_Layer->m_Z*LAYER_SIZE + z;
+ unsigned int Size = Data.m_CompressedSize; // Needs to be size of compressed data
+ unsigned int USize = Data.m_UncompressedSize; // Uncompressed size
+ fwrite( &ChunkX, sizeof( ChunkX ), 1, f );
+ fwrite( &ChunkZ, sizeof( ChunkZ ), 1, f );
+ fwrite( &Size, sizeof( Size ), 1, f );
+ fwrite( &USize, sizeof( USize ), 1, f );
+ }
+ }
+ }
+
+ //----------------
+ // Chunk data
+ for( int i = 0; i < LAYER_SIZE*LAYER_SIZE; ++i )
+ {
+ char* Compressed = a_Layer->m_Chunks[i].m_Compressed;
+ if( Compressed )
+ {
+ fwrite( Compressed, a_Layer->m_Chunks[i].m_CompressedSize, 1, f );
+ if(a_Layer->m_Chunks[i].m_LiveChunk) // If there's a live chunk we have no need for compressed data
+ {
+ delete [] a_Layer->m_Chunks[i].m_Compressed;
+ a_Layer->m_Chunks[i].m_Compressed = 0;
+ a_Layer->m_Chunks[i].m_CompressedSize = 0;
+ }
+ }
+ }
+
+
+ fclose(f);
+ }
+ else
+ {
+ LOGERROR("ERROR: Could not write to file %s", SourceFile );
+ }
+}
+
+cChunkMap::cChunkLayer* cChunkMap::LoadLayer(int a_LayerX, int a_LayerZ )
+{
+ char SourceFile[128];
+
+ #ifdef _WIN32
+ sprintf_s(SourceFile, 128, "world/X%i_Z%i.pak", a_LayerX, a_LayerZ );
+ #else
+ sprintf(SourceFile, "world/X%i_Z%i.pak", a_LayerX, a_LayerZ );
+ #endif
+
+ FILE* f = 0;
+ #ifdef _WIN32
+ if( fopen_s(&f, SourceFile, "rb" ) == 0 ) // no error
+ #else
+ if( (f = fopen(SourceFile, "rb" )) != 0 ) // no error
+ #endif
+ {
+ char PakVersion = 0;
+ char ChunkVersion = 0;
+ if( fread( &PakVersion, sizeof(PakVersion), 1, f) != 1 ) { LOGERROR("ERROR READING FROM FILE %s", SourceFile); fclose(f); return false; }
+ if( PakVersion != 1 ) { LOGERROR("WRONG PAK VERSION!"); fclose(f); return 0; }
+ if( fread( &ChunkVersion, sizeof(ChunkVersion), 1, f) != 1 ) { LOGERROR("ERROR READING FROM FILE %s", SourceFile); fclose(f); return false; }
+ if( PakVersion != 1 ) { LOGERROR("WRONG CHUNK VERSION!"); fclose(f); return 0; }
+
+ short NumChunks = 0;
+ if( fread( &NumChunks, sizeof(NumChunks), 1, f) != 1 ) { LOGERROR("ERROR READING FROM FILE %s", SourceFile); fclose(f); return false; }
+ LOG("Num chunks: %i", NumChunks );
+
+ cChunkLayer* Layer = new cChunkLayer( LAYER_SIZE*LAYER_SIZE );
+ Layer->m_X = a_LayerX;
+ Layer->m_Z = a_LayerZ;
+ cChunkData** OrderedData = new cChunkData*[ NumChunks ]; // So we can loop over the chunks in the order they were loaded
+ // Loop over all chunk headers
+ for( short i = 0; i < NumChunks; ++i )
+ {
+ int ChunkX = 0;
+ int ChunkZ = 0;
+ if( fread( &ChunkX, sizeof(ChunkX), 1, f) != 1 ) { LOGERROR("ERROR READING FROM FILE %s", SourceFile); fclose(f); return false; }
+ if( fread( &ChunkZ, sizeof(ChunkZ), 1, f) != 1 ) { LOGERROR("ERROR READING FROM FILE %s", SourceFile); fclose(f); return false; }
+ cChunkData* Data = Layer->GetChunk( ChunkX, ChunkZ );
+ if( Data )
+ {
+ if( fread( &Data->m_CompressedSize, sizeof(Data->m_CompressedSize), 1, f) != 1 ) { LOGERROR("ERROR READING FROM FILE %s", SourceFile); fclose(f); return false; }
+ if( fread( &Data->m_UncompressedSize, sizeof(Data->m_UncompressedSize), 1, f) != 1 ) { LOGERROR("ERROR READING FROM FILE %s", SourceFile); fclose(f); return false; }
+ }
+ else
+ {
+ LOGERROR("Chunk with wrong coordinates in pak file! %i %i", ChunkX, ChunkZ );
+ fclose(f);
+ return 0;
+ }
+
+ OrderedData[i] = Data;
+ }
+
+ // Loop over chunks again, in the order they were loaded, and load their compressed data
+ for( short i = 0; i < NumChunks; ++i )
+ {
+ cChunkData* Data = OrderedData[i];
+ Data->m_Compressed = new char[ Data->m_CompressedSize ];
+ if( fread( Data->m_Compressed, Data->m_CompressedSize, 1, f) != 1 ) { LOGERROR("ERROR READING FROM FILE %s", SourceFile); fclose(f); return false; }
+
+ /* // Some testing...
+ uLongf DestSize = Data->m_UncompressedSize;
+ char* BlockData = new char[ DestSize ];
+ int errorcode = uncompress( (Bytef*)BlockData, &DestSize, (Bytef*)Data->m_Compressed, Data->m_CompressedSize );
+ if( errorcode != Z_OK )
+ {
+ LOGERROR("lulwut");
+ }
+ */
+ }
+ delete [] OrderedData;
+
+ fclose(f);
+ return Layer;
+ }
+ else
+ {
+ //LOGWARN("Could not open file %s", SourceFile );
+ }
+ return 0;
+}
\ No newline at end of file diff --git a/source/cChunkMap.h b/source/cChunkMap.h new file mode 100644 index 000000000..57ad313dc --- /dev/null +++ b/source/cChunkMap.h @@ -0,0 +1,91 @@ +#pragma once
+
+class cEntity;
+class cChunk;
+class cChunkMap
+{
+public:
+ cChunkMap( int a_Width, int a_Height );
+ ~cChunkMap();
+
+ void AddChunk( cChunk* a_Chunk );
+ unsigned int MakeHash( int a_X, int a_Z );
+
+ cChunk* GetChunk( int a_X, int a_Y, int a_Z );
+ void RemoveChunk( cChunk* a_Chunk );
+
+ void Tick( float a_Dt );
+
+ void UnloadUnusedChunks();
+ bool RemoveEntityFromChunk( cEntity & a_Entity, cChunk* a_CalledFrom = 0 );
+ void SaveAllChunks();
+private:
+ class cChunkData
+ {
+ public:
+ cChunkData()
+ : m_Compressed( 0 )
+ , m_LiveChunk( 0 )
+ , m_CompressedSize( 0 )
+ , m_UncompressedSize( 0 )
+ {}
+ char* m_Compressed;
+ unsigned int m_CompressedSize;
+ unsigned int m_UncompressedSize;
+ cChunk* m_LiveChunk;
+ };
+
+ class cChunkLayer
+ {
+ public:
+ cChunkLayer()
+ : m_Chunks( 0 )
+ , m_X( 0 )
+ , m_Z( 0 )
+ , m_NumChunksLoaded( 0 )
+ {}
+ cChunkLayer( int a_NumChunks )
+ : m_Chunks( new cChunkData[a_NumChunks] )
+ , m_X( 0 )
+ , m_Z( 0 )
+ , m_NumChunksLoaded( 0 )
+ {}
+ cChunkData* GetChunk( int a_X, int a_Z );
+ cChunkData* m_Chunks;
+ int m_X, m_Z;
+ int m_NumChunksLoaded;
+ };
+
+ void SaveLayer( cChunkLayer* a_Layer );
+ cChunkLayer* LoadLayer( int a_LayerX, int a_LayerZ );
+ cChunkLayer* GetLayerForChunk( int a_ChunkX, int a_ChunkZ );
+ cChunkLayer* GetLayer( int a_LayerX, int a_LayerZ );
+ cChunkLayer* AddLayer( const cChunkLayer & a_Layer );
+ bool RemoveLayer( cChunkLayer* a_Layer );
+ void CompressChunk( cChunkData* a_ChunkData );
+
+ int m_NumLayers;
+ cChunkLayer* m_Layers;
+
+ class cChunkNode
+ {
+ public:
+ cChunkNode();
+ ~cChunkNode();
+ void push_back( cChunk* a_Chunk );
+ unsigned int size() { return m_Size; }
+ unsigned int allocated() { return m_Allocated; }
+ void resize( unsigned int a_NewSize );
+
+ void erase( cChunk* a_Chunk );
+
+ cChunk** GetChunks() { return m_Chunks; }
+ private:
+ unsigned int m_Size;
+ unsigned int m_Allocated;
+ cChunk** m_Chunks;
+ };
+
+ cChunkNode* m_Nodes;
+ int m_Width, m_Height;
+};
\ No newline at end of file diff --git a/source/cClientHandle.cpp b/source/cClientHandle.cpp new file mode 100644 index 000000000..f274795c1 --- /dev/null +++ b/source/cClientHandle.cpp @@ -0,0 +1,1082 @@ +#ifndef _WIN32
+#include <cstring>
+#include <semaphore.h>
+#include <errno.h>
+#endif
+
+#include "cClientHandle.h"
+#include "cServer.h"
+#include "cWorld.h"
+#include "cChunk.h"
+#include "cPickup.h"
+#include "cPluginManager.h"
+#include "cPlayer.h"
+#include "cInventory.h"
+#include "cChestEntity.h"
+#include "cSignEntity.h"
+#include "cMCLogger.h"
+#include "cWindow.h"
+#include "cCraftingWindow.h"
+#include "cItem.h"
+#include "cTorch.h"
+#include "cStairs.h"
+#include "cLadder.h"
+#include "cSign.h"
+#include "cBlockToPickup.h"
+#include "cMonster.h"
+#include "cChatColor.h"
+#include "cThread.h"
+#include "cSocket.h"
+
+#include "cTracer.h"
+#include "Vector3f.h"
+#include "Vector3d.h"
+
+#include "cCriticalSection.h"
+#include "cSemaphore.h"
+#include "cEvent.h"
+#include "cSleep.h"
+#include "cRoot.h"
+
+#include "cBlockingTCPLink.h"
+#include "cAuthenticator.h"
+
+#include "packets/cPacket_KeepAlive.h"
+#include "packets/cPacket_PlayerPosition.h"
+#include "packets/cPacket_Respawn.h"
+#include "packets/cPacket_UpdateHealth.h"
+#include "packets/cPacket_RelativeEntityMoveLook.h"
+#include "packets/cPacket_Chat.h"
+#include "packets/cPacket_Login.h"
+#include "packets/cPacket_WindowClick.h"
+#include "packets/cPacket_PlayerMoveLook.h"
+#include "packets/cPacket_TimeUpdate.h"
+#include "packets/cPacket_BlockDig.h"
+#include "packets/cPacket_Handshake.h"
+#include "packets/cPacket_PlayerLook.h"
+#include "packets/cPacket_ArmAnim.h"
+#include "packets/cPacket_BlockPlace.h"
+#include "packets/cPacket_Flying.h"
+#include "packets/cPacket_Disconnect.h"
+#include "packets/cPacket_PickupSpawn.h"
+#include "packets/cPacket_ItemSwitch.h"
+#include "packets/cPacket_EntityEquipment.h"
+#include "packets/cPacket_UseEntity.h"
+#include "packets/cPacket_WindowClose.h"
+#include "packets/cPacket_13.h"
+#include "packets/cPacket_UpdateSign.h"
+#include "packets/cPacket_Ping.h"
+
+
+#define MAX_SEMAPHORES (2000)
+
+typedef std::list<cPacket*> PacketList;
+
+struct cClientHandle::sClientHandleState
+{
+ sClientHandleState()
+ : ProtocolVersion( 0 )
+ , pReceiveThread( 0 )
+ , pSendThread( 0 )
+ , pAuthenticateThread( 0 )
+ , pSemaphore( 0 )
+ {
+ for( int i = 0; i < 256; ++i )
+ PacketMap[i] = 0;
+ }
+ int ProtocolVersion;
+ std::string Username;
+ std::string Password;
+
+ PacketList PendingParsePackets;
+ PacketList PendingNrmSendPackets;
+ PacketList PendingLowSendPackets;
+
+ cThread* pReceiveThread;
+ cThread* pSendThread;
+ cThread* pAuthenticateThread;
+
+ cSocket Socket;
+
+ cCriticalSection CriticalSection;
+ cCriticalSection SendCriticalSection;
+ cCriticalSection SocketCriticalSection;
+ cSemaphore* pSemaphore;
+
+ cPacket* PacketMap[256];
+};
+
+cClientHandle::cClientHandle(const cSocket & a_Socket)
+ : m_bDestroyed( false )
+ , m_Player( 0 )
+ , m_bKicking( false )
+ , m_TimeLastPacket( cWorld::GetTime() )
+ , m_bLoggedIn( false )
+ , m_bKeepThreadGoing( true )
+ , m_pState( new sClientHandleState )
+{
+ LOG("cClientHandle::cClientHandle");
+
+ m_pState->Socket = a_Socket;
+
+ m_pState->pSemaphore = new cSemaphore( MAX_SEMAPHORES, 0 );
+
+ // All the packets that can be received from the client
+ m_pState->PacketMap[E_KEEP_ALIVE] = new cPacket_KeepAlive;
+ m_pState->PacketMap[E_HANDSHAKE] = new cPacket_Handshake;
+ m_pState->PacketMap[E_LOGIN] = new cPacket_Login;
+ m_pState->PacketMap[E_PLAYERPOS] = new cPacket_PlayerPosition;
+ m_pState->PacketMap[E_PLAYERLOOK] = new cPacket_PlayerLook;
+ m_pState->PacketMap[E_PLAYERMOVELOOK] = new cPacket_PlayerMoveLook;
+ m_pState->PacketMap[E_CHAT] = new cPacket_Chat;
+ m_pState->PacketMap[E_ANIMATION] = new cPacket_ArmAnim;
+ m_pState->PacketMap[E_FLYING] = new cPacket_Flying;
+ m_pState->PacketMap[E_BLOCK_DIG] = new cPacket_BlockDig;
+ m_pState->PacketMap[E_BLOCK_PLACE] = new cPacket_BlockPlace;
+ m_pState->PacketMap[E_DISCONNECT] = new cPacket_Disconnect;
+ m_pState->PacketMap[E_ITEM_SWITCH] = new cPacket_ItemSwitch;
+ m_pState->PacketMap[E_ENTITY_EQUIPMENT] = new cPacket_EntityEquipment;
+ m_pState->PacketMap[E_PICKUP_SPAWN] = new cPacket_PickupSpawn;
+ m_pState->PacketMap[E_USE_ENTITY] = new cPacket_UseEntity;
+ m_pState->PacketMap[E_WINDOW_CLOSE] = new cPacket_WindowClose;
+ m_pState->PacketMap[E_WINDOW_CLICK] = new cPacket_WindowClick;
+ m_pState->PacketMap[E_PACKET_13] = new cPacket_13;
+ m_pState->PacketMap[E_UPDATE_SIGN] = new cPacket_UpdateSign;
+ m_pState->PacketMap[E_RESPAWN] = new cPacket_Respawn;
+ m_pState->PacketMap[E_PING] = new cPacket_Ping;
+
+ memset( m_LoadedChunks, 0x00, sizeof(cChunk*)*VIEWDISTANCE*VIEWDISTANCE );
+
+ //////////////////////////////////////////////////////////////////////////
+ m_pState->pReceiveThread = new cThread( ReceiveThread, this );
+ m_pState->pSendThread = new cThread( SendThread, this );
+ m_pState->pReceiveThread->Start( true );
+ m_pState->pSendThread->Start( true );
+ //////////////////////////////////////////////////////////////////////////
+
+ LOG("New ClientHandle" );
+}
+
+cClientHandle::~cClientHandle()
+{
+ LOG("Deleting client %s", GetUsername() );
+
+ for(unsigned int i = 0; i < VIEWDISTANCE*VIEWDISTANCE; i++)
+ {
+ if( m_LoadedChunks[i] ) m_LoadedChunks[i]->RemoveClient( this );
+ }
+
+ // First stop sending thread
+ m_bKeepThreadGoing = false;
+
+ m_pState->SocketCriticalSection.Lock();
+ if( m_pState->Socket )
+ {
+ cPacket_Disconnect Disconnect;
+ Disconnect.m_Reason = "Server shut down? Kthnxbai";
+ Disconnect.Send( m_pState->Socket );
+
+ closesocket( m_pState->Socket );
+ m_pState->Socket = 0;
+ }
+ m_pState->SocketCriticalSection.Unlock();
+
+ m_pState->pSemaphore->Signal();
+ delete m_pState->pAuthenticateThread;
+ delete m_pState->pReceiveThread;
+ delete m_pState->pSendThread;
+ delete m_pState->pSemaphore;
+
+ while( !m_pState->PendingParsePackets.empty() )
+ {
+ delete *m_pState->PendingParsePackets.begin();
+ m_pState->PendingParsePackets.erase( m_pState->PendingParsePackets.begin() );
+ }
+ while( !m_pState->PendingNrmSendPackets.empty() )
+ {
+ delete *m_pState->PendingNrmSendPackets.begin();
+ m_pState->PendingNrmSendPackets.erase( m_pState->PendingNrmSendPackets.begin() );
+ }
+ if(m_Player)
+ {
+ m_Player->SetClientHandle( 0 );
+ m_Player->Destroy();
+ m_Player = 0;
+ }
+ for(int i = 0; i < 256; i++)
+ {
+ if( m_pState->PacketMap[i] )
+ delete m_pState->PacketMap[i];
+ }
+
+ delete m_pState;
+}
+
+void cClientHandle::Destroy()
+{
+ m_bDestroyed = true;
+ m_pState->SocketCriticalSection.Lock();
+ if( m_pState->Socket )
+ {
+ closesocket( m_pState->Socket );
+ m_pState->Socket = 0;
+ }
+ m_pState->SocketCriticalSection.Unlock();
+}
+
+void cClientHandle::Kick( const char* a_Reason )
+{
+ Send( cPacket_Disconnect( a_Reason ) );
+ m_bKicking = true;
+}
+
+void cClientHandle::StreamChunks()
+{
+ if( !m_bLoggedIn )
+ return;
+ int ChunkPosX = (int)m_Player->GetPosX() / 16;
+ if( m_Player->GetPosX() < 0 ) ChunkPosX -= 1;
+ int ChunkPosZ = (int)m_Player->GetPosZ() / 16;
+ if( m_Player->GetPosZ() < 0 ) ChunkPosZ -= 1;
+
+ cChunk* NeededChunks[VIEWDISTANCE*VIEWDISTANCE];
+ for(int x = 0; x < VIEWDISTANCE; x++)
+ {
+ for(int z = 0; z < VIEWDISTANCE; z++)
+ {
+ NeededChunks[x + z*VIEWDISTANCE] = cRoot::Get()->GetWorld()->GetChunk( x + ChunkPosX-(VIEWDISTANCE-1)/2, 0, z + ChunkPosZ-(VIEWDISTANCE-1)/2 );
+ }
+ }
+
+ cChunk* MissingChunks[VIEWDISTANCE*VIEWDISTANCE];
+ memset( MissingChunks, 0, VIEWDISTANCE*VIEWDISTANCE*sizeof(cChunk*) );
+ unsigned int MissIndex = 0;
+ for(int i = 0; i < VIEWDISTANCE*VIEWDISTANCE; i++) // Handshake loop - touch each chunk once
+ {
+ bool bChunkMissing = true;
+ for(int j = 0; j < VIEWDISTANCE*VIEWDISTANCE; j++)
+ {
+ if( m_LoadedChunks[j] == NeededChunks[i] )
+ {
+ bChunkMissing = false;
+ break;
+ }
+ }
+ if(bChunkMissing)
+ {
+ MissingChunks[MissIndex] = NeededChunks[i];
+ MissIndex++;
+ }
+ }
+
+ if( MissIndex > 0 )
+ { // Chunks are gonna be streamed in, so chunks probably also need to be streamed out
+ for(int x = 0; x < VIEWDISTANCE; x++)
+ {
+ for(int z = 0; z < VIEWDISTANCE; z++)
+ {
+ cChunk* Chunk = m_LoadedChunks[x + z*VIEWDISTANCE];
+ if( Chunk )
+ {
+ if( Chunk->GetPosX() < ChunkPosX-(VIEWDISTANCE-1)/2
+ || Chunk->GetPosX() > ChunkPosX+(VIEWDISTANCE-1)/2
+ || Chunk->GetPosZ() < ChunkPosZ-(VIEWDISTANCE-1)/2
+ || Chunk->GetPosZ() > ChunkPosZ+(VIEWDISTANCE-1)/2 )
+ {
+ Chunk->RemoveClient( this );
+ Chunk->AsyncUnload( this );
+ }
+ }
+ }
+ }
+
+ StreamChunksSmart( MissingChunks, MissIndex );
+
+ memcpy( m_LoadedChunks, NeededChunks, VIEWDISTANCE*VIEWDISTANCE*sizeof(cChunk*) );
+ }
+}
+
+void cClientHandle::StreamChunksSmart( cChunk** a_Chunks, unsigned int a_NumChunks )
+{
+ int X = (int)m_Player->GetPosX() / 16;
+ int Y = (int)m_Player->GetPosY() / 128;
+ int Z = (int)m_Player->GetPosZ() / 16;
+
+ bool bAllDone = false;
+ while( !bAllDone )
+ {
+ bAllDone = true;
+ int ClosestIdx = -1;
+ unsigned int ClosestSqrDist = (unsigned int)-1; // wraps around, becomes biggest number possible
+ for(unsigned int i = 0; i < a_NumChunks; ++i)
+ {
+ if( a_Chunks[i] )
+ {
+ bAllDone = false;
+ int DistX = a_Chunks[i]->GetPosX()-X;
+ int DistY = a_Chunks[i]->GetPosY()-Y;
+ int DistZ = a_Chunks[i]->GetPosZ()-Z;
+ unsigned int SqrDist = (DistX*DistX)+(DistY*DistY)+(DistZ*DistZ);
+ if( SqrDist < ClosestSqrDist )
+ {
+ ClosestSqrDist = SqrDist;
+ ClosestIdx = i;
+ }
+ }
+ }
+ if(ClosestIdx > -1)
+ {
+ a_Chunks[ClosestIdx]->Send( this );
+ a_Chunks[ClosestIdx]->AddClient( this );
+ a_Chunks[ClosestIdx] = 0;
+ }
+ }
+}
+
+void cClientHandle::AddPacket(cPacket * a_Packet)
+{
+ m_pState->CriticalSection.Lock();
+ m_pState->PendingParsePackets.push_back( a_Packet->Clone() );
+ m_pState->CriticalSection.Unlock();
+}
+
+void cClientHandle::RemovePacket( cPacket * a_Packet )
+{
+ delete a_Packet;
+ m_pState->PendingParsePackets.remove( a_Packet );
+}
+
+void cClientHandle::HandlePendingPackets()
+{
+ m_pState->CriticalSection.Lock();
+ while( m_pState->PendingParsePackets.begin() != m_pState->PendingParsePackets.end() )
+ {
+ HandlePacket( *m_pState->PendingParsePackets.begin() );
+ RemovePacket( *m_pState->PendingParsePackets.begin() );
+ }
+ m_pState->CriticalSection.Unlock();
+}
+
+void cClientHandle::HandlePacket( cPacket* a_Packet )
+{
+ m_TimeLastPacket = cWorld::GetTime();
+
+// cPacket* CopiedPacket = a_Packet->Clone();
+// a_Packet = CopiedPacket;
+
+ //LOG("Packet: 0x%02x", a_Packet->m_PacketID );
+
+ if( m_bKicking ) return;
+
+ if(!m_bLoggedIn)
+ {
+ switch( a_Packet->m_PacketID )
+ {
+ case E_PING: // Somebody tries to retreive information about the server
+ {
+ LOGINFO("Got ping");
+ char NumPlayers[8];
+ sprintf_s(NumPlayers, 8, "%i", cRoot::Get()->GetWorld()->GetNumPlayers() );
+ std::string response = std::string("Should be able to connect now!" + cChatColor::Delimiter + NumPlayers + cChatColor::Delimiter + "9001" );
+ Kick( response.c_str() );
+ }
+ break;
+ case E_HANDSHAKE:
+ {
+ cPacket_Handshake* PacketData = reinterpret_cast<cPacket_Handshake*>(a_Packet);
+ m_pState->Username = PacketData->m_Username;
+ LOG("HANDSHAKE %s", GetUsername() );
+ cPacket_Chat Connecting(m_pState->Username + " is connecting.");
+ cRoot::Get()->GetServer()->Broadcast( Connecting, this );
+
+ // Give a server handshake thingy back
+ cPacket_Handshake Handshake;
+ Handshake.m_Username = cRoot::Get()->GetServer()->GetServerID();//ServerID;//"2e66f1dc032ab5f0";
+ Send( Handshake );
+ }
+ break;
+ case E_LOGIN:
+ {
+ LOG("LOGIN %s", GetUsername() );
+ cPacket_Login* PacketData = reinterpret_cast<cPacket_Login*>(a_Packet);
+ if( m_pState->Username.compare( PacketData->m_Username ) != 0 )
+ {
+ Kick("Login Username does not match Handshake username!");
+ return;
+ }
+ //m_Password = PacketData->m_Password;
+
+ if( cRoot::Get()->GetPluginManager()->CallHook( cPluginManager::E_PLUGIN_LOGIN, 1, PacketData ) )
+ {
+ Destroy();
+ return;
+ }
+
+ if( m_pState->pAuthenticateThread ) delete m_pState->pAuthenticateThread;
+ m_pState->pAuthenticateThread = new cThread( AuthenticateThread, this );
+ m_pState->pAuthenticateThread->Start( true );
+ }
+ break;
+ case E_PLAYERMOVELOOK: // After this is received we're safe to send anything
+ {
+ if( !m_Player )
+ {
+ Kick("Received wrong packet! Check your login sequence!");
+ return;
+ }
+ if( !cRoot::Get()->GetPluginManager()->CallHook( cPluginManager::E_PLUGIN_PLAYER_JOIN, 1, m_Player ) )
+ {
+ // Broadcast that this player has joined the game! Yay~
+ cPacket_Chat Joined( m_pState->Username + " joined the game!");
+ cRoot::Get()->GetServer()->Broadcast( Joined, this );
+ }
+
+ // Now initialize player (adds to entity list etc.)
+ m_Player->Initialize();
+
+ // Broadcasts to all but this ( this is actually handled in cChunk.cpp, after entity is added to the chunk )
+ //m_Player->SpawnOn( 0 );
+
+ // Send all already connected players to new player
+ //cRoot::Get()->GetServer()->SendAllEntitiesTo( this );
+
+ // Then we can start doing more stuffs! :D
+ m_bLoggedIn = true;
+ LOG("%s completely logged in", GetUsername() );
+ StreamChunks();
+ }
+ break;
+ case E_KEEP_ALIVE:
+ break;
+ default:
+ {
+ LOG("INVALID RESPONSE FOR LOGIN: needed 0x%02x got 0x%02x", E_PLAYERMOVELOOK, a_Packet->m_PacketID );
+ Kick("INVALID RESPONSE FOR LOGIN: needed 0x0d!");
+ }
+ break;
+ }
+ }
+ else // m_bLoggedIn == true
+ {
+ switch( a_Packet->m_PacketID )
+ {
+ case E_PLAYERPOS:
+ {
+ cPacket_PlayerPosition* PacketData = reinterpret_cast<cPacket_PlayerPosition*>(a_Packet);
+ //LOG("recv player pos: %0.2f %0.2f %0.2f", PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ );
+ m_Player->MoveTo( Vector3d( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ ) );
+ m_Player->SetStance( PacketData->m_Stance );
+ m_Player->SetTouchGround( PacketData->m_bFlying );
+ }
+ break;
+ case E_BLOCK_DIG:
+ {
+ cPacket_BlockDig* PacketData = reinterpret_cast<cPacket_BlockDig*>(a_Packet);
+ //LOG("OnBlockDig: %i %i %i Dir: %i Stat: %i", PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ, PacketData->m_Direction, PacketData->m_Status );
+ if( PacketData->m_Status == 0x04 ) // Drop block
+ {
+ m_Player->TossItem( false );
+ }
+ else
+ {
+ cWorld* World = cRoot::Get()->GetWorld();
+ char OldBlock = World->GetBlock(PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ);
+ char MetaData = World->GetBlockMeta(PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ);
+ bool bBroken = (PacketData->m_Status == 0x02) || g_BlockOneHitDig[(int)OldBlock];
+
+ cItem PickupItem;
+ if( bBroken ) // broken
+ {
+ ENUM_ITEM_ID PickupID = cBlockToPickup::ToPickup( (ENUM_BLOCK_ID)OldBlock, m_Player->GetInventory().GetEquippedItem().m_ItemID );
+ PickupItem.m_ItemID = PickupID;
+ PickupItem.m_ItemHealth = MetaData;
+ PickupItem.m_ItemCount = 1;
+ }
+ if(!cRoot::Get()->GetPluginManager()->CallHook( cPluginManager::E_PLUGIN_BLOCK_DIG, 2, PacketData, m_Player, &PickupItem ) )
+ {
+ if( bBroken ) // Block broken
+ {
+ if( cRoot::Get()->GetWorld()->DigBlock( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ, PickupItem ) )
+ {
+ m_Player->GetInventory().GetEquippedItem().m_ItemHealth ++;
+ LOG("Health: %i", m_Player->GetInventory().GetEquippedItem().m_ItemHealth);
+ }
+ }
+ }
+ else
+ {
+ cRoot::Get()->GetWorld()->SendBlockTo( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ, m_Player );
+ }
+ }
+ }
+ break;
+ case E_BLOCK_PLACE:
+ {
+ cPacket_BlockPlace* PacketData = reinterpret_cast<cPacket_BlockPlace*>(a_Packet);
+ cItem & Equipped = m_Player->GetInventory().GetEquippedItem();
+ if( Equipped.m_ItemID != PacketData->m_ItemType ) // Not valid
+ {
+ LOGWARN("Player %s tried to place a block that was not selected! (could indicate bot)", GetUsername() );
+ break;
+ }
+
+ if(cRoot::Get()->GetPluginManager()->CallHook( cPluginManager::E_PLUGIN_BLOCK_PLACE, 2, PacketData, m_Player ) )
+ {
+ if( PacketData->m_Direction > -1 )
+ {
+ AddDirection( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ, PacketData->m_Direction );
+ cRoot::Get()->GetWorld()->SendBlockTo( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ, m_Player );
+ }
+ break;
+ }
+
+ //LOG("%i %i %i %i %i %i", PacketData->m_Count, PacketData->m_Direction, PacketData->m_ItemType, PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ );
+
+ //printf("Place Dir:%i %i %i %i : %i\n", PacketData->m_Direction, PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ, PacketData->m_ItemType);
+ // 'use' useable items instead of placing blocks
+ bool bPlaceBlock = true;
+ if( PacketData->m_Direction >= 0 )
+ {
+ ENUM_BLOCK_ID BlockID = (ENUM_BLOCK_ID)cRoot::Get()->GetWorld()->GetBlock( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ );
+ switch( BlockID )
+ {
+ case E_BLOCK_WORKBENCH:
+ {
+ bPlaceBlock = false;
+ cWindow* Window = new cCraftingWindow( 0, true );
+ m_Player->OpenWindow( Window );
+ }
+ break;
+ case E_BLOCK_FURNACE:
+ case E_BLOCK_CHEST:
+ {
+ bPlaceBlock = false;
+ cBlockEntity* BlockEntity = cRoot::Get()->GetWorld()->GetBlockEntity( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ );
+ if( BlockEntity )
+ {
+ BlockEntity->UsedBy( *m_Player );
+ }
+ }
+ break;
+ default:
+ break;
+ };
+ }
+
+ // Some checks to see if it's a placeable item :P
+ if( bPlaceBlock )
+ {
+ cItem Item;
+ Item.m_ItemID = Equipped.m_ItemID;
+ Item.m_ItemCount = 1;
+
+ // Hacked in edible items go!~
+ bool bEat = false;
+ switch( Item.m_ItemID )
+ {
+ case E_ITEM_APPLE:
+ m_Player->Heal( 4 ); // 2 hearts
+ bEat = true;
+ break;
+ case E_ITEM_GOLDEN_APPLE:
+ m_Player->Heal( 20 ); // 10 hearts
+ bEat = true;
+ break;
+ case E_ITEM_MUSHROOM_SOUP:
+ m_Player->Heal( 10 ); // 5 hearts
+ bEat = true;
+ break;
+ case E_ITEM_BREAD:
+ m_Player->Heal( 5 ); // 2.5 hearts
+ bEat = true;
+ break;
+ case E_ITEM_RAW_MEAT:
+ m_Player->Heal( 3 ); // 1.5 hearts
+ bEat = true;
+ break;
+ case E_ITEM_COOKED_MEAT:
+ m_Player->Heal( 8 ); // 4 hearts
+ bEat = true;
+ break;
+ case E_ITEM_RAW_FISH:
+ m_Player->Heal( 2 ); // 1 heart
+ bEat = true;
+ break;
+ case E_ITEM_COOKED_FISH:
+ m_Player->Heal( 5 ); // 2.5 hearts
+ bEat = true;
+ break;
+ default:
+ break;
+ };
+
+ if( bEat )
+ {
+ m_Player->GetInventory().RemoveItem( Item );
+ break;
+ }
+
+ if( PacketData->m_Direction < 0 ) // clicked in air
+ break;
+
+ char MetaData = (char)Equipped.m_ItemHealth;
+ switch( PacketData->m_ItemType ) // Special handling for special items
+ {
+ case E_BLOCK_TORCH:
+ MetaData = cTorch::DirectionToMetaData( PacketData->m_Direction );
+ break;
+ case E_BLOCK_COBBLESTONE_STAIRS:
+ case E_BLOCK_WOODEN_STAIRS:
+ MetaData = cStairs::RotationToMetaData( m_Player->GetRotation() );
+ break;
+ case E_BLOCK_LADDER:
+ MetaData = cLadder::DirectionToMetaData( PacketData->m_Direction );
+ break;
+ case E_ITEM_SIGN:
+ LOG("Dir: %i", PacketData->m_Direction);
+ if( PacketData->m_Direction == 1 )
+ {
+ LOG("Player Rotation: %f", m_Player->GetRotation() );
+ MetaData = cSign::RotationToMetaData( m_Player->GetRotation() );
+ LOG("Sign rotation %i", MetaData);
+ PacketData->m_ItemType = E_BLOCK_SIGN_POST;
+ }
+ else
+ {
+ MetaData = cSign::DirectionToMetaData( PacketData->m_Direction );
+ PacketData->m_ItemType = E_BLOCK_WALLSIGN;
+ }
+ break;
+ default:
+ break;
+ };
+
+ if( IsValidBlock( PacketData->m_ItemType) )
+ {
+ if( m_Player->GetInventory().RemoveItem( Item ) )
+ {
+ int X = PacketData->m_PosX;
+ char Y = PacketData->m_PosY;
+ int Z = PacketData->m_PosZ;
+ AddDirection( X, Y, Z, PacketData->m_Direction );
+
+ cRoot::Get()->GetWorld()->SetBlock( X, Y, Z, (char)PacketData->m_ItemType, MetaData );
+ }
+ }
+ }
+ /*
+ // Remove stuff with stick! :D
+ if( m_Username.compare("FakeTruth") == 0 )
+ { // It's me! :D
+ if( PacketData->m_ItemType == 280 )
+ {
+ cRoot::Get()->GetWorld()->SetBlock( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ, 0, 0 );
+ }
+ }
+ */
+ }
+ break;
+ case E_PICKUP_SPAWN:
+ {
+ LOG("Received packet E_PICKUP_SPAWN");
+ cPacket_PickupSpawn* PacketData = reinterpret_cast<cPacket_PickupSpawn*>(a_Packet);
+
+ cItem DroppedItem;
+ DroppedItem.m_ItemID = (ENUM_ITEM_ID)PacketData->m_Item;
+ DroppedItem.m_ItemCount = PacketData->m_Count;
+ DroppedItem.m_ItemHealth = 0x0; // TODO: Somehow figure out what item was dropped, and apply correct health
+ if( m_Player->GetInventory().RemoveItem( DroppedItem ) )
+ {
+ cPickup* Pickup = new cPickup( PacketData );
+ Pickup->Initialize();
+ }
+ }
+ break;
+ case E_CHAT:
+ {
+ cPacket_Chat* PacketData = reinterpret_cast<cPacket_Chat*>(a_Packet);
+ if( !cRoot::Get()->GetServer()->Command( *this, PacketData->m_Message.c_str() ) )
+ {
+ PacketData->m_Message.insert( 0, "<"+m_Player->GetColor() + m_pState->Username + cChatColor::White + "> " );
+ cRoot::Get()->GetServer()->Broadcast( *PacketData );
+ }
+ }
+ break;
+ case E_PLAYERLOOK:
+ {
+ cPacket_PlayerLook* PacketData = reinterpret_cast<cPacket_PlayerLook*>(a_Packet);
+ m_Player->SetRotation( PacketData->m_Rotation );
+ m_Player->SetPitch( PacketData->m_Pitch );
+ m_Player->SetTouchGround( PacketData->m_bFlying );
+ m_Player->WrapRotation();
+ }
+ break;
+ case E_PLAYERMOVELOOK:
+ {
+ cPacket_PlayerMoveLook* PacketData = reinterpret_cast<cPacket_PlayerMoveLook*>(a_Packet);
+ m_Player->MoveTo( Vector3d( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ ) );
+ m_Player->SetStance( PacketData->m_Stance );
+ m_Player->SetTouchGround( PacketData->m_bFlying );
+ m_Player->SetRotation( PacketData->m_Rotation );
+ m_Player->SetPitch( PacketData->m_Pitch );
+ m_Player->WrapRotation();
+ }
+ break;
+ case E_ANIMATION:
+ {
+ cPacket_ArmAnim* PacketData = reinterpret_cast<cPacket_ArmAnim*>(a_Packet);
+ PacketData->m_EntityID = m_Player->GetUniqueID();
+ cRoot::Get()->GetServer()->Broadcast( *PacketData, this );
+ }
+ break;
+ case E_ITEM_SWITCH:
+ {
+ cPacket_ItemSwitch* PacketData = reinterpret_cast<cPacket_ItemSwitch*>(a_Packet);
+
+ m_Player->GetInventory().SetEquippedSlot( PacketData->m_SlotNum );
+
+ cPacket_EntityEquipment Equipment;
+ Equipment.m_ItemID = (short)m_Player->GetInventory().GetEquippedItem().m_ItemID;
+ Equipment.m_Slot = 0;
+ Equipment.m_UniqueID = m_Player->GetUniqueID();
+ cRoot::Get()->GetServer()->Broadcast( Equipment, this );
+ }
+ break;
+ case E_WINDOW_CLOSE:
+ {
+ cPacket_WindowClose* PacketData = reinterpret_cast<cPacket_WindowClose*>(a_Packet);
+ if( PacketData->m_Close > 0 ) // Don't care about closing inventory
+ {
+ m_Player->CloseWindow();
+ }
+ }
+ break;
+ case E_WINDOW_CLICK:
+ {
+ cPacket_WindowClick* PacketData = reinterpret_cast<cPacket_WindowClick*>(a_Packet);
+ if( PacketData->m_WindowID == 0 )
+ {
+ m_Player->GetInventory().Clicked( PacketData );
+ }
+ else
+ {
+ cWindow* Window = m_Player->GetWindow();
+ if( Window ) Window->Clicked( PacketData, *m_Player );
+ else LOG("No 'other' window! WTF");
+ }
+ }
+ break;
+ case E_UPDATE_SIGN:
+ {
+ cPacket_UpdateSign* PacketData = reinterpret_cast<cPacket_UpdateSign*>(a_Packet);
+ cWorld* World = cRoot::Get()->GetWorld();
+ cChunk* Chunk = World->GetChunkOfBlock( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ );
+ cBlockEntity* BlockEntity = Chunk->GetBlockEntity( PacketData->m_PosX, PacketData->m_PosY, PacketData->m_PosZ );
+ if( BlockEntity && (BlockEntity->GetBlockType() == E_BLOCK_SIGN_POST || BlockEntity->GetBlockType() == E_BLOCK_WALLSIGN ) )
+ {
+ cSignEntity* Sign = reinterpret_cast< cSignEntity* >(BlockEntity);
+ Sign->SetLines( PacketData->m_Line1, PacketData->m_Line2, PacketData->m_Line3, PacketData->m_Line4 );
+ Sign->SendTo( 0 ); // Broadcast to all players in chunk
+ }
+ }
+ break;
+ case E_USE_ENTITY:
+ {
+ cPacket_UseEntity* PacketData = reinterpret_cast<cPacket_UseEntity*>(a_Packet);
+ if( PacketData->m_bLeftClick )
+ {
+ cWorld* World = cRoot::Get()->GetWorld();
+ cEntity* Entity = World->GetEntity( PacketData->m_TargetID );
+ if( Entity && Entity->IsA("cPawn") )
+ {
+ cPawn* Pawn = (cPawn*)Entity;
+ Pawn->TakeDamage( 1, m_Player );
+ }
+ }
+ }
+ break;
+ case E_RESPAWN:
+ {
+ m_Player->Respawn();
+ }
+ break;
+ case E_DISCONNECT:
+ {
+ LOG("Received d/c packet from %s", GetUsername() );
+ cPacket_Disconnect* PacketData = reinterpret_cast<cPacket_Disconnect*>(a_Packet);
+ if( !cRoot::Get()->GetPluginManager()->CallHook( cPluginManager::E_PLUGIN_DISCONNECT, 2, PacketData->m_Reason.c_str(), m_Player ) )
+ {
+ cPacket_Chat DisconnectMessage( m_pState->Username + " disconnected: " + PacketData->m_Reason );
+ cRoot::Get()->GetServer()->Broadcast( DisconnectMessage );
+ }
+ Destroy();
+ return;
+ }
+ break;
+ default:
+ break;
+ }
+ }
+}
+
+void cClientHandle::AuthenticateThread( void* a_Param )
+{
+ cClientHandle* self = (cClientHandle*)a_Param;
+
+ cAuthenticator Authenticator;
+ if( !Authenticator.Authenticate( self->GetUsername(), cRoot::Get()->GetServer()->GetServerID() ) )
+ {
+ self->Kick("You could not be authenticated, sorry buddy!");
+ return;
+ }
+
+ self->SendLoginResponse();
+}
+
+void cClientHandle::SendLoginResponse()
+{
+ cWorld* World = cRoot::Get()->GetWorld();
+ World->LockEntities();
+ // Spawn player (only serversided, so data is loaded)
+ m_Player = new cPlayer( this, GetUsername() ); // !!DO NOT INITIALIZE!! <- is done after receiving MoveLook Packet
+
+ cRoot::Get()->GetPluginManager()->CallHook( cPluginManager::E_PLUGIN_PLAYER_SPAWN, 1, m_Player );
+
+ // Return a server login packet
+ cPacket_Login LoginResponse;
+ LoginResponse.m_ProtocolVersion = m_Player->GetUniqueID();
+ //LoginResponse.m_Username = "";
+ LoginResponse.m_MapSeed = 0;
+ LoginResponse.m_Dimension = 0;
+ Send( LoginResponse );
+
+ // Send position
+ Send( cPacket_PlayerMoveLook( m_Player ) );
+
+ // Send time
+ Send( cPacket_TimeUpdate( (cRoot::Get()->GetWorld()->GetWorldTime() ) ) );
+
+ // Send inventory
+ m_Player->GetInventory().SendWholeInventory( this );
+
+ // Send health
+ Send( cPacket_UpdateHealth( (short)m_Player->GetHealth() ) );
+ World->UnlockEntities();
+}
+
+void cClientHandle::Tick(float a_Dt)
+{
+ (void)a_Dt;
+ if( cWorld::GetTime() - m_TimeLastPacket > 30.f ) // 30 seconds time-out
+ {
+ cPacket_Disconnect DC("Nooooo!! You timed out! D: Come back!");
+ DC.Send( m_pState->Socket );
+
+ cSleep::MilliSleep( 1000 ); // Give packet some time to be received
+
+ Destroy();
+ }
+}
+
+void cClientHandle::Send( const cPacket & a_Packet, ENUM_PRIORITY a_Priority /* = E_PRIORITY_NORMAL */ )
+{
+ if( m_bKicking ) return; // Don't add more packets if player is getting kicked anyway
+
+ bool bSignalSemaphore = true;
+ m_pState->SendCriticalSection.Lock();
+ if( a_Priority == E_PRIORITY_NORMAL )
+ {
+ if( a_Packet.m_PacketID == E_REL_ENT_MOVE_LOOK )
+ {
+ PacketList & Packets = m_pState->PendingNrmSendPackets;
+ for( std::list<cPacket*>::iterator itr = Packets.begin(); itr != Packets.end(); ++itr )
+ {
+ bool bBreak = false;
+ switch( (*itr)->m_PacketID )
+ {
+ case E_REL_ENT_MOVE_LOOK:
+ {
+ const cPacket_RelativeEntityMoveLook* ThisPacketData = reinterpret_cast< const cPacket_RelativeEntityMoveLook* >(&a_Packet);
+ cPacket_RelativeEntityMoveLook* PacketData = reinterpret_cast< cPacket_RelativeEntityMoveLook* >(*itr);
+ if( ThisPacketData->m_UniqueID == PacketData->m_UniqueID )
+ {
+ //LOGINFO("Optimized by removing double packet");
+ Packets.erase( itr );
+ bBreak = true;
+ bSignalSemaphore = false; // Because 1 packet is removed, semaphore count is the same
+ break;
+ }
+ }
+ break;
+ default:
+ break;
+ }
+ if( bBreak )
+ break;
+ }
+ }
+ m_pState->PendingNrmSendPackets.push_back( a_Packet.Clone() );
+ }
+ else if( a_Priority == E_PRIORITY_LOW ) m_pState->PendingLowSendPackets.push_back( a_Packet.Clone() );
+ m_pState->SendCriticalSection.Unlock();
+ if( bSignalSemaphore )
+ m_pState->pSemaphore->Signal();
+}
+
+void cClientHandle::SendThread( void *lpParam )
+{
+ cClientHandle* self = (cClientHandle*)lpParam;
+ sClientHandleState* m_pState = self->m_pState;
+ PacketList & NrmSendPackets = m_pState->PendingNrmSendPackets;
+ PacketList & LowSendPackets = m_pState->PendingLowSendPackets;
+
+
+ while( self->m_bKeepThreadGoing && m_pState->Socket )
+ {
+ m_pState->pSemaphore->Wait();
+ m_pState->SendCriticalSection.Lock();
+ //LOG("Pending packets: %i", m_PendingPackets.size() );
+ if( NrmSendPackets.size() + LowSendPackets.size() > MAX_SEMAPHORES )
+ {
+ LOGERROR("ERROR: Too many packets in queue for player %s !!", self->GetUsername() );
+ cPacket_Disconnect DC("Too many packets in queue.");
+ DC.Send( m_pState->Socket );
+
+ cSleep::MilliSleep( 1000 ); // Give packet some time to be received
+
+ self->Destroy();
+ m_pState->SendCriticalSection.Unlock();
+ break;
+ }
+ if( NrmSendPackets.size() == 0 && LowSendPackets.size() == 0 )
+ {
+ if( self->m_bKeepThreadGoing ) LOGERROR("ERROR: Semaphore was signaled while PendingSendPackets.size == 0");
+ m_pState->SendCriticalSection.Unlock();
+ continue;
+ }
+ if( NrmSendPackets.size() > MAX_SEMAPHORES/2 )
+ {
+ LOGINFO("Pending packets: %i Last: 0x%02x", NrmSendPackets.size(), (*NrmSendPackets.rbegin())->m_PacketID );
+ }
+
+ cPacket* Packet = 0;
+ if( NrmSendPackets.size() > 0 )
+ {
+ Packet = *NrmSendPackets.begin();
+ NrmSendPackets.erase( NrmSendPackets.begin() );
+ }
+ else if( LowSendPackets.size() > 0 )
+ {
+ Packet = *LowSendPackets.begin();
+ LowSendPackets.erase( LowSendPackets.begin() );
+ }
+ m_pState->SendCriticalSection.Unlock();
+
+ m_pState->SocketCriticalSection.Lock();
+ if( !m_pState->Socket )
+ {
+ m_pState->SocketCriticalSection.Unlock();
+ break;
+ }
+ bool bSuccess = Packet->Send( m_pState->Socket );
+ m_pState->SocketCriticalSection.Unlock();
+ if( !bSuccess )
+ {
+ LOGERROR("ERROR: While sending packet 0x%02x", Packet->m_PacketID );
+ delete Packet;
+ self->Destroy();
+ break;
+ }
+ delete Packet;
+
+ if( self->m_bKicking && (NrmSendPackets.size() + LowSendPackets.size() == 0) ) // Disconnect player after all packets have been sent
+ {
+ cSleep::MilliSleep( 1000 ); // Give all packets some time to be received
+ self->Destroy();
+ break;
+ }
+ }
+
+ return;
+}
+
+
+extern std::string GetWSAError();
+
+void cClientHandle::ReceiveThread( void *lpParam )
+{
+ LOG("ReceiveThread");
+
+ cClientHandle* self = (cClientHandle*)lpParam;
+
+
+ char temp = 0;
+ int iStat = 0;
+
+ cSocket socket = self->GetSocket();
+
+ while( self->m_bKeepThreadGoing )
+ {
+ iStat = recv(socket, &temp, 1, 0);
+ if( cSocket::IsSocketError(iStat) || iStat == 0 )
+ {
+ LOG("CLIENT DISCONNECTED (%i bytes):%s", iStat, GetWSAError().c_str() );
+ break;
+ }
+ else
+ {
+ cPacket* pPacket = self->m_pState->PacketMap[ (unsigned char)temp ];
+ if( pPacket )
+ {
+ if( pPacket->Parse( socket ) )
+ {
+ self->AddPacket( pPacket );
+ //self->HandlePendingPackets();
+ }
+ else
+ {
+#ifndef _WIN32
+ LOGERROR("Something went wrong during PacketID 0x%02x (%i)", temp, errno );
+#else
+ LOGERROR("Something went wrong during PacketID 0x%02x (%s)", temp, GetWSAError().c_str() );
+#endif
+ LOG("CLIENT %s DISCONNECTED", self->GetUsername() );
+ break;
+ }
+ }
+ else
+ {
+ LOG("Unknown packet: 0x%2x %c %i", (unsigned char)temp, (unsigned char)temp, (unsigned char)temp );
+
+
+ char c_Str[128];
+#ifdef _WIN32
+ sprintf_s( c_Str, "[C->S] Unknown PacketID: 0x%2x", (unsigned char)temp );
+#else
+ sprintf( c_Str, "[C->S] Unknown PacketID: 0x%2x", (unsigned char)temp );
+#endif
+ cPacket_Disconnect DC(c_Str);
+ DC.Send( socket );
+
+ cSleep::MilliSleep( 1000 ); // Give packet some time to be received
+ break;
+ }
+ }
+ }
+
+ self->Destroy();
+
+ LOG("ReceiveThread STOPPED");
+ return;
+}
+
+
+const char* cClientHandle::GetUsername()
+{
+ return m_pState->Username.c_str();
+}
+
+const cSocket & cClientHandle::GetSocket()
+{
+ return m_pState->Socket;
+}
\ No newline at end of file diff --git a/source/cClientHandle.h b/source/cClientHandle.h new file mode 100644 index 000000000..224ba46b3 --- /dev/null +++ b/source/cClientHandle.h @@ -0,0 +1,70 @@ +#pragma once
+
+class cSocket;
+class cSemaphore;
+class cEvent;
+class Game;
+class cPacket;
+class cChunk;
+class cPlayer;
+class cClientHandle // tolua_export
+{ // tolua_export
+public:
+ enum ENUM_PRIORITY
+ {
+ E_PRIORITY_LOW,
+ E_PRIORITY_NORMAL
+ };
+
+ cClientHandle(const cSocket & a_Socket);
+ ~cClientHandle();
+
+ static const int VIEWDISTANCE = 13;
+
+ const cSocket & GetSocket();
+ cPlayer* GetPlayer() { return m_Player; } // tolua_export
+
+ void Kick( const char* a_Reason ); //tolua_export
+
+ void AddPacket( cPacket * a_Packet );
+ void HandlePendingPackets();
+
+ void StreamChunks();
+ void StreamChunksSmart( cChunk** a_Chunks, unsigned int a_NumChunks );
+
+ inline void SetLoggedIn( bool a_bLoggedIn ) { m_bLoggedIn = a_bLoggedIn; }
+ inline bool IsLoggedIn() { return m_bLoggedIn; }
+
+ void Tick(float a_Dt);
+
+ bool IsDestroyed() { return m_bDestroyed; }
+ void Destroy();
+
+ cChunk* m_LoadedChunks[VIEWDISTANCE*VIEWDISTANCE];
+
+ void Send( const cPacket & a_Packet, ENUM_PRIORITY a_Priority = E_PRIORITY_NORMAL );
+
+ static void SendThread( void *lpParam );
+ static void ReceiveThread( void *lpParam );
+ static void AuthenticateThread( void* a_Param );
+
+ const char* GetUsername();
+private:
+ void HandlePacket( cPacket* a_Packet );
+ void RemovePacket( cPacket * a_Packet );
+
+ void SendLoginResponse();
+
+ struct sClientHandleState;
+ sClientHandleState* m_pState;
+
+ bool m_bDestroyed;
+ cPlayer* m_Player;
+ bool m_bKicking;
+
+ float m_TimeLastPacket;
+
+ bool m_bLoggedIn;
+
+ bool m_bKeepThreadGoing;
+}; // tolua_export
diff --git a/source/cCraftingWindow.cpp b/source/cCraftingWindow.cpp new file mode 100644 index 000000000..be3de600b --- /dev/null +++ b/source/cCraftingWindow.cpp @@ -0,0 +1,103 @@ +#include "cCraftingWindow.h"
+#include "cItem.h"
+#include "cMCLogger.h"
+#include "cRecipeChecker.h"
+#include "cPlayer.h"
+#include "cClientHandle.h"
+#include "cInventory.h"
+#include "cPickup.h"
+#include "cRoot.h"
+
+#include "packets/cPacket_WindowClick.h"
+#include "packets/cPacket_InventorySlot.h"
+
+cCraftingWindow::cCraftingWindow( cWindowOwner* a_Owner, bool a_bInventoryVisible )
+ : cWindow( a_Owner, a_bInventoryVisible )
+{
+ SetWindowID( 1 );
+ SetWindowType( 1 ); // Workbench
+
+ cItem* Slots = new cItem[10];
+ SetSlots( Slots, 10 );
+}
+
+void cCraftingWindow::Clicked( cPacket_WindowClick* a_ClickPacket, cPlayer & a_Player )
+{
+ bool bDontCook = false;
+ // Override for craft result slot
+ if( a_ClickPacket->m_SlotNum == 0 )
+ {
+ LOG("In craft slot: %i x %i !!", GetSlot(0)->m_ItemID, GetSlot(0)->m_ItemCount );
+ cItem* DraggingItem = GetDraggingItem( &a_Player );
+ if( DraggingItem->m_ItemID <= 0 )
+ {
+ *DraggingItem = *GetSlot(0);
+ GetSlot(0)->Empty();
+ }
+ else if( DraggingItem->Equals( *GetSlot(0) ) )
+ {
+ if( DraggingItem->m_ItemCount + GetSlot(0)->m_ItemCount <= 64 )
+ {
+ DraggingItem->m_ItemCount += GetSlot(0)->m_ItemCount;
+ GetSlot(0)->Empty();
+ }
+ else
+ {
+ bDontCook = true;
+ }
+ }
+ else
+ {
+ bDontCook = true;
+ }
+ LOG("Dragging Dish %i", DraggingItem->m_ItemCount );
+ }
+ else
+ {
+ cWindow::Clicked( a_ClickPacket, a_Player );
+ }
+
+ if( a_ClickPacket->m_SlotNum >= 0 && a_ClickPacket->m_SlotNum < 10 )
+ {
+ cItem CookedItem;
+ if( a_ClickPacket->m_SlotNum == 0 && !bDontCook )
+ {
+ CookedItem = cRoot::Get()->GetRecipeChecker()->CookIngredients( GetSlots()+1, 3, 3, true );
+ }
+ else
+ {
+ CookedItem = cRoot::Get()->GetRecipeChecker()->CookIngredients( GetSlots()+1, 3, 3 );
+ }
+ *GetSlot(0) = CookedItem;
+ LOG("You cooked: %i x %i !!", GetSlot(0)->m_ItemID, GetSlot(0)->m_ItemCount );
+ }
+ SendWholeWindow( a_Player.GetClientHandle() );
+ a_Player.GetInventory().SendWholeInventory( a_Player.GetClientHandle() );
+ // Separate packet for result =/ Don't know why
+ cPacket_InventorySlot Packet;
+ Packet.m_WindowID = (char)GetWindowID();
+ Packet.m_SlotNum = 0;
+ Packet.m_ItemID = (short)GetSlot(0)->m_ItemID;
+ Packet.m_ItemCount = GetSlot(0)->m_ItemCount;
+ Packet.m_ItemUses = (char)GetSlot(0)->m_ItemHealth;
+ a_Player.GetClientHandle()->Send( Packet );
+}
+
+void cCraftingWindow::Close( cPlayer & a_Player )
+{
+ // Start from slot 1, don't drop what's in the result slot
+ for( int i = 1; i < GetNumSlots(); i++ )
+ {
+ cItem* Item = GetSlot( i );
+ if( Item->m_ItemID > 0 && Item->m_ItemCount > 0 )
+ {
+ float vX = 0, vY = 0, vZ = 0;
+ EulerToVector( -a_Player.GetRotation(), a_Player.GetPitch(), vZ, vX, vY );
+ vY = -vY*2 + 1.f;
+ cPickup* Pickup = new cPickup( (int)(a_Player.GetPosX()*32), (int)(a_Player.GetPosY()*32) + (int)(1.6f*32), (int)(a_Player.GetPosZ()*32), *Item, vX*2, vY*2, vZ*2 );
+ Pickup->Initialize();
+ }
+ Item->Empty();
+ }
+ cWindow::Close( a_Player );
+}
\ No newline at end of file diff --git a/source/cCraftingWindow.h b/source/cCraftingWindow.h new file mode 100644 index 000000000..df32bf74a --- /dev/null +++ b/source/cCraftingWindow.h @@ -0,0 +1,13 @@ +#pragma once
+
+#include "cWindow.h"
+
+class cWindowOwner;
+class cCraftingWindow : public cWindow
+{
+public:
+ cCraftingWindow( cWindowOwner* a_Owner, bool a_bInventoryVisible );
+
+ virtual void Clicked( cPacket_WindowClick* a_ClickPacket, cPlayer & a_Player );
+ virtual void Close( cPlayer & a_Player );
+};
\ No newline at end of file diff --git a/source/cCriticalSection.cpp b/source/cCriticalSection.cpp new file mode 100644 index 000000000..85f89c195 --- /dev/null +++ b/source/cCriticalSection.cpp @@ -0,0 +1,60 @@ +#include "cCriticalSection.h"
+#include "cMCLogger.h"
+
+#ifdef _WIN32
+#include <Windows.h>
+#else
+#include <pthread.h>
+#endif
+
+cCriticalSection::cCriticalSection()
+{
+#ifdef _WIN32
+ m_CriticalSectionPtr = new CRITICAL_SECTION;
+ InitializeCriticalSection( (CRITICAL_SECTION*)m_CriticalSectionPtr );
+#else
+ m_Attributes = new pthread_mutexattr_t;
+ pthread_mutexattr_init((pthread_mutexattr_t*)m_Attributes);
+ pthread_mutexattr_settype((pthread_mutexattr_t*)m_Attributes, PTHREAD_MUTEX_RECURSIVE);
+
+ m_CriticalSectionPtr = new pthread_mutex_t;
+ if( pthread_mutex_init( (pthread_mutex_t*)m_CriticalSectionPtr, (pthread_mutexattr_t*)m_Attributes ) != 0 )
+ {
+ LOG("ERROR: Could not initialize Critical Section!");
+ }
+#endif
+}
+
+cCriticalSection::~cCriticalSection()
+{
+#ifdef _WIN32
+ DeleteCriticalSection( (CRITICAL_SECTION*)m_CriticalSectionPtr );
+ delete (CRITICAL_SECTION*)m_CriticalSectionPtr;
+#else
+ if( pthread_mutex_destroy( (pthread_mutex_t*)m_CriticalSectionPtr ) != 0 )
+ {
+ LOG("ERROR: Could not destroy Critical Section!");
+ }
+ delete (pthread_mutex_t*)m_CriticalSectionPtr;
+ pthread_mutexattr_destroy( (pthread_mutexattr_t*)m_Attributes );
+ delete (pthread_mutexattr_t*)m_Attributes;
+#endif
+}
+
+void cCriticalSection::Lock()
+{
+#ifdef _WIN32
+ EnterCriticalSection( (CRITICAL_SECTION*)m_CriticalSectionPtr );
+#else
+ pthread_mutex_lock( (pthread_mutex_t*)m_CriticalSectionPtr );
+#endif
+}
+
+void cCriticalSection::Unlock()
+{
+#ifdef _WIN32
+ LeaveCriticalSection( (CRITICAL_SECTION*)m_CriticalSectionPtr );
+#else
+ pthread_mutex_unlock( (pthread_mutex_t*)m_CriticalSectionPtr );
+#endif
+}
diff --git a/source/cCriticalSection.h b/source/cCriticalSection.h new file mode 100644 index 000000000..fd1d34e46 --- /dev/null +++ b/source/cCriticalSection.h @@ -0,0 +1,16 @@ +#pragma once
+
+class cCriticalSection
+{
+public:
+ cCriticalSection();
+ ~cCriticalSection();
+
+ void Lock();
+ void Unlock();
+private:
+ void* m_CriticalSectionPtr; // Pointer to a CRITICAL_SECTION object
+#ifndef _WIN32
+ void* m_Attributes;
+#endif
+};
\ No newline at end of file diff --git a/source/cCuboid.cpp b/source/cCuboid.cpp new file mode 100644 index 000000000..9f102129c --- /dev/null +++ b/source/cCuboid.cpp @@ -0,0 +1,10 @@ +#include "cCuboid.h"
+
+#include <algorithm> // swap
+
+void cCuboid::Sort()
+{
+ if( p1.x > p2.x ) std::swap( p1.x, p2.x );
+ if( p1.y > p2.y ) std::swap( p1.y, p2.y );
+ if( p1.z > p2.z ) std::swap( p1.z, p2.z );
+}
\ No newline at end of file diff --git a/source/cCuboid.h b/source/cCuboid.h new file mode 100644 index 000000000..28e222e41 --- /dev/null +++ b/source/cCuboid.h @@ -0,0 +1,40 @@ +#pragma once
+
+#include "Vector3i.h"
+#include "Vector3d.h"
+
+class cCuboid //tolua_export
+{ //tolua_export
+public: //tolua_export
+ cCuboid() {} //tolua_export
+ cCuboid( const cCuboid & a_Cuboid ) : p1( a_Cuboid.p1 ), p2( a_Cuboid.p2 ) {} //tolua_export
+ cCuboid( const Vector3i & a_p1, const Vector3i & a_p2 ) : p1( a_p1 ), p2( a_p2 ) {} //tolua_export
+
+
+ Vector3i p1, p2; //tolua_export
+
+ void Sort(); //tolua_export
+
+ bool IsInside( const Vector3i & v ) const //tolua_export
+ { //tolua_export
+ if( v.x >= p1.x && v.x <= p2.x
+ && v.y >= p1.y && v.y <= p2.y
+ && v.z >= p1.z && v.z <= p2.z )
+ {
+ return true;
+ }
+ return false;
+ } //tolua_export
+
+ bool IsInside( const Vector3d & v ) const //tolua_export
+ { //tolua_export
+ if( v.x >= p1.x && v.x <= p2.x
+ && v.y >= p1.y && v.y <= p2.y
+ && v.z >= p1.z && v.z <= p2.z )
+ {
+ return true;
+ }
+ return false;
+ } //tolua_export
+
+}; //tolua_export
\ No newline at end of file diff --git a/source/cEntity.cpp b/source/cEntity.cpp new file mode 100644 index 000000000..3b62bec9c --- /dev/null +++ b/source/cEntity.cpp @@ -0,0 +1,283 @@ +#include "cEntity.h"
+#include "cWorld.h"
+#include "cChunk.h"
+#include "cMCLogger.h"
+#include "cServer.h"
+#include "cRoot.h"
+#include "Vector3d.h"
+#include "Vector3f.h"
+#include "Matrix4f.h"
+#include "cReferenceManager.h"
+#include "cClientHandle.h"
+
+#include "packets/cPacket_DestroyEntity.h"
+
+int cEntity::m_EntityCount = 0;
+
+cEntity::cEntity(const double & a_X, const double & a_Y, const double & a_Z)
+ : m_UniqueID( 0 )
+ , m_Referencers( new cReferenceManager( cReferenceManager::RFMNGR_REFERENCERS ) )
+ , m_References( new cReferenceManager( cReferenceManager::RFMNGR_REFERENCES ) )
+ , m_ChunkX( 0 )
+ , m_ChunkY( 0 )
+ , m_ChunkZ( 0 )
+ , m_Pos( new Vector3d( a_X, a_Y, a_Z ) )
+ , m_bDirtyPosition( true )
+ , m_Rot( new Vector3f() )
+ , m_bDirtyOrientation( true )
+ , m_bDestroyed( false )
+ , m_EntityType( E_ENTITY )
+{
+ m_EntityCount++;
+ m_UniqueID = m_EntityCount;
+}
+
+cEntity::~cEntity()
+{
+ delete m_Referencers;
+ delete m_References;
+ cChunk* Chunk = cRoot::Get()->GetWorld()->GetChunkUnreliable( m_ChunkX, m_ChunkY, m_ChunkZ );
+ if( Chunk )
+ {
+ cPacket_DestroyEntity DestroyEntity( this );
+ Chunk->Broadcast( DestroyEntity );
+ Chunk->RemoveEntity( *this );
+ }
+ delete m_Pos;
+ delete m_Rot;
+}
+
+void cEntity::Initialize()
+{
+ cRoot::Get()->GetWorld()->AddEntity( this );
+
+ cWorld::BlockToChunk( (int)m_Pos->x, (int)m_Pos->y, (int)m_Pos->z, m_ChunkX, m_ChunkY, m_ChunkZ );
+ cChunk* Chunk = cRoot::Get()->GetWorld()->GetChunk( m_ChunkX, m_ChunkY, m_ChunkZ );
+ if( Chunk )
+ {
+ //LOG("Adding entity %i to chunk %i %i %i", m_UniqueID, Chunk->GetPosX(), Chunk->GetPosY(), Chunk->GetPosZ() );
+ Chunk->AddEntity( *this );
+ }
+}
+
+void cEntity::WrapRotation()
+{
+ while(m_Rot->x > 180.f) m_Rot->x-=360.f; // Wrap it
+ while(m_Rot->x < -180.f) m_Rot->x+=360.f;
+ while(m_Rot->y > 180.f) m_Rot->y-=360.f;
+ while(m_Rot->y < -180.f) m_Rot->y+=360.f;
+}
+
+void cEntity::MoveToCorrectChunk()
+{
+ int ChunkX = 0, ChunkY = 0, ChunkZ = 0;
+ cWorld::BlockToChunk( (int)m_Pos->x, (int)m_Pos->y, (int)m_Pos->z, ChunkX, ChunkY, ChunkZ );
+ if( m_ChunkX != ChunkX || m_ChunkY != ChunkY || m_ChunkZ != ChunkZ )
+ {
+ cWorld* World = cRoot::Get()->GetWorld();
+ LOG("From %i %i To %i %i", m_ChunkX, m_ChunkZ, ChunkX, ChunkZ );
+ cChunk* Chunk = World->GetChunkUnreliable( m_ChunkX, m_ChunkY, m_ChunkZ );
+
+ typedef std::list< cClientHandle* > ClientList;
+ ClientList BeforeClients;
+ if( Chunk )
+ {
+ Chunk->RemoveEntity( *this );
+ BeforeClients = Chunk->GetClients();
+ }
+ m_ChunkX = ChunkX; m_ChunkY = ChunkY; m_ChunkZ = ChunkZ;
+ cChunk* NewChunk = World->GetChunk( m_ChunkX, m_ChunkY, m_ChunkZ );
+ ClientList AfterClients;
+ if( NewChunk )
+ {
+ NewChunk->AddEntity( *this );
+ AfterClients = NewChunk->GetClients();
+ }
+
+
+ /********************
+ * I reaalllyyyy don't like this piece of code, but it's needed I guess (maybe there's a way to optimize this)
+ **/
+ // Now compare clients before with after
+ for( ClientList::iterator itr = BeforeClients.begin(); itr != BeforeClients.end(); ++itr )
+ {
+ bool bFound = false;
+ for( ClientList::iterator itr2 = AfterClients.begin(); itr2 != AfterClients.end(); ++itr2 )
+ {
+ if( *itr2 == *itr )
+ {
+ bFound = true;
+ break;
+ }
+ }
+ if( !bFound ) // Client was in old chunk, but not new, so destroy on that client
+ {
+ cPacket_DestroyEntity DestroyEntity( this );
+ (*itr)->Send( DestroyEntity );
+ }
+ }
+
+ // Now compare clients after with before
+ for( ClientList::iterator itr = AfterClients.begin(); itr != AfterClients.end(); ++itr )
+ {
+ bool bFound = false;
+ for( ClientList::iterator itr2 = BeforeClients.begin(); itr2 != BeforeClients.end(); ++itr2 )
+ {
+ if( *itr2 == *itr )
+ {
+ bFound = true;
+ break;
+ }
+ }
+ if( !bFound ) // Client is in the new chunk, but not in old, so spawn on the client
+ {
+ SpawnOn( *itr );
+ }
+ }
+ }
+}
+
+
+CLASS_DEF_GETCLASS( cEntity );
+bool cEntity::IsA( const char* a_EntityType )
+{
+ //LOG("IsA( cEntity ) : %s", a_EntityType);
+ if( strcmp( a_EntityType, "cEntity" ) == 0 ) return true;
+ return false;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// Set orientations
+void cEntity::SetRot( const Vector3f & a_Rot )
+{
+ *m_Rot = a_Rot;
+ m_bDirtyOrientation = true;
+}
+
+void cEntity::SetRotation( float a_Rotation )
+{
+ m_Rot->x = a_Rotation;
+ m_bDirtyOrientation = true;
+}
+
+void cEntity::SetPitch( float a_Pitch )
+{
+ m_Rot->y = a_Pitch;
+ m_bDirtyOrientation = true;
+}
+
+void cEntity::SetRoll( float a_Roll )
+{
+ m_Rot->z = a_Roll;
+ m_bDirtyOrientation = true;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// Get orientations
+const Vector3f & cEntity::GetRot()
+{
+ return *m_Rot;
+}
+
+float cEntity::GetRotation()
+{
+ return m_Rot->x;
+}
+
+float cEntity::GetPitch()
+{
+ return m_Rot->y;
+}
+
+float cEntity::GetRoll()
+{
+ return m_Rot->z;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// Get look vector (this is NOT a rotation!)
+Vector3f cEntity::GetLookVector()
+{
+ Matrix4f m;
+ m.Init( Vector3f(), 0, m_Rot->x, -m_Rot->y );
+ Vector3f Look = m.Transform( Vector3f(0, 0, 1) );
+ LOG("Look: %0.1f %0.1f %0.1f", Look.x, Look.y, Look.z );
+ return Look;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// Set position
+void cEntity::SetPosition( const Vector3d & a_Pos )
+{
+ *m_Pos = a_Pos;
+ MoveToCorrectChunk();
+ m_bDirtyPosition = true;
+}
+
+void cEntity::SetPosition( const double & a_PosX, const double & a_PosY, const double & a_PosZ )
+{
+ m_Pos->Set( a_PosX, a_PosY, a_PosZ );
+ MoveToCorrectChunk();
+ m_bDirtyPosition = true;
+}
+
+void cEntity::SetPosX( const double & a_PosX )
+{
+ m_Pos->x = a_PosX;
+ MoveToCorrectChunk();
+ m_bDirtyPosition = true;
+}
+
+void cEntity::SetPosY( const double & a_PosY )
+{
+ m_Pos->y = a_PosY;
+ MoveToCorrectChunk();
+ m_bDirtyPosition = true;
+}
+
+void cEntity::SetPosZ( const double & a_PosZ )
+{
+ m_Pos->z = a_PosZ;
+ MoveToCorrectChunk();
+ m_bDirtyPosition = true;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// Get position
+const Vector3d & cEntity::GetPosition()
+{
+ return *m_Pos;
+}
+
+const double & cEntity::GetPosX()
+{
+ return m_Pos->x;
+}
+
+const double & cEntity::GetPosY()
+{
+ return m_Pos->y;
+}
+
+const double & cEntity::GetPosZ()
+{
+ return m_Pos->z;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// Reference stuffs
+void cEntity::AddReference( cEntity*& a_EntityPtr )
+{
+ m_References->AddReference( a_EntityPtr );
+ a_EntityPtr->ReferencedBy( a_EntityPtr );
+}
+
+void cEntity::ReferencedBy( cEntity*& a_EntityPtr )
+{
+ m_Referencers->AddReference( a_EntityPtr );
+}
+
+void cEntity::Dereference( cEntity*& a_EntityPtr )
+{
+ m_Referencers->Dereference( a_EntityPtr );
+}
diff --git a/source/cEntity.h b/source/cEntity.h new file mode 100644 index 000000000..602abeeaf --- /dev/null +++ b/source/cEntity.h @@ -0,0 +1,108 @@ +#pragma once
+
+#include "MemoryLeak.h"
+
+#define CLASS_PROT_ISA() virtual bool IsA( const char* a_EntityType );
+#define CLASS_PROT_GETCLASS() virtual const char* GetClass();
+
+/* Can't use this (yet) because of tolua */
+#define CLASS_PROTOTYPE() \
+ CLASS_PROT_ISA(); \
+ CLASS_PROT_GETCLASS();
+
+#define CLASS_DEF_ISA( classname, superclass ) \
+ bool classname::IsA( const char* a_EntityType ) \
+ { \
+ if( strcmp( a_EntityType, #classname ) == 0 ) return true; \
+ return superclass::IsA( a_EntityType ); \
+ }
+
+#define CLASS_DEF_GETCLASS( classname ) \
+ const char* classname::GetClass() \
+ { \
+ return #classname; \
+ }
+
+#define CLASS_DEFINITION( classname, superclass ) \
+ CLASS_DEF_ISA( classname, superclass ) \
+ CLASS_DEF_GETCLASS( classname )
+
+class cReferenceManager;
+class Vector3d;
+class Vector3f;
+class cClientHandle;
+class cEntity //tolua_export
+{ //tolua_export
+public: //tolua_export
+ cEntity(const double & a_X, const double & a_Y, const double & a_Z); //tolua_export
+ virtual ~cEntity(); //tolua_export
+
+ virtual void Initialize(); //tolua_export
+
+ enum ENUM_ENTITY_TYPE //tolua_export
+ { //tolua_export
+ E_ENTITY, //tolua_export
+ E_PLAYER, //tolua_export
+ E_PICKUP //tolua_export
+ }; //tolua_export
+
+ virtual unsigned int GetEntityType() { return m_EntityType; } //tolua_export
+ virtual bool IsA( const char* a_EntityType ); //tolua_export
+ virtual const char* GetClass(); //tolua_export
+
+
+ const Vector3d & GetPosition(); //tolua_export
+ const double & GetPosX(); //tolua_export
+ const double & GetPosY(); //tolua_export
+ const double & GetPosZ(); //tolua_export
+ const Vector3f & GetRot(); //tolua_export
+ float GetRotation(); //tolua_export
+ float GetPitch(); //tolua_export
+ float GetRoll(); //tolua_export
+ Vector3f GetLookVector(); //tolua_export
+
+ void SetPosX( const double & a_PosX ); //tolua_export
+ void SetPosY( const double & a_PosY ); //tolua_export
+ void SetPosZ( const double & a_PosZ ); //tolua_export
+ void SetPosition( const double & a_PosX, const double & a_PosY, const double & a_PosZ ); //tolua_export
+ void SetPosition( const Vector3d & a_Pos ); //tolua_export
+ void SetRot( const Vector3f & a_Rot ); //tolua_export
+ void SetRotation( float a_Rotation ); //tolua_export
+ void SetPitch( float a_Pitch ); //tolua_export
+ void SetRoll( float a_Roll ); //tolua_export
+
+ inline int GetUniqueID() { return m_UniqueID; } //tolua_export
+ inline bool IsDestroyed() { return m_bDestroyed; } //tolua_export
+
+ void Destroy() { m_bDestroyed = true; } //tolua_export
+
+ virtual void Tick(float a_Dt) = 0; //tolua_export
+
+ virtual void SpawnOn( cClientHandle* a_Target ) = 0; //tolua_export
+ void WrapRotation();
+
+protected:
+ void MoveToCorrectChunk();
+
+ friend class cReferenceManager;
+ void AddReference( cEntity*& a_EntityPtr );
+ void ReferencedBy( cEntity*& a_EntityPtr );
+ void Dereference( cEntity*& a_EntityPtr );
+
+ static int m_EntityCount;
+ int m_UniqueID;
+
+ cReferenceManager* m_Referencers;
+ cReferenceManager* m_References;
+
+ int m_ChunkX, m_ChunkY, m_ChunkZ;
+ Vector3d* m_Pos;
+ bool m_bDirtyPosition;
+
+ Vector3f* m_Rot;
+ bool m_bDirtyOrientation;
+
+ bool m_bDestroyed;
+
+ ENUM_ENTITY_TYPE m_EntityType;
+}; //tolua_export
diff --git a/source/cEvent.cpp b/source/cEvent.cpp new file mode 100644 index 000000000..f3a0a3570 --- /dev/null +++ b/source/cEvent.cpp @@ -0,0 +1,112 @@ +#include "cEvent.h"
+#include "cMCLogger.h"
+
+#ifdef _WIN32
+#include <Windows.h>
+#else
+#include <semaphore.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#endif
+
+cEvent::cEvent( unsigned int a_NumEvents /* = 1 */ )
+ : m_NumEvents( a_NumEvents )
+#ifndef _WIN32
+ , m_bNamed( false )
+#endif
+{
+ if( m_NumEvents < 1 ) m_NumEvents = 1;
+
+#ifdef _WIN32
+ m_Handle = new HANDLE[ m_NumEvents ];
+ for( unsigned int i = 0; i < m_NumEvents; i++)
+ {
+ ((HANDLE*)m_Handle)[i] = CreateEvent( 0, FALSE, FALSE, 0 );
+ }
+#else
+ m_Handle = new sem_t*[ m_NumEvents ];
+ for( unsigned int i = 0; i < m_NumEvents; i++)
+ {
+
+ sem_t* & HandlePtr = ((sem_t**)m_Handle)[i];
+ HandlePtr = new sem_t;
+
+ if( sem_init( HandlePtr, 0, 0 ) )
+ {
+ LOG("WARNING cEvent: Could not create unnamed semaphore, fallback to named.");
+ m_bNamed = true;
+ delete HandlePtr; // named semaphores return their own address
+
+ char c_Str[32];
+ sprintf( c_Str, "cEvent%p", &HandlePtr );
+ HandlePtr = sem_open( c_Str, O_CREAT, 777, 0 );
+ if( HandlePtr == SEM_FAILED )
+ LOG("ERROR: Could not create Event. (%i)", errno);
+ else
+ if( sem_unlink( c_Str ) != 0 )
+ LOG("ERROR: Could not unlink cEvent. (%i)", errno);
+ }
+ }
+#endif
+}
+
+cEvent::~cEvent()
+{
+#ifdef _WIN32
+ for( unsigned int i = 0; i < m_NumEvents; i++ )
+ {
+ CloseHandle( ((HANDLE*)m_Handle)[i] );
+ }
+ delete [] (HANDLE*)m_Handle;
+#else
+ for( unsigned int i = 0; i < m_NumEvents; i++ )
+ {
+ if( m_bNamed )
+ {
+ sem_t* & HandlePtr = ((sem_t**)m_Handle)[i];
+ char c_Str[32];
+ sprintf( c_Str, "cEvent%p", &HandlePtr );
+ // LOG("Closing event: %s", c_Str );
+ // LOG("Sem ptr: %p", HandlePtr );
+ if( sem_close( HandlePtr ) != 0 )
+ {
+ LOG("ERROR: Could not close cEvent. (%i)", errno);
+ }
+ }
+ else
+ {
+ sem_destroy( ((sem_t**)m_Handle)[i] );
+ delete ((sem_t**)m_Handle)[i];
+ }
+ }
+ delete [] (sem_t**)m_Handle; m_Handle = 0;
+#endif
+}
+
+void cEvent::Wait()
+{
+#ifdef _WIN32
+ WaitForMultipleObjects( m_NumEvents, (HANDLE*)m_Handle, true, INFINITE );
+#else
+ for(unsigned int i = 0; i < m_NumEvents; i++)
+ {
+ if( sem_wait( ((sem_t**)m_Handle)[i] ) != 0 )
+ {
+ LOG("ERROR: Could not wait for cEvent. (%i)", errno);
+ }
+ }
+#endif
+}
+
+void cEvent::Set(unsigned int a_EventNum /* = 0 */)
+{
+#ifdef _WIN32
+ SetEvent( ((HANDLE*)m_Handle)[a_EventNum] );
+#else
+ if( sem_post( ((sem_t**)m_Handle)[a_EventNum] ) != 0 )
+ {
+ LOG("ERROR: Could not set cEvent. (%i)", errno);
+ }
+#endif
+}
diff --git a/source/cEvent.h b/source/cEvent.h new file mode 100644 index 000000000..b0b1d73be --- /dev/null +++ b/source/cEvent.h @@ -0,0 +1,18 @@ +#pragma once
+
+class cEvent
+{
+public:
+ cEvent( unsigned int a_NumEvents = 1 );
+ ~cEvent();
+
+ void Wait();
+ void Set(unsigned int a_EventNum = 0);
+private:
+ unsigned int m_NumEvents;
+ void* m_Handle; // HANDLE[] pointer
+
+#ifndef _WIN32
+ bool m_bNamed;
+#endif
+};
diff --git a/source/cFurnaceEntity.cpp b/source/cFurnaceEntity.cpp new file mode 100644 index 000000000..1bca35aca --- /dev/null +++ b/source/cFurnaceEntity.cpp @@ -0,0 +1,372 @@ +#include "cFurnaceEntity.h"
+#include "BlockID.h"
+#include "cItem.h"
+#include "cFurnaceWindow.h"
+#include "cPlayer.h"
+#include "cWorld.h"
+#include "cChunk.h"
+#include "cClientHandle.h"
+#include "cFurnaceRecipe.h"
+#include "cServer.h"
+#include "cPickup.h"
+#include "cRoot.h"
+
+#include "packets/cPacket_InventoryProgressBar.h"
+
+#include "cMCLogger.h"
+
+#include <json/json.h>
+
+cFurnaceEntity::cFurnaceEntity(int a_X, int a_Y, int a_Z)
+ : cBlockEntity( E_BLOCK_FURNACE, a_X, a_Y, a_Z )
+ , m_Items( new cItem[3] )
+ , m_CookingItem( 0 )
+ , m_CookTime( 0 )
+ , m_TimeCooked( 0 )
+ , m_BurnTime( 0 )
+ , m_TimeBurned( 0 )
+{
+}
+
+cFurnaceEntity::~cFurnaceEntity()
+{
+ // Tell window its owner is destroyed
+ if( GetWindow() )
+ {
+ GetWindow()->OwnerDestroyed();
+ }
+
+ // Clean up items
+ if( m_Items )
+ {
+ delete [] m_Items;
+ }
+}
+
+void cFurnaceEntity::Destroy()
+{
+ // Drop items
+ for( int i = 0; i < 3; i++)
+ {
+ if( !m_Items[i].IsEmpty() )
+ {
+ cPickup* Pickup = new cPickup( m_PosX*32 + 16, m_PosY*32 + 16, m_PosZ*32 + 16, m_Items[i], 0, 1.f, 0 );
+ Pickup->Initialize();
+ m_Items[i].Empty();
+ }
+ }
+
+ // Remove from tick list
+ cWorld* World = cRoot::Get()->GetWorld();
+ cChunk* Chunk = World->GetChunkOfBlock( m_PosX, m_PosY, m_PosZ );
+ Chunk->RemoveTickBlockEntity( this );
+}
+
+void cFurnaceEntity::UsedBy( cPlayer & a_Player )
+{
+ LOG("Used a furnace");
+
+ if( !GetWindow() )
+ {
+ cWindow* Window = new cFurnaceWindow( this );
+ Window->SetSlots( m_Items, 3 );
+ Window->SetWindowTitle("UberFurnace");
+ OpenWindow( Window );
+ }
+ if( GetWindow() )
+ {
+ if( a_Player.GetWindow() != GetWindow() )
+ {
+ a_Player.OpenWindow( GetWindow() );
+
+ GetWindow()->SendWholeWindow( a_Player.GetClientHandle() );
+ }
+ }
+}
+
+bool cFurnaceEntity::Tick( float a_Dt )
+{
+ //LOG("Time left: %0.1f Time burned: %0.1f Burn time: %0.1f", m_CookTime - m_TimeCooked, m_TimeBurned, m_BurnTime );
+ if( m_CookingItem && ( (m_TimeBurned < m_BurnTime) || (m_TimeCooked + a_Dt >= m_CookTime) ) )
+ {
+ if( m_CookingItem->Equals( m_Items[2] ) || m_Items[2].IsEmpty() )
+ {
+ m_TimeCooked += a_Dt;
+ if( m_TimeCooked >= m_CookTime )
+ {
+ m_Items[0].m_ItemCount--;
+ if( m_Items[0].IsEmpty() ) m_Items[0].Empty();
+
+ m_Items[2].m_ItemHealth = m_CookingItem->m_ItemHealth;
+ m_Items[2].m_ItemID = m_CookingItem->m_ItemID;
+ m_Items[2].m_ItemCount += m_CookingItem->m_ItemCount;
+ delete m_CookingItem;
+ m_CookingItem = 0;
+
+ cWindow* Window = GetWindow();
+ if( Window )
+ {
+ const std::list< cPlayer* > & OpenedBy = Window->GetOpenedBy();
+ for( std::list< cPlayer* >::const_iterator itr = OpenedBy.begin(); itr != OpenedBy.end(); ++itr )
+ {
+ Window->SendWholeWindow( (*itr)->GetClientHandle() );
+ }
+ }
+
+ m_TimeCooked = 0.f;
+ StartCooking();
+ }
+ cWindow* Window = GetWindow();
+ if( Window )
+ {
+ const std::list< cPlayer* > & OpenedBy = Window->GetOpenedBy();
+ for( std::list< cPlayer* >::const_iterator itr = OpenedBy.begin(); itr != OpenedBy.end(); ++itr )
+ {
+ cClientHandle* Client = (*itr)->GetClientHandle();
+
+ cPacket_InventoryProgressBar Progress;
+ Progress.m_ProgressBar = 0;
+ Progress.m_WindowID = (char)Window->GetWindowID();
+ Progress.m_Value = (short)( m_TimeCooked * (180.f/m_CookTime) );
+ if( Progress.m_Value > 180 ) Progress.m_Value = 180;
+ if( Progress.m_Value < 0 ) Progress.m_Value = 0;
+ Client->Send( Progress );
+ }
+ }
+ }
+ }
+
+ m_TimeBurned += a_Dt;
+
+ cWindow* Window = GetWindow();
+ if( m_TimeBurned >= m_BurnTime )
+ {
+ m_TimeBurned -= m_BurnTime;
+ m_BurnTime = 0;
+ if( StartCooking() && Window )
+ {
+ const std::list< cPlayer* > & OpenedBy = Window->GetOpenedBy();
+ for( std::list< cPlayer* >::const_iterator itr = OpenedBy.begin(); itr != OpenedBy.end(); ++itr )
+ {
+ Window->SendWholeWindow( (*itr)->GetClientHandle() );
+ }
+ }
+ }
+ if( Window )
+ {
+ const std::list< cPlayer* > & OpenedBy = Window->GetOpenedBy();
+ for( std::list< cPlayer* >::const_iterator itr = OpenedBy.begin(); itr != OpenedBy.end(); ++itr )
+ {
+ cClientHandle* Client = (*itr)->GetClientHandle();
+
+ cPacket_InventoryProgressBar Progress;
+ Progress.m_WindowID = (char)Window->GetWindowID();
+ Progress.m_ProgressBar = 1;
+
+ if( m_BurnTime > 0.f ) Progress.m_Value = (short)( m_TimeBurned * (150.f/m_BurnTime) );
+ else Progress.m_Value = 0;
+ if( Progress.m_Value > 150 ) Progress.m_Value = 150;
+ if( Progress.m_Value < 0 ) Progress.m_Value = 0;
+ Client->Send( Progress );
+ }
+ }
+ return ((m_CookingItem != 0) || (m_TimeBurned < m_BurnTime)) && m_BurnTime > 0.f; // Keep on ticking, if there's more to cook, or if it's cooking
+}
+
+bool cFurnaceEntity::StartCooking()
+{
+ cFurnaceRecipe* FR = cRoot::Get()->GetFurnaceRecipe();
+ float BurnTime = FR->GetBurnTime( m_Items[1] );
+ if( (m_TimeBurned < m_BurnTime) || BurnTime > 0.f ) // burnable material
+ {
+ const cFurnaceRecipe::Recipe* R = FR->GetRecipeFrom( m_Items[0] );
+ if( R ) // cook able ingredient
+ {
+ if( m_Items[2].Equals( *R->Out ) || m_Items[2].IsEmpty() )
+ {
+ // good to go
+
+ if( m_TimeBurned >= m_BurnTime ) // burn new material
+ {
+ m_Items[1].m_ItemCount--;
+ if( m_Items[1].m_ItemCount <= 0 ) m_Items[1].Empty();
+ m_TimeBurned = 0;
+ m_BurnTime = BurnTime;
+ }
+
+ if( !m_CookingItem ) // Only cook new item if not already cooking
+ {
+ m_CookingItem = new cItem( *R->Out ); // Resulting item
+ m_TimeCooked = 0.f;
+ m_CookTime = R->CookTime;
+ }
+ cWorld* World = cRoot::Get()->GetWorld();
+ cChunk* Chunk = World->GetChunkOfBlock( m_PosX, m_PosY, m_PosZ );
+ Chunk->AddTickBlockEntity( this );
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+void cFurnaceEntity::ResetCookTimer()
+{
+ if( m_CookingItem )
+ {
+ delete m_CookingItem;
+ m_CookingItem = 0;
+ }
+ m_TimeCooked = 0.f;
+ m_CookTime = 0.f;
+}
+
+void cFurnaceEntity::WriteToFile(FILE* a_File)
+{
+ fwrite( &m_BlockType, sizeof( ENUM_BLOCK_ID ), 1, a_File );
+ fwrite( &m_PosX, sizeof( int ), 1, a_File );
+ fwrite( &m_PosY, sizeof( int ), 1, a_File );
+ fwrite( &m_PosZ, sizeof( int ), 1, a_File );
+
+ unsigned int NumSlots = 3;
+ fwrite( &NumSlots, sizeof(unsigned int), 1, a_File );
+ for(unsigned int i = 0; i < NumSlots; i++)
+ {
+ cItem* Item = &m_Items[i];
+ if( Item )
+ {
+ fwrite( &Item->m_ItemID, sizeof(Item->m_ItemID), 1, a_File );
+ fwrite( &Item->m_ItemCount, sizeof(Item->m_ItemCount), 1, a_File );
+ fwrite( &Item->m_ItemHealth, sizeof(Item->m_ItemHealth), 1, a_File );
+ }
+ }
+ cItem Item;
+ if( m_CookingItem ) Item = *m_CookingItem;
+ fwrite( &Item.m_ItemID, sizeof(Item.m_ItemID), 1, a_File );
+ fwrite( &Item.m_ItemCount, sizeof(Item.m_ItemCount), 1, a_File );
+ fwrite( &Item.m_ItemHealth, sizeof(Item.m_ItemHealth), 1, a_File );
+
+ fwrite( &m_CookTime, sizeof(float), 1, a_File );
+ fwrite( &m_TimeCooked, sizeof(float), 1, a_File );
+ fwrite( &m_BurnTime, sizeof(float), 1, a_File );
+ fwrite( &m_TimeBurned, sizeof(float), 1, a_File );
+}
+
+bool cFurnaceEntity::LoadFromFile(FILE* a_File)
+{
+ if( fread( &m_PosX, sizeof(int), 1, a_File) != 1 ) { LOGERROR("ERROR READING FURNACE FROM FILE"); return false; }
+ if( fread( &m_PosY, sizeof(int), 1, a_File) != 1 ) { LOGERROR("ERROR READING FURNACE FROM FILE"); return false; }
+ if( fread( &m_PosZ, sizeof(int), 1, a_File) != 1 ) { LOGERROR("ERROR READING FURNACE FROM FILE"); return false; }
+
+ unsigned int NumSlots = 0;
+ if( fread( &NumSlots, sizeof(unsigned int), 1, a_File) != 1 ) { LOGERROR("ERROR READING FURNACE FROM FILE"); return false; }
+ m_Items = new cItem[ NumSlots ];
+ for(unsigned int i = 0; i < NumSlots; i++)
+ {
+ cItem & Item = m_Items[ i ];
+ if( fread( &Item.m_ItemID, sizeof(Item.m_ItemID), 1, a_File) != 1 ) { LOGERROR("ERROR READING FURNACE FROM FILE"); return false; }
+ if( fread( &Item.m_ItemCount, sizeof(Item.m_ItemCount), 1, a_File) != 1 ) { LOGERROR("ERROR READING FURNACE FROM FILE"); return false; }
+ if( fread( &Item.m_ItemHealth, sizeof(Item.m_ItemHealth), 1, a_File)!= 1 ) { LOGERROR("ERROR READING FURNACE FROM FILE"); return false; }
+ }
+ cItem Item;
+ if( fread( &Item.m_ItemID, sizeof(Item.m_ItemID), 1, a_File) != 1 ) { LOGERROR("ERROR READING FURNACE FROM FILE"); return false; }
+ if( fread( &Item.m_ItemCount, sizeof(Item.m_ItemCount), 1, a_File) != 1 ) { LOGERROR("ERROR READING FURNACE FROM FILE"); return false; }
+ if( fread( &Item.m_ItemHealth, sizeof(Item.m_ItemHealth), 1, a_File)!= 1 ) { LOGERROR("ERROR READING FURNACE FROM FILE"); return false; }
+ if( !Item.IsEmpty() ) m_CookingItem = new cItem( Item );
+
+ if( fread( &m_CookTime, sizeof(float), 1, a_File) != 1 ) { LOGERROR("ERROR READING FURNACE FROM FILE"); return false; }
+ if( fread( &m_TimeCooked, sizeof(float), 1, a_File) != 1 ) { LOGERROR("ERROR READING FURNACE FROM FILE"); return false; }
+ if( fread( &m_BurnTime, sizeof(float), 1, a_File) != 1 ) { LOGERROR("ERROR READING FURNACE FROM FILE"); return false; }
+ if( fread( &m_TimeBurned, sizeof(float), 1, a_File) != 1 ) { LOGERROR("ERROR READING FURNACE FROM FILE"); return false; }
+
+ return true;
+}
+
+bool cFurnaceEntity::LoadFromJson( const Json::Value& a_Value )
+{
+ m_PosX = a_Value.get("x", 0).asInt();
+ m_PosY = a_Value.get("y", 0).asInt();
+ m_PosZ = a_Value.get("z", 0).asInt();
+
+ Json::Value AllSlots = a_Value.get("Slots", 0);
+ int SlotIdx = 0;
+ for( Json::Value::iterator itr = AllSlots.begin(); itr != AllSlots.end(); ++itr )
+ {
+ Json::Value & Slot = *itr;
+ cItem & Item = m_Items[ SlotIdx ];
+ Item.m_ItemID = (ENUM_ITEM_ID)Slot.get("ID", -1 ).asInt();
+ if( Item.m_ItemID > 0 )
+ {
+ Item.m_ItemCount = (char)Slot.get("Count", -1 ).asInt();
+ Item.m_ItemHealth = (short)Slot.get("Health", -1 ).asInt();
+ }
+ SlotIdx++;
+ }
+
+ // Get currently cooking item
+ Json::Value JsonItem = a_Value.get("Cooking", Json::nullValue );
+ if( !JsonItem.empty() )
+ {
+ cItem Item;
+ Item.m_ItemID = (ENUM_ITEM_ID)JsonItem.get("ID", -1).asInt();
+ if( Item.m_ItemID > 0 )
+ {
+ Item.m_ItemCount = (char)JsonItem.get("Count", -1).asInt();
+ Item.m_ItemHealth = (short)JsonItem.get("Health", -1).asInt();
+ }
+ if( !Item.IsEmpty() )
+ {
+ m_CookingItem = new cItem( Item );
+
+ cChunk* Chunk = cRoot::Get()->GetWorld()->GetChunkOfBlock( m_PosX, m_PosY, m_PosZ );
+ Chunk->AddTickBlockEntity( this );
+ }
+ }
+
+ m_CookTime = (float)a_Value.get("CookTime", 0).asDouble();
+ m_TimeCooked = (float)a_Value.get("TimeCooked", 0).asDouble();
+ m_BurnTime = (float)a_Value.get("BurnTime", 0).asDouble();
+ m_TimeBurned = (float)a_Value.get("TimeBurned", 0).asDouble();
+
+ return true;
+}
+
+void cFurnaceEntity::SaveToJson( Json::Value& a_Value )
+{
+ a_Value["x"] = m_PosX;
+ a_Value["y"] = m_PosY;
+ a_Value["z"] = m_PosZ;
+
+ Json::Value AllSlots;
+ for(unsigned int i = 0; i < 3; i++)
+ {
+ Json::Value Slot;
+ cItem & Item = m_Items[ i ];
+ Slot["ID"] = Item.m_ItemID;
+ if( Item.m_ItemID > 0 )
+ {
+ Slot["Count"] = Item.m_ItemCount;
+ Slot["Health"] = Item.m_ItemHealth;
+ }
+ AllSlots.append( Slot );
+ }
+ a_Value["Slots"] = AllSlots;
+
+ // Currently cooking item
+ if( m_CookingItem )
+ {
+ Json::Value JsonItem;
+ JsonItem["ID"] = m_CookingItem->m_ItemID;
+ if( m_CookingItem->m_ItemID > 0 )
+ {
+ JsonItem["Count"] = m_CookingItem->m_ItemCount;
+ JsonItem["Health"] = m_CookingItem->m_ItemHealth;
+ }
+ a_Value["Cooking"] = JsonItem;
+ }
+
+ a_Value["CookTime"] = m_CookTime;
+ a_Value["TimeCooked"] = m_TimeCooked;
+ a_Value["BurnTime"] = m_BurnTime;
+ a_Value["TimeBurned"] = m_TimeBurned;
+}
\ No newline at end of file diff --git a/source/cFurnaceEntity.h b/source/cFurnaceEntity.h new file mode 100644 index 000000000..a1ab051ba --- /dev/null +++ b/source/cFurnaceEntity.h @@ -0,0 +1,43 @@ +#pragma once
+
+#include "cBlockEntity.h"
+#include "cWindowOwner.h"
+#include "FileDefine.h"
+
+namespace Json
+{
+ class Value;
+}
+
+class cClientHandle;
+class cServer;
+class cItem;
+class cNBTData;
+class cFurnaceEntity : public cBlockEntity, public cWindowOwner
+{
+public:
+ cFurnaceEntity(int a_X, int a_Y, int a_Z);
+ virtual ~cFurnaceEntity();
+ virtual void Destroy();
+
+ void WriteToFile(FILE* a_File);
+ bool LoadFromFile(FILE* a_File);
+
+ bool LoadFromJson( const Json::Value& a_Value );
+ void SaveToJson( Json::Value& a_Value );
+
+ bool Tick( float a_Dt );
+ virtual void UsedBy( cPlayer & a_Player );
+
+ bool StartCooking();
+
+ void ResetCookTimer();
+private:
+ cItem* m_Items;
+ cItem* m_CookingItem;
+ float m_CookTime;
+ float m_TimeCooked;
+
+ float m_BurnTime;
+ float m_TimeBurned;
+};
\ No newline at end of file diff --git a/source/cFurnaceRecipe.cpp b/source/cFurnaceRecipe.cpp new file mode 100644 index 000000000..2885f769d --- /dev/null +++ b/source/cFurnaceRecipe.cpp @@ -0,0 +1,214 @@ +#include "cFurnaceRecipe.h"
+#include "cItem.h"
+#include "cMCLogger.h"
+
+#include <fstream>
+#include <sstream>
+
+typedef std::list< cFurnaceRecipe::Recipe > RecipeList;
+typedef std::list< cFurnaceRecipe::Fuel > FuelList;
+struct cFurnaceRecipe::sFurnaceRecipeState
+{
+ RecipeList Recipes;
+ FuelList Fuel;
+};
+
+cFurnaceRecipe::cFurnaceRecipe()
+ : m_pState( new sFurnaceRecipeState )
+{
+ ReloadRecipes();
+}
+
+cFurnaceRecipe::~cFurnaceRecipe()
+{
+ ClearRecipes();
+ delete m_pState;
+}
+
+void cFurnaceRecipe::ReloadRecipes()
+{
+ ClearRecipes();
+ LOG("--Loading furnace recipes--");
+
+ std::ifstream f;
+ char a_File[] = "furnace.txt";
+ f.open(a_File, std::ios::in);
+ std::string input;
+
+ if( !f.good() )
+ {
+ f.close();
+ LOG("Could not open file for recipes: %s", a_File);
+ return;
+ }
+
+ bool bSyntaxError = false;
+ while( f.good() )
+ {
+ char c;
+
+ //////////////////////////////////////////////////////////////////////////
+ // comments
+ f >> c;
+ f.unget();
+ if( c == '#' )
+ {
+ while( f.good() && c != '\n' )
+ {
+ f.get( c );
+ }
+ continue;
+ }
+
+
+ //////////////////////////////////////////////////////////////////////////
+ // Line breaks
+ f.get( c );
+ while( f.good() && ( c == '\n' || c == '\r' ) ) { f.get( c ); }
+ if( f.eof() ) break;
+ f.unget();
+
+ //////////////////////////////////////////////////////////////////////////
+ // Check for fuel
+ f >> c;
+ if( c == '!' ) // It's fuel :)
+ {
+ // Read item
+ int IItemID = 0, IItemCount = 0, IItemHealth = 0;
+ f >> IItemID;
+ f >> c; if( c != ':' ) { bSyntaxError = true; break; }
+ f >> IItemCount;
+
+ // Optional health
+ f >> c;
+ if( c != ':' )
+ f.unget();
+ else
+ {
+ f >> IItemHealth;
+ }
+
+ // Burn time
+ float BurnTime;
+ f >> c; if( c != '=' ) { bSyntaxError = true; break; }
+ f >> BurnTime;
+
+ // Add to fuel list
+ Fuel F;
+ F.In = new cItem( (ENUM_ITEM_ID) IItemID, (char)IItemCount, (short)IItemHealth );
+ F.BurnTime = BurnTime;
+ m_pState->Fuel.push_back( F );
+ continue;
+ }
+ f.unget();
+
+ //////////////////////////////////////////////////////////////////////////
+ // Read items
+ int IItemID = 0, IItemCount = 0, IItemHealth = 0;
+ f >> IItemID;
+ f >> c; if( c != ':' ) { bSyntaxError = true; break; }
+ f >> IItemCount;
+
+ // Optional health
+ f >> c;
+ if( c != ':' )
+ f.unget();
+ else
+ {
+ f >> IItemHealth;
+ }
+
+ float CookTime;
+ f >> c; if( c != '@' ) { bSyntaxError = true; break; }
+ f >> CookTime;
+
+ int OItemID = 0, OItemCount = 0, OItemHealth = 0;
+ f >> c; if( c != '=' ) { bSyntaxError = true; break; }
+ f >> OItemID;
+ f >> c; if( c != ':' ) { bSyntaxError = true; break; }
+ f >> OItemCount;
+
+ // Optional health
+ f >> c;
+ if( c != ':' )
+ f.unget();
+ else
+ {
+ f >> OItemHealth;
+ }
+
+ // Add to recipe list
+ Recipe R;
+ R.In = new cItem( (ENUM_ITEM_ID)IItemID, (char)IItemCount, (short)IItemHealth );
+ R.Out = new cItem( (ENUM_ITEM_ID)OItemID, (char)OItemCount, (short)OItemHealth );
+ R.CookTime = CookTime;
+ m_pState->Recipes.push_back( R );
+ }
+ if( bSyntaxError )
+ {
+ LOGERROR("ERROR: FurnaceRecipe, syntax error" );
+ }
+ LOG("Got %i furnace recipes, and %i fuels.", m_pState->Recipes.size(), m_pState->Fuel.size() );
+
+ LOG("--Done loading furnace recipes--");
+}
+
+void cFurnaceRecipe::ClearRecipes()
+{
+ for( RecipeList::iterator itr = m_pState->Recipes.begin(); itr != m_pState->Recipes.end(); ++itr )
+ {
+ Recipe R = *itr;
+ delete R.In;
+ delete R.Out;
+ }
+ m_pState->Recipes.clear();
+
+ for( FuelList::iterator itr = m_pState->Fuel.begin(); itr != m_pState->Fuel.end(); ++itr )
+ {
+ Fuel F = *itr;
+ delete F.In;
+ }
+ m_pState->Fuel.clear();
+}
+
+const cFurnaceRecipe::Recipe* cFurnaceRecipe::GetRecipeFrom( const cItem & a_Ingredient ) const
+{
+ const Recipe* BestRecipe = 0;
+ for( RecipeList::const_iterator itr = m_pState->Recipes.begin(); itr != m_pState->Recipes.end(); ++itr )
+ {
+ const Recipe & R = *itr;
+ if( (R.In->m_ItemID == a_Ingredient.m_ItemID) && (R.In->m_ItemCount <= a_Ingredient.m_ItemCount ) )
+ {
+ if( BestRecipe && (BestRecipe->In->m_ItemCount > R.In->m_ItemCount) )
+ {
+ continue;
+ }
+ else
+ {
+ BestRecipe = &R;
+ }
+ }
+ }
+ return BestRecipe;
+}
+
+float cFurnaceRecipe::GetBurnTime( const cItem & a_Fuel ) const
+{
+ float BestFuel = 0.f;
+ for( FuelList::const_iterator itr = m_pState->Fuel.begin(); itr != m_pState->Fuel.end(); ++itr )
+ {
+ const Fuel & F = *itr;
+ if( (F.In->m_ItemID == a_Fuel.m_ItemID) && (F.In->m_ItemCount <= a_Fuel.m_ItemCount ) )
+ {
+ if( BestFuel > 0.f && (BestFuel > F.BurnTime ) )
+ {
+ continue;
+ }
+ else
+ {
+ BestFuel = F.BurnTime;
+ }
+ }
+ }
+ return BestFuel;
+}
\ No newline at end of file diff --git a/source/cFurnaceRecipe.h b/source/cFurnaceRecipe.h new file mode 100644 index 000000000..7489b09e6 --- /dev/null +++ b/source/cFurnaceRecipe.h @@ -0,0 +1,34 @@ +#pragma once
+
+#include <list>
+
+class cItem;
+class cFurnaceRecipe
+{
+public:
+ cFurnaceRecipe();
+ ~cFurnaceRecipe();
+
+ void ReloadRecipes();
+
+ struct Fuel
+ {
+ cItem* In;
+ float BurnTime;
+ };
+
+ struct Recipe
+ {
+ cItem* In;
+ cItem* Out;
+ float CookTime;
+ };
+ const Recipe* GetRecipeFrom( const cItem & a_Ingredient ) const;
+ float GetBurnTime( const cItem & a_Fuel ) const;
+
+private:
+ void ClearRecipes();
+
+ struct sFurnaceRecipeState;
+ sFurnaceRecipeState* m_pState;
+};
\ No newline at end of file diff --git a/source/cFurnaceWindow.cpp b/source/cFurnaceWindow.cpp new file mode 100644 index 000000000..8b86f16d6 --- /dev/null +++ b/source/cFurnaceWindow.cpp @@ -0,0 +1,42 @@ +#include "cFurnaceWindow.h"
+#include "cItem.h"
+#include "cFurnaceEntity.h"
+#include "cPlayer.h"
+
+#include "packets/cPacket_WindowClick.h"
+
+#include "cMCLogger.h"
+
+cFurnaceWindow::cFurnaceWindow( cFurnaceEntity* a_Owner )
+ : cWindow( a_Owner, true )
+ , m_Furnace( a_Owner )
+{
+ SetWindowID( 1 );
+ SetWindowType( 2 ); // Furnace
+}
+
+void cFurnaceWindow::Clicked( cPacket_WindowClick* a_ClickPacket, cPlayer & a_Player )
+{
+ cItem Fuel = *GetSlot( 0 );
+
+ cWindow::Clicked( a_ClickPacket, a_Player );
+ if( m_Furnace )
+ {
+ if( a_ClickPacket->m_SlotNum >= 0 && a_ClickPacket->m_SlotNum <= 2 ) // them important slots
+ {
+ if( Fuel.m_ItemID != GetSlot( 0 )->m_ItemID )
+ m_Furnace->ResetCookTimer();
+
+ if( m_Furnace->StartCooking() )
+ {
+ SendWholeWindow( a_Player.GetClientHandle() );
+ }
+ }
+ }
+}
+
+void cFurnaceWindow::Close( cPlayer & a_Player )
+{
+ m_Furnace = 0;
+ cWindow::Close( a_Player );
+}
\ No newline at end of file diff --git a/source/cFurnaceWindow.h b/source/cFurnaceWindow.h new file mode 100644 index 000000000..8dd7d3223 --- /dev/null +++ b/source/cFurnaceWindow.h @@ -0,0 +1,16 @@ +#pragma once
+
+#include "cWindow.h"
+
+class cFurnaceEntity;
+class cWindowOwner;
+class cFurnaceWindow : public cWindow
+{
+public:
+ cFurnaceWindow( cFurnaceEntity* a_Owner );
+
+ virtual void Clicked( cPacket_WindowClick* a_ClickPacket, cPlayer & a_Player );
+ virtual void Close( cPlayer & a_Player );
+private:
+ cFurnaceEntity* m_Furnace;
+};
\ No newline at end of file diff --git a/source/cGenSettings.cpp b/source/cGenSettings.cpp new file mode 100644 index 000000000..7c7206d91 --- /dev/null +++ b/source/cGenSettings.cpp @@ -0,0 +1,10 @@ +#include "cGenSettings.h"
+
+
+float cGenSettings::HeightFreq1 = 0.1f;
+float cGenSettings::HeightFreq2 = 1.f;
+float cGenSettings::HeightFreq3 = 2.f;
+
+float cGenSettings::HeightAmp1 = 1.f;
+float cGenSettings::HeightAmp2 = 0.5f;
+float cGenSettings::HeightAmp3 = 0.5f;
\ No newline at end of file diff --git a/source/cGenSettings.h b/source/cGenSettings.h new file mode 100644 index 000000000..ba76f55e9 --- /dev/null +++ b/source/cGenSettings.h @@ -0,0 +1,9 @@ +#pragma once
+
+class cGenSettings
+{
+public:
+ static float HeightFreq1, HeightAmp1;
+ static float HeightFreq2, HeightAmp2;
+ static float HeightFreq3, HeightAmp3;
+};
\ No newline at end of file diff --git a/source/cGroup.cpp b/source/cGroup.cpp new file mode 100644 index 000000000..2590c5303 --- /dev/null +++ b/source/cGroup.cpp @@ -0,0 +1,34 @@ +#include "cGroup.h"
+
+void cGroup::AddCommand( std::string a_Command )
+{
+ m_Commands[ a_Command ] = true;
+}
+
+void cGroup::AddPermission( std::string a_Permission )
+{
+ m_Permissions[ a_Permission ] = true;
+}
+
+bool cGroup::HasCommand( std::string a_Command )
+{
+ if( m_Commands.find("*") != m_Commands.end() ) return true;
+
+ CommandMap::iterator itr = m_Commands.find( a_Command );
+ if( itr != m_Commands.end() )
+ {
+ if( itr->second ) return true;
+ }
+
+ for( GroupList::iterator itr = m_Inherits.begin(); itr != m_Inherits.end(); ++itr )
+ {
+ if( (*itr)->HasCommand( a_Command ) ) return true;
+ }
+ return false;
+}
+
+void cGroup::InheritFrom( cGroup* a_Group )
+{
+ m_Inherits.remove( a_Group );
+ m_Inherits.push_back( a_Group );
+}
\ No newline at end of file diff --git a/source/cGroup.h b/source/cGroup.h new file mode 100644 index 000000000..303df85fa --- /dev/null +++ b/source/cGroup.h @@ -0,0 +1,39 @@ +#pragma once
+
+#include <string>
+#include <map>
+#include <list>
+
+class cGroup //tolua_export
+{ //tolua_export
+public: //tolua_export
+ cGroup() {}
+ ~cGroup() {}
+
+ void SetName( std::string a_Name ) { m_Name = a_Name; } //tolua_export
+ const std::string & GetName() const { return m_Name; } //tolua_export
+ void SetColor( std::string a_Color ) { m_Color = a_Color; } //tolua_export
+ void AddCommand( std::string a_Command ); //tolua_export
+ void AddPermission( std::string a_Permission ); //tolua_export
+ void InheritFrom( cGroup* a_Group ); //tolua_export
+
+ bool HasCommand( std::string a_Command ); //tolua_export
+
+ typedef std::map< std::string, bool > PermissionMap;
+ const PermissionMap & GetPermissions() const { return m_Permissions; }
+
+ typedef std::map< std::string, bool > CommandMap;
+ const CommandMap & GetCommands() const { return m_Commands; }
+
+ std::string GetColor() const { return m_Color; } //tolua_export
+
+ typedef std::list< cGroup* > GroupList;
+ const GroupList & GetInherits() const { return m_Inherits; }
+private:
+ std::string m_Name;
+ std::string m_Color;
+
+ PermissionMap m_Permissions;
+ CommandMap m_Commands;
+ GroupList m_Inherits;
+};//tolua_export
\ No newline at end of file diff --git a/source/cGroupManager.cpp b/source/cGroupManager.cpp new file mode 100644 index 000000000..4d7bf7a9a --- /dev/null +++ b/source/cGroupManager.cpp @@ -0,0 +1,104 @@ +#include "cGroupManager.h"
+#include "cGroup.h"
+#include "../iniFile/iniFile.h"
+#include "cChatColor.h"
+#include "cMCLogger.h"
+#include "cRoot.h"
+
+extern std::vector< std::string > StringSplit( std::string str, std::string delim);
+
+typedef std::map< std::string, cGroup* > GroupMap;
+struct cGroupManager::sGroupManagerState
+{
+ GroupMap Groups;
+};
+
+cGroupManager* cGroupManager::GetGroupManager()
+{
+ LOGWARN("WARNING: Using deprecated function cGroupManager::GetGroupManager() use cRoot::Get()->GetGroupManager() instead!");
+ return cRoot::Get()->GetGroupManager();
+}
+
+cGroupManager::~cGroupManager()
+{
+ for( GroupMap::iterator itr = m_pState->Groups.begin(); itr != m_pState->Groups.end(); ++itr )
+ {
+ delete itr->second;
+ }
+ m_pState->Groups.clear();
+
+ delete m_pState;
+}
+
+cGroupManager::cGroupManager()
+ : m_pState( new sGroupManagerState )
+{
+ LOG("-- Loading Groups --");
+ cIniFile IniFile("groups.ini");
+ if( IniFile.ReadFile() )
+ {
+ unsigned int NumKeys = IniFile.GetNumKeys();
+ for( unsigned int i = 0; i < NumKeys; i++ )
+ {
+ std::string KeyName = IniFile.GetKeyName( i );
+ cGroup* Group = GetGroup( KeyName.c_str() );
+
+ LOG("Loading group: %s", KeyName.c_str() );
+
+ Group->SetName( KeyName );
+ char Color = IniFile.GetValue( KeyName, "Color", "-" )[0];
+ if( Color != '-' )
+ Group->SetColor( cChatColor::MakeColor(Color) );
+ else
+ Group->SetColor( cChatColor::White );
+
+ std::string Commands = IniFile.GetValue( KeyName, "Commands", "" );
+ if( Commands.size() > 0 )
+ {
+ std::vector< std::string > Split = StringSplit( Commands, "," );
+ for( unsigned int i = 0; i < Split.size(); i++)
+ {
+ Group->AddCommand( Split[i] );
+ //LOG("%s", Split[i].c_str() );
+ }
+ }
+
+ std::string Permissions = IniFile.GetValue( KeyName, "Permissions", "" );
+ if( Permissions.size() > 0 )
+ {
+ std::vector< std::string > Split = StringSplit( Permissions, "," );
+ for( unsigned int i = 0; i < Split.size(); i++)
+ {
+ Group->AddPermission( Split[i] );
+ LOGINFO("Permission: %s", Split[i].c_str() );
+ }
+ }
+
+ std::string Groups = IniFile.GetValue( KeyName, "Inherits", "" );
+ if( Groups.size() > 0 )
+ {
+ std::vector< std::string > Split = StringSplit( Groups, "," );
+ for( unsigned int i = 0; i < Split.size(); i++)
+ {
+ Group->InheritFrom( GetGroup( Split[i].c_str() ) );
+ }
+ }
+ }
+ }
+ LOG("-- Done Loading Groups --");
+}
+
+cGroup* cGroupManager::GetGroup( const char* a_Name )
+{
+ GroupMap::iterator itr = m_pState->Groups.find( a_Name );
+ if( itr != m_pState->Groups.end() )
+ {
+ return itr->second;
+ }
+
+ cGroup* Group = new cGroup();
+ m_pState->Groups[a_Name] = Group;
+
+ return Group;
+
+}
\ No newline at end of file diff --git a/source/cGroupManager.h b/source/cGroupManager.h new file mode 100644 index 000000000..fbd16f117 --- /dev/null +++ b/source/cGroupManager.h @@ -0,0 +1,17 @@ +#pragma once
+
+class cGroup;
+class cGroupManager
+{
+public:
+ static cGroupManager * GetGroupManager(); //tolua_export
+
+ cGroup* GetGroup( const char* a_Name );
+private:
+ friend class cRoot;
+ cGroupManager();
+ ~cGroupManager();
+
+ struct sGroupManagerState;
+ sGroupManagerState* m_pState;
+};
\ No newline at end of file diff --git a/source/cHeartBeat.cpp b/source/cHeartBeat.cpp new file mode 100644 index 000000000..b518a753a --- /dev/null +++ b/source/cHeartBeat.cpp @@ -0,0 +1,119 @@ +#include "cHeartBeat.h"
+#include "cMCLogger.h"
+#include "md5/md5.h"
+
+#include <stdio.h>
+
+#include "cRoot.h"
+#include "cServer.h"
+#include "cSleep.h"
+
+cHeartBeat::cHeartBeat()
+{
+ m_State = 0;
+ Authenticate();
+}
+
+cHeartBeat::~cHeartBeat()
+{
+}
+
+void cHeartBeat::ReceivedData( char a_Data[256], int a_Size )
+{
+ if( a_Size < 0 ) // Disconnected
+ return;
+
+ char MySalt[] = "1234567890";
+
+ if( a_Size == 0 )
+ {
+ Authenticate();
+ return;
+ }
+
+ bool bLoop = false;
+ do
+ {
+ switch (m_State)
+ {
+ case 1:
+ {
+ m_ServerID = std::string( a_Data, a_Size );
+ LOGINFO("Got server ID %s", m_ServerID.c_str() );
+ std::string Hash = md5( m_ServerID + std::string( MySalt ) );
+ CloseSocket();
+ if( Connect( "mc-server.org", 80 ) )
+ {
+ SendMessage( (std::string("GET http://master.mc-server.org/?hash=") + Hash + std::string("&server=") + m_ServerID + "\n").c_str() );
+ m_State = 2;
+ }
+ }
+ break;
+ case 2:
+ {
+ std::string ReturnedString = std::string( a_Data, a_Size );
+ if( ReturnedString.compare("VALIDATED") == 0 )
+ {
+ LOGINFO("Successfully validated server on master server list");
+ }
+ else
+ {
+ LOGINFO("Could not validate server! Will try again later.");
+ cSleep::MilliSleep( 10*1000 );
+ Authenticate();
+ return;
+ }
+ m_State = 3;
+ } // Don't break, but fall through and update server info
+ case 3:
+ {
+ cSleep::MilliSleep( 10*1000 );
+ SendUpdate();
+ m_State = 4;
+ }
+ break;
+ case 4:
+ {
+ if( a_Data[0] == '0' )
+ {
+ LOGINFO("Successfully updated server info!");
+ cSleep::MilliSleep( 10*1000 );
+ SendUpdate();
+ }
+ else
+ {
+ LOGINFO("Failed to update server info, reauthenticating");
+ Authenticate();
+ }
+ }
+ default:
+ break;
+ };
+ } while( bLoop );
+}
+
+void cHeartBeat::SendUpdate()
+{
+ CloseSocket();
+ if( Connect( "mc-server.org", 80 ) )
+ {
+ int Port = cRoot::Get()->GetServer()->GetPort();
+ char c_Port[16];
+ sprintf_s( c_Port, 16, "%i", Port );
+
+ std::string sPort = std::string( c_Port );
+ std::string sChecksum = md5( m_ServerID + sPort );
+ SendMessage( (std::string("GET http://master.mc-server.org/?update=") + m_ServerID + std::string("&checksum=") + sChecksum + std::string("&port=") + sPort + "\n").c_str() );
+ }
+}
+
+void cHeartBeat::Authenticate()
+{
+ CloseSocket();
+ if( Connect( "mc-server.org", 80 ) )
+ {
+ m_State = 1;
+ int RetVal = SendMessage( "GET http://master.mc-server.org/\r\n\r\n");
+ LOGINFO("Returned %i", RetVal );
+ }
+}
diff --git a/source/cHeartBeat.h b/source/cHeartBeat.h new file mode 100644 index 000000000..8a5373af4 --- /dev/null +++ b/source/cHeartBeat.h @@ -0,0 +1,21 @@ +#pragma once
+
+#include "cTCPLink.h"
+
+#include <string>
+
+class cHeartBeat : public cTCPLink
+{
+public:
+ cHeartBeat();
+ ~cHeartBeat();
+private:
+ virtual void ReceivedData( char a_Data[256], int a_Size );
+
+ void Authenticate();
+ int m_State;
+
+ void SendUpdate();
+
+ std::string m_ServerID;
+};
\ No newline at end of file diff --git a/source/cInventory.cpp b/source/cInventory.cpp new file mode 100644 index 000000000..e78ac226e --- /dev/null +++ b/source/cInventory.cpp @@ -0,0 +1,364 @@ +#include "cInventory.h"
+#include <string> //memset
+#include "cPlayer.h"
+#include "cClientHandle.h"
+#include "cMCLogger.h"
+#include "cWindow.h"
+#include "cItem.h"
+#include "cRecipeChecker.h"
+#include "cRoot.h"
+
+#include "packets/cPacket_WindowClick.h"
+#include "packets/cPacket_WholeInventory.h"
+#include "packets/cPacket_InventorySlot.h"
+
+cInventory::~cInventory()
+{
+ delete [] m_Slots;
+ delete m_EquippedItem;
+ if( GetWindow() ) GetWindow()->Close( *m_Owner );
+ CloseWindow();
+}
+
+cInventory::cInventory(cPlayer* a_Owner)
+{
+ m_Owner = a_Owner;
+
+ m_Slots = new cItem[c_NumSlots];
+ for(unsigned int i = 0; i < c_NumSlots; i++)
+ m_Slots[i].Empty();
+
+ m_CraftSlots = m_Slots + c_CraftOffset;
+ m_ArmorSlots = m_Slots + c_ArmorOffset;
+ m_MainSlots = m_Slots + c_MainOffset;
+ m_HotSlots = m_Slots + c_HotOffset;
+
+ m_EquippedItem = new cItem();
+ m_EquippedSlot = 0;
+
+ if( !GetWindow() )
+ {
+ cWindow* Window = new cWindow( this, false );
+ Window->SetSlots( m_Slots, c_NumSlots );
+ Window->SetWindowID( 0 );
+ OpenWindow( Window );
+ }
+}
+
+void cInventory::Clear()
+{
+ for(unsigned int i = 0; i < c_NumSlots; i++)
+ m_Slots[i].Empty();
+}
+
+cItem* cInventory::GetSlotsForType( int a_Type )
+{
+ switch( a_Type )
+ {
+ case -1:
+ return m_MainSlots;
+ case -2:
+ return m_CraftSlots;
+ case -3:
+ return m_ArmorSlots;
+ }
+ return 0;
+}
+
+int cInventory::GetSlotCountForType( int a_Type )
+{
+ switch( a_Type )
+ {
+ case -1:
+ return 36;
+ case -2:
+ case -3:
+ return 4;
+ }
+ return 0;
+}
+
+void cInventory::Clicked( cPacket_WindowClick* a_ClickPacket )
+{
+ bool bDontCook = false;
+ if( GetWindow() )
+ {
+ // Override for craft result slot
+ if( a_ClickPacket->m_SlotNum == (short)c_CraftOffset )
+ {
+ LOG("In craft slot: %i x %i !!", m_Slots[c_CraftOffset].m_ItemID, m_Slots[c_CraftOffset].m_ItemCount );
+ cItem* DraggingItem = GetWindow()->GetDraggingItem();
+ if( DraggingItem->IsEmpty() )
+ {
+ *DraggingItem = m_Slots[c_CraftOffset];
+ m_Slots[c_CraftOffset].Empty();
+ }
+ else if( DraggingItem->Equals( m_Slots[c_CraftOffset] ) )
+ {
+ if( DraggingItem->m_ItemCount + m_Slots[c_CraftOffset].m_ItemCount <= 64 )
+ {
+ DraggingItem->m_ItemCount += m_Slots[c_CraftOffset].m_ItemCount;
+ m_Slots[0].Empty();
+ }
+ else
+ {
+ bDontCook = true;
+ }
+ }
+ else
+ {
+ bDontCook = true;
+ }
+ LOG("Dragging Dish %i", DraggingItem->m_ItemCount );
+ }
+ else
+ {
+ GetWindow()->Clicked( a_ClickPacket, *m_Owner );
+ }
+ }
+ else
+ {
+ LOG("No Inventory window! WTF");
+ }
+
+ if( a_ClickPacket->m_SlotNum >= (short)c_CraftOffset && a_ClickPacket->m_SlotNum < (short)(c_CraftOffset+c_CraftSlots+1) )
+ {
+ cItem CookedItem;
+ if( a_ClickPacket->m_SlotNum == 0 && !bDontCook )
+ {
+ CookedItem = cRoot::Get()->GetRecipeChecker()->CookIngredients( m_Slots+c_CraftOffset+1, 2, 2, true );
+ }
+ else
+ {
+ CookedItem = cRoot::Get()->GetRecipeChecker()->CookIngredients( m_Slots+c_CraftOffset+1, 2, 2 );
+ }
+ m_Slots[c_CraftOffset] = CookedItem;
+ LOG("You cooked: %i x %i !!", m_Slots[c_CraftOffset].m_ItemID, m_Slots[c_CraftOffset].m_ItemCount );
+ SendWholeInventory( m_Owner->GetClientHandle() );
+ }
+ SendSlot( 0 );
+}
+
+bool cInventory::AddToBar( cItem & a_Item, const int a_Offset, const int a_Size, bool* a_bChangedSlots, int a_Mode /* = 0 */ )
+{
+ // Fill already present stacks
+ if( a_Mode < 2 )
+ {
+ for(int i = 0; i < a_Size; i++)
+ {
+ if( m_Slots[i + a_Offset].m_ItemID == a_Item.m_ItemID && m_Slots[i + a_Offset].m_ItemCount < 64 )
+ {
+ int NumFree = 64 - m_Slots[i + a_Offset].m_ItemCount;
+ if( NumFree >= a_Item.m_ItemCount )
+ {
+
+ //printf("1. Adding %i items ( free: %i )\n", a_Item.m_ItemCount, NumFree );
+ m_Slots[i + a_Offset].m_ItemCount += a_Item.m_ItemCount;
+ a_Item.m_ItemCount = 0;
+ a_bChangedSlots[i + a_Offset] = true;
+ break;
+ }
+ else
+ {
+ //printf("2. Adding %i items\n", NumFree );
+ m_Slots[i + a_Offset].m_ItemCount += (char)NumFree;
+ a_Item.m_ItemCount -= (char)NumFree;
+ a_bChangedSlots[i + a_Offset] = true;
+ }
+ }
+ }
+ }
+
+ if( a_Mode > 0 )
+ {
+ // If we got more left, find first empty slot
+ for(int i = 0; i < a_Size && a_Item.m_ItemCount > 0; i++)
+ {
+ if( m_Slots[i + a_Offset].m_ItemID == -1 )
+ {
+ m_Slots[i + a_Offset] = a_Item;
+ a_Item.m_ItemCount = 0;
+ a_bChangedSlots[i + a_Offset] = true;
+ }
+ }
+ }
+
+ return true;
+}
+
+bool cInventory::AddItem( cItem & a_Item )
+{
+ cItem BackupSlots[c_NumSlots];
+ memcpy( BackupSlots, m_Slots, c_NumSlots * sizeof( cItem ) );
+
+ bool ChangedSlots[c_NumSlots];
+ memset( ChangedSlots, false, c_NumSlots * sizeof( bool ) );
+
+ if( a_Item.m_ItemCount > 0 ) AddToBar( a_Item, c_HotOffset, c_HotSlots, ChangedSlots, 0 );
+ if( a_Item.m_ItemCount > 0 ) AddToBar( a_Item, c_MainOffset, c_MainSlots, ChangedSlots, 0 );
+ if( a_Item.m_ItemCount > 0 ) AddToBar( a_Item, c_HotOffset, c_HotSlots, ChangedSlots, 2 );
+ if( a_Item.m_ItemCount > 0 ) AddToBar( a_Item, c_MainOffset, c_MainSlots, ChangedSlots, 2 );
+
+ if( a_Item.m_ItemCount > 0 ) // Could not add all items
+ {
+ // retore backup
+ memcpy( m_Slots, BackupSlots, c_NumSlots * sizeof( cItem ) );
+ return false;
+ }
+
+ for(unsigned int i = 0; i < c_NumSlots; i++)
+ {
+ if( ChangedSlots[i] )
+ {
+ LOG("Item was added to %i ID:%i Count:%i", i, m_Slots[i].m_ItemID, m_Slots[i].m_ItemCount );
+ SendSlot(i);
+ }
+ }
+
+ return (a_Item.m_ItemCount == 0);
+}
+
+// TODO: Right now if you dont have enough items, the items you did have are removed, and the function returns false anyway
+bool cInventory::RemoveItem( cItem & a_Item )
+{
+ // First check equipped slot
+ if( m_EquippedSlot >= 0 && m_EquippedSlot < 9 )
+ {
+ if( m_HotSlots[m_EquippedSlot].m_ItemID == a_Item.m_ItemID )
+ {
+ cItem & Item = m_HotSlots[m_EquippedSlot];
+ if(Item.m_ItemCount > a_Item.m_ItemCount)
+ {
+ Item.m_ItemCount -= a_Item.m_ItemCount;
+ SendSlot( m_EquippedSlot + c_HotOffset );
+ return true;
+ }
+ else if(Item.m_ItemCount > 0 )
+ {
+ a_Item.m_ItemCount -= Item.m_ItemCount;
+ Item.Empty();
+ SendSlot( m_EquippedSlot + c_HotOffset );
+ }
+ }
+ }
+
+ // Then check other slotz
+ if( a_Item.m_ItemCount > 0 )
+ {
+ for(int i = 0; i < 36; i++)
+ {
+ cItem & Item = m_MainSlots[i];
+ if( Item.m_ItemID == a_Item.m_ItemID )
+ {
+ if(Item.m_ItemCount > a_Item.m_ItemCount)
+ {
+ Item.m_ItemCount -= a_Item.m_ItemCount;
+ SendSlot( i + c_MainOffset );
+ return true;
+ }
+ else if(Item.m_ItemCount > 0 )
+ {
+ a_Item.m_ItemCount -= Item.m_ItemCount;
+ Item.Empty();
+ SendSlot( i + c_MainOffset );
+ }
+ }
+ }
+ }
+
+ if( a_Item.m_ItemCount == 0 )
+ return true;
+ else
+ return false;
+}
+
+cItem* cInventory::GetSlot( int a_SlotNum )
+{
+ if( a_SlotNum < 0 || a_SlotNum >= (short)c_NumSlots ) return 0;
+ return &m_Slots[a_SlotNum];
+}
+
+cItem* cInventory::GetFromHotBar( int a_SlotNum )
+{
+ if( a_SlotNum < 0 || a_SlotNum >= 9 ) return 0;
+ return &m_HotSlots[a_SlotNum];
+}
+
+void cInventory::SetEquippedSlot( int a_SlotNum )
+{
+ if( a_SlotNum < 0 || a_SlotNum >= 9 ) m_EquippedSlot = 0;
+ else m_EquippedSlot = (short)a_SlotNum;
+}
+
+cItem & cInventory::GetEquippedItem()
+{
+ cItem* Item = GetFromHotBar( m_EquippedSlot );
+ if( Item )
+ {
+ *m_EquippedItem = *Item;
+ return *Item;
+ }
+ else
+ {
+ m_EquippedItem->Empty();
+ }
+ return *m_EquippedItem;
+}
+
+void cInventory::SendWholeInventory( cClientHandle* a_Client )
+{
+ cPacket_WholeInventory Inventory( this );
+ a_Client->Send( Inventory );
+}
+
+void cInventory::SendSlot( int a_SlotNum )
+{
+ cItem* Item = GetSlot( a_SlotNum );
+ if( Item )
+ {
+ cPacket_InventorySlot InventorySlot;
+ InventorySlot.m_ItemCount = Item->m_ItemCount;
+ InventorySlot.m_ItemID = (short)Item->m_ItemID;
+ InventorySlot.m_ItemUses = (char)Item->m_ItemHealth;
+ InventorySlot.m_SlotNum = (short)a_SlotNum;
+ InventorySlot.m_WindowID = 0; // Inventory window ID
+ m_Owner->GetClientHandle()->Send( InventorySlot );
+ }
+}
+
+void cInventory::DrawInventory()
+{
+ printf("%i %i %i %i\n", m_ArmorSlots[0].m_ItemCount, m_ArmorSlots[1].m_ItemCount, m_CraftSlots[0].m_ItemCount, m_CraftSlots[1].m_ItemCount );
+ printf("%i %i %i %i\n", m_ArmorSlots[2].m_ItemCount, m_ArmorSlots[3].m_ItemCount, m_CraftSlots[2].m_ItemCount, m_CraftSlots[3].m_ItemCount );
+ for(int y = 0; y < 4; y++)
+ {
+ for(int x = 0; x < 9; x++)
+ {
+ printf("%i ", m_MainSlots[x + y*9].m_ItemCount );
+ }
+ printf("\n");
+ }
+}
+
+void cInventory::WriteToFile(FILE* a_File)
+{
+ for(unsigned int i = 0; i < c_NumSlots; i++)
+ {
+ cItem & Item = m_Slots[i];
+ fwrite( &Item.m_ItemID, sizeof(Item.m_ItemID), 1, a_File );
+ fwrite( &Item.m_ItemCount, sizeof(Item.m_ItemCount), 1, a_File );
+ fwrite( &Item.m_ItemHealth, sizeof(Item.m_ItemHealth), 1, a_File );
+ }
+}
+
+bool cInventory::LoadFromFile(FILE* a_File)
+{
+ for(unsigned int i = 0; i < c_NumSlots; i++)
+ {
+ cItem & Item = m_Slots[i];
+ if( fread( &Item.m_ItemID, sizeof(Item.m_ItemID), 1, a_File) != 1 ) { LOGERROR("ERROR READING INVENTORY FROM FILE"); return false; }
+ if( fread( &Item.m_ItemCount, sizeof(Item.m_ItemCount), 1, a_File) != 1 ) { LOGERROR("ERROR READING INVENTORY FROM FILE"); return false; }
+ if( fread( &Item.m_ItemHealth, sizeof(Item.m_ItemHealth), 1, a_File)!= 1 ) { LOGERROR("ERROR READING INVENTORY FROM FILE"); return false; }
+ }
+ return true;
+}
diff --git a/source/cInventory.h b/source/cInventory.h new file mode 100644 index 000000000..19460142f --- /dev/null +++ b/source/cInventory.h @@ -0,0 +1,67 @@ +#pragma once
+
+#include "MemoryLeak.h"
+#include "cWindowOwner.h"
+#include "FileDefine.h"
+
+class cItem;
+class cClientHandle;
+class cPlayer;
+class cPacket_WindowClick;
+class cPacket_EntityEquipment;
+class cInventory //tolua_export
+ : public cWindowOwner
+{ //tolua_export
+public:
+ cInventory(cPlayer* a_Owner);
+ ~cInventory();
+
+ void Clear(); //tolua_export
+
+ cItem* GetSlotsForType( int a_Type );
+ int GetSlotCountForType( int a_Type );
+
+ bool AddItem( cItem & a_Item ); //tolua_export
+ bool RemoveItem( cItem & a_Item ); //tolua_export
+ void DrawInventory();
+
+ void WriteToFile(FILE* a_File);
+ bool LoadFromFile(FILE* a_File);
+
+ void SendWholeInventory( cClientHandle* a_Client );
+
+ cItem* GetSlot( int a_SlotNum ); //tolua_export
+ cItem* GetSlots() { return m_Slots; }
+ cItem* GetFromHotBar( int a_SlotNum ); //tolua_export
+
+ cItem & GetEquippedItem(); //tolua_export
+ void SetEquippedSlot( int a_SlotNum ); //tolua_export
+
+ void Clicked( cPacket_WindowClick* a_ClickPacket );
+
+ void SendSlot( int a_SlotNum ); //tolua_export
+
+ static const unsigned int c_NumSlots = 45;
+ static const unsigned int c_MainSlots = 27;
+ static const unsigned int c_HotSlots = 9;
+ static const unsigned int c_CraftSlots = 4;
+ static const unsigned int c_ArmorSlots = 4;
+
+ static const unsigned int c_CraftOffset = 0;
+ static const unsigned int c_ArmorOffset = 5;
+ static const unsigned int c_MainOffset = 9;
+ static const unsigned int c_HotOffset = 36;
+private:
+ bool AddToBar( cItem & a_Item, const int a_Offset, const int a_Size, bool* a_bChangedSlots, int a_Mode = 0 );
+
+ cItem* m_Slots;
+ cItem* m_MainSlots;
+ cItem* m_CraftSlots;
+ cItem* m_ArmorSlots;
+ cItem* m_HotSlots;
+
+ cItem* m_EquippedItem;
+ short m_EquippedSlot;
+
+ cPlayer* m_Owner;
+}; //tolua_export
\ No newline at end of file diff --git a/source/cItem.h b/source/cItem.h new file mode 100644 index 000000000..edf3468ac --- /dev/null +++ b/source/cItem.h @@ -0,0 +1,33 @@ +#pragma once
+
+#include "Defines.h"
+#include "BlockID.h"
+
+class cItem //tolua_export
+{ //tolua_export
+public:
+ cItem( ENUM_ITEM_ID a_ItemID = E_ITEM_EMPTY, char a_ItemCount = 0, short a_ItemHealth = 0 ) //tolua_export
+ : m_ItemID ( a_ItemID )
+ , m_ItemCount ( a_ItemCount )
+ , m_ItemHealth ( a_ItemHealth )
+ { //tolua_export
+ if(!isValidItem( m_ItemID ) ) m_ItemID = E_ITEM_EMPTY;
+ } //tolua_export
+ void Empty() //tolua_export
+ { //tolua_export
+ m_ItemID = E_ITEM_EMPTY;
+ m_ItemCount = 0;
+ m_ItemHealth = 0;
+ } //tolua_export
+ bool IsEmpty() //tolua_export
+ { //tolua_export
+ return (m_ItemID <= 0 || m_ItemCount <= 0);
+ } //tolua_export
+ bool Equals( cItem & a_Item ) //tolua_export
+ { //tolua_export
+ return ( (m_ItemID == a_Item.m_ItemID) && (m_ItemHealth == a_Item.m_ItemHealth) );
+ } //tolua_export
+ ENUM_ITEM_ID m_ItemID; //tolua_export
+ char m_ItemCount; //tolua_export
+ short m_ItemHealth; //tolua_export
+}; //tolua_export
\ No newline at end of file diff --git a/source/cLadder.h b/source/cLadder.h new file mode 100644 index 000000000..be3964f10 --- /dev/null +++ b/source/cLadder.h @@ -0,0 +1,43 @@ +#pragma once
+
+class cLadder //tolua_export
+{ //tolua_export
+public:
+
+ static char DirectionToMetaData( char a_Direction ) //tolua_export
+ { //tolua_export
+ switch( a_Direction )
+ {
+ case 0x2:
+ return 0x2;
+ case 0x3:
+ return 0x3;
+ case 0x4:
+ return 0x4;
+ case 0x5:
+ return 0x5;
+ default:
+ break;
+ };
+ return 0x2;
+ } //tolua_export
+
+ static char MetaDataToDirection( char a_MetaData ) //tolua_export
+ { //tolua_export
+ switch( a_MetaData )
+ {
+ case 0x2:
+ return 0x2;
+ case 0x3:
+ return 0x3;
+ case 0x4:
+ return 0x4;
+ case 0x5:
+ return 0x5;
+ default:
+ break;
+ };
+ return 0x2;
+ } //tolua_export
+
+}; //tolua_export
\ No newline at end of file diff --git a/source/cLog.cpp b/source/cLog.cpp new file mode 100644 index 000000000..105916a2f --- /dev/null +++ b/source/cLog.cpp @@ -0,0 +1,136 @@ +#include "cLog.h"
+#include <fstream>
+#include <ctime>
+#include <stdarg.h>
+
+#ifdef _WIN32
+#include <Windows.h>
+#else
+#include <sys/stat.h> // for mkdir
+#include <sys/types.h>
+
+#define sprintf_s(buffer, buffer_size, stringbuffer, ...) (sprintf(buffer, stringbuffer, __VA_ARGS__))
+#define vsnprintf_s(buffer, buffer_size, maxcount, stringbuffer, ...) (vsnprintf(buffer, maxcount, stringbuffer, __VA_ARGS__))
+#endif
+
+#include <string>
+
+cLog* cLog::s_Log = NULL;
+
+cLog::cLog( const char* a_FileName )
+ : m_File(NULL)
+{
+ s_Log = this;
+
+ // create logs directory
+#ifdef _WIN32
+ {
+ SECURITY_ATTRIBUTES Attrib;
+ Attrib.nLength = sizeof(SECURITY_ATTRIBUTES);
+ Attrib.lpSecurityDescriptor = NULL;
+ Attrib.bInheritHandle = false;
+ ::CreateDirectory("logs", &Attrib);
+ }
+#else
+ {
+ mkdir("logs", S_IRWXU | S_IRWXG | S_IRWXO);
+ }
+#endif
+
+ OpenLog( (std::string("logs/") + std::string(a_FileName)).c_str() );
+}
+
+cLog::~cLog()
+{
+ CloseLog();
+ s_Log = NULL;
+}
+
+cLog* cLog::GetInstance()
+{
+ if(s_Log)
+ return s_Log;
+
+ new cLog("log.txt");
+ return s_Log;
+}
+
+void cLog::CloseLog()
+{
+ if( m_File )
+ fclose (m_File);
+ m_File = 0;
+}
+
+void cLog::OpenLog( const char* a_FileName )
+{
+ if(m_File) fclose (m_File);
+ #ifdef _WIN32
+ fopen_s( &m_File, a_FileName, "a+" );
+ #else
+ m_File = fopen(a_FileName, "a+" );
+ #endif
+}
+
+void cLog::ClearLog()
+{
+ #ifdef _WIN32
+ if( fopen_s( &m_File, "log.txt", "w" ) == 0)
+ fclose (m_File);
+ #else
+ m_File = fopen("log.txt", "w" );
+ if( m_File )
+ fclose (m_File);
+ #endif
+ m_File = 0;
+}
+
+void cLog::Log(const char* a_Format, va_list argList )
+{
+ char c_Buffer[1024];
+
+ if( argList != 0 )
+ {
+ vsnprintf_s(c_Buffer, 1024, 1024, a_Format, argList );
+ }
+ else
+ {
+ sprintf_s( c_Buffer, 1024, "%s", a_Format );
+ }
+
+ time_t rawtime;
+ time ( &rawtime );
+#ifdef _WIN32
+ struct tm timeinfo;
+ localtime_s( &timeinfo, &rawtime );
+#else
+ struct tm* timeinfo;
+ timeinfo = localtime( &rawtime );
+#endif
+ char c_Buffer2[1024];
+#ifdef _WIN32
+ sprintf_s(c_Buffer2, 1024, "[%02d:%02d:%02d] %s\n", timeinfo.tm_hour, timeinfo.tm_min, timeinfo.tm_sec, c_Buffer);
+#else
+ sprintf(c_Buffer2, "[%02d:%02d:%02d] %s\n", timeinfo->tm_hour, timeinfo->tm_min, timeinfo->tm_sec, c_Buffer);
+#endif
+ if(m_File){
+ fputs(c_Buffer2, m_File);
+ fflush(m_File);
+ }
+
+
+ printf("%s", c_Buffer2 );
+}
+
+void cLog::Log(const char* a_Format, ...)
+{
+ va_list argList;
+ va_start(argList, a_Format);
+ Log( a_Format, argList );
+ va_end(argList);
+}
+
+void cLog::SimpleLog(const char* a_String)
+{
+ Log("%s", a_String );
+}
diff --git a/source/cLog.h b/source/cLog.h new file mode 100644 index 000000000..b2292ba7b --- /dev/null +++ b/source/cLog.h @@ -0,0 +1,30 @@ +#pragma once
+
+#include "MemoryLeak.h"
+#include "FileDefine.h"
+
+#ifndef _WIN32
+#include <stdarg.h>
+#endif
+
+class cLog { // tolua_export
+private:
+ FILE* m_File;
+ static cLog* s_Log;
+
+#ifdef _WIN32
+ typedef char* va_list;
+#endif
+public:
+ cLog( const char* a_FileName );
+ ~cLog();
+ void Log(const char* a_Format, va_list argList );
+ void Log(const char* a_Format, ...);
+ //tolua_begin
+ void SimpleLog(const char* a_String);
+ void OpenLog( const char* a_FileName );
+ void CloseLog();
+ void ClearLog();
+ static cLog* GetInstance();
+};
+//tolua_end
diff --git a/source/cLuaCommandBinder.cpp b/source/cLuaCommandBinder.cpp new file mode 100644 index 000000000..a800513e1 --- /dev/null +++ b/source/cLuaCommandBinder.cpp @@ -0,0 +1,106 @@ +#include "cLuaCommandBinder.h"
+#include "cMCLogger.h"
+#include "cPlayer.h"
+#include "cPlugin_Lua.h"
+
+#include "tolua++.h"
+
+extern std::vector<std::string> StringSplit(std::string str, std::string delim);
+extern bool report_errors(lua_State* lua, int status);
+
+cLuaCommandBinder::cLuaCommandBinder()
+{
+}
+
+cLuaCommandBinder::~cLuaCommandBinder()
+{
+}
+
+void cLuaCommandBinder::ClearBindings()
+{
+ m_BoundCommands.clear();
+}
+
+void cLuaCommandBinder::RemoveBindingsForPlugin( cPlugin* a_Plugin )
+{
+ for( CommandMap::iterator itr = m_BoundCommands.begin(); itr != m_BoundCommands.end(); )
+ {
+ if( itr->second.Plugin == a_Plugin )
+ {
+ LOGINFO("Unbinding %s ", itr->first.c_str( ) );
+ luaL_unref( itr->second.LuaState, LUA_REGISTRYINDEX, itr->second.Reference ); // unreference
+ CommandMap::iterator eraseme = itr;
+ ++itr;
+ m_BoundCommands.erase( eraseme );
+ continue;
+ }
+ ++itr;
+ }
+}
+
+bool cLuaCommandBinder::BindCommand( const std::string & a_Command, const std::string & a_Permission, cPlugin* a_Plugin, lua_State * a_LuaState, int a_FunctionReference )
+{
+ if( m_BoundCommands.find( a_Command ) != m_BoundCommands.end() )
+ {
+ LOGERROR("ERROR: Trying to bind command \"%s\" that has already been bound.", a_Command.c_str() );
+ return false;
+ }
+ LOGINFO("Binding %s (%s)", a_Command.c_str(), a_Permission.c_str() );
+ m_BoundCommands[ a_Command ] = BoundFunction( a_Plugin, a_LuaState, a_FunctionReference, a_Permission );
+ return true;
+}
+
+bool cLuaCommandBinder::HandleCommand( const std::string & a_Command, cPlayer* a_Player )
+{
+ std::vector<std::string> Split = StringSplit( a_Command, " ");
+ CommandMap::iterator FoundCommand = m_BoundCommands.find( Split[0] );
+ if( FoundCommand != m_BoundCommands.end() )
+ {
+ const BoundFunction & func = FoundCommand->second;
+ if( func.Permission.size() > 0 )
+ {
+ if( !a_Player->HasPermission( func.Permission.c_str() ) )
+ {
+ return false;
+ }
+ }
+
+ // For enabling 'self' in the function, it's kind of a hack I'm not sure this is the way to go
+ lua_pushvalue(func.LuaState, LUA_GLOBALSINDEX);
+ lua_pushstring(func.LuaState, "self");
+ tolua_pushusertype( func.LuaState, func.Plugin, "cPlugin" );
+ lua_rawset(func.LuaState, -3);
+ lua_pop(func.LuaState, 1);
+
+ LOGINFO("1. Stack size: %i", lua_gettop(func.LuaState) );
+ lua_rawgeti( func.LuaState, LUA_REGISTRYINDEX, func.Reference); // same as lua_getref()
+
+ // Push the split
+ LOGINFO("2. Stack size: %i", lua_gettop(func.LuaState) );
+ lua_createtable(func.LuaState, Split.size(), 0);
+ int newTable = lua_gettop(func.LuaState);
+ int index = 1;
+ std::vector<std::string>::const_iterator iter = Split.begin();
+ while(iter != Split.end()) {
+ tolua_pushstring( func.LuaState, (*iter).c_str() );
+ lua_rawseti(func.LuaState, newTable, index);
+ ++iter;
+ ++index;
+ }
+ LOGINFO("3. Stack size: %i", lua_gettop(func.LuaState) );
+ // Push player
+ tolua_pushusertype( func.LuaState, a_Player, "cPlayer" );
+ LOGINFO("Calling bound function! :D");
+ int s = lua_pcall(func.LuaState, 2, 1, 0);
+ if( report_errors( func.LuaState, s ) )
+ {
+ LOGINFO("error. Stack size: %i", lua_gettop(func.LuaState) );
+ return false;
+ }
+ bool RetVal = (tolua_toboolean(func.LuaState, -1, 0) > 0);
+ lua_pop(func.LuaState, 1); // Pop return value
+ LOGINFO("ok. Stack size: %i", lua_gettop(func.LuaState) );
+ return RetVal;
+ }
+ return false;
+}
diff --git a/source/cLuaCommandBinder.h b/source/cLuaCommandBinder.h new file mode 100644 index 000000000..bafc16ee8 --- /dev/null +++ b/source/cLuaCommandBinder.h @@ -0,0 +1,36 @@ +#pragma once
+
+#include <vector>
+#include <string>
+#include <map>
+
+struct lua_State;
+class cPlugin;
+class cPlayer;
+class cLuaCommandBinder
+{
+public:
+ cLuaCommandBinder();
+ ~cLuaCommandBinder();
+
+ bool HandleCommand( const std::string & a_Command, cPlayer* a_Player );
+
+ bool BindCommand( const std::string & a_Command, const std::string & a_Permission, cPlugin* a_Plugin, lua_State * a_LuaState, int a_FunctionReference );
+
+ void ClearBindings();
+ void RemoveBindingsForPlugin( cPlugin* a_Plugin );
+private:
+ struct BoundFunction
+ {
+ BoundFunction() : Plugin( 0 ), LuaState( 0 ), Reference( 0 ) {}
+ BoundFunction( cPlugin* a_Plugin, lua_State * a_LuaState, int a_Reference, const std::string & a_Permission ) : Plugin( a_Plugin ), LuaState( a_LuaState ), Reference( a_Reference ), Permission( a_Permission ) {}
+ cPlugin* Plugin;
+ lua_State* LuaState;
+ int Reference;
+ std::string Permission;
+ };
+
+ typedef std::map< std::string, BoundFunction > CommandMap;
+ CommandMap m_BoundCommands;
+
+};
diff --git a/source/cMCLogger.cpp b/source/cMCLogger.cpp new file mode 100644 index 000000000..0c6d25df3 --- /dev/null +++ b/source/cMCLogger.cpp @@ -0,0 +1,155 @@ +#include "cMCLogger.h"
+#include "cLog.h"
+#include "cCriticalSection.h"
+
+#include <stdio.h>
+#include <cstdarg>
+#include <time.h>
+
+#ifndef _WIN32
+#define sprintf_s(buffer, buffer_size, stringbuffer, ...) (sprintf(buffer, stringbuffer, __VA_ARGS__))
+#else
+#include <Windows.h>
+#endif
+
+cMCLogger* cMCLogger::s_MCLogger = 0;
+
+cMCLogger* cMCLogger::GetInstance()
+{
+ return s_MCLogger;
+}
+
+cMCLogger::cMCLogger()
+{
+ m_CriticalSection = new cCriticalSection();
+ char c_Buffer[128];
+ sprintf_s(c_Buffer, 128, "LOG_%d.txt", (int)time(0) );
+ m_Log = new cLog(c_Buffer);
+ m_Log->Log("--- Started Log ---");
+
+ s_MCLogger = this;
+}
+
+cMCLogger::cMCLogger( char* a_File )
+{
+ m_CriticalSection = new cCriticalSection();
+ m_Log = new cLog( a_File );
+}
+
+cMCLogger::~cMCLogger()
+{
+ m_Log->Log("--- Stopped Log ---");
+ delete m_Log;
+ delete m_CriticalSection;
+ if( this == s_MCLogger )
+ s_MCLogger = 0;
+}
+
+void cMCLogger::LogSimple(const char* a_Text, int a_LogType /* = 0 */ )
+{
+ switch( a_LogType )
+ {
+ case 0:
+ Log(a_Text, 0);
+ break;
+ case 1:
+ Info(a_Text, 0);
+ break;
+ case 2:
+ Warn(a_Text, 0);
+ break;
+ case 3:
+ Error(a_Text, 0);
+ break;
+ default:
+ Log(a_Text, 0);
+ break;
+ }
+}
+
+void cMCLogger::Log(const char* a_Format, va_list a_ArgList)
+{
+ m_CriticalSection->Lock();
+ SetColor( 0x7 ); // 0x7 is default grey color
+ m_Log->Log( a_Format, a_ArgList );
+ m_CriticalSection->Unlock();
+}
+
+void cMCLogger::Info(const char* a_Format, va_list a_ArgList)
+{
+ m_CriticalSection->Lock();
+// for( int i = 0; i < 16; i++)
+// {
+// for( int j = 0; j < 16; j++ )
+// {
+// SetConsoleTextAttribute( hConsole, i | (j<<4) );
+// printf("0x%x", (i|j<<4));
+// }
+// printf("\n");
+// }
+
+ SetColor( 0xe ); // 0xe is yellow
+ m_Log->Log( a_Format, a_ArgList );
+ m_CriticalSection->Unlock();
+}
+
+void cMCLogger::Warn(const char* a_Format, va_list a_ArgList)
+{
+ m_CriticalSection->Lock();
+ SetColor( 0xc ); // 0xc is red
+ m_Log->Log( a_Format, a_ArgList );
+ m_CriticalSection->Unlock();
+}
+
+void cMCLogger::Error(const char* a_Format, va_list a_ArgList)
+{
+ m_CriticalSection->Lock();
+ SetColor( 0xc0 ); // 0xc0 is red bg and black text
+ m_Log->Log( a_Format, a_ArgList );
+ m_CriticalSection->Unlock();
+}
+
+void cMCLogger::SetColor( unsigned char a_Color )
+{
+#ifdef _WIN32
+ HANDLE hConsole = GetStdHandle( STD_OUTPUT_HANDLE );
+ SetConsoleTextAttribute( hConsole, a_Color );
+#else
+ (void)a_Color;
+#endif
+}
+
+
+//////////////////////////////////////////////////////////////////////////
+// Global functions
+void LOG(const char* a_Format, ...)
+{
+ va_list argList;
+ va_start(argList, a_Format);
+ cMCLogger::GetInstance()->Log( a_Format, argList );
+ va_end(argList);
+}
+
+void LOGINFO(const char* a_Format, ...)
+{
+ va_list argList;
+ va_start(argList, a_Format);
+ cMCLogger::GetInstance()->Info( a_Format, argList );
+ va_end(argList);
+}
+
+void LOGWARN(const char* a_Format, ...)
+{
+ va_list argList;
+ va_start(argList, a_Format);
+ cMCLogger::GetInstance()->Warn( a_Format, argList );
+ va_end(argList);
+}
+
+void LOGERROR(const char* a_Format, ...)
+{
+ va_list argList;
+ va_start(argList, a_Format);
+ cMCLogger::GetInstance()->Error( a_Format, argList );
+ va_end(argList);
+}
diff --git a/source/cMCLogger.h b/source/cMCLogger.h new file mode 100644 index 000000000..4bfae66f1 --- /dev/null +++ b/source/cMCLogger.h @@ -0,0 +1,39 @@ +#pragma once
+
+#ifndef _WIN32
+#include <stdarg.h>
+#endif
+
+class cCriticalSection;
+class cLog;
+class cMCLogger //tolua_export
+{ //tolua_export
+private:
+#ifdef _WIN32
+ typedef char* va_list;
+#endif
+public: //tolua_export
+ cMCLogger();
+ cMCLogger( char* a_File ); //tolua_export
+ ~cMCLogger(); //tolua_export
+
+ void Log(const char* a_Format, va_list a_ArgList);
+ void Info(const char* a_Format, va_list a_ArgList);
+ void Warn(const char* a_Format, va_list a_ArgList);
+ void Error(const char* a_Format, va_list a_ArgList);
+
+ void LogSimple(const char* a_Text, int a_LogType = 0 ); //tolua_export
+
+ static cMCLogger* GetInstance();
+private:
+ void SetColor( unsigned char a_Color );
+
+ cCriticalSection* m_CriticalSection;
+ cLog* m_Log;
+ static cMCLogger* s_MCLogger;
+}; //tolua_export
+
+extern void LOG(const char* a_Format, ...);
+extern void LOGINFO(const char* a_Format, ...);
+extern void LOGWARN(const char* a_Format, ...);
+extern void LOGERROR(const char* a_Format, ...);
\ No newline at end of file diff --git a/source/cMakeDir.cpp b/source/cMakeDir.cpp new file mode 100644 index 000000000..a4d62afdd --- /dev/null +++ b/source/cMakeDir.cpp @@ -0,0 +1,24 @@ +#include "cMakeDir.h"
+
+#ifndef _WIN32
+//#include <cstring> // If something is missing, uncomment some of these!
+//#include <cstdlib>
+//#include <stdio.h>
+#include <sys/stat.h> // for mkdir
+//#include <sys/types.h>
+#else
+#include <Windows.h>
+#endif
+
+void cMakeDir::MakeDir( const char* a_Directory )
+{
+#ifdef _WIN32
+ SECURITY_ATTRIBUTES Attrib;
+ Attrib.nLength = sizeof(SECURITY_ATTRIBUTES);
+ Attrib.lpSecurityDescriptor = NULL;
+ Attrib.bInheritHandle = false;
+ ::CreateDirectory("world", &Attrib);
+#else
+ mkdir("world", S_IRWXU | S_IRWXG | S_IRWXO);
+#endif
+}
\ No newline at end of file diff --git a/source/cMakeDir.h b/source/cMakeDir.h new file mode 100644 index 000000000..378df2a36 --- /dev/null +++ b/source/cMakeDir.h @@ -0,0 +1,7 @@ +#pragma once
+
+class cMakeDir
+{
+public:
+ static void MakeDir( const char* a_Directory );
+};
\ No newline at end of file diff --git a/source/cMonster.cpp b/source/cMonster.cpp new file mode 100644 index 000000000..63ef1d862 --- /dev/null +++ b/source/cMonster.cpp @@ -0,0 +1,609 @@ +#include "cMonster.h"
+#include "cRoot.h"
+#include "cServer.h"
+#include "cClientHandle.h"
+#include "cWorld.h"
+#include "cMCLogger.h"
+#include "cChunk.h"
+#include "cPlayer.h"
+#include "BlockID.h"
+#include "Defines.h"
+
+#include "packets/cPacket_SpawnMob.h"
+#include "packets/cPacket_EntityLook.h"
+#include "packets/cPacket_TeleportEntity.h"
+#include "packets/cPacket_RelativeEntityMoveLook.h"
+#include "packets/cPacket_RelativeEntityMove.h"
+#include "packets/cPacket_Metadata.h"
+
+#include "Vector3f.h"
+#include "Vector3i.h"
+#include "Vector3d.h"
+
+#include "cTracer.h"
+#include "../iniFile/iniFile.h"
+
+#ifndef _WIN32
+#include <cstdlib> // rand
+#include <unistd.h>
+#include <string.h>
+#endif
+
+#include <string>
+
+
+cMonster::cMonster()
+ : m_Target(0)
+ , m_Destination( new Vector3f() )
+ , m_bMovingToDestination(false)
+ , m_Speed( new Vector3f() )
+ , m_DestinationTime( 0 )
+ , m_Gravity( -9.81 )
+ , m_bOnGround( false )
+ , m_DestroyTimer( 0 )
+ , m_Jump(0)
+ , m_MobType( 0 )
+ , m_EMState(IDLE)
+ , m_SightDistance(25)
+ ,m_SeePlayerInterval (0)
+ ,m_EMPersonality(AGGRESSIVE)
+ ,m_AttackDamage(1.0)
+ ,m_AttackRange(5.0)
+ ,m_AttackInterval(0)
+ ,m_AttackRate(3)
+ ,m_bPassiveAggressive(false)
+ ,idle_interval(0)
+ ,m_bBurnable(true)
+ ,m_EMMetaState(NORMAL)
+ ,m_FireDamageInterval(0)
+ ,m_BurnPeriod(0)
+{
+ LOG("cMonster::cMonster()");
+ LOG("In state: %s",GetState());
+ m_Health = 10;
+
+ int RandVal = rand() % 4;
+ if( RandVal == 0 )
+ m_MobType = 90; // Pig
+ else if( RandVal == 1 )
+ m_MobType = 91; // Sheep
+ else if( RandVal == 2 )
+ m_MobType = 92; // Cow
+ else
+ m_MobType = 93; // Hen
+}
+
+cMonster::~cMonster()
+{
+
+ LOG("cMonster::~cMonster()");
+ delete m_Destination;
+ delete m_Speed;
+}
+
+bool cMonster::IsA( const char* a_EntityType )
+{
+ //LOG("IsA( cMonster ) : %s", a_EntityType);
+ if( strcmp( a_EntityType, "cMonster" ) == 0 ) return true;
+ return cPawn::IsA( a_EntityType );
+}
+
+void cMonster::SpawnOn( cClientHandle* a_Target )
+{
+ LOG("Spawn monster on client");
+ cPacket_SpawnMob Spawn;
+ Spawn.m_UniqueID = GetUniqueID();
+ Spawn.m_Type = m_MobType;
+ *Spawn.m_Pos = Vector3i((*m_Pos)*32);
+ Spawn.m_Yaw = 0;
+ Spawn.m_Pitch = 0;
+ Spawn.m_MetaDataSize = 1;
+ Spawn.m_MetaData = new char[Spawn.m_MetaDataSize];
+ Spawn.m_MetaData[0] = 0x7f; // not on fire/crouching/riding
+ //Spawn.m_MetaData[1] = 0x7f; // terminator
+ if( a_Target == 0 )
+ {
+ cChunk* Chunk = cRoot::Get()->GetWorld()->GetChunk( m_ChunkX, m_ChunkY, m_ChunkZ );
+ Chunk->Broadcast( Spawn );
+ }
+ else
+ {
+ a_Target->Send( Spawn );
+ }
+}
+
+void cMonster::MoveToPosition( const Vector3f & a_Position )
+{
+ m_bMovingToDestination = true;
+
+ *m_Destination = a_Position;
+}
+
+bool cMonster::ReachedDestination()
+{
+ Vector3f Distance = (*m_Destination) - Vector3f( m_Pos );
+ if( Distance.SqrLength() < 2.f )
+ return true;
+
+ return false;
+}
+
+void cMonster::Tick(float a_Dt)
+{
+ if( m_Health <= 0 )
+ {
+ m_DestroyTimer += a_Dt/1000;
+ if( m_DestroyTimer > 1 )
+ {
+ Destroy();
+ }
+ return;
+ }
+
+ //a_Dt/=1000;
+ a_Dt/=1000;
+
+ if( m_bMovingToDestination )
+ {
+ Vector3f Pos( m_Pos );
+ Vector3f Distance = *m_Destination - Pos;
+ if( !ReachedDestination() )
+ {
+ Distance.y = 0;
+ Distance.Normalize();
+ Distance*=3;
+ m_Speed->x = Distance.x;
+ m_Speed->z = Distance.z;
+ }
+ else
+ {
+ m_bMovingToDestination = false;
+ }
+
+ if( m_Speed->SqrLength() > 0.f )
+ {
+ if( m_bOnGround )
+ {
+ Vector3f NormSpeed = m_Speed->NormalizeCopy();
+ Vector3f NextBlock = Vector3f( *m_Pos ) + NormSpeed;
+ double NextHeight = (double)cRoot::Get()->GetWorld()->GetHeight( (int)NextBlock.x, (int)NextBlock.z );
+ if( NextHeight > m_Pos->y - 1.2 && NextHeight - m_Pos->y < 2.5 )
+ {
+ m_bOnGround = false;
+ m_Speed->y = 7.f; // Jump!!
+ }
+ }
+ }
+ }
+
+ HandlePhysics( a_Dt );
+
+ ReplicateMovement();
+
+ Vector3f Distance = *m_Destination - Vector3f( m_Pos );
+ if( Distance.SqrLength() > 0.1f )
+ {
+ float Rotation, Pitch;
+ Distance.Normalize();
+ VectorToEuler( Distance.x, Distance.y, Distance.z, Rotation, Pitch );
+ SetRotation( Rotation );
+ SetPitch( Pitch );
+ }
+
+ CheckMetaDataBurn(); //Check to see if Enemy should burn based on block they are on
+
+ if(m_EMMetaState == BURNING) {
+ InStateBurning(a_Dt);
+ }
+
+ if(m_EMState == IDLE) { //If enemy passive we ignore checks for player visibility
+ InStateIdle(a_Dt);
+ }
+
+ if(m_EMState == CHASING) { //If we do not see a player anymore skip chasing action
+ InStateChasing(a_Dt);
+ }
+
+ if(m_EMState == ESCAPING) {
+ InStateEscaping(a_Dt);
+ }
+
+ m_SeePlayerInterval += a_Dt;
+ if(m_SeePlayerInterval > 1) {
+ int rem = rand()%3 + 1; //check most of the time but miss occasionally
+ //LOG("See Player Interval: %3.3f",m_SeePlayerInterval);
+ m_SeePlayerInterval = 0.0;
+ if(rem >= 2) {
+ if(m_EMState == IDLE && m_EMPersonality != PASSIVE) {
+ CheckEventSeePlayer();
+ return;
+ }
+ if(m_EMState == CHASING || m_EMState == ESCAPING){
+ CheckEventLostPlayer();
+ return;
+ }
+ }
+ }
+
+
+}
+
+void cMonster::ReplicateMovement()
+{
+ cChunk* InChunk = cRoot::Get()->GetWorld()->GetChunkUnreliable( m_ChunkX, m_ChunkY, m_ChunkZ );
+ if( !InChunk ) return;
+
+ if(m_bDirtyOrientation && !m_bDirtyPosition)
+ {
+ cPacket_EntityLook EntityLook( this );
+ InChunk->Broadcast( EntityLook );
+ m_bDirtyOrientation = false;
+ }
+ if( m_bDirtyPosition )
+ {
+
+ float DiffX = (float)(GetPosX() - m_LastPosX );
+ float DiffY = (float)(GetPosY() - m_LastPosY );
+ float DiffZ = (float)(GetPosZ() - m_LastPosZ );
+ float SqrDist = DiffX*DiffX + DiffY*DiffY + DiffZ*DiffZ;
+ if( SqrDist > 4*4 // 4 blocks is max Relative Move
+ || cWorld::GetTime() - m_TimeLastTeleportPacket > 2 ) // Send an absolute position every 2 seconds
+ {
+ //LOG("Teleported %f", sqrtf(SqrDist) );
+ cPacket_TeleportEntity TeleportEntity( this );
+ InChunk->Broadcast( TeleportEntity );
+ m_TimeLastTeleportPacket = cWorld::GetTime();
+ }
+ else
+ { // Relative move sucks balls! It's always wrong wtf!
+ if( m_bDirtyOrientation )
+ {
+ cPacket_RelativeEntityMoveLook RelativeEntityMoveLook;
+ RelativeEntityMoveLook.m_UniqueID = GetUniqueID();
+ RelativeEntityMoveLook.m_MoveX = (char)(DiffX*32);
+ RelativeEntityMoveLook.m_MoveY = (char)(DiffY*32);
+ RelativeEntityMoveLook.m_MoveZ = (char)(DiffZ*32);
+ RelativeEntityMoveLook.m_Yaw = (char)((GetRotation()/360.f)*256);
+ RelativeEntityMoveLook.m_Pitch = (char)((GetPitch()/360.f)*256);
+ InChunk->Broadcast( RelativeEntityMoveLook );
+ }
+ else
+ {
+ cPacket_RelativeEntityMove RelativeEntityMove;
+ RelativeEntityMove.m_UniqueID = GetUniqueID();
+ RelativeEntityMove.m_MoveX = (char)(DiffX*32);
+ RelativeEntityMove.m_MoveY = (char)(DiffY*32);
+ RelativeEntityMove.m_MoveZ = (char)(DiffZ*32);
+ InChunk->Broadcast( RelativeEntityMove );
+ }
+ }
+ m_LastPosX = GetPosX();
+ m_LastPosY = GetPosY();
+ m_LastPosZ = GetPosZ();
+ m_bDirtyPosition = false;
+ }
+}
+
+void cMonster::HandlePhysics(float a_Dt)
+{
+ if( m_bOnGround ) // check if it's still on the ground
+ {
+ cWorld* World = cRoot::Get()->GetWorld();
+ if( World->GetBlock( (int)m_Pos->x, (int)m_Pos->y -1, (int)m_Pos->z ) == E_BLOCK_AIR )
+ {
+ m_bOnGround = false;
+ }
+ if( World->GetBlock( (int)m_Pos->x, (int)m_Pos->y, (int)m_Pos->z ) != E_BLOCK_AIR ) // If in ground itself, push it out
+ {
+ m_bOnGround = true;
+ m_Pos->y += 0.2;
+ m_bDirtyPosition = true;
+ }
+ m_Speed->x *= 0.7f/(1+a_Dt);
+ if( fabs(m_Speed->x) < 0.05 ) m_Speed->x = 0;
+ m_Speed->z *= 0.7f/(1+a_Dt);
+ if( fabs(m_Speed->z) < 0.05 ) m_Speed->z = 0;
+ }
+
+ if( !m_bOnGround )
+ {
+ float Gravity = -9.81f*a_Dt;
+ m_Speed->y += Gravity;
+ }
+
+ if( m_Speed->SqrLength() > 0.f )
+ {
+ cTracer Tracer( cRoot::Get()->GetWorld() );
+ int Ret = Tracer.Trace( *m_Pos, *m_Speed, 2 );
+ if( Ret ) // Oh noez! we hit something
+ {
+ // Set to hit position
+ if( (*Tracer.RealHit - Vector3f(*m_Pos)).SqrLength() <= ( *m_Speed * a_Dt ).SqrLength() )
+ {
+ if( Ret == 1 )
+ {
+
+ if( Tracer.HitNormal->x != 0.f ) m_Speed->x = 0.f;
+ if( Tracer.HitNormal->y != 0.f ) m_Speed->y = 0.f;
+ if( Tracer.HitNormal->z != 0.f ) m_Speed->z = 0.f;
+
+ if( Tracer.HitNormal->y > 0 ) // means on ground
+ {
+ m_bOnGround = true;
+ }
+ }
+ *m_Pos = Tracer.RealHit;
+ *m_Pos += *Tracer.HitNormal * 0.2;
+
+ }
+ else
+ *m_Pos += *m_Speed*a_Dt;
+ }
+ else
+ { // We didn't hit anything, so move =]
+ *m_Pos += *m_Speed*a_Dt;
+ }
+
+ m_bDirtyPosition = true;
+ }
+}
+
+void cMonster::TakeDamage( int a_Damage, cEntity* a_Instigator )
+{
+ cPawn::TakeDamage( a_Damage, a_Instigator );
+ m_Target = a_Instigator;
+ AddReference( m_Target );
+ if(m_EMPersonality == AGGRESSIVE) {
+ m_EMState = CHASING;
+ }
+ if(m_EMPersonality == COWARDLY || m_EMPersonality == PASSIVE) {
+ //m_bPassiveAggressive can be set so if the monster based on time of day for example
+ //so the monster will only attack if provoked
+ m_EMState = (m_bPassiveAggressive)? CHASING : ESCAPING;
+ }
+ //LOG("Take damage");
+}
+
+void cMonster::KilledBy( cEntity* a_Killer )
+{
+ cPawn::KilledBy( a_Killer );
+ m_DestroyTimer = 0;
+}
+
+//----State Logic
+
+const char *cMonster::GetState() {
+ switch(m_EMState) {
+ case IDLE:
+ return "Idle";
+ break;
+ case ATTACKING:
+ return "Attacking";
+ break;
+ case CHASING:
+ return "Chasing";
+ break;
+ default:
+ return "Unknown";
+ break;
+ }
+}
+
+//for debugging
+void cMonster::SetState(const char* a_str) {
+ std::string str = a_str;
+ if(str.compare("Idle") == 0 ) {
+ m_EMState = IDLE;
+ } else if(str.compare("Attacking") == 0 ) {
+ m_EMState = ATTACKING;
+ } else if(str.compare("Chasing") == 0 ) {
+ m_EMState = CHASING;
+ } else {
+ printf("Invalid State");
+ }
+}
+
+//Checks to see if EventSeePlayer should be fired
+//monster sez: Do I see the player
+void cMonster::CheckEventSeePlayer() {
+
+ //LOG("Checking if I see any players");
+ cMonster::ListClosePlayers(this);
+
+}
+
+void cMonster::CheckEventLostPlayer() {
+ Vector3f pos;
+ cTracer LineOfSight(cRoot::Get()->GetWorld() );
+
+ //LOG("Checking if I lost my enemy");
+ if(m_Target != 0) {
+ pos = m_Target->GetPosition();
+ if((pos - *m_Pos).Length() > m_SightDistance || LineOfSight.Trace(*m_Pos,(pos - *m_Pos), (int)(pos - *m_Pos).Length())){
+ //LOG("Losing Player: %5.5f",(pos - *m_Pos).Length());
+ EventLosePlayer();
+ }
+ } else {
+ LOG("Enemy went poof");
+ EventLosePlayer();
+ }
+}
+
+//What to do if player is seen
+//default to change state to chasing
+void cMonster::EventSeePlayer(cEntity *a_SeenPlayer) {
+ m_Target = a_SeenPlayer;
+ AddReference( m_Target );
+ if(m_EMPersonality == AGGRESSIVE) {
+ m_EMState = CHASING;
+ }
+ if(m_EMPersonality == COWARDLY) {
+ m_EMState = ESCAPING;
+ }
+ //LOG("Saw Player: %s",GetState());
+}
+
+void cMonster::EventLosePlayer(){
+ Dereference(m_Target);
+ m_Target = 0;
+ //LOG("Lost Player");
+ m_EMState = IDLE;
+}
+
+//What to do if in Idle State
+void cMonster::InStateIdle(float a_Dt) {
+ idle_interval += a_Dt;
+ if(idle_interval > 1) { //at this interval the results are predictable
+ int rem = rand()%6 + 1;
+ //LOG("Moving: int: %3.3f rem: %i",idle_interval,rem);
+ idle_interval = 0;
+ Vector3f Dist;
+ Dist.x = (float)((rand()%11)-5);
+ Dist.z = (float)((rand()%11)-5);
+ if( Dist.SqrLength() > 2 && rem >= 3)
+ {
+ m_Destination->x = (float)(m_Pos->x + Dist.x);
+ m_Destination->z = (float)(m_Pos->z + Dist.z);
+ m_Destination->y = (float)cRoot::Get()->GetWorld()->GetHeight( (int)m_Destination->x, (int)m_Destination->z ) + 1.2f;
+ MoveToPosition( *m_Destination );
+ }
+ }
+}
+
+//What to do if On fire
+void cMonster::InStateBurning(float a_Dt) {
+ m_FireDamageInterval += a_Dt;
+ char block = cRoot::Get()->GetWorld()->GetBlock( (int)m_Pos->x, (int)m_Pos->y, (int)m_Pos->z );
+ char bblock = cRoot::Get()->GetWorld()->GetBlock( (int)m_Pos->x, (int)m_Pos->y -1, (int)m_Pos->z );
+ if(m_FireDamageInterval > 1) {
+
+ m_FireDamageInterval = 0;
+ int rem = rand()%3 + 1; //Burn most of the time
+ if(rem >= 2) {
+ //printf("OUCH burning!!!\n");
+ TakeDamage(1, this);
+ }
+ m_BurnPeriod++;
+ if(block == E_BLOCK_LAVA || block == E_BLOCK_STATIONARY_LAVA || block == E_BLOCK_FIRE
+ || bblock == E_BLOCK_LAVA || bblock == E_BLOCK_STATIONARY_LAVA || bblock == E_BLOCK_FIRE)
+ m_BurnPeriod = 0;
+
+ if(m_BurnPeriod > 5) {
+
+ cChunk* InChunk = cRoot::Get()->GetWorld()->GetChunkUnreliable( m_ChunkX, m_ChunkY, m_ChunkZ );
+ m_EMMetaState = NORMAL;
+ cPacket_Metadata md(NORMAL, GetUniqueID());
+ //md.m_UniqueID = GetUniqueID();
+ InChunk->Broadcast(md);
+ m_BurnPeriod = 0;
+
+ }
+ }
+
+}
+
+//What to do if in Chasing State
+//This state should always be defined in each child class
+void cMonster::InStateChasing(float a_Dt) {
+ (void)a_Dt;
+}
+
+//What to do if in Escaping State
+void cMonster::InStateEscaping(float a_Dt) {
+ (void)a_Dt;
+ if(m_Target) {
+ Vector3d newloc = *m_Pos;
+ newloc.x = (m_Target->GetPosition().x < newloc.x)? (newloc.x + m_SightDistance): (newloc.x - m_SightDistance);
+ newloc.z = (m_Target->GetPosition().z < newloc.z)? (newloc.z + m_SightDistance): (newloc.z - m_SightDistance);
+ MoveToPosition(newloc);
+ } else {
+ m_EMState = IDLE; //this shouldnt be required but just to be safe
+ }
+}
+
+
+//Do attack here
+//a_Dt is passed so we can set attack rate
+void cMonster::Attack(float a_Dt) {
+ m_AttackInterval += a_Dt*m_AttackRate;
+ if(m_Target != 0 && m_AttackInterval > 3.0) { //Setting this higher gives us more wiggle room for attackrate
+ //LOG("ATTACK!");
+ m_AttackInterval = 0.0;
+ ((cPawn *)m_Target)->TakeDamage((int)m_AttackDamage,this);
+ }
+}
+//----Change Entity MetaData
+void cMonster::CheckMetaDataBurn() {
+ char block = cRoot::Get()->GetWorld()->GetBlock( (int)m_Pos->x, (int)m_Pos->y, (int)m_Pos->z );
+ char bblock = cRoot::Get()->GetWorld()->GetBlock( (int)m_Pos->x, (int)m_Pos->y -1, (int)m_Pos->z );
+ if(m_bBurnable && m_EMMetaState != BURNING && (block == E_BLOCK_LAVA || block == E_BLOCK_STATIONARY_LAVA || block == E_BLOCK_FIRE
+ || bblock == E_BLOCK_LAVA || bblock == E_BLOCK_STATIONARY_LAVA || bblock == E_BLOCK_FIRE)) {
+ cChunk* InChunk = cRoot::Get()->GetWorld()->GetChunkUnreliable( m_ChunkX, m_ChunkY, m_ChunkZ );
+ if(!InChunk)
+ return;
+ //printf("I should burn");
+ m_EMMetaState = BURNING;
+ cPacket_Metadata md(BURNING,GetUniqueID());
+ InChunk->Broadcast(md);
+ }
+}
+
+//----Debug
+
+void cMonster::ListMonsters() {
+
+ cWorld::EntityList Entities = cRoot::Get()->GetWorld()->GetEntities();
+ cRoot::Get()->GetWorld()->LockEntities();
+ for( cWorld::EntityList::iterator itr = Entities.begin(); itr != Entities.end(); ++itr) {
+ if((*itr)->GetEntityType() == cEntity::E_ENTITY){
+ LOG("In state: %s type: %i attack rate: %i",((cMonster *)(*itr))->GetState(), ((cMonster *)(*itr))->GetMobType(),((cMonster *)(*itr))->GetAttackRate());
+
+ }
+ }
+ cRoot::Get()->GetWorld()->UnlockEntities();
+}
+
+//Checks for Players close by and if they are visible
+void cMonster::ListClosePlayers(cMonster *m) {
+ int tries = 0;
+ cTracer LineOfSight(cRoot::Get()->GetWorld() );
+ cWorld::EntityList Entities = cRoot::Get()->GetWorld()->GetEntities();
+ for( cWorld::EntityList::iterator itr = Entities.begin(); itr != Entities.end(); ++itr) {
+ tries++;
+ if((*itr)->GetEntityType() == cEntity::E_PLAYER){
+ Vector3f pos = (*itr)->GetPosition();
+ if((pos - *(m->m_Pos)).Length() <= m->m_SightDistance){
+ if(!LineOfSight.Trace(*(m->m_Pos),(pos - *(m->m_Pos)),(int)(pos - *(m->m_Pos)).Length())){
+ //LOG("I SEE PLAYER !!!!!!!!!!!!!!!!!");
+ m->EventSeePlayer(*itr);
+ return; //get the first one in sight later we can reiterate and check
+ //for the closest out of all that match and make it more realistic
+
+ }
+ }
+
+ }
+ if(tries > 100) {
+ //LOG("I Give Up");
+ m->EventLosePlayer();
+ return;
+ }
+ }
+}
+
+void cMonster::GetMonsterConfig(const char* pm_name) {
+ (void)pm_name;
+}
+
+void cMonster::SetAttackRate(int ar) {
+ m_AttackRate = (float)ar;
+}
+void cMonster::SetAttackRange(float ar) {
+ m_AttackRange = ar;
+}
+void cMonster::SetAttackDamage(float ad) {
+ m_AttackDamage = ad;
+}
+void cMonster::SetSightDistance(float sd) {
+ m_SightDistance = sd;
+}
diff --git a/source/cMonster.h b/source/cMonster.h new file mode 100644 index 000000000..b0cb19543 --- /dev/null +++ b/source/cMonster.h @@ -0,0 +1,85 @@ +#pragma once
+#include "cPawn.h"
+
+class Vector3f;
+class cClientHandle;
+class cMonster : public cPawn //tolua_export
+{ //tolua_export
+public:
+
+ cMonster();
+ virtual ~cMonster();
+
+ virtual bool IsA( const char* a_EntityType );
+
+ virtual void SpawnOn( cClientHandle* a_Target );
+
+ virtual void Tick(float a_Dt);
+ virtual void HandlePhysics(float a_Dt);
+ virtual void ReplicateMovement();
+
+ virtual void TakeDamage( int a_Damage, cEntity* a_Instigator );
+ virtual void KilledBy( cEntity* a_Killer );
+
+ virtual void MoveToPosition( const Vector3f & a_Position );
+ virtual bool ReachedDestination();
+
+ const char *GetState();
+ void SetState(const char* str);
+ static void ListMonsters();
+
+ virtual void CheckEventSeePlayer();
+ virtual void EventSeePlayer(cEntity *);
+ float m_SightDistance;
+ static void ListClosePlayers(cMonster *);
+ virtual void GetMonsterConfig(const char* pm_name);
+ virtual void EventLosePlayer();
+ virtual void CheckEventLostPlayer();
+
+ virtual void InStateIdle(float a_Dt);
+ virtual void InStateChasing(float a_Dt);
+ virtual void InStateEscaping(float a_Dt);
+ virtual void InStateBurning(float a_Dt);
+
+ virtual void Attack(float a_Dt);
+ int GetMobType() {return m_MobType;}
+ int GetAttackRate(){return (int)m_AttackRate;}
+ void SetAttackRate(int ar);
+ void SetAttackRange(float ar);
+ void SetAttackDamage(float ad);
+ void SetSightDistance(float sd);
+ virtual void CheckMetaDataBurn();
+
+ enum MState{ATTACKING, IDLE, CHASING, ESCAPING} m_EMState;
+ enum MPersonality{PASSIVE,AGGRESSIVE,COWARDLY} m_EMPersonality;
+ enum MMetaState{NORMAL,BURNING,CROUCHED,RIDING} m_EMMetaState;
+
+protected:
+
+ cEntity* m_Target;
+ float m_AttackRate;
+ float idle_interval;
+
+ Vector3f* m_Destination;
+ bool m_bMovingToDestination;
+ bool m_bPassiveAggressive;
+ bool m_bBurnable;
+
+ Vector3f* m_Speed;
+ float m_DestinationTime;
+
+ float m_Gravity;
+ bool m_bOnGround;
+
+ float m_DestroyTimer;
+ float m_Jump;
+
+ char m_MobType;
+
+ float m_SeePlayerInterval;
+ float m_AttackDamage;
+ float m_AttackRange;
+ float m_AttackInterval;
+ float m_FireDamageInterval;
+ float m_BurnPeriod;
+}; //tolua_export
diff --git a/source/cMonsterConfig.cpp b/source/cMonsterConfig.cpp new file mode 100644 index 000000000..4d309ec06 --- /dev/null +++ b/source/cMonsterConfig.cpp @@ -0,0 +1,93 @@ +#include "cMonsterConfig.h" +#include "cMonster.h" +#include "../iniFile/iniFile.h" +#include <list> +#include <vector> +#include <cstdio> +//#include "../source/cprintf.h" +#include <string> +using namespace std; + +extern std::vector<std::string> StringSplit(std::string str, std::string delim); + +struct cMonsterConfig::sAttributesStruct
+{
+ string m_name;
+ float m_SightDistance;
+ float m_AttackDamage;
+ float m_AttackRange;
+ float m_AttackRate;
+}; + +struct cMonsterConfig::sMonsterConfigState +{ + int TypeCount;
+ string MonsterTypes;
+ list< sAttributesStruct > AttributesList; +}; + +cMonsterConfig::cMonsterConfig(int TypeC) + : m_pState( new sMonsterConfigState ) +{ + m_pState->TypeCount = TypeC; + Initialize(); +} + +cMonsterConfig::~cMonsterConfig() { + delete m_pState; +} + +void cMonsterConfig::Initialize() { + + sAttributesStruct Attributes; + cIniFile SettingsIniFile("settings.ini"); + cIniFile MonstersIniFile("monsters.ini"); + + if(!SettingsIniFile.ReadFile() || !MonstersIniFile.ReadFile()) { + printf("Error: Must have both settings.ini and monsters.ini to configure attributes\n\tusing default attributes \n"); + return; + } + + m_pState->MonsterTypes = SettingsIniFile.GetValue("Monsters","Types",""); + + if( m_pState->MonsterTypes.empty() ) { + printf("Error: No Monster types listed in config file, using default attributes \n"); + return; + } + + vector<string> SplitList = StringSplit(m_pState->MonsterTypes,","); + for(unsigned int i = 0; i < SplitList.size(); ++i) { + if(!SplitList[i].empty()) { + printf("Getting Attributes for: %s \n",SplitList[i].c_str()); + Attributes.m_name = SplitList[i].c_str(); + Attributes.m_AttackDamage = (float)MonstersIniFile.GetValueF(SplitList[i].c_str(),"AttackDamage",0); + printf("Got AttackDamage: %3.3f \n",Attributes.m_AttackDamage); + Attributes.m_AttackRange = (float)MonstersIniFile.GetValueF(SplitList[i].c_str(),"AttackRange",0); + printf("Got AttackRange: %3.3f \n",Attributes.m_AttackRange); + Attributes.m_SightDistance = (float)MonstersIniFile.GetValueF(SplitList[i].c_str(),"SightDistance",0); + printf("Got SightDistance: %3.3f \n",Attributes.m_SightDistance); + Attributes.m_AttackRate = (float)MonstersIniFile.GetValueF(SplitList[i].c_str(),"AttackRate",0); + printf("Got AttackRate: %3.3f \n",Attributes.m_AttackRate); + m_pState->AttributesList.push_front(Attributes); + } + } + +} + +void cMonsterConfig::AssignAttributes(cMonster *m, const char* n) +{ + list<sAttributesStruct>::iterator itr; + for(itr = m_pState->AttributesList.begin(); itr != m_pState->AttributesList.end(); ++itr) { + if(itr->m_name.compare(n) == 0) { + //printf("found my attribs: %s :\n",itr->m_name.c_str()); + m->SetAttackDamage(itr->m_AttackDamage); + m->SetAttackRange(itr->m_AttackRange); + m->SetSightDistance(itr->m_SightDistance); + m->SetAttackRate((int)itr->m_AttackRate); + } + } +} + +cMonsterConfig *cMonsterConfig::Get() { + return this; +} diff --git a/source/cMonsterConfig.h b/source/cMonsterConfig.h new file mode 100644 index 000000000..12b03d8e1 --- /dev/null +++ b/source/cMonsterConfig.h @@ -0,0 +1,18 @@ +#pragma once
+
+class cMonster;
+class cMonsterConfig
+{
+public:
+ cMonsterConfig(int TypeC);
+ ~cMonsterConfig();
+ cMonsterConfig *Get();
+
+ void AssignAttributes(cMonster *m, const char* n);
+
+private:
+ struct sAttributesStruct;
+ struct sMonsterConfigState;
+ sMonsterConfigState* m_pState;
+ void Initialize();
+};
\ No newline at end of file diff --git a/source/cNoise.cpp b/source/cNoise.cpp new file mode 100644 index 000000000..1d321c089 --- /dev/null +++ b/source/cNoise.cpp @@ -0,0 +1,253 @@ +#include "cNoise.h"
+#include <math.h>
+
+#define FAST_FLOOR( x ) ( (x) < 0 ? ((int)x)-1 : ((int)x) )
+
+cNoise::cNoise( unsigned int a_Seed )
+ : m_Seed( a_Seed )
+{
+}
+
+
+cNoise::~cNoise()
+{
+}
+
+/****************
+ * Random value generator
+ **/
+float cNoise::IntNoise( int a_X ) const
+{
+ int x = ((a_X*m_Seed)<<13) ^ a_X;
+ return ( 1.0f - ( (x * (x * x * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0f);
+}
+
+float cNoise::IntNoise2D( int a_X, int a_Y ) const
+{
+ int n = a_X + a_Y * 57 + m_Seed*57*57;
+ n = (n<<13) ^ n;
+ return ( 1.0f - ( (n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0f);
+}
+
+float cNoise::IntNoise3D( int a_X, int a_Y, int a_Z ) const
+{
+ int n = a_X + a_Y * 57 + a_Z * 57*57 + m_Seed*57*57*57;
+ n = (n<<13) ^ n;
+ return ( 1.0f - ( (n * (n * n * 15731 + 789221) + 1376312589) & 0x7fffffff) / 1073741824.0f);
+}
+
+/***************
+ * Interpolated (and 1 smoothed) noise in 1-dimension
+ **/
+float cNoise::LinearNoise1D( float a_X ) const
+{
+ int BaseX = FAST_FLOOR( a_X );
+ float FracX = (a_X) - BaseX;
+ return LinearInterpolate( IntNoise( BaseX ), IntNoise( BaseX+1 ), FracX);
+}
+
+float cNoise::CosineNoise1D( float a_X ) const
+{
+ int BaseX = FAST_FLOOR( a_X );
+ float FracX = (a_X) - BaseX;
+ return CosineInterpolate( IntNoise( BaseX ), IntNoise( BaseX+1 ), FracX);
+}
+
+float cNoise::CubicNoise1D( float a_X ) const
+{
+ int BaseX = FAST_FLOOR( a_X );
+ float FracX = (a_X) - BaseX;
+ return CubicInterpolate( IntNoise( BaseX-1 ), IntNoise( BaseX ), IntNoise( BaseX+1 ), IntNoise( BaseX+2 ), FracX);
+}
+
+float cNoise::SmoothNoise1D( int a_X ) const
+{
+ return IntNoise(a_X)/2 + IntNoise(a_X-1)/4 + IntNoise(a_X+1)/4;
+}
+
+/******************
+ * Interpolated (and 1 smoothed) noise in 2-dimensions
+ **/
+float cNoise::LinearNoise2D( float a_X, float a_Y ) const
+{
+ const int BaseX = FAST_FLOOR( a_X );
+ const int BaseY = FAST_FLOOR( a_Y );
+
+ const float tl = IntNoise2D( BaseX, BaseY );
+ const float tr = IntNoise2D( BaseX+1, BaseY );
+ const float bl = IntNoise2D( BaseX, BaseY+1 );
+ const float br = IntNoise2D( BaseX+1, BaseY+1 );
+
+ const float FracX = (a_X) - BaseX;
+ const float interp1 = LinearInterpolate( tl, tr, FracX );
+ const float interp2 = LinearInterpolate( bl, br, FracX );
+
+ const float FracY = (a_Y) - BaseY;
+ return LinearInterpolate( interp1, interp2, FracY );
+}
+
+float cNoise::CosineNoise2D( float a_X, float a_Y ) const
+{
+ const int BaseX = FAST_FLOOR( a_X );
+ const int BaseY = FAST_FLOOR( a_Y );
+
+ const float tl = IntNoise2D( BaseX, BaseY );
+ const float tr = IntNoise2D( BaseX+1, BaseY );
+ const float bl = IntNoise2D( BaseX, BaseY+1 );
+ const float br = IntNoise2D( BaseX+1, BaseY+1 );
+
+ const float FracX = (a_X) - BaseX;
+ const float interp1 = CosineInterpolate( tl, tr, FracX );
+ const float interp2 = CosineInterpolate( bl, br, FracX );
+
+ const float FracY = (a_Y) - BaseY;
+ return CosineInterpolate( interp1, interp2, FracY );
+}
+
+float cNoise::CubicNoise2D( float a_X, float a_Y ) const
+{
+ const int BaseX = FAST_FLOOR( a_X );
+ const int BaseY = FAST_FLOOR( a_Y );
+
+ const float points[4][4] = {
+
+ IntNoise2D( BaseX-1, BaseY-1 ), IntNoise2D( BaseX, BaseY-1 ), IntNoise2D( BaseX+1, BaseY-1 ), IntNoise2D( BaseX+2, BaseY-1 ),
+ IntNoise2D( BaseX-1, BaseY ), IntNoise2D( BaseX, BaseY ), IntNoise2D( BaseX+1, BaseY ), IntNoise2D( BaseX+2, BaseY ),
+ IntNoise2D( BaseX-1, BaseY+1 ), IntNoise2D( BaseX, BaseY+1 ), IntNoise2D( BaseX+1, BaseY+1 ), IntNoise2D( BaseX+2, BaseY+1 ),
+ IntNoise2D( BaseX-1, BaseY+2 ), IntNoise2D( BaseX, BaseY+2 ), IntNoise2D( BaseX+1, BaseY+2 ), IntNoise2D( BaseX+2, BaseY+2 ),
+
+ };
+
+ const float FracX = (a_X) - BaseX;
+ const float interp1 = CubicInterpolate( points[0][0], points[0][1], points[0][2], points[0][3], FracX );
+ const float interp2 = CubicInterpolate( points[1][0], points[1][1], points[1][2], points[1][3], FracX );
+ const float interp3 = CubicInterpolate( points[2][0], points[2][1], points[2][2], points[2][3], FracX );
+ const float interp4 = CubicInterpolate( points[3][0], points[3][1], points[3][2], points[3][3], FracX );
+
+
+ const float FracY = (a_Y) - BaseY;
+ return CubicInterpolate( interp1, interp2, interp3, interp4, FracY );
+}
+
+/******************
+ * Interpolated (and 1 smoothed) noise in 3-dimensions
+ **/
+float cNoise::CosineNoise3D( float a_X, float a_Y, float a_Z ) const
+{
+ const int BaseX = FAST_FLOOR( a_X );
+ const int BaseY = FAST_FLOOR( a_Y );
+ const int BaseZ = FAST_FLOOR( a_Z );
+
+ const float ftl = IntNoise3D( BaseX, BaseY, BaseZ );
+ const float ftr = IntNoise3D( BaseX+1, BaseY, BaseZ );
+ const float fbl = IntNoise3D( BaseX, BaseY+1, BaseZ );
+ const float fbr = IntNoise3D( BaseX+1, BaseY+1, BaseZ );
+
+ const float btl = IntNoise3D( BaseX, BaseY, BaseZ+1 );
+ const float btr = IntNoise3D( BaseX+1, BaseY, BaseZ+1 );
+ const float bbl = IntNoise3D( BaseX, BaseY+1, BaseZ+1 );
+ const float bbr = IntNoise3D( BaseX+1, BaseY+1, BaseZ+1 );
+
+ const float FracX = (a_X) - BaseX;
+ const float finterp1 = CosineInterpolate( ftl, ftr, FracX );
+ const float finterp2 = CosineInterpolate( fbl, fbr, FracX );
+ const float binterp1 = CosineInterpolate( btl, btr, FracX );
+ const float binterp2 = CosineInterpolate( bbl, bbr, FracX );
+
+ const float FracY = (a_Y) - BaseY;
+ const float interp1 = CosineInterpolate( finterp1, finterp2, FracY );
+ const float interp2 = CosineInterpolate( binterp1, binterp2, FracY );
+
+ const float FracZ = (a_Z) - BaseZ;
+ return CosineInterpolate( interp1, interp2, FracZ );
+}
+
+float cNoise::CubicNoise3D( float a_X, float a_Y, float a_Z ) const
+{
+ const int BaseX = FAST_FLOOR( a_X );
+ const int BaseY = FAST_FLOOR( a_Y );
+ const int BaseZ = FAST_FLOOR( a_Z );
+
+ const float points1[4][4] = {
+ IntNoise3D( BaseX-1, BaseY-1, BaseZ-1 ), IntNoise3D( BaseX, BaseY-1, BaseZ-1 ), IntNoise3D( BaseX+1, BaseY-1, BaseZ-1 ), IntNoise3D( BaseX+2, BaseY-1, BaseZ-1 ),
+ IntNoise3D( BaseX-1, BaseY, BaseZ-1 ), IntNoise3D( BaseX, BaseY, BaseZ-1 ), IntNoise3D( BaseX+1, BaseY, BaseZ-1 ), IntNoise3D( BaseX+2, BaseY, BaseZ-1 ),
+ IntNoise3D( BaseX-1, BaseY+1, BaseZ-1 ), IntNoise3D( BaseX, BaseY+1, BaseZ-1 ), IntNoise3D( BaseX+1, BaseY+1, BaseZ-1 ), IntNoise3D( BaseX+2, BaseY+1, BaseZ-1 ),
+ IntNoise3D( BaseX-1, BaseY+2, BaseZ-1 ), IntNoise3D( BaseX, BaseY+2, BaseZ-1 ), IntNoise3D( BaseX+1, BaseY+2, BaseZ-1 ), IntNoise3D( BaseX+2, BaseY+2, BaseZ-1 ),
+ };
+
+ const float FracX = (a_X) - BaseX;
+ const float x1interp1 = CubicInterpolate( points1[0][0], points1[0][1], points1[0][2], points1[0][3], FracX );
+ const float x1interp2 = CubicInterpolate( points1[1][0], points1[1][1], points1[1][2], points1[1][3], FracX );
+ const float x1interp3 = CubicInterpolate( points1[2][0], points1[2][1], points1[2][2], points1[2][3], FracX );
+ const float x1interp4 = CubicInterpolate( points1[3][0], points1[3][1], points1[3][2], points1[3][3], FracX );
+
+ const float points2[4][4] = {
+ IntNoise3D( BaseX-1, BaseY-1, BaseZ ), IntNoise3D( BaseX, BaseY-1, BaseZ ), IntNoise3D( BaseX+1, BaseY-1, BaseZ ), IntNoise3D( BaseX+2, BaseY-1, BaseZ ),
+ IntNoise3D( BaseX-1, BaseY, BaseZ ), IntNoise3D( BaseX, BaseY, BaseZ ), IntNoise3D( BaseX+1, BaseY, BaseZ ), IntNoise3D( BaseX+2, BaseY, BaseZ ),
+ IntNoise3D( BaseX-1, BaseY+1, BaseZ ), IntNoise3D( BaseX, BaseY+1, BaseZ ), IntNoise3D( BaseX+1, BaseY+1, BaseZ ), IntNoise3D( BaseX+2, BaseY+1, BaseZ ),
+ IntNoise3D( BaseX-1, BaseY+2, BaseZ ), IntNoise3D( BaseX, BaseY+2, BaseZ ), IntNoise3D( BaseX+1, BaseY+2, BaseZ ), IntNoise3D( BaseX+2, BaseY+2, BaseZ ),
+ };
+
+ const float x2interp1 = CubicInterpolate( points2[0][0], points2[0][1], points2[0][2], points2[0][3], FracX );
+ const float x2interp2 = CubicInterpolate( points2[1][0], points2[1][1], points2[1][2], points2[1][3], FracX );
+ const float x2interp3 = CubicInterpolate( points2[2][0], points2[2][1], points2[2][2], points2[2][3], FracX );
+ const float x2interp4 = CubicInterpolate( points2[3][0], points2[3][1], points2[3][2], points2[3][3], FracX );
+
+ const float points3[4][4] = {
+ IntNoise3D( BaseX-1, BaseY-1, BaseZ+1 ), IntNoise3D( BaseX, BaseY-1, BaseZ+1 ), IntNoise3D( BaseX+1, BaseY-1, BaseZ+1 ), IntNoise3D( BaseX+2, BaseY-1, BaseZ+1 ),
+ IntNoise3D( BaseX-1, BaseY, BaseZ+1 ), IntNoise3D( BaseX, BaseY, BaseZ+1 ), IntNoise3D( BaseX+1, BaseY, BaseZ+1 ), IntNoise3D( BaseX+2, BaseY, BaseZ+1 ),
+ IntNoise3D( BaseX-1, BaseY+1, BaseZ+1 ), IntNoise3D( BaseX, BaseY+1, BaseZ+1 ), IntNoise3D( BaseX+1, BaseY+1, BaseZ+1 ), IntNoise3D( BaseX+2, BaseY+1, BaseZ+1 ),
+ IntNoise3D( BaseX-1, BaseY+2, BaseZ+1 ), IntNoise3D( BaseX, BaseY+2, BaseZ+1 ), IntNoise3D( BaseX+1, BaseY+2, BaseZ+1 ), IntNoise3D( BaseX+2, BaseY+2, BaseZ+1 ),
+ };
+
+ const float x3interp1 = CubicInterpolate( points3[0][0], points3[0][1], points3[0][2], points3[0][3], FracX );
+ const float x3interp2 = CubicInterpolate( points3[1][0], points3[1][1], points3[1][2], points3[1][3], FracX );
+ const float x3interp3 = CubicInterpolate( points3[2][0], points3[2][1], points3[2][2], points3[2][3], FracX );
+ const float x3interp4 = CubicInterpolate( points3[3][0], points3[3][1], points3[3][2], points3[3][3], FracX );
+
+ const float points4[4][4] = {
+ IntNoise3D( BaseX-1, BaseY-1, BaseZ+2 ), IntNoise3D( BaseX, BaseY-1, BaseZ+2 ), IntNoise3D( BaseX+1, BaseY-1, BaseZ+2 ), IntNoise3D( BaseX+2, BaseY-1, BaseZ+2 ),
+ IntNoise3D( BaseX-1, BaseY, BaseZ+2 ), IntNoise3D( BaseX, BaseY, BaseZ+2 ), IntNoise3D( BaseX+1, BaseY, BaseZ+2 ), IntNoise3D( BaseX+2, BaseY, BaseZ+2 ),
+ IntNoise3D( BaseX-1, BaseY+1, BaseZ+2 ), IntNoise3D( BaseX, BaseY+1, BaseZ+2 ), IntNoise3D( BaseX+1, BaseY+1, BaseZ+2 ), IntNoise3D( BaseX+2, BaseY+1, BaseZ+2 ),
+ IntNoise3D( BaseX-1, BaseY+2, BaseZ+2 ), IntNoise3D( BaseX, BaseY+2, BaseZ+2 ), IntNoise3D( BaseX+1, BaseY+2, BaseZ+2 ), IntNoise3D( BaseX+2, BaseY+2, BaseZ+2 ),
+ };
+
+ const float x4interp1 = CubicInterpolate( points4[0][0], points4[0][1], points4[0][2], points4[0][3], FracX );
+ const float x4interp2 = CubicInterpolate( points4[1][0], points4[1][1], points4[1][2], points4[1][3], FracX );
+ const float x4interp3 = CubicInterpolate( points4[2][0], points4[2][1], points4[2][2], points4[2][3], FracX );
+ const float x4interp4 = CubicInterpolate( points4[3][0], points4[3][1], points4[3][2], points4[3][3], FracX );
+
+ const float FracY = (a_Y) - BaseY;
+ const float yinterp1 = CubicInterpolate( x1interp1, x1interp2, x1interp3, x1interp4, FracY );
+ const float yinterp2 = CubicInterpolate( x2interp1, x2interp2, x2interp3, x2interp4, FracY );
+ const float yinterp3 = CubicInterpolate( x3interp1, x3interp2, x3interp3, x3interp4, FracY );
+ const float yinterp4 = CubicInterpolate( x4interp1, x4interp2, x4interp3, x4interp4, FracY );
+
+ const float FracZ = (a_Z) - BaseZ;
+ return CubicInterpolate( yinterp1, yinterp2, yinterp3, yinterp4, FracZ );
+}
+
+/******************
+ * Private
+ **/
+float cNoise::CubicInterpolate( float a_A, float a_B, float a_C, float a_D, float a_Pct ) const
+{
+ float P = (a_D - a_C) - (a_A - a_B);
+ float Q = (a_A - a_B) - P;
+ float R = a_C - a_A;
+ float S = a_B;
+
+ return P*(a_Pct*a_Pct*a_Pct) + Q*(a_Pct*a_Pct) + R*a_Pct + S;
+}
+
+float cNoise::CosineInterpolate( float a_A, float a_B, float a_Pct ) const
+{
+ const float ft = a_Pct * 3.1415927f;
+ const float f = (1.f - cosf(ft)) * 0.5f;
+ return a_A*(1-f) + a_B*f;
+}
+
+float cNoise::LinearInterpolate( float a_A, float a_B, float a_Pct ) const
+{
+ return a_A*(1.f-a_Pct) + a_B*a_Pct;
+}
\ No newline at end of file diff --git a/source/cNoise.h b/source/cNoise.h new file mode 100644 index 000000000..538970da3 --- /dev/null +++ b/source/cNoise.h @@ -0,0 +1,33 @@ +#pragma once
+
+class cNoise
+{
+public:
+ cNoise( unsigned int a_Seed );
+ ~cNoise();
+
+ float IntNoise( int a_X ) const;
+ float IntNoise2D( int a_X, int a_Y ) const;
+ float IntNoise3D( int a_X, int a_Y, int a_Z ) const;
+
+ float LinearNoise1D( float a_X ) const;
+ float CosineNoise1D( float a_X ) const;
+ float CubicNoise1D( float a_X ) const;
+ float SmoothNoise1D( int a_X ) const;
+
+ float LinearNoise2D( float a_X, float a_Y ) const;
+ float CosineNoise2D( float a_X, float a_Y ) const;
+ float CubicNoise2D( float a_X, float a_Y ) const;
+
+ float CosineNoise3D( float a_X, float a_Y, float a_Z ) const;
+ float CubicNoise3D( float a_X, float a_Y, float a_Z ) const;
+
+ void SetSeed( unsigned int a_Seed ) { m_Seed = a_Seed; }
+private:
+ float CubicInterpolate( float a_A, float a_B, float a_C, float a_D, float a_Pct ) const;
+ float CosineInterpolate( float a_A, float a_B, float a_Pct ) const;
+ float LinearInterpolate( float a_A, float a_B, float a_Pct ) const;
+
+ unsigned int m_Seed;
+};
+
diff --git a/source/cPawn.cpp b/source/cPawn.cpp new file mode 100644 index 000000000..d9f2ec8b5 --- /dev/null +++ b/source/cPawn.cpp @@ -0,0 +1,96 @@ +#include "cPawn.h"
+#include "cRoot.h"
+#include "cServer.h"
+#include "cWorld.h"
+#include "cPlayer.h"
+#include "cChunk.h"
+#include "cMCLogger.h"
+#include "cPluginManager.h"
+
+#include "packets/cPacket_TeleportEntity.h"
+#include "packets/cPacket_EntityStatus.h"
+
+CLASS_DEFINITION( cPawn, cEntity )
+
+cPawn::cPawn()
+ : cEntity( 0, 0, 0 )
+ , m_LastPosX( 0.0 )
+ , m_LastPosY( 0.0 )
+ , m_LastPosZ( 0.0 )
+ , m_TimeLastTeleportPacket( 0.f )
+{
+ m_Health = 20;
+}
+
+cPawn::~cPawn()
+{
+
+}
+
+void cPawn::Heal( int a_Health )
+{
+ (void)a_Health;
+}
+
+void cPawn::TakeDamage( int a_Damage, cEntity* a_Instigator )
+{
+ TakeDamageInfo TDI;
+ TDI.Damage = a_Damage;
+ TDI.Instigator = a_Instigator;
+ cRoot::Get()->GetPluginManager()->CallHook( cPluginManager::E_PLUGIN_TAKE_DAMAGE, 2, this, &TDI );
+
+
+
+ if( TDI.Damage == 0 ) return;
+ if( m_Health <= 0 ) return; // Can't take damage if already dead
+
+ m_Health -= (short)TDI.Damage;
+ if( m_Health < 0 ) m_Health = 0;
+
+ cPacket_EntityStatus Status;
+ Status.m_UniqueID = GetUniqueID();
+ Status.m_Status = cPacket_EntityStatus::STATUS_TAKEDAMAGE;
+ cChunk* Chunk = cRoot::Get()->GetWorld()->GetChunkUnreliable( m_ChunkX, m_ChunkY, m_ChunkZ );
+ if( Chunk )
+ Chunk->Broadcast( Status );
+
+ if( m_Health <= 0 )
+ KilledBy( TDI.Instigator );
+}
+
+void cPawn::KilledBy( cEntity* a_Killer )
+{
+ m_Health = 0;
+
+ if( cRoot::Get()->GetPluginManager()->CallHook( cPluginManager::E_PLUGIN_KILLED, 2, this, a_Killer ) )
+ {
+ return; // Give plugins a chance to 'unkill' the pawn.
+ }
+
+ cPacket_EntityStatus Status;
+ Status.m_UniqueID = GetUniqueID();
+ Status.m_Status = cPacket_EntityStatus::STATUS_DIE;
+ cChunk* Chunk = cRoot::Get()->GetWorld()->GetChunkUnreliable( m_ChunkX, m_ChunkY, m_ChunkZ );
+ if( Chunk )
+ Chunk->Broadcast( Status ); // Die
+}
+
+void cPawn::TeleportTo( cEntity* a_Entity )
+{
+ TeleportTo( a_Entity->GetPosX(), a_Entity->GetPosY(), a_Entity->GetPosZ() );
+}
+
+void cPawn::TeleportTo( const double & a_PosX, const double & a_PosY, const double & a_PosZ )
+{
+ SetPosition( a_PosX, a_PosY, a_PosZ );
+ cPacket_TeleportEntity TeleportEntity( this );
+ if( IsA("cPlayer") )
+ {
+ cPlayer* Player = (cPlayer*)this;
+ cRoot::Get()->GetServer()->Broadcast( TeleportEntity, Player->GetClientHandle() );
+ }
+ else
+ {
+ cRoot::Get()->GetServer()->Broadcast( TeleportEntity );
+ }
+}
diff --git a/source/cPawn.h b/source/cPawn.h new file mode 100644 index 000000000..2339bde03 --- /dev/null +++ b/source/cPawn.h @@ -0,0 +1,31 @@ +#pragma once
+#include "cEntity.h"
+
+struct TakeDamageInfo //tolua_export
+{ //tolua_export
+ int Damage; //tolua_export
+ cEntity* Instigator; //tolua_export
+}; //tolua_export
+
+class cPawn : public cEntity //tolua_export
+{ //tolua_export
+public:
+ CLASS_PROTOTYPE();
+
+ cPawn();
+ virtual ~cPawn();
+
+ virtual void TeleportTo( cEntity* a_Entity ); //tolua_export
+ virtual void TeleportTo( const double & a_PosX, const double & a_PosY, const double & a_PosZ ); //tolua_export
+
+ void Heal( int a_Health ); //tolua_export
+ virtual void TakeDamage( int a_Damage, cEntity* a_Instigator ); //tolua_export
+ virtual void KilledBy( cEntity* a_Killer ); //tolua_export
+ int GetHealth() { return m_Health; } //tolua_export
+
+protected:
+ short m_Health;
+
+ double m_LastPosX, m_LastPosY, m_LastPosZ;
+ float m_TimeLastTeleportPacket;
+}; //tolua_export
diff --git a/source/cPickup.cpp b/source/cPickup.cpp new file mode 100644 index 000000000..585c1e32b --- /dev/null +++ b/source/cPickup.cpp @@ -0,0 +1,229 @@ +#ifndef _WIN32
+#include <cstdlib>
+#endif
+
+#include "cPickup.h"
+#include "cClientHandle.h"
+#include "cInventory.h"
+#include "cWorld.h"
+#include "cServer.h"
+#include "cPlayer.h"
+#include "cPluginManager.h"
+#include "cItem.h"
+#include "cRoot.h"
+#include "cMCLogger.h"
+#include "cTracer.h"
+#include "cChunk.h"
+
+#include "packets/cPacket_TeleportEntity.h"
+#include "packets/cPacket_PickupSpawn.h"
+#include "packets/cPacket_CollectItem.h"
+
+#include "Vector3d.h"
+#include "Vector3f.h"
+
+CLASS_DEFINITION( cPickup, cEntity )
+
+cPickup::~cPickup()
+{
+ delete m_Item;
+}
+
+cPickup::cPickup(int a_X, int a_Y, int a_Z, const cItem & a_Item, float a_SpeedX /* = 0.f */, float a_SpeedY /* = 0.f */, float a_SpeedZ /* = 0.f */)
+ : cEntity( ((double)(a_X))/32, ((double)(a_Y))/32, ((double)(a_Z))/32 )
+ , m_Speed( new Vector3f( a_SpeedX, a_SpeedY, a_SpeedZ ) )
+ , m_bOnGround( false )
+ , m_bReplicated( false )
+ , m_Timer( 0.f )
+ , m_Item( new cItem( a_Item ) )
+ , m_bCollected( false )
+{
+
+ //LOG("New pickup: ID(%i) Amount(%i) Health(%i)", m_Item.m_ItemID, m_Item.m_ItemCount, m_Item.m_ItemHealth );
+
+ // Spawn it on clients
+ cPacket_PickupSpawn PickupSpawn;
+ PickupSpawn.m_UniqueID = m_UniqueID;
+ PickupSpawn.m_Item = (short)m_Item->m_ItemID;
+ PickupSpawn.m_Count = m_Item->m_ItemCount;
+ PickupSpawn.m_Health = m_Item->m_ItemHealth;
+ PickupSpawn.m_PosX = a_X;
+ PickupSpawn.m_PosY = a_Y;
+ PickupSpawn.m_PosZ = a_Z;
+ PickupSpawn.m_Rotation = (char)(m_Speed->x * 8);
+ PickupSpawn.m_Pitch = (char)(m_Speed->y * 8);
+ PickupSpawn.m_Roll = (char)(m_Speed->z * 8);
+ cRoot::Get()->GetServer()->Broadcast( PickupSpawn );
+
+ m_EntityType = E_PICKUP;
+}
+
+cPickup::cPickup(cPacket_PickupSpawn* a_PickupSpawnPacket)
+ : cEntity( ((double)a_PickupSpawnPacket->m_PosX)/32, ((double)a_PickupSpawnPacket->m_PosY)/32, ((double)a_PickupSpawnPacket->m_PosZ)/32 )
+ , m_bOnGround( false )
+ , m_bReplicated( false )
+ , m_Timer( 0.f )
+ , m_bCollected( false )
+{
+ a_PickupSpawnPacket->m_UniqueID = m_UniqueID;
+
+ m_Item = new cItem();
+ m_Item->m_ItemID = (ENUM_ITEM_ID)a_PickupSpawnPacket->m_Item;
+ m_Item->m_ItemCount = a_PickupSpawnPacket->m_Count;
+ m_Item->m_ItemHealth = 0x0;
+
+ m_Speed->x = (float)(a_PickupSpawnPacket->m_Rotation) / 8;
+ m_Speed->y = (float)(a_PickupSpawnPacket->m_Pitch) / 8;
+ m_Speed->z = (float)(a_PickupSpawnPacket->m_Roll) / 8;
+
+ // Spawn it on clients
+ cRoot::Get()->GetServer()->Broadcast( *a_PickupSpawnPacket );
+
+ m_EntityType = E_PICKUP;
+}
+
+void cPickup::SpawnOn( cClientHandle* a_Target )
+{
+ cPacket_PickupSpawn PickupSpawn;
+ PickupSpawn.m_UniqueID = m_UniqueID;
+ PickupSpawn.m_Item = (short)m_Item->m_ItemID;
+ PickupSpawn.m_Count = m_Item->m_ItemCount;
+ PickupSpawn.m_Health = m_Item->m_ItemHealth;
+ PickupSpawn.m_PosX = (int)(m_Pos->x * 32);
+ PickupSpawn.m_PosY = (int)(m_Pos->y * 32);
+ PickupSpawn.m_PosZ = (int)(m_Pos->z * 32);
+ PickupSpawn.m_Rotation = (char)(m_Speed->x * 8);
+ PickupSpawn.m_Pitch = (char)(m_Speed->y * 8);
+ PickupSpawn.m_Roll = (char)(m_Speed->z * 8);
+ a_Target->Send( PickupSpawn );
+}
+
+void cPickup::Tick(float a_Dt)
+{
+ m_Timer+=a_Dt;
+ a_Dt = a_Dt / 1000.f;
+ if(m_bCollected)
+ {
+ if(m_Timer > 500.f) // 0.5 second
+ {
+ Destroy();
+ return;
+ }
+ }
+
+ if( m_Timer > 1000*60*5 ) // 5 minutes
+ {
+ Destroy();
+ return;
+ }
+
+ if( m_Pos->y < 0 ) // Out of this world!
+ {
+ Destroy();
+ return;
+ }
+
+ HandlePhysics( a_Dt );
+
+ if( !m_bReplicated || m_bDirtyPosition )
+ {
+ MoveToCorrectChunk();
+ m_bReplicated = true;
+ m_bDirtyPosition = false;
+ cChunk* Chunk = cRoot::Get()->GetWorld()->GetChunkUnreliable( m_ChunkX, m_ChunkY, m_ChunkZ );
+ if( Chunk )
+ {
+ cPacket_TeleportEntity TeleportEntity( this );
+ Chunk->Broadcast( TeleportEntity );
+ }
+ }
+
+ //printf("YSpeed: %f, OnGround: %i\n", m_SpeedY, m_bOnGround );
+}
+
+void cPickup::HandlePhysics(float a_Dt)
+{
+ if( m_bOnGround ) // check if it's still on the ground
+ {
+ cWorld* World = cRoot::Get()->GetWorld();
+ int BlockX = (int)m_Pos->x;
+ if( m_Pos->x < 0 ) BlockX--;
+ int BlockZ = (int)m_Pos->z;
+ if( m_Pos->z < 0 ) BlockZ--;
+ if( World->GetBlock( BlockX, (int)m_Pos->y -1, BlockZ ) == E_BLOCK_AIR )
+ {
+ m_bOnGround = false;
+ }
+ if( World->GetBlock( BlockX, (int)m_Pos->y, BlockZ ) != E_BLOCK_AIR ) // If in ground itself, push it out
+ {
+ m_bOnGround = true;
+ m_Pos->y += 0.2;
+ m_bReplicated = false;
+ }
+ m_Speed->x *= 0.7f/(1+a_Dt);
+ if( fabs(m_Speed->x) < 0.05 ) m_Speed->x = 0;
+ m_Speed->z *= 0.7f/(1+a_Dt);
+ if( fabs(m_Speed->z) < 0.05 ) m_Speed->z = 0;
+ }
+
+ if( !m_bOnGround )
+ {
+
+ float Gravity = -9.81f*a_Dt;
+ m_Speed->y += Gravity;
+
+ cTracer Tracer( cRoot::Get()->GetWorld() );
+ int Ret = Tracer.Trace( *m_Pos, *m_Speed, 2 );
+ if( Ret ) // Oh noez! we hit something
+ {
+ // Set to hit position
+ if( (*Tracer.RealHit - Vector3f(*m_Pos)).SqrLength() <= ( *m_Speed * a_Dt ).SqrLength() )
+ {
+ m_bReplicated = false; // It's only interesting to replicate when we actually hit something...
+ if( Ret == 1 )
+ {
+
+ if( Tracer.HitNormal->x != 0.f ) m_Speed->x = 0.f;
+ if( Tracer.HitNormal->y != 0.f ) m_Speed->y = 0.f;
+ if( Tracer.HitNormal->z != 0.f ) m_Speed->z = 0.f;
+
+ if( Tracer.HitNormal->y > 0 ) // means on ground
+ {
+ m_bOnGround = true;
+ }
+ }
+ *m_Pos = Tracer.RealHit;
+ *m_Pos += *Tracer.HitNormal * 0.2;
+
+ }
+ else
+ *m_Pos += *m_Speed*a_Dt;
+ }
+ else
+ { // We didn't hit anything, so move =]
+ *m_Pos += *m_Speed*a_Dt;
+ }
+ }
+}
+
+bool cPickup::CollectedBy( cPlayer* a_Dest )
+{
+ if(m_bCollected) return false; // It's already collected!
+ if(m_Timer < 1000.f) return false; // Not old enough
+
+ if( cRoot::Get()->GetPluginManager()->CallHook( cPluginManager::E_PLUGIN_COLLECT_ITEM, 2, this, a_Dest ) ) return false;
+
+ if( a_Dest->GetInventory().AddItem( *m_Item ) )
+ {
+ cPacket_CollectItem CollectItem;
+ CollectItem.m_CollectedID = m_UniqueID;
+ CollectItem.m_CollectorID = a_Dest->GetUniqueID();
+ cRoot::Get()->GetServer()->Broadcast( CollectItem );
+
+ m_bCollected = true;
+ m_Timer = 0;
+ return true;
+ }
+
+ return false;
+}
diff --git a/source/cPickup.h b/source/cPickup.h new file mode 100644 index 000000000..cad766e42 --- /dev/null +++ b/source/cPickup.h @@ -0,0 +1,34 @@ +#pragma once
+
+#include "cEntity.h"
+
+class cPacket_PickupSpawn;
+class cPlayer;
+class cItem;
+class cPickup : public cEntity //tolua_export
+{ //tolua_export
+public:
+ CLASS_PROTOTYPE();
+
+ cPickup(int a_X, int a_Y, int a_Z, const cItem & a_Item, float a_SpeedX = 0.f, float a_SpeedY = 0.f, float a_SpeedZ = 0.f); //tolua_export
+ cPickup(cPacket_PickupSpawn* a_PickupSpawnPacket); //tolua_export
+ ~cPickup(); //tolua_export
+
+ cItem* GetItem() { return m_Item; } //tolua_export
+
+ void SpawnOn( cClientHandle* a_Target );
+ virtual bool CollectedBy( cPlayer* a_Dest ); //tolua_export
+
+ void Tick(float a_Dt);
+ void HandlePhysics(float a_Dt);
+private:
+ Vector3f* m_Speed;
+ bool m_bOnGround;
+ bool m_bReplicated;
+
+ float m_Timer;
+
+ cItem* m_Item;
+
+ bool m_bCollected;
+};//tolua_export
\ No newline at end of file diff --git a/source/cPlayer.cpp b/source/cPlayer.cpp new file mode 100644 index 000000000..8552abd3e --- /dev/null +++ b/source/cPlayer.cpp @@ -0,0 +1,713 @@ +#include "cPlayer.h"
+#include "cServer.h"
+#include "cInventory.h"
+#include "cClientHandle.h"
+#include "cWorld.h"
+#include "cPickup.h"
+#include "cPluginManager.h"
+#include "cChunk.h"
+#include "cMCLogger.h"
+#include "cWindow.h"
+#include "cBlockEntity.h"
+#include "cGroupManager.h"
+#include "cGroup.h"
+#include "cChatColor.h"
+#include "cItem.h"
+#include "cTracer.h"
+#include "cRoot.h"
+
+#include "packets/cPacket_NamedEntitySpawn.h"
+#include "packets/cPacket_EntityLook.h"
+#include "packets/cPacket_TeleportEntity.h"
+#include "packets/cPacket_RelativeEntityMove.h"
+#include "packets/cPacket_RelativeEntityMoveLook.h"
+#include "packets/cPacket_UpdateHealth.h"
+#include "packets/cPacket_Respawn.h"
+#include "packets/cPacket_PlayerPosition.h"
+#include "packets/cPacket_DestroyEntity.h"
+#include "packets/cPacket_Metadata.h"
+#include "packets/cPacket_Chat.h"
+
+#include "Vector3d.h"
+#include "Vector3f.h"
+
+#include "../iniFile/iniFile.h"
+
+#ifndef _WIN32 // for mkdir
+#include <sys/stat.h>
+#include <sys/types.h>
+#endif
+
+extern std::vector< std::string > StringSplit( std::string str, std::string delim);
+
+CLASS_DEFINITION( cPlayer, cPawn );
+
+typedef std::map< std::string, bool > PermissionMap;
+struct cPlayer::sPlayerState
+{
+ PermissionMap ResolvedPermissions;
+ PermissionMap Permissions;
+
+ cPlayer::GroupList ResolvedGroups;
+ cPlayer::GroupList Groups;
+
+ std::string PlayerName;
+};
+
+cPlayer::cPlayer(cClientHandle* a_Client, const char* a_PlayerName)
+ : m_bBurnable(true)
+ , e_EPMetaState(NORMAL)
+ , m_bVisible( true )
+ , m_LastGroundHeight( 0 )
+ , m_bTouchGround( false )
+ , m_Stance( 0.0 )
+ , m_Inventory( 0 )
+ , m_CurrentWindow( 0 )
+ , m_TimeLastPickupCheck( 0.f )
+ , m_Color('-')
+ , m_FireDamageInterval(0)
+ , m_BurnPeriod(0)
+ , m_ClientHandle( a_Client )
+ , m_pState( new sPlayerState )
+{
+ m_EntityType = E_PLAYER;
+ m_Inventory = new cInventory( this );
+
+ m_TimeLastTeleportPacket = cWorld::GetTime();
+ m_TimeLastPickupCheck = cWorld::GetTime();
+
+ m_pState->PlayerName = a_PlayerName;
+ m_bDirtyPosition = true; // So chunks are streamed to player at spawn
+
+ if( !LoadFromDisk() )
+ {
+ m_Inventory->Clear();
+ SetPosX( cRoot::Get()->GetWorld()->GetSpawnX() );
+ SetPosY( cRoot::Get()->GetWorld()->GetSpawnY() );
+ SetPosZ( cRoot::Get()->GetWorld()->GetSpawnZ() );
+ }
+
+ MoveToCorrectChunk();
+ cRoot::Get()->GetWorld()->AddPlayer( this );
+}
+
+cPlayer::~cPlayer(void)
+{
+ SaveToDisk();
+ m_ClientHandle = 0;
+ CloseWindow();
+ if( m_Inventory )
+ {
+ delete m_Inventory;
+ m_Inventory = 0;
+ }
+ delete m_pState;
+ cRoot::Get()->GetWorld()->RemovePlayer( this );
+}
+
+void cPlayer::SpawnOn( cClientHandle* a_Target )
+{
+ if( a_Target == m_ClientHandle || !m_bVisible ) return;
+ LOG("cPlayer::SpawnOn -> Sending %s to %s", m_pState->PlayerName.c_str(), (a_Target)?a_Target->GetUsername():"Everybody" );
+ cPacket_NamedEntitySpawn SpawnPacket;
+ SpawnPacket.m_UniqueID = m_UniqueID;
+ SpawnPacket.m_PlayerName = m_pState->PlayerName;
+ SpawnPacket.m_PosX = (int)(m_Pos->x * 32);
+ SpawnPacket.m_PosY = (int)(m_Pos->y * 32);
+ SpawnPacket.m_PosZ = (int)(m_Pos->z * 32);
+ SpawnPacket.m_Rotation = (char)((m_Rot->x/360.f)*256);
+ SpawnPacket.m_Pitch = (char)((m_Rot->y/360.f)*256);
+ SpawnPacket.m_CurrentItem = (short)m_Inventory->GetEquippedItem().m_ItemID;
+ if( a_Target == 0 )
+ {
+ cChunk* Chunk = cRoot::Get()->GetWorld()->GetChunk( m_ChunkX, m_ChunkY, m_ChunkZ );
+ Chunk->Broadcast( SpawnPacket, m_ClientHandle );
+ }
+ else
+ {
+ a_Target->Send( SpawnPacket );
+ }
+}
+
+void cPlayer::Tick(float a_Dt)
+{
+ cChunk* InChunk = cRoot::Get()->GetWorld()->GetChunk( m_ChunkX, m_ChunkY, m_ChunkZ );
+ if(m_bDirtyOrientation && !m_bDirtyPosition)
+ {
+ cPacket_EntityLook EntityLook( this );
+ InChunk->Broadcast( EntityLook, m_ClientHandle );
+ m_bDirtyOrientation = false;
+ }
+ if(m_bDirtyPosition )
+ {
+ cRoot::Get()->GetPluginManager()->CallHook( cPluginManager::E_PLUGIN_PLAYER_MOVE, 1, this );
+
+ float DiffX = (float)(GetPosX() - m_LastPosX );
+ float DiffY = (float)(GetPosY() - m_LastPosY );
+ float DiffZ = (float)(GetPosZ() - m_LastPosZ );
+ float SqrDist = DiffX*DiffX + DiffY*DiffY + DiffZ*DiffZ;
+ if( SqrDist > 4*4 // 4 blocks is max Relative Move
+ || cWorld::GetTime() - m_TimeLastTeleportPacket > 2 ) // Send an absolute position every 2 seconds
+ {
+ //LOG("Teleported %f", sqrtf(SqrDist) );
+ cPacket_TeleportEntity TeleportEntity( this );
+ InChunk->Broadcast( TeleportEntity, m_ClientHandle );
+ m_TimeLastTeleportPacket = cWorld::GetTime();
+ }
+ else
+ { // Relative move sucks balls! It's always wrong wtf!
+ if( m_bDirtyOrientation )
+ {
+ cPacket_RelativeEntityMoveLook RelativeEntityMoveLook;
+ RelativeEntityMoveLook.m_UniqueID = GetUniqueID();
+ RelativeEntityMoveLook.m_MoveX = (char)(DiffX*32);
+ RelativeEntityMoveLook.m_MoveY = (char)(DiffY*32);
+ RelativeEntityMoveLook.m_MoveZ = (char)(DiffZ*32);
+ RelativeEntityMoveLook.m_Yaw = (char)((GetRotation()/360.f)*256);
+ RelativeEntityMoveLook.m_Pitch = (char)((GetPitch()/360.f)*256);
+ InChunk->Broadcast( RelativeEntityMoveLook, m_ClientHandle );
+ }
+ else
+ {
+ cPacket_RelativeEntityMove RelativeEntityMove;
+ RelativeEntityMove.m_UniqueID = GetUniqueID();
+ RelativeEntityMove.m_MoveX = (char)(DiffX*32);
+ RelativeEntityMove.m_MoveY = (char)(DiffY*32);
+ RelativeEntityMove.m_MoveZ = (char)(DiffZ*32);
+ InChunk->Broadcast( RelativeEntityMove, m_ClientHandle );
+ }
+ }
+ m_LastPosX = GetPosX();
+ m_LastPosY = GetPosY();
+ m_LastPosZ = GetPosZ();
+ m_bDirtyPosition = false;
+ m_ClientHandle->StreamChunks();
+ }
+
+ if( m_Health > 0 ) // make sure player is alive
+ {
+ if( cWorld::GetTime() - m_TimeLastPickupCheck > 0.5f ) // Each 0.5 second, check for pickups
+ {
+ m_TimeLastPickupCheck = cWorld::GetTime();
+ // and also check if near a pickup
+ // TODO: Don't only check in current chunks, but also close chunks (chunks within range)
+ cChunk* Chunk = cRoot::Get()->GetWorld()->GetChunk( m_ChunkX, m_ChunkY, m_ChunkZ );
+ Chunk->LockEntities();
+ cWorld::EntityList Entities = Chunk->GetEntities();
+ for( cWorld::EntityList::iterator itr = Entities.begin(); itr != Entities.end();++itr)
+ {
+ if( (*itr)->GetEntityType() != cEntity::E_PICKUP ) continue; // Only pickups
+ float DiffX = (float)((*itr)->GetPosX() - GetPosX() );
+ float DiffY = (float)((*itr)->GetPosY() - GetPosY() );
+ float DiffZ = (float)((*itr)->GetPosZ() - GetPosZ() );
+ float SqrDist = DiffX*DiffX + DiffY*DiffY + DiffZ*DiffZ;
+ if(SqrDist < 1.5f*1.5f) // 1.5 block
+ {
+ cPickup* Pickup = reinterpret_cast<cPickup*>(*itr);
+ Pickup->CollectedBy( this );
+ }
+ }
+ Chunk->UnlockEntities();
+ }
+ }
+ CheckMetaDataBurn();
+ if(e_EPMetaState == BURNING){
+ InStateBurning(a_Dt);
+ }
+}
+
+void cPlayer::InStateBurning(float a_Dt) {
+ m_FireDamageInterval += a_Dt;
+ char block = cRoot::Get()->GetWorld()->GetBlock( (int)m_Pos->x, (int)m_Pos->y, (int)m_Pos->z );
+ char bblock = cRoot::Get()->GetWorld()->GetBlock( (int)m_Pos->x, (int)m_Pos->y -1, (int)m_Pos->z );
+ if(m_FireDamageInterval > 1000) {
+
+ m_FireDamageInterval = 0;
+ int rem = rand()%3 + 1; //Burn most of the time
+ if(rem >= 2) {
+ //printf("OUCH burning!!!\n");
+ TakeDamage(1, this);
+ }
+ m_BurnPeriod++;
+ if(block == E_BLOCK_LAVA || block == E_BLOCK_STATIONARY_LAVA || block == E_BLOCK_FIRE
+ || bblock == E_BLOCK_LAVA || bblock == E_BLOCK_STATIONARY_LAVA || bblock == E_BLOCK_FIRE)
+ m_BurnPeriod = 0;
+
+ if(m_BurnPeriod > 5) {
+
+ cChunk* InChunk = cRoot::Get()->GetWorld()->GetChunkUnreliable( m_ChunkX, m_ChunkY, m_ChunkZ );
+ e_EPMetaState = NORMAL;
+ cPacket_Metadata md(NORMAL, GetUniqueID());
+ //md.m_UniqueID = GetUniqueID();
+ InChunk->Broadcast(md);
+ m_BurnPeriod = 0;
+
+ }
+
+ }
+
+}
+
+//----Change Entity MetaData
+void cPlayer::CheckMetaDataBurn() {
+ char block = cRoot::Get()->GetWorld()->GetBlock( (int)m_Pos->x, (int)m_Pos->y, (int)m_Pos->z );
+ char bblock = cRoot::Get()->GetWorld()->GetBlock( (int)m_Pos->x, (int)m_Pos->y -1, (int)m_Pos->z );
+ if(m_bBurnable && e_EPMetaState != BURNING && (block == E_BLOCK_LAVA || block == E_BLOCK_STATIONARY_LAVA || block == E_BLOCK_FIRE
+ || bblock == E_BLOCK_LAVA || bblock == E_BLOCK_STATIONARY_LAVA || bblock == E_BLOCK_FIRE)) {
+ cChunk* InChunk = cRoot::Get()->GetWorld()->GetChunkUnreliable( m_ChunkX, m_ChunkY, m_ChunkZ );
+ if(!InChunk)
+ return;
+ printf("I should burn");
+ e_EPMetaState = BURNING;
+ cPacket_Metadata md(BURNING,GetUniqueID());
+ InChunk->Broadcast(md);
+ }
+}
+
+void cPlayer::SetTouchGround( bool a_bTouchGround )
+{
+ m_bTouchGround = a_bTouchGround;
+
+ if( !m_bTouchGround )
+ {
+ cWorld* World = cRoot::Get()->GetWorld();
+ char BlockID = World->GetBlock( (int)m_Pos->x, (int)m_Pos->y, (int)m_Pos->z );
+ if( BlockID != E_BLOCK_AIR )
+ {
+ m_bTouchGround = true;
+ }
+ if( BlockID == E_BLOCK_WATER || BlockID == E_BLOCK_STATIONARY_WATER || BlockID == E_BLOCK_LADDER || BlockID == E_BLOCK_TORCH )
+ {
+ m_LastGroundHeight = (float)m_Pos->y;
+ }
+ }
+
+ if( m_bTouchGround )
+ {
+ float Dist = (float)(m_LastGroundHeight - m_Pos->y);
+ if( Dist > 4.f ) // Player dropped
+ {
+ int Damage = (int)(Dist - 4.f);
+ if( Damage > 0 )
+ {
+ TakeDamage( Damage, 0 );
+ }
+ }
+
+ m_LastGroundHeight = (float)m_Pos->y;
+ }
+}
+
+void cPlayer::Heal( int a_Health )
+{
+ if( m_Health < 20 )
+ {
+ m_Health += (short)a_Health;
+ if( m_Health > 20 )
+ {
+ m_Health = 20;
+ }
+
+ cPacket_UpdateHealth Health;
+ Health.m_Health = m_Health;
+ m_ClientHandle->Send( Health );
+ }
+}
+
+void cPlayer::TakeDamage( int a_Damage, cEntity* a_Instigator )
+{
+ cPawn::TakeDamage( a_Damage, a_Instigator );
+
+ cPacket_UpdateHealth Health;
+ Health.m_Health = m_Health;
+ m_ClientHandle->Send( Health );
+}
+
+void cPlayer::KilledBy( cEntity* a_Killer )
+{
+ cPawn::KilledBy( a_Killer );
+
+ if( m_Health > 0 ) return; // not dead yet =]
+
+ m_bVisible = false; // So new clients don't see the player
+
+ // Puke out all the items
+ cItem* Items = m_Inventory->GetSlots();
+ for( unsigned int i = 1; i < m_Inventory->c_NumSlots; ++i )
+ {
+ if( !Items[i].IsEmpty() )
+ {
+ float SpeedX = ((rand()%1000)-500) /100.f;
+ float SpeedY = ((rand()%1000)) /100.f;
+ float SpeedZ = ((rand()%1000)-500) /100.f;
+ cPickup* Pickup = new cPickup( (int)(m_Pos->x*32), (int)(m_Pos->y*32), (int)(m_Pos->z*32), Items[i], SpeedX, SpeedY, SpeedZ );
+ Pickup->Initialize();
+ }
+ Items[i].Empty();
+ }
+ SaveToDisk(); // Save it, yeah the world is a tough place !
+}
+
+void cPlayer::Respawn()
+{
+ m_Health = 20;
+
+ cWorld* World = cRoot::Get()->GetWorld();
+ m_ClientHandle->Send( cPacket_Respawn() );
+ TeleportTo( World->GetSpawnX(), World->GetSpawnY(), World->GetSpawnZ() );
+ SetVisible( true );
+}
+
+double cPlayer::GetEyeHeight()
+{
+ return m_Stance;
+}
+
+Vector3d cPlayer::GetEyePosition()
+{
+ return Vector3d( m_Pos->x, m_Stance, m_Pos->z );
+}
+
+void cPlayer::OpenWindow( cWindow* a_Window )
+{
+ CloseWindow();
+ a_Window->Open( *this );
+ m_CurrentWindow = a_Window;
+}
+
+void cPlayer::CloseWindow()
+{
+ if( m_CurrentWindow ) m_CurrentWindow->Close( *this );
+ m_CurrentWindow = 0;
+}
+
+#ifdef SendMessage // Cause stupid windows.h defines SendMessage as SendMessageA
+#undef SendMessage
+#endif
+void cPlayer::SendMessage( const char* a_Message )
+{
+ m_ClientHandle->Send( cPacket_Chat( a_Message ) );
+}
+
+void cPlayer::TeleportTo( cEntity* a_Entity )
+{
+ cPawn::TeleportTo( a_Entity );
+ cPacket_PlayerPosition PlayerPosition( this );
+ m_ClientHandle->Send( PlayerPosition );
+}
+
+void cPlayer::TeleportTo( const double & a_PosX, const double & a_PosY, const double & a_PosZ )
+{
+ cPawn::TeleportTo( a_PosX, a_PosY, a_PosZ );
+ cPacket_PlayerPosition PlayerPosition( this );
+ m_ClientHandle->Send( PlayerPosition );
+}
+
+void cPlayer::MoveTo( const Vector3d & a_NewPos )
+{
+ // TODO: should do some checks to see if player is not moving through terrain
+ SetPosition( a_NewPos );
+}
+
+void cPlayer::SetVisible( bool a_bVisible )
+{
+ if( a_bVisible == true && m_bVisible == false ) // Make visible
+ {
+ m_bVisible = true;
+ SpawnOn( 0 ); // Spawn on everybody
+ }
+ if( a_bVisible == false && m_bVisible == true )
+ {
+ m_bVisible = false;
+ cPacket_DestroyEntity DestroyEntity( this );
+ cChunk* Chunk = cRoot::Get()->GetWorld()->GetChunkUnreliable( m_ChunkX, m_ChunkY, m_ChunkZ );
+ if( Chunk )
+ {
+ Chunk->Broadcast( DestroyEntity ); // Destroy on all clients
+ }
+ }
+}
+
+void cPlayer::AddToGroup( const char* a_GroupName )
+{
+ cGroup* Group = cRoot::Get()->GetGroupManager()->GetGroup( a_GroupName );
+ m_pState->Groups.push_back( Group );
+ LOG("Added %s to group %s", m_pState->PlayerName.c_str(), a_GroupName );
+ ResolveGroups();
+ ResolvePermissions();
+}
+
+bool cPlayer::CanUseCommand( const char* a_Command )
+{
+ for( GroupList::iterator itr = m_pState->Groups.begin(); itr != m_pState->Groups.end(); ++itr )
+ {
+ if( (*itr)->HasCommand( a_Command ) ) return true;
+ }
+ return false;
+}
+
+bool cPlayer::HasPermission( const char* a_Permission )
+{
+ std::vector< std::string > Split = StringSplit( a_Permission, "." );
+ PermissionMap Possibilities = m_pState->ResolvedPermissions;
+ // Now search the namespaces
+ while( Possibilities.begin() != Possibilities.end() )
+ {
+ PermissionMap::iterator itr = Possibilities.begin();
+ if( itr->second )
+ {
+ std::vector< std::string > OtherSplit = StringSplit( itr->first, "." );
+ if( OtherSplit.size() <= Split.size() )
+ {
+ unsigned int i;
+ for( i = 0; i < OtherSplit.size(); ++i )
+ {
+ if( OtherSplit[i].compare( Split[i] ) != 0 )
+ {
+ if( OtherSplit[i].compare("*") == 0 ) return true; // WildCard man!! WildCard!
+ break;
+ }
+ }
+ if( i == Split.size() ) return true;
+ }
+ }
+ Possibilities.erase( itr );
+ }
+
+ // Nothing that matched :(
+ return false;
+}
+
+bool cPlayer::IsInGroup( const char* a_Group )
+{
+ for( GroupList::iterator itr = m_pState->ResolvedGroups.begin(); itr != m_pState->ResolvedGroups.end(); ++itr )
+ {
+ if( strcmp( a_Group, (*itr)->GetName().c_str() ) == 0 )
+ return true;
+ }
+ return false;
+}
+
+void cPlayer::ResolvePermissions()
+{
+ m_pState->ResolvedPermissions.clear(); // Start with an empty map yo~
+
+ // Copy all player specific permissions into the resolved permissions map
+ for( PermissionMap::iterator itr = m_pState->Permissions.begin(); itr != m_pState->Permissions.end(); ++itr )
+ {
+ m_pState->ResolvedPermissions[ itr->first ] = itr->second;
+ }
+
+ for( GroupList::iterator GroupItr = m_pState->ResolvedGroups.begin(); GroupItr != m_pState->ResolvedGroups.end(); ++GroupItr )
+ {
+ const cGroup::PermissionMap & Permissions = (*GroupItr)->GetPermissions();
+ for( cGroup::PermissionMap::const_iterator itr = Permissions.begin(); itr != Permissions.end(); ++itr )
+ {
+ m_pState->ResolvedPermissions[ itr->first ] = itr->second;
+ }
+ }
+}
+
+void cPlayer::ResolveGroups()
+{
+ // Clear resolved groups first
+ m_pState->ResolvedGroups.clear();
+
+ // Get a complete resolved list of all groups the player is in
+ std::map< cGroup*, bool > AllGroups; // Use a map, because it's faster than iterating through a list to find duplicates
+ GroupList ToIterate;
+ for( GroupList::iterator GroupItr = m_pState->Groups.begin(); GroupItr != m_pState->Groups.end(); ++GroupItr )
+ {
+ ToIterate.push_back( *GroupItr );
+ }
+ while( ToIterate.begin() != ToIterate.end() )
+ {
+ cGroup* CurrentGroup = *ToIterate.begin();
+ if( AllGroups.find( CurrentGroup ) != AllGroups.end() )
+ {
+ LOGERROR("ERROR: Player %s is in the same group multiple times (%s). FIX IT!", m_pState->PlayerName.c_str(), CurrentGroup->GetName().c_str() );
+ }
+ else
+ {
+ AllGroups[ CurrentGroup ] = true;
+ m_pState->ResolvedGroups.push_back( CurrentGroup ); // Add group to resolved list
+ const cGroup::GroupList & Inherits = CurrentGroup->GetInherits();
+ for( cGroup::GroupList::const_iterator itr = Inherits.begin(); itr != Inherits.end(); ++itr )
+ {
+ if( AllGroups.find( *itr ) != AllGroups.end() )
+ {
+ LOGERROR("ERROR: Player %s is in the same group multiple times due to inheritance (%s). FIX IT!", m_pState->PlayerName.c_str(), (*itr)->GetName().c_str() );
+ continue;
+ }
+ ToIterate.push_back( *itr );
+ }
+ }
+ ToIterate.erase( ToIterate.begin() );
+ }
+}
+
+std::string cPlayer::GetColor()
+{
+ if( m_Color != '-' )
+ return cChatColor::MakeColor( m_Color );
+
+ if( m_pState->Groups.size() < 1 )
+ return cChatColor::White;
+
+ return (*m_pState->Groups.begin())->GetColor();
+}
+
+void cPlayer::TossItem( bool a_bDraggingItem, int a_Amount /* = 1 */ )
+{
+ if( a_bDraggingItem )
+ {
+ cItem* Item = GetInventory().GetWindow()->GetDraggingItem();
+ if( Item->m_ItemID > 0 && Item->m_ItemCount >= a_Amount )
+ {
+ float vX = 0, vY = 0, vZ = 0;
+ EulerToVector( -GetRotation(), GetPitch(), vZ, vX, vY );
+ vY = -vY*2 + 1.f;
+ cPickup* Pickup = new cPickup( (int)(GetPosX()*32), (int)(GetPosY()*32) + (int)(1.6f*32), (int)(GetPosZ()*32), cItem( Item->m_ItemID, (char)a_Amount, Item->m_ItemHealth), vX*2, vY*2, vZ*2 );
+ Pickup->Initialize();
+ if( Item->m_ItemCount > a_Amount )
+ Item->m_ItemCount -= (char)a_Amount;
+ else
+ Item->Empty();
+ }
+ return;
+ }
+
+ // Else drop equipped item
+ cItem DroppedItem = GetInventory().GetEquippedItem();
+ if( DroppedItem.m_ItemID > 0 && DroppedItem.m_ItemCount > 0 )
+ {
+ DroppedItem.m_ItemCount = 1;
+ if( GetInventory().RemoveItem( DroppedItem ) )
+ {
+ DroppedItem.m_ItemCount = 1; // RemoveItem decreases the count, so set it to 1 again
+ float vX = 0, vY = 0, vZ = 0;
+ EulerToVector( -GetRotation(), GetPitch(), vZ, vX, vY );
+ vY = -vY*2 + 1.f;
+ cPickup* Pickup = new cPickup( (int)(GetPosX()*32), (int)(GetPosY()*32) + (int)(1.6f*32), (int)(GetPosZ()*32), DroppedItem, vX*2, vY*2, vZ*2 );
+ Pickup->Initialize();
+ }
+ }
+}
+
+bool cPlayer::LoadFromDisk()
+{
+ cIniFile IniFile("users.ini");
+ if( IniFile.ReadFile() )
+ {
+ std::string Groups = IniFile.GetValue(m_pState->PlayerName, "Groups", "");
+ if( Groups.size() > 0 )
+ {
+ std::vector< std::string > Split = StringSplit( Groups, "," );
+ for( unsigned int i = 0; i < Split.size(); i++ )
+ {
+ AddToGroup( Split[i].c_str() );
+ }
+ }
+ else
+ {
+ AddToGroup("Default");
+ }
+
+ m_Color = IniFile.GetValue(m_pState->PlayerName, "Color", "-")[0];
+ }
+ else
+ {
+ AddToGroup("Default");
+ }
+ ResolvePermissions();
+
+ // Log player permissions, cause it's what the cool kids do
+ LOGINFO("Player %s has permissions:", m_pState->PlayerName.c_str() );
+ for( PermissionMap::iterator itr = m_pState->ResolvedPermissions.begin(); itr != m_pState->ResolvedPermissions.end(); ++itr )
+ {
+ if( itr->second ) LOGINFO("%s", itr->first.c_str() );
+ }
+
+ char SourceFile[128];
+ sprintf_s(SourceFile, 128, "world/player/%s.bin", m_pState->PlayerName.c_str() );
+
+ FILE* f;
+ #ifdef _WIN32
+ if( fopen_s(&f, SourceFile, "rb" ) == 0 ) // no error
+ #else
+ if( (f = fopen(SourceFile, "rb" ) ) != 0 ) // no error
+ #endif
+ {
+ if( fread( &m_Pos->x, sizeof(double), 1, f) != 1 ) { LOGERROR("ERROR READING FROM FILE %s", SourceFile); fclose(f); return false; }
+ if( fread( &m_Pos->y, sizeof(double), 1, f) != 1 ) { LOGERROR("ERROR READING FROM FILE %s", SourceFile); fclose(f); return false; }
+ if( fread( &m_Pos->z, sizeof(double), 1, f) != 1 ) { LOGERROR("ERROR READING FROM FILE %s", SourceFile); fclose(f); return false; }
+ if( fread( &m_Rot->x, sizeof(float), 1, f) != 1 ) { LOGERROR("ERROR READING FROM FILE %s", SourceFile); fclose(f); return false; }
+ if( fread( &m_Rot->y, sizeof(float), 1, f) != 1 ) { LOGERROR("ERROR READING FROM FILE %s", SourceFile); fclose(f); return false; }
+ if( fread( &m_Rot->z, sizeof(float), 1, f) != 1 ) { LOGERROR("ERROR READING FROM FILE %s", SourceFile); fclose(f); return false; }
+ if( fread( &m_Health, sizeof(m_Health), 1, f) != 1 ) { LOGERROR("ERROR READING FROM FILE %s", SourceFile); fclose(f); return false; }
+ if( !m_Inventory->LoadFromFile( f ) ) { LOGERROR("ERROR READING INVENTORY FROM FILE %s", SourceFile); fclose(f); return false; }
+ fclose(f);
+ return true;
+ }
+ return false;
+}
+
+bool cPlayer::SaveToDisk()
+{
+ #ifdef _WIN32
+ { // Make sure some folders exist
+ SECURITY_ATTRIBUTES Attrib;
+ Attrib.nLength = sizeof(SECURITY_ATTRIBUTES);
+ Attrib.lpSecurityDescriptor = NULL;
+ Attrib.bInheritHandle = false;
+ ::CreateDirectory("world", &Attrib);
+ ::CreateDirectory("world/player", &Attrib);
+ }
+ #else
+ {
+ mkdir("world", S_IRWXU | S_IRWXG | S_IRWXO);
+ mkdir("world/player", S_IRWXU | S_IRWXG | S_IRWXO);
+ }
+ #endif
+
+ char SourceFile[128];
+ sprintf_s(SourceFile, 128, "world/player/%s.bin", m_pState->PlayerName.c_str() );
+
+ FILE* f;
+ #ifdef _WIN32
+ if( fopen_s(&f, SourceFile, "wb" ) == 0 ) // no error
+ #else
+ if( (f = fopen(SourceFile, "wb" ) ) != 0 ) // no error
+ #endif
+ {
+ fwrite( &m_Pos->x, sizeof(double), 1, f );
+ fwrite( &m_Pos->y, sizeof(double), 1, f );
+ fwrite( &m_Pos->z, sizeof(double), 1, f );
+ fwrite( &m_Rot->x, sizeof(float), 1, f );
+ fwrite( &m_Rot->y, sizeof(float), 1, f );
+ fwrite( &m_Rot->z, sizeof(float), 1, f );
+ fwrite( &m_Health, sizeof(m_Health), 1, f );
+ m_Inventory->WriteToFile( f );
+ fclose(f);
+ return true;
+ }
+
+ LOGERROR("ERROR WRITING PLAYER %s TO FILE %s", m_pState->PlayerName.c_str(), SourceFile);
+ return false;
+}
+
+
+const char* cPlayer::GetName()
+{
+ return m_pState->PlayerName.c_str();
+}
+
+void cPlayer::SetName( const char* a_Name )
+{
+ m_pState->PlayerName = a_Name;
+}
+
+const cPlayer::GroupList & cPlayer::GetGroups()
+{
+ return m_pState->Groups;
+}
\ No newline at end of file diff --git a/source/cPlayer.h b/source/cPlayer.h new file mode 100644 index 000000000..6f05b824d --- /dev/null +++ b/source/cPlayer.h @@ -0,0 +1,96 @@ +#pragma once
+
+#include "cPawn.h"
+#include <list>
+
+class cGroup;
+class cWindow;
+class cInventory;
+class cClientHandle;
+class cPlayer : public cPawn //tolua_export
+{ //tolua_export
+public:
+ CLASS_PROTOTYPE();
+
+ cPlayer(cClientHandle* a_Client, const char* a_PlayerName);
+ virtual ~cPlayer();
+
+ virtual void SpawnOn( cClientHandle* a_Target );
+ virtual void Tick(float a_Dt);
+
+ void SetTouchGround( bool a_bTouchGround );
+ inline void SetStance( const double & a_Stance ) { m_Stance = a_Stance; }
+ double GetEyeHeight(); //tolua_export
+ Vector3d GetEyePosition(); //tolua_export
+ inline bool GetFlying() { return m_bTouchGround; } //tolua_export
+ inline const double & GetStance() { return m_Stance; } //tolua_export
+ cInventory & GetInventory() { return *m_Inventory; } //tolua_export
+ virtual void TeleportTo( cEntity* a_Entity ); //tolua_export
+ virtual void TeleportTo( const double & a_PosX, const double & a_PosY, const double & a_PosZ ); //tolua_export
+
+ // Tries to move to a new position, with collision checks and stuff
+ virtual void MoveTo( const Vector3d & a_NewPos ); //tolua_export
+
+ cWindow* GetWindow() { return m_CurrentWindow; }
+ void OpenWindow( cWindow* a_Window );
+ void CloseWindow();
+
+ cClientHandle* GetClientHandle() { return m_ClientHandle; } //tolua_export
+ void SetClientHandle( cClientHandle* a_Client ) { m_ClientHandle = a_Client; }
+
+ void SendMessage( const char* a_Message ); //tolua_export
+
+ const char* GetName(); //tolua_export
+ void SetName( const char* a_Name ); //tolua_export
+
+ typedef std::list< cGroup* > GroupList;
+ void AddToGroup( const char* a_GroupName ); //tolua_export
+ bool CanUseCommand( const char* a_Command ); //tolua_export
+ bool HasPermission( const char* a_Permission ); //tolua_export
+ const GroupList & GetGroups(); // >> EXPORTED IN MANUALBINDINGS <<
+ bool IsInGroup( const char* a_Group ); //tolua_export
+
+ std::string GetColor(); //tolua_export
+
+ void TossItem( bool a_bDraggingItem, int a_Amount = 1 ); //tolua_export
+
+ void Heal( int a_Health ); //tolua_export
+ void TakeDamage( int a_Damage, cEntity* a_Instigator ); //tolua_export
+ void KilledBy( cEntity* a_Killer ); //tolua_export
+ void Respawn(); //tolua_export
+
+ void SetVisible( bool a_bVisible ); //tolua_export
+ bool IsVisible() { return m_bVisible; } //tolua_export
+
+ bool SaveToDisk();
+ bool LoadFromDisk();
+
+ //Burning logic
+ bool m_bBurnable;
+ enum PMetaState{NORMAL,BURNING,CROUCHED,RIDING} e_EPMetaState;
+ virtual void CheckMetaDataBurn();
+ virtual void InStateBurning(float a_Dt);
+
+protected:
+ struct sPlayerState;
+ sPlayerState* m_pState;
+
+ bool m_bVisible;
+
+ float m_LastGroundHeight;
+ bool m_bTouchGround;
+ double m_Stance;
+ cInventory* m_Inventory;
+ cWindow* m_CurrentWindow;
+
+ float m_TimeLastPickupCheck;
+
+ void ResolvePermissions();
+
+ void ResolveGroups();
+ char m_Color;
+ float m_FireDamageInterval;
+ float m_BurnPeriod;
+
+ cClientHandle* m_ClientHandle;
+}; //tolua_export
diff --git a/source/cPlugin.cpp b/source/cPlugin.cpp new file mode 100644 index 000000000..10f5d74d3 --- /dev/null +++ b/source/cPlugin.cpp @@ -0,0 +1,78 @@ +#include "cPlugin.h"
+#include <stdio.h>
+
+#include "cMCLogger.h"
+
+cPlugin::cPlugin()
+ : m_Version( 0 )
+{
+}
+
+cPlugin::~cPlugin()
+{
+}
+
+// bool cPlugin::Initialize()
+// {
+// LOG("cPlugin::Initialize()");
+// return false;
+// }
+
+void cPlugin::Tick(float a_Dt)
+{
+ (void)a_Dt;
+}
+
+bool cPlugin::OnBlockPlace( cPacket_BlockPlace* a_PacketData, cPlayer* a_Player )
+{
+ (void)a_PacketData;
+ (void)a_Player;
+ return false;
+}
+
+bool cPlugin::OnCollectItem( cPickup* a_Pickup, cPlayer* a_Player )
+{
+ (void)a_Pickup;
+ (void)a_Player;
+ return false;
+}
+
+bool cPlugin::OnDisconnect( std::string a_Reason, cPlayer* a_Player )
+{
+ (void)a_Reason;
+ (void)a_Player;
+ return false;
+}
+
+bool cPlugin::OnChat( std::string a_Chat, cPlayer* a_Player )
+{
+ (void)a_Chat;
+ (void)a_Player;
+ return false;
+}
+
+bool cPlugin::OnLogin( cPacket_Login* a_PacketData )
+{
+ (void)a_PacketData;
+ return false;
+}
+
+void cPlugin::OnPlayerSpawn( cPlayer* a_Player )
+{
+ (void)a_Player;
+}
+
+bool cPlugin::OnPlayerJoin( cPlayer* a_Player )
+{
+ (void)a_Player;
+ return false;
+}
+
+void cPlugin::AddCommand( std::string & a_Command, std::string & a_Description, std::string & a_Permission )
+{
+ CommandStruct Command;
+ Command.Command = a_Command;
+ Command.Description = a_Description;
+ Command.Permission = a_Permission;
+ m_Commands.push_back( Command );
+}
diff --git a/source/cPlugin.h b/source/cPlugin.h new file mode 100644 index 000000000..6c38871f3 --- /dev/null +++ b/source/cPlugin.h @@ -0,0 +1,76 @@ +#pragma once
+
+#include "MemoryLeak.h"
+
+#include <vector>
+#include <string>
+
+class cPacket_BlockPlace;
+class cPacket_PickupSpawn;
+class cPacket_EntityEquipment;
+class cPacket_Disconnect;
+class cPacket_Chat;
+class cPacket_BlockDig;
+class cPacket_Login;
+class cClientHandle;
+class cPlayer;
+class cPickup;
+class cItem;
+class cEntity;
+class cPawn;
+struct TakeDamageInfo;
+
+// tolua_begin
+class cPlugin
+{
+public:
+ cPlugin();
+ virtual ~cPlugin();
+
+ virtual void OnDisable() {}
+ virtual bool Initialize() = 0;
+
+ // Called each tick
+ virtual void Tick(float a_Dt);
+
+ /**
+ * On all these functions, return true if you want to override default behavior
+ * You can also return false, so default behavior is used, but with changed PacketData
+ **/
+ virtual bool OnCollectItem( cPickup* a_Pickup, cPlayer* a_Player );
+ virtual bool OnDisconnect( std::string a_Reason, cPlayer* a_Player );
+ virtual bool OnBlockPlace( cPacket_BlockPlace* a_PacketData, cPlayer* a_Player );
+ virtual bool OnBlockDig( cPacket_BlockDig* a_PacketData, cPlayer* a_Player, cItem* a_PickupItem ) { (void)a_PacketData; (void)a_Player; (void)a_PickupItem; return false; }
+ virtual bool OnChat( std::string a_Chat, cPlayer* a_Player );
+ virtual bool OnLogin( cPacket_Login* a_PacketData );
+ virtual void OnPlayerSpawn( cPlayer* a_Player );
+ virtual bool OnPlayerJoin( cPlayer* a_Player );
+ virtual void OnPlayerMove( cPlayer* a_Player ) { (void)a_Player; }
+ virtual void OnTakeDamage( cPawn* a_Pawn, TakeDamageInfo* a_TakeDamageInfo ) { (void)a_Pawn; (void)a_TakeDamageInfo; }
+ virtual bool OnKilled( cPawn* a_Killed, cEntity* a_Killer ) { (void)a_Killed; (void)a_Killer; return false; }
+
+ // Accessors
+ std::string GetName() const { return m_Name; }
+ void SetName( std::string a_Name ) { m_Name = a_Name; }
+
+ int GetVersion() const { return m_Version; }
+ void SetVersion( int a_Version ) { m_Version = a_Version; }
+
+ struct CommandStruct
+ {
+ std::string Command;
+ std::string Description;
+ std::string Permission;
+ };
+
+ void AddCommand( std::string & a_Command, std::string & a_Description, std::string & a_Permission );
+ // tolua_end
+ typedef bool (FuncCommandHandler)( std::string & a_Command, std::vector< std::string > & a_Split );
+ void BindCommand( FuncCommandHandler* a_Function, std::string & a_Command ); // >> EXPORTED IN MANUALBINDINGS <<
+ const std::vector< CommandStruct > & GetCommands() const { return m_Commands; } // >> EXPORTED IN MANUALBINDINGS <<
+
+private:
+ std::vector< CommandStruct > m_Commands;
+ std::string m_Name;
+ int m_Version;
+}; //tolua_export
diff --git a/source/cPluginManager.cpp b/source/cPluginManager.cpp new file mode 100644 index 000000000..db776f0a7 --- /dev/null +++ b/source/cPluginManager.cpp @@ -0,0 +1,423 @@ +#include "cPluginManager.h"
+#include "cPlugin.h"
+#include "cPlugin_Lua.h"
+#include "cMCLogger.h"
+#include "cWebAdmin.h"
+#include "cItem.h"
+#include "cRoot.h"
+#include "cLuaCommandBinder.h"
+
+#include <stdarg.h>
+
+#include "../iniFile/iniFile.h"
+
+extern std::vector<std::string> StringSplit(std::string str, std::string delim);
+
+typedef std::list< cPlugin_Lua* > LuaPluginList;
+typedef std::map< cPluginManager::PluginHook, cPluginManager::PluginList > HookMap;
+
+struct cPluginManager::sPluginManagerState
+{
+ LuaPluginList LuaPlugins;
+ cPluginManager::PluginList Plugins;
+ HookMap Hooks;
+};
+
+cPluginManager* cPluginManager::GetPluginManager()
+{
+ LOGWARN("WARNING: Using deprecated function cPluginManager::GetPluginManager() use cRoot::Get()->GetPluginManager() instead!");
+ return cRoot::Get()->GetPluginManager();
+}
+
+cPluginManager::cPluginManager()
+ : m_pState( new sPluginManagerState )
+ , m_LuaCommandBinder( new cLuaCommandBinder() )
+ , m_bReloadPlugins(false)
+{
+}
+
+cPluginManager::~cPluginManager()
+{
+ UnloadPluginsNow();
+ delete m_LuaCommandBinder;
+ delete m_pState;
+}
+
+void cPluginManager::ReloadPlugins()
+{
+ m_bReloadPlugins = true;
+}
+
+void cPluginManager::ReloadPluginsNow()
+{
+ LOG("--Loading plugins--");
+ m_bReloadPlugins = false;
+ UnloadPluginsNow();
+
+ cIniFile IniFile("settings.ini");
+ if( IniFile.ReadFile() )
+ {
+ unsigned int KeyNum = IniFile.FindKey("Plugins");
+ unsigned int NumPlugins = IniFile.GetNumValues( KeyNum );
+ if( NumPlugins > 0 )
+ {
+ for(unsigned int i = 0; i < NumPlugins; i++)
+ {
+ std::string ValueName = IniFile.GetValueName(KeyNum, i );
+ if( ValueName.compare("Plugin") == 0 )
+ { // It's a plugin
+ std::string PluginFile = IniFile.GetValue(KeyNum, i );
+ if( PluginFile.compare("") != 0 )
+ {
+ // allow for comma separated plugin list
+ // degrades and works fine for the plugin
+ // per line
+ std::vector< std::string > split = StringSplit( PluginFile, "," );
+ for (unsigned int j = 0; j < split.size(); j++) {
+ cPlugin_Lua* Plugin = new cPlugin_Lua( (split[j] + std::string(".lua") ).c_str() );
+ if( !AddLuaPlugin( Plugin ) )
+ {
+ delete Plugin;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if( GetNumPlugins() == 0 )
+ {
+ LOG("No plugins loaded");
+ }
+ else
+ {
+ LOG("Loaded %i plugin(s)", GetNumPlugins() );
+ }
+ }
+ else
+ {
+ LOG("WARNING: Can't find settings.ini, so can't load any plugins.");
+ }
+ LOG("--Done loading plugins--");
+}
+
+void cPluginManager::Tick(float a_Dt)
+{
+ if( m_bReloadPlugins )
+ {
+ ReloadPluginsNow();
+ }
+
+
+ HookMap::iterator Plugins = m_pState->Hooks.find( E_PLUGIN_TICK );
+ if( Plugins != m_pState->Hooks.end() )
+ {
+ for( PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr )
+ {
+ (*itr)->Tick( a_Dt );
+ }
+ }
+}
+
+bool cPluginManager::CallHook( PluginHook a_Hook, unsigned int a_NumArgs, ... )
+{
+ HookMap::iterator Plugins = m_pState->Hooks.find( a_Hook );
+
+ // Special case for chat hook, since you can also bind commands (bound commands don't use chat hook)
+ if( a_Hook == E_PLUGIN_CHAT )
+ {
+ if( a_NumArgs != 2 ) return false;
+ va_list argptr;
+ va_start( argptr, a_NumArgs);
+ const char* Message = va_arg(argptr, const char* );
+ cPlayer* Player = va_arg(argptr, cPlayer* );
+ va_end (argptr);
+
+ if( m_LuaCommandBinder->HandleCommand( std::string( Message ), Player ) )
+ return true;
+
+ if( Plugins != m_pState->Hooks.end() )
+ {
+ for( PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr )
+ {
+ if( (*itr)->OnChat( Message, Player ) )
+ return true;
+ }
+ }
+
+ return false;
+ }
+
+ if( Plugins != m_pState->Hooks.end() )
+ {
+ switch( a_Hook )
+ {
+ case E_PLUGIN_COLLECT_ITEM:
+ {
+ if( a_NumArgs != 2 ) break;
+ va_list argptr;
+ va_start( argptr, a_NumArgs);
+ cPickup* Pickup = va_arg(argptr, cPickup* );
+ cPlayer* Player = va_arg(argptr, cPlayer* );
+ va_end (argptr);
+ for( PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr )
+ {
+ if( (*itr)->OnCollectItem( Pickup, Player ) )
+ return true;
+ }
+ }
+ break;
+ case E_PLUGIN_BLOCK_DIG:
+ {
+ if( a_NumArgs != 2 ) break;
+ va_list argptr;
+ va_start( argptr, a_NumArgs);
+ cPacket_BlockDig* Packet = va_arg(argptr, cPacket_BlockDig* );
+ cPlayer* Player = va_arg(argptr, cPlayer* );
+ cItem* Item = va_arg( argptr, cItem* );
+ va_end (argptr);
+ for( PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr )
+ {
+ if( (*itr)->OnBlockDig( Packet, Player, Item ) )
+ return true;
+ }
+ }
+ break;
+ case E_PLUGIN_BLOCK_PLACE:
+ {
+ if( a_NumArgs != 2 ) break;
+ va_list argptr;
+ va_start( argptr, a_NumArgs);
+ cPacket_BlockPlace* Packet = va_arg(argptr, cPacket_BlockPlace* );
+ cPlayer* Player = va_arg(argptr, cPlayer* );
+ va_end (argptr);
+ for( PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr )
+ {
+ if( (*itr)->OnBlockPlace( Packet, Player ) )
+ return true;
+ }
+ }
+ break;
+ case E_PLUGIN_DISCONNECT:
+ {
+ if( a_NumArgs != 2 ) break;
+ va_list argptr;
+ va_start( argptr, a_NumArgs);
+ const char* Reason = va_arg(argptr, const char* );
+ cPlayer* Player = va_arg(argptr, cPlayer* );
+ va_end (argptr);
+ for( PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr )
+ {
+ if( (*itr)->OnDisconnect( Reason, Player ) )
+ return true;
+ }
+ }
+ break;
+ case E_PLUGIN_LOGIN:
+ {
+ if( a_NumArgs != 1 ) break;
+ va_list argptr;
+ va_start( argptr, a_NumArgs);
+ cPacket_Login* Packet = va_arg(argptr, cPacket_Login* );
+ va_end (argptr);
+ for( PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr )
+ {
+ if( (*itr)->OnLogin( Packet ) )
+ return true;
+ }
+ }
+ break;
+ case E_PLUGIN_PLAYER_JOIN:
+ {
+ if( a_NumArgs != 1 ) break;
+ va_list argptr;
+ va_start( argptr, a_NumArgs);
+ cPlayer* Player = va_arg(argptr, cPlayer* );
+ va_end (argptr);
+ for( PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr )
+ {
+ if( (*itr)->OnPlayerJoin( Player ) )
+ return true;
+ }
+ }
+ break;
+ case E_PLUGIN_PLAYER_MOVE:
+ {
+ if( a_NumArgs != 1 ) break;
+ va_list argptr;
+ va_start( argptr, a_NumArgs);
+ cPlayer* Player = va_arg(argptr, cPlayer* );
+ va_end (argptr);
+ for( PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr )
+ {
+ (*itr)->OnPlayerMove( Player );
+ }
+ }
+ break;
+ case E_PLUGIN_TAKE_DAMAGE:
+ {
+ if( a_NumArgs != 2 ) break;
+ va_list argptr;
+ va_start( argptr, a_NumArgs);
+ cPawn* Pawn = va_arg(argptr, cPawn* );
+ TakeDamageInfo* TDI = va_arg(argptr, TakeDamageInfo* );
+ va_end (argptr);
+ for( PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr )
+ {
+ (*itr)->OnTakeDamage( Pawn, TDI );
+ }
+ }
+ break;
+ case E_PLUGIN_KILLED:
+ {
+ if( a_NumArgs != 2 ) break;
+ va_list argptr;
+ va_start( argptr, a_NumArgs);
+ cPawn* Killed = va_arg(argptr, cPawn* );
+ cEntity* Killer = va_arg(argptr, cEntity* );
+ va_end (argptr);
+ for( PluginList::iterator itr = Plugins->second.begin(); itr != Plugins->second.end(); ++itr )
+ {
+ if( (*itr)->OnKilled( Killed, Killer ) )
+ return true;
+ }
+ }
+ break;
+ default:
+ LOG("WARNING: Calling Unknown hook: %i", a_Hook );
+ break;
+ }
+ }
+ return false;
+}
+
+cPlugin* cPluginManager::GetPlugin( std::string a_Plugin )
+{
+ for( PluginList::iterator itr = m_pState->Plugins.begin(); itr != m_pState->Plugins.end(); ++itr )
+ {
+ if( (*itr)->GetName().compare( a_Plugin ) == 0 )
+ {
+ return *itr;
+ }
+ }
+ return 0;
+}
+
+const cPluginManager::PluginList & cPluginManager::GetAllPlugins()
+{
+ return m_pState->Plugins;
+}
+
+void cPluginManager::UnloadPluginsNow()
+{
+ m_pState->Hooks.clear();
+
+ while( m_pState->LuaPlugins.size() > 0 )
+ {
+ cPlugin_Lua* LuaPlugin = *m_pState->LuaPlugins.begin();
+ if( LuaPlugin )
+ {
+ cWebAdmin* WebAdmin = cRoot::Get()->GetWebAdmin();
+ if( WebAdmin ) WebAdmin->RemovePlugin( LuaPlugin->GetLuaState() );
+ delete LuaPlugin;
+ }
+ m_pState->LuaPlugins.remove( LuaPlugin );
+ }
+
+ while( m_pState->Plugins.size() > 0 )
+ {
+ RemovePlugin( *m_pState->Plugins.begin(), true );
+ }
+}
+
+void cPluginManager::RemovePlugin( cPlugin* a_Plugin, bool a_bDelete /* = false */ )
+{
+ if( a_bDelete )
+ {
+ m_LuaCommandBinder->RemoveBindingsForPlugin( a_Plugin );
+ m_pState->Plugins.remove( a_Plugin );
+ a_Plugin->OnDisable();
+ delete a_Plugin;
+ }
+ else
+ {
+ for( LuaPluginList::iterator itr = m_pState->LuaPlugins.begin(); itr != m_pState->LuaPlugins.end(); ++itr )
+ {
+ (*itr)->RemovePlugin( a_Plugin );
+ }
+ }
+}
+
+bool cPluginManager::AddPlugin( cPlugin* a_Plugin )
+{
+ if( a_Plugin->Initialize() )
+ {
+ m_pState->Plugins.remove( a_Plugin );
+ m_pState->Plugins.push_back( a_Plugin );
+ return true;
+ }
+ return false;
+}
+
+bool cPluginManager::AddPlugin( lua_State* a_LuaState, cPlugin* a_Plugin )
+{
+ cPlugin_Lua* LuaPlugin = GetLuaPlugin( a_LuaState );
+ if( LuaPlugin && a_Plugin->Initialize() )
+ {
+ m_pState->Plugins.remove( a_Plugin );
+ m_pState->Plugins.push_back( a_Plugin );
+ LuaPlugin->AddPlugin( a_Plugin );
+ return true;
+ }
+ return false;
+}
+
+bool cPluginManager::AddLuaPlugin( cPlugin_Lua* a_Plugin )
+{
+ m_pState->LuaPlugins.push_back( a_Plugin ); // It HAS to be in here before calling Initialize, so it can be found by AddPlugin()
+ if(a_Plugin->Initialize() )
+ {
+ return true;
+ }
+ LOG(">>>>>>> Could not initialize a plugin! ");
+ m_pState->LuaPlugins.remove( a_Plugin );
+ return false;
+}
+
+void cPluginManager::RemoveLuaPlugin( std::string a_FileName )
+{
+ for( LuaPluginList::iterator itr = m_pState->LuaPlugins.begin(); itr != m_pState->LuaPlugins.end(); ++itr )
+ {
+ if( (*itr)->GetFileName() == a_FileName )
+ {
+ cPlugin_Lua* Plugin = *itr;
+ delete Plugin;
+ m_pState->LuaPlugins.remove( Plugin );
+ return;
+ }
+ }
+}
+
+cPlugin_Lua* cPluginManager::GetLuaPlugin( lua_State* a_State )
+{
+ for( LuaPluginList::iterator itr = m_pState->LuaPlugins.begin(); itr != m_pState->LuaPlugins.end(); ++itr )
+ {
+ if( (*itr)->GetLuaState() == a_State )
+ {
+ return *itr;
+ }
+ }
+ return 0;
+}
+
+void cPluginManager::AddHook( cPlugin* a_Plugin, PluginHook a_Hook )
+{
+ PluginList & Plugins = m_pState->Hooks[ a_Hook ];
+ Plugins.remove( a_Plugin );
+ Plugins.push_back( a_Plugin );
+}
+
+unsigned int cPluginManager::GetNumPlugins()
+{
+ return m_pState->Plugins.size();
+}
\ No newline at end of file diff --git a/source/cPluginManager.h b/source/cPluginManager.h new file mode 100644 index 000000000..32c7b9d3a --- /dev/null +++ b/source/cPluginManager.h @@ -0,0 +1,68 @@ +#pragma once
+
+#include <list>
+
+struct lua_State;
+class cLuaCommandBinder;
+class cPlugin;
+class cPlugin_Lua;
+class cPluginManager //tolua_export
+{ //tolua_export
+public: //tolua_export
+
+ // Called each tick
+ virtual void Tick(float a_Dt);
+
+ enum PluginHook //tolua_export
+ { //tolua_export
+ E_PLUGIN_TICK, //tolua_export
+ E_PLUGIN_CHAT, //tolua_export
+ E_PLUGIN_COLLECT_ITEM, //tolua_export
+ E_PLUGIN_BLOCK_DIG, //tolua_export
+ E_PLUGIN_BLOCK_PLACE, //tolua_export
+ E_PLUGIN_DISCONNECT, //tolua_export
+ E_PLUGIN_HANDSHAKE, //tolua_export
+ E_PLUGIN_LOGIN, //tolua_export
+ E_PLUGIN_PLAYER_SPAWN, //tolua_export
+ E_PLUGIN_PLAYER_JOIN, //tolua_export
+ E_PLUGIN_PLAYER_MOVE, //tolua_export
+ E_PLUGIN_TAKE_DAMAGE, //tolua_export
+ E_PLUGIN_KILLED, //tolua_export
+ }; //tolua_export
+
+ static cPluginManager * GetPluginManager(); //tolua_export
+
+ typedef std::list< cPlugin* > PluginList;
+ cPlugin* GetPlugin( std::string a_Plugin ); //tolua_export
+ const PluginList & GetAllPlugins(); // >> EXPORTED IN MANUALBINDINGS <<
+
+ void ReloadPlugins(); //tolua_export
+ bool AddPlugin( cPlugin* a_Plugin );
+ bool AddPlugin( lua_State* a_LuaState, cPlugin* a_Plugin ); //tolua_export
+ bool AddLuaPlugin( cPlugin_Lua* a_Plugin );
+ void AddHook( cPlugin* a_Plugin, PluginHook a_Hook ); //tolua_export
+
+ unsigned int GetNumPlugins(); //tolua_export
+
+ bool CallHook( PluginHook a_Hook, unsigned int a_NumArgs, ... );
+
+ void RemovePlugin( cPlugin* a_Plugin, bool a_bDelete = false ); //tolua_export
+ void RemoveLuaPlugin( std::string a_FileName ); //tolua_export
+ cPlugin_Lua* GetLuaPlugin( lua_State* a_State ); //tolua_export
+
+ cLuaCommandBinder* GetLuaCommandBinder() { return m_LuaCommandBinder; }
+private:
+ friend class cRoot;
+ cPluginManager();
+ ~cPluginManager();
+
+ struct sPluginManagerState;
+ sPluginManagerState* m_pState;
+
+ void ReloadPluginsNow();
+ void UnloadPluginsNow();
+
+ cLuaCommandBinder* m_LuaCommandBinder;
+
+ bool m_bReloadPlugins;
+}; //tolua_export
diff --git a/source/cPlugin_Lua.cpp b/source/cPlugin_Lua.cpp new file mode 100644 index 000000000..3265f0615 --- /dev/null +++ b/source/cPlugin_Lua.cpp @@ -0,0 +1,97 @@ +#define LUA_USE_POSIX
+#include "cMCLogger.h"
+#include <string>
+#include "cPlugin_Lua.h"
+#include "cPluginManager.h"
+#include "cRoot.h"
+
+extern "C"
+{
+ #include "lualib.h"
+}
+
+#include "tolua++.h"
+#include "Bindings.h"
+#include "ManualBindings.h"
+
+bool report_errors(lua_State* lua, int status)
+{
+ if ( status!=0 )
+ {
+ std::string s = lua_tostring(lua, -1);
+ LOGERROR("-- %s", s.c_str() );
+ lua_pop(lua, 1);
+ return true;
+ }
+ return false;
+}
+
+cPlugin_Lua::~cPlugin_Lua()
+{
+ UnloadPlugins();
+ if( m_LuaState )
+ {
+ lua_close( m_LuaState );
+ m_LuaState = 0;
+ }
+}
+
+cPlugin_Lua::cPlugin_Lua(const char* a_Plugin)
+: m_LuaState( 0 )
+{
+ m_FileName.assign( a_Plugin );
+}
+
+bool cPlugin_Lua::Initialize()
+{
+ if( !m_LuaState )
+ {
+ m_LuaState = lua_open();
+ luaL_openlibs( m_LuaState );
+ tolua_AllToLua_open(m_LuaState);
+ ManualBindings::Bind( m_LuaState );
+ }
+
+ int s = luaL_loadfile(m_LuaState, (std::string("Plugins/") + m_FileName ).c_str() );
+ if( report_errors( m_LuaState, s ) )
+ {
+ LOGERROR("Can't load plugin %s", m_FileName.c_str() );
+ lua_close( m_LuaState );
+ m_LuaState = 0;
+ return false;
+ }
+
+ s = lua_pcall(m_LuaState, 0, LUA_MULTRET, 0);
+ if( report_errors( m_LuaState, s ) )
+ {
+ LOGERROR("Error in plugin %s", m_FileName.c_str() );
+ lua_close( m_LuaState );
+ m_LuaState = 0;
+ return false;
+ }
+ return true;
+}
+
+void cPlugin_Lua::AddPlugin( cPlugin* a_Plugin )
+{
+ m_Plugins.push_back( a_Plugin );
+}
+
+void cPlugin_Lua::RemovePlugin( cPlugin* a_Plugin )
+{
+ m_Plugins.remove( a_Plugin );
+ cRoot::Get()->GetPluginManager()->RemovePlugin( a_Plugin, true );
+}
+
+void cPlugin_Lua::UnloadPlugins()
+{
+ while( m_Plugins.begin() != m_Plugins.end() )
+ {
+ RemovePlugin( *m_Plugins.begin() );
+ }
+}
+
+lua_State* cPlugin_Lua::GetLuaState()
+{
+ return m_LuaState;
+}
\ No newline at end of file diff --git a/source/cPlugin_Lua.h b/source/cPlugin_Lua.h new file mode 100644 index 000000000..e84ac8451 --- /dev/null +++ b/source/cPlugin_Lua.h @@ -0,0 +1,34 @@ +#pragma once
+
+#include <string>
+#include <list>
+
+class cPickup;
+class cPlayer;
+class cPacket_BlockPlace;
+class cPacket_BlockDig;
+class cPacket_Login;
+class cPlugin;
+class cPlugin_Lua //tolua_export
+{ //tolua_export
+public:
+ cPlugin_Lua(const char* a_Plugin);
+ ~cPlugin_Lua();
+
+ virtual bool Initialize();
+
+ std::string GetFileName() { return m_FileName; } //tolua_export
+ typedef struct lua_State lua_State;
+ lua_State* GetLuaState();
+
+ void AddPlugin( cPlugin* a_Plugin );
+ void RemovePlugin( cPlugin* a_Plugin );
+private:
+ void UnloadPlugins();
+
+ std::string m_FileName;
+ lua_State* m_LuaState;
+
+ typedef std::list< cPlugin* > PluginList;
+ PluginList m_Plugins;
+}; //tolua_export
\ No newline at end of file diff --git a/source/cRecipeChecker.cpp b/source/cRecipeChecker.cpp new file mode 100644 index 000000000..d85cb3c31 --- /dev/null +++ b/source/cRecipeChecker.cpp @@ -0,0 +1,458 @@ +#include "cRecipeChecker.h"
+
+#include <fstream>
+#include <sstream>
+#include <vector>
+#include <string>
+#include <list>
+
+#ifndef _WIN32
+#include <cstring>
+#include <cstdlib>
+#endif
+
+#include "Defines.h"
+#include "cMCLogger.h"
+#include "cRoot.h"
+
+typedef std::list< cRecipeChecker::Recipe* > RecipeList;
+struct cRecipeChecker::sRecipeCheckerState
+{
+ RecipeList Recipes;
+};
+
+cRecipeChecker* cRecipeChecker::GetRecipeChecker()
+{
+ LOGWARN("WARNING: Using deprecated function cRecipeChecker::GetRecipeChecker() use cRoot::Get()->GetRecipeChecker() instead!");
+ return cRoot::Get()->GetRecipeChecker();
+}
+
+cRecipeChecker::Recipe::~Recipe()
+{
+ delete [] Slots;
+ Slots = 0;
+}
+
+cRecipeChecker::~cRecipeChecker()
+{
+ ClearRecipes();
+ delete m_pState;
+}
+
+cRecipeChecker::cRecipeChecker()
+ : m_pState( new sRecipeCheckerState )
+{
+ ReloadRecipes();
+}
+
+void cRecipeChecker::ClearRecipes()
+{
+ while( m_pState->Recipes.size() > 0 )
+ {
+ delete *m_pState->Recipes.begin();
+ m_pState->Recipes.remove( *m_pState->Recipes.begin() );
+ }
+}
+
+void PrintRecipe( std::vector< cRecipeChecker::RecipeSlot > & RecipeSlots )
+{
+ LOG("Recipe:");
+ for(unsigned int i = 0; i < RecipeSlots.size(); i++)
+ {
+ cRecipeChecker::RecipeSlot Slot = RecipeSlots[i];
+ LOG("x:%i y:%i id:%i #%i", Slot.x, Slot.y, Slot.Item.m_ItemID, Slot.Item.m_ItemCount );
+ }
+}
+
+void PrintNear( std::ifstream & f, int a_History = 64 )
+{
+ f.clear();
+
+ // Calculate how far we can move pointer back
+ std::streamoff Position = f.tellg();
+ f.seekg( 0, std::ios_base::beg );
+ std::streamoff Difference = Position - f.tellg();
+ if( Difference > a_History ) Difference = a_History;
+ f.seekg( Position - Difference, std::ios_base::beg );
+
+ std::string Near;
+ if( f.good() )
+ {
+ while( f.good() && Near.size() < (unsigned int)Difference )
+ {
+ char c;
+ f.get(c);
+ Near.push_back( c );
+ }
+ }
+ LOGERROR("Error near: \"%s\"", Near.c_str() );
+}
+
+void cRecipeChecker::ReloadRecipes()
+{
+ LOG("--Loading recipes--");
+ ClearRecipes();
+
+ /*
+ char a_File[] = "recipes.txt";
+
+ FILE* f = 0;
+ #ifdef _WIN32
+ if( fopen_s(&f, a_File, "rb" ) == 0 ) // no error
+ #else
+ if( (f = fopen(a_File, "rb" )) != 0 ) // no error
+ #endif
+ {
+ char c;
+ while( fread( &c, sizeof(char), 1, f) == 1 )
+ {
+
+ }
+ }
+ else
+ {
+ LOG("Could not open file for recipes: %s", a_File);
+ return;
+ }
+ */
+
+
+ std::ifstream f;
+
+ char a_File[] = "recipes.txt";
+ f.open(a_File, std::ios::in);
+ std::string input;
+
+ if( !f.good() )
+ {
+ f.close();
+ LOG("Could not open file for recipes: %s", a_File);
+ return;
+ }
+
+ std::vector< RecipeSlot > RecipeSlots;
+
+ bool bError = false;
+ while( f.good() )
+ {
+ bool bLoadSlot = false;
+ bool bLoadResult = false;
+
+ char c;
+ f >> c;
+ f.unget();
+ if( c == '#' )
+ {
+ //LOG("Ignoring comment");
+ while( f.good() && c != '\n' )
+ {
+ f.get( c );
+ }
+ continue;
+ }
+
+ f.get( c );
+ while( f.good() && ( c == '\n' || c == '\r' ) ) { f.get( c ); }
+ if( f.eof() ) break;
+ f.unget();
+
+ int width, height;
+ f >> width;
+ f >> c; if( c != 'x' ) { bError=true; break; }
+ f >> height;
+ f >> c;
+ if( c == ',' ) bLoadSlot = true;
+
+ while( f.good() && bLoadSlot )
+ {
+ bool bDontAddRecipe = false;
+ int x, y, ItemID, Amount;
+ if( f.peek() == '*' )
+ {
+ f >> c;
+ x = -1;
+ }
+ else
+ {
+ f >> x;
+ }
+ f >> c; if( c != ':' ) { bError=true; break; }
+ if( f.peek() == '*' )
+ {
+ f >> c;
+ y = -1;
+ }
+ else
+ {
+ f >> y;
+ }
+ f >> c; if( c != ':' ) { bError=true; break; }
+ f >> ItemID;
+ f >> c; if( c != ':' ) { bError=true; break; }
+ f >> Amount;
+
+ f >> c;
+ if( c == '@' ) bLoadResult = true;
+ if( c != ',' ) bLoadSlot = false;
+
+ if( !isValidItem( ItemID ) )
+ {
+ LOGERROR("Error in recipes file (%s): Invalid Item ID %i", a_File, ItemID );
+ bDontAddRecipe = true;
+ }
+ if( x < 0 && y < 0 )
+ {
+ if( Amount < 0 )
+ {
+ LOGERROR("Error in recipes file (%s): Invalid use of negative amount on wildcard coordinates", a_File );
+ bDontAddRecipe = true;
+ }
+ for(int x = 0; x < width; ++x) for(int y = 0; y < height; ++y )
+ {
+ cItem Item( (ENUM_ITEM_ID)ItemID, (char)Amount );
+ RecipeSlot Slot;
+ Slot.Item = Item;
+ Slot.x = x;
+ Slot.y = y;
+ RecipeSlots.push_back( Slot );
+ }
+ }
+ else if( x < 0 )
+ {
+ if( Amount < 0 )
+ {
+ for(int x = 0; x < width; ++x) for(int yy = 0; yy < height; ++yy )
+ {
+ if( yy == y-1 ) continue;
+ cItem Item( (ENUM_ITEM_ID)ItemID, (char)abs(Amount) );
+ RecipeSlot Slot;
+ Slot.Item = Item;
+ Slot.x = x;
+ Slot.y = yy;
+ RecipeSlots.push_back( Slot );
+ }
+ }
+ else
+ {
+ for(int x = 0; x < width; ++x)
+ {
+ cItem Item( (ENUM_ITEM_ID)ItemID, (char)Amount );
+ RecipeSlot Slot;
+ Slot.Item = Item;
+ Slot.x = x;
+ Slot.y = y-1;
+ RecipeSlots.push_back( Slot );
+ }
+ }
+ }
+ else if( y < 0 )
+ {
+ if( Amount < 0 )
+ {
+ for(int xx = 0; xx < width; ++xx) for(int y = 0; y < height; ++y )
+ {
+ if( xx == x-1 ) continue;
+ cItem Item( (ENUM_ITEM_ID)ItemID, (char)abs(Amount) );
+ RecipeSlot Slot;
+ Slot.Item = Item;
+ Slot.x = xx;
+ Slot.y = y;
+ RecipeSlots.push_back( Slot );
+ }
+ }
+ else
+ {
+ for(int y = 0; y < height; ++y)
+ {
+ cItem Item( (ENUM_ITEM_ID)ItemID, (char)Amount );
+ RecipeSlot Slot;
+ Slot.Item = Item;
+ Slot.x = x-1;
+ Slot.y = y;
+ RecipeSlots.push_back( Slot );
+ }
+ }
+ }
+ else
+ {
+ if( Amount < 0 )
+ {
+ for(int xx = 0; xx < width; ++xx) for(int yy = 0; yy < height; ++yy )
+ {
+ if( xx == x-1 && yy == y-1 ) continue;
+ cItem Item( (ENUM_ITEM_ID)ItemID, (char)abs(Amount) );
+ RecipeSlot Slot;
+ Slot.Item = Item;
+ Slot.x = xx;
+ Slot.y = yy;
+ RecipeSlots.push_back( Slot );
+ }
+ }
+ else
+ {
+ cItem Item( (ENUM_ITEM_ID)ItemID, (char)Amount );
+ RecipeSlot Slot;
+ Slot.Item = Item;
+ Slot.x = x-1;
+ Slot.y = y-1;
+ RecipeSlots.push_back( Slot );
+ }
+ }
+ //LOG("%i %i %i %i", x, y, ItemID, Amount );
+
+ if( bLoadResult )
+ {
+ bLoadResult = false;
+ f >> ItemID;
+ f >> c; if( c != ':' ) { bError=true; break; }
+ f >> Amount;
+ //LOG("%i %i", ItemID, Amount );
+ if( !isValidItem( ItemID ) )
+ {
+ LOGERROR("Error in recipes file (%s): Invalid Item ID %i", a_File, ItemID );
+ bDontAddRecipe = true;
+ }
+
+ // Do a sanity check - Handshake algorithm :)
+ bool bDuplicateEntries = false;
+ for(unsigned int i = 0; i < RecipeSlots.size(); i++)
+ {
+ for(unsigned int j = i+1; j < RecipeSlots.size(); j++)
+ {
+ if( RecipeSlots[i].x == RecipeSlots[j].x && RecipeSlots[i].y == RecipeSlots[j].y )
+ {
+ LOGERROR("Error in recipes file (%s): Duplicate item on coordinates %i:%i", a_File, RecipeSlots[i].x+1, RecipeSlots[i].y+1 );
+ bDontAddRecipe = true;
+ bDuplicateEntries = true;
+ break;
+ }
+ }
+ }
+ if( bDuplicateEntries )
+ {
+ PrintNear( f, 64 );
+ PrintRecipe( RecipeSlots );
+ }
+
+ if( bDontAddRecipe == false )
+ {
+ cItem Item( (ENUM_ITEM_ID)ItemID, (char)Amount );
+ Recipe* recipe = new Recipe;
+ recipe->Result = Item;
+ recipe->NumItems = RecipeSlots.size();
+ recipe->Slots = new RecipeSlot[ recipe->NumItems ];
+ memcpy( recipe->Slots, &RecipeSlots[0], sizeof(RecipeSlot)*recipe->NumItems );
+ m_pState->Recipes.push_back( recipe );
+ //LOG("Loaded recipe for %i times %i", Amount, ItemID );
+ }
+
+ RecipeSlots.clear();
+ }
+ }
+ if( bError ) break;
+ }
+ if( bError || ( !f.eof() && !f.good() ) )
+ {
+ LOGERROR("Error: Wrong format");
+ PrintNear( f, 128 );
+ }
+ f.close();
+
+ LOG("Found %i recipes", m_pState->Recipes.size() );
+// for(RecipeList::iterator itr = m_pState->Recipes.begin(); itr != m_pState->Recipes.end(); ++itr )
+// {
+// LOG("Recipe for %i times %i", (*itr)->Result.m_ItemCount, (*itr)->Result.m_ItemID );
+// for(unsigned int j = 0; j < (*itr)->NumItems; j++)
+// {
+// RecipeSlot Slot = (*itr)->Slots[j];
+// LOG("%i %i %i %i", Slot.x, Slot.y, Slot.Item.m_ItemID, Slot.Item.m_ItemCount );
+// }
+// }
+ LOG("--Done loading recipes--");
+}
+
+cItem cRecipeChecker::CookIngredients( cItem* a_Items, int a_Width, int a_Height, bool a_bConsumeIngredients /* = false */ )
+{
+ int iLeft = 999, iTop = 999;
+ int iRight = 0, iBottom = 0;
+ for(int y = 0; y < a_Height; y++ ) for(int x = 0; x < a_Width; x++)
+ {
+ cItem Item = a_Items[x + y*a_Width];
+ if( Item.m_ItemID != E_ITEM_EMPTY && Item.m_ItemCount > 0 )
+ {
+ iRight = MAX(x, iRight);
+ iBottom = MAX(y, iBottom);
+ iLeft = MIN(x, iLeft);
+ iTop = MIN(y, iTop);
+ }
+ }
+
+ for(RecipeList::iterator itr = m_pState->Recipes.begin(); itr != m_pState->Recipes.end(); ++itr )
+ {
+ Recipe* recipe = (*itr);
+ int Left = 999, Top = 999;
+ int Right = 0, Bottom = 0;
+ for(unsigned int i = 0; i < recipe->NumItems; i++)
+ {
+ Right = MAX(recipe->Slots[i].x, Right);
+ Bottom = MAX(recipe->Slots[i].y, Bottom);
+ Left = MIN(recipe->Slots[i].x, Left);
+ Top = MIN(recipe->Slots[i].y, Top);
+ }
+ if( Right-Left != iRight-iLeft || Bottom-Top != iBottom-iTop ) continue;
+ // it has the right dimensions
+
+ // Check for empty spaces
+ unsigned int Hash = 0;
+ for(unsigned int i = 0; i < recipe->NumItems; i++)
+ {
+ int x = recipe->Slots[i].x - Left + iLeft +1;
+ int y = recipe->Slots[i].y - Top + iTop +1;
+ Hash += x + y * a_Width;
+ }
+ for(int y = 0; y < a_Height; y++ ) for(int x = 0; x < a_Width; x++)
+ {
+ cItem & Item = a_Items[x + y*a_Width];
+ if( Item.m_ItemID != E_ITEM_EMPTY && Item.m_ItemCount > 0 )
+ {
+ Hash -= (x+1) + (y+1)*a_Width;
+ }
+ }
+ if( Hash != 0 ) continue; // Empty spaces not in right place
+
+ bool bWrong = false;
+ for(unsigned int i = 0; i < recipe->NumItems; i++)
+ {
+ int x = recipe->Slots[i].x - Left + iLeft;
+ int y = recipe->Slots[i].y - Top + iTop;
+ cItem Item = a_Items[x + y*a_Width];
+ if( Item.m_ItemID != recipe->Slots[i].Item.m_ItemID
+ || Item.m_ItemCount < recipe->Slots[i].Item.m_ItemCount )
+ {
+ bWrong = true;
+ break;
+ }
+ }
+ if( bWrong ) continue;
+
+ cItem Dish = recipe->Result;
+
+ // else
+ if( a_bConsumeIngredients )
+ {
+ // Consume! nomnom~
+ for(unsigned int i = 0; i < recipe->NumItems; i++)
+ {
+ int x = recipe->Slots[i].x - Left + iLeft;
+ int y = recipe->Slots[i].y - Top + iTop;
+ a_Items[x + y*a_Width].m_ItemCount -= recipe->Slots[i].Item.m_ItemCount;
+ if( a_Items[x + y*a_Width].m_ItemCount <= 0 ) a_Items[x + y*a_Width].Empty();
+ }
+ Dish = CookIngredients( a_Items, a_Width, a_Height, false );
+ }
+
+ // Return the resulting dish!
+ return Dish;
+ }
+ return cItem();
+}
diff --git a/source/cRecipeChecker.h b/source/cRecipeChecker.h new file mode 100644 index 000000000..91084b7de --- /dev/null +++ b/source/cRecipeChecker.h @@ -0,0 +1,39 @@ +#pragma once
+
+#include "cItem.h"
+
+class cRecipeChecker
+{
+public:
+ static cRecipeChecker * GetRecipeChecker();
+
+ // Grid of cItems of a_Width width and a_Height Height
+ cItem CookIngredients( cItem* a_Items, int a_Width, int a_Height, bool a_bConsumeIngredients = false );
+
+ struct RecipeSlot
+ {
+ cItem Item;
+ int x, y;
+ };
+
+ struct Recipe
+ {
+ Recipe() : Slots( 0 ), NumItems( 0 ) {}
+ ~Recipe();
+ RecipeSlot* Slots; // Array of RecipeSlots
+ unsigned int NumItems;
+ cItem Result;
+ };
+
+ void ReloadRecipes();
+ static void DeleteMe();
+private:
+ friend class cRoot;
+ cRecipeChecker();
+ ~cRecipeChecker();
+
+ struct sRecipeCheckerState;
+ sRecipeCheckerState* m_pState;
+
+ void ClearRecipes();
+};
\ No newline at end of file diff --git a/source/cReferenceManager.cpp b/source/cReferenceManager.cpp new file mode 100644 index 000000000..cad6ca0a2 --- /dev/null +++ b/source/cReferenceManager.cpp @@ -0,0 +1,36 @@ +#include "cReferenceManager.h"
+#include "cEntity.h"
+
+cReferenceManager::cReferenceManager( ENUM_REFERENCE_MANAGER_TYPE a_Type )
+ : m_Type( a_Type )
+{
+}
+
+cReferenceManager::~cReferenceManager()
+{
+ if( m_Type == RFMNGR_REFERENCERS )
+ {
+ for( std::list< cEntity** >::iterator itr = m_References.begin(); itr != m_References.end(); ++itr )
+ {
+ *(*itr) = 0; // Set referenced pointer to 0
+ }
+ }
+ else
+ {
+ for( std::list< cEntity** >::iterator itr = m_References.begin(); itr != m_References.end(); ++itr )
+ {
+ cEntity* Ptr = (*(*itr));
+ if( Ptr ) Ptr->Dereference( *(*itr) );
+ }
+ }
+}
+
+void cReferenceManager::AddReference( cEntity*& a_EntityPtr )
+{
+ m_References.push_back( &a_EntityPtr );
+}
+
+void cReferenceManager::Dereference( cEntity*& a_EntityPtr )
+{
+ m_References.remove( &a_EntityPtr );
+}
\ No newline at end of file diff --git a/source/cReferenceManager.h b/source/cReferenceManager.h new file mode 100644 index 000000000..397527de1 --- /dev/null +++ b/source/cReferenceManager.h @@ -0,0 +1,22 @@ +#pragma once
+
+#include <list>
+
+class cEntity;
+class cReferenceManager
+{
+public:
+ enum ENUM_REFERENCE_MANAGER_TYPE
+ {
+ RFMNGR_REFERENCERS,
+ RFMNGR_REFERENCES,
+ };
+ cReferenceManager( ENUM_REFERENCE_MANAGER_TYPE a_Type );
+ ~cReferenceManager();
+
+ void AddReference( cEntity*& a_EntityPtr );
+ void Dereference( cEntity*& a_EntityPtr );
+private:
+ ENUM_REFERENCE_MANAGER_TYPE m_Type;
+ std::list< cEntity** > m_References;
+};
\ No newline at end of file diff --git a/source/cRoot.cpp b/source/cRoot.cpp new file mode 100644 index 000000000..7f0012764 --- /dev/null +++ b/source/cRoot.cpp @@ -0,0 +1,162 @@ +#include "cRoot.h"
+#include "cMCLogger.h"
+#include "cServer.h"
+#include "cWorld.h"
+#include "cWebAdmin.h"
+#include "cFurnaceRecipe.h"
+#include "cGroupManager.h"
+#include "cRecipeChecker.h"
+#include "cPluginManager.h"
+#include "cMonsterConfig.h"
+#include "cSleep.h"
+
+#include "../iniFile/iniFile.h"
+
+#include <iostream>
+#include <time.h>
+#include <cstdio>
+
+#ifndef _WIN32
+#include <cstring>
+#endif
+
+cRoot* cRoot::s_Root = 0;
+
+cRoot::cRoot()
+ : m_Server( 0 )
+ , m_World( 0 )
+ , m_MonsterConfig( 0 )
+ , m_GroupManager( 0 )
+ , m_RecipeChecker( 0 )
+ , m_FurnaceRecipe( 0 )
+ , m_WebAdmin( 0 )
+ , m_PluginManager( 0 )
+ , m_Log( 0 )
+ , m_bStop( false )
+ , m_bRestart( false )
+ , m_hInputThread( 0 )
+{
+ s_Root = this;
+}
+
+cRoot::~cRoot()
+{
+ s_Root = 0;
+}
+
+#ifdef _WIN32
+DWORD WINAPI cRoot_InputThread(LPVOID lpParam)
+#else
+void *cRoot_InputThread( void *lpParam )
+#endif
+{
+ cRoot* Root = (cRoot*)lpParam;
+
+ while( 1 )
+ {
+ std::string Command;
+ std::getline(std::cin, Command);
+ Root->ServerCommand( Command.c_str() );
+ }
+ return 0;
+}
+
+void cRoot::Start()
+{
+ if( m_Log ) delete m_Log, m_Log = 0;
+ m_Log = new cMCLogger();
+
+#ifdef _WIN32
+ m_hInputThread = CreateThread(
+ NULL, // default security
+ 0, // default stack size
+ cRoot_InputThread, // name of the thread function
+ this, // thread parameters
+ 0, // default startup flags
+ NULL);
+#else
+ m_hInputThread = new pthread_t;
+ pthread_create( (pthread_t*)m_hInputThread, NULL, cRoot_InputThread, this );
+#endif
+
+ m_bStop = false;
+ while(!m_bStop)
+ {
+ m_bRestart = false;
+
+ m_Server = new cServer();
+
+ cIniFile IniFile("settings.ini"); IniFile.ReadFile();
+ int Port = IniFile.GetValueI("Server", "Port", 25565 );
+ if(!m_Server->InitServer( Port ))
+ {
+ LOG("Failed to start server, shutting down.");
+ return;
+ }
+
+
+ cIniFile WebIniFile("webadmin.ini");
+ if( WebIniFile.ReadFile() )
+ {
+ if( WebIniFile.GetValueB("WebAdmin", "Enabled", false ) == true )
+ {
+ m_WebAdmin = new cWebAdmin(8080);
+ }
+ }
+
+ m_GroupManager = new cGroupManager();
+ m_RecipeChecker = new cRecipeChecker();
+ m_FurnaceRecipe = new cFurnaceRecipe();
+ m_World = new cWorld();
+ m_World->InitializeSpawn();
+
+ m_PluginManager = new cPluginManager(); // This should be last
+ m_PluginManager->ReloadPluginsNow();
+ m_MonsterConfig = new cMonsterConfig(2);
+
+ // This sets stuff in motion
+ m_Server->StartListenThread();
+ //cHeartBeat* HeartBeat = new cHeartBeat();
+
+ while( !m_bStop && !m_bRestart ) // These are modified by external threads
+ {
+ cSleep::MilliSleep( 1000 );
+ }
+
+ // Deallocate stuffs
+ m_Server->Shutdown(); // This waits for threads to stop and d/c clients
+ delete m_PluginManager; m_PluginManager = 0; // This should be first
+ delete m_MonsterConfig; m_MonsterConfig = 0;
+ if( m_WebAdmin ) { delete m_WebAdmin; m_WebAdmin = 0; }
+ delete m_FurnaceRecipe; m_FurnaceRecipe = 0;
+ delete m_RecipeChecker; m_RecipeChecker = 0;
+ delete m_GroupManager; m_GroupManager = 0;
+ delete m_World; m_World = 0;
+ //delete HeartBeat; HeartBeat = 0;
+ delete m_Server; m_Server = 0;
+ }
+
+ // No other way to get it to exit
+#ifdef _WIN32
+ TerminateThread( m_hInputThread, 0 );
+#else
+ // TODO: pthread_kill
+ delete (pthread_t*)m_hInputThread;
+#endif
+
+ delete m_Log; m_Log = 0;
+}
+
+void cRoot::ServerCommand( const char* a_Cmd )
+{
+ //LOG("Command: %s", a_Cmd );
+ m_Server->ServerCommand( a_Cmd );
+ if( strcmp(a_Cmd, "stop") == 0 )
+ {
+ m_bStop = true;
+ }
+ else if( strcmp( a_Cmd, "restart") == 0 )
+ {
+ m_bRestart = true;
+ }
+}
diff --git a/source/cRoot.h b/source/cRoot.h new file mode 100644 index 000000000..0ba59ae93 --- /dev/null +++ b/source/cRoot.h @@ -0,0 +1,52 @@ +#pragma once
+
+class cMonsterConfig;
+class cMCLogger;
+class cGroupManager;
+class cRecipeChecker;
+class cFurnaceRecipe;
+class cWebAdmin;
+class cPluginManager;
+class cServer;
+class cWorld;
+class cRoot //tolua_export
+{ //tolua_export
+public:
+ static cRoot* Get() { return s_Root; } //tolua_export
+
+ cRoot();
+ ~cRoot();
+
+ void Start();
+
+ cServer* GetServer() { return m_Server; } //tolua_export
+ cWorld* GetWorld() { return m_World; } //tolua_export
+ cMonsterConfig *GetMonsterConfig() { return m_MonsterConfig;}
+
+ cGroupManager* GetGroupManager() { return m_GroupManager; } //tolua_export
+ cRecipeChecker* GetRecipeChecker() { return m_RecipeChecker; } //tolua_export
+ cFurnaceRecipe* GetFurnaceRecipe() { return m_FurnaceRecipe; } //tolua_export
+ cWebAdmin* GetWebAdmin() { return m_WebAdmin; } //tolua_export
+ cPluginManager* GetPluginManager() { return m_PluginManager; } //tolua_export
+
+ void ServerCommand( const char* a_Cmd ); //tolua_export
+private:
+ cServer* m_Server;
+ cWorld* m_World;
+ cMonsterConfig *m_MonsterConfig;
+
+ cGroupManager* m_GroupManager;
+ cRecipeChecker* m_RecipeChecker;
+ cFurnaceRecipe* m_FurnaceRecipe;
+ cWebAdmin* m_WebAdmin;
+ cPluginManager* m_PluginManager;
+
+ cMCLogger* m_Log;
+
+ bool m_bStop;
+ bool m_bRestart;
+
+ void* m_hInputThread;
+
+ static cRoot* s_Root;
+}; //tolua_export
\ No newline at end of file diff --git a/source/cSemaphore.cpp b/source/cSemaphore.cpp new file mode 100644 index 000000000..96c542df6 --- /dev/null +++ b/source/cSemaphore.cpp @@ -0,0 +1,96 @@ +#include "cSemaphore.h"
+#include "cMCLogger.h"
+
+#ifdef _WIN32
+#include <Windows.h>
+#else
+#include <semaphore.h>
+#include <errno.h>
+#include <fcntl.h>
+#include <stdio.h>
+#endif
+
+cSemaphore::cSemaphore( unsigned int a_MaxCount, unsigned int a_InitialCount /* = 0 */ )
+#ifndef _WIN32
+ : m_bNamed( false )
+#endif
+{
+#ifndef _WIN32
+ (void)a_MaxCount;
+ m_Handle = new sem_t;
+ if( sem_init( (sem_t*)m_Handle, 0, 0 ) )
+ {
+ LOG("WARNING cSemaphore: Could not create unnamed semaphore, fallback to named.");
+ delete (sem_t*)m_Handle; // named semaphores return their own address
+ m_bNamed = true;
+
+ char c_Str[32];
+ sprintf( c_Str, "cSemaphore%p", this );
+ m_Handle = sem_open( c_Str, O_CREAT, 777, a_InitialCount );
+ if( m_Handle == SEM_FAILED )
+ {
+ LOG("ERROR: Could not create Semaphore. (%i)", errno );
+ }
+ else
+ {
+ if( sem_unlink( c_Str ) != 0 )
+ {
+ LOG("ERROR: Could not unlink cSemaphore. (%i)", errno);
+ }
+ }
+ }
+#else
+ m_Handle = CreateSemaphore(
+ NULL, // security attribute
+ a_InitialCount, // initial count
+ a_MaxCount, // maximum count
+ 0 // name (optional)
+ );
+#endif
+}
+
+cSemaphore::~cSemaphore()
+{
+#ifdef _WIN32
+ CloseHandle( m_Handle );
+#else
+ if( m_bNamed )
+ {
+ if( sem_close( (sem_t*)m_Handle ) != 0 )
+ {
+ LOG("ERROR: Could not close cSemaphore. (%i)", errno);
+ }
+ }
+ else
+ {
+ sem_destroy( (sem_t*)m_Handle );
+ delete (sem_t*)m_Handle;
+ }
+ m_Handle = 0;
+
+#endif
+}
+
+void cSemaphore::Wait()
+{
+#ifndef _WIN32
+ if( sem_wait( (sem_t*)m_Handle ) != 0)
+ {
+ LOG("ERROR: Could not wait for cSemaphore. (%i)", errno);
+ }
+#else
+ WaitForSingleObject( m_Handle, INFINITE);
+#endif
+}
+
+void cSemaphore::Signal()
+{
+#ifndef _WIN32
+ if( sem_post( (sem_t*)m_Handle ) != 0 )
+ {
+ LOG("ERROR: Could not signal cSemaphore. (%i)", errno);
+ }
+#else
+ ReleaseSemaphore( m_Handle, 1, NULL );
+#endif
+}
diff --git a/source/cSemaphore.h b/source/cSemaphore.h new file mode 100644 index 000000000..86e473d11 --- /dev/null +++ b/source/cSemaphore.h @@ -0,0 +1,17 @@ +#pragma once
+
+class cSemaphore
+{
+public:
+ cSemaphore( unsigned int a_MaxCount, unsigned int a_InitialCount = 0 );
+ ~cSemaphore();
+
+ void Wait();
+ void Signal();
+private:
+ void* m_Handle; // HANDLE pointer + +#ifndef _WIN32 + bool m_bNamed; +#endif
+}; diff --git a/source/cServer.cpp b/source/cServer.cpp new file mode 100644 index 000000000..966444a25 --- /dev/null +++ b/source/cServer.cpp @@ -0,0 +1,553 @@ +// ReDucTor is an awesome guy who helped me a lot
+
+#include "cServer.h"
+#include "cClientHandle.h"
+#include "cMCLogger.h"
+#include "cThread.h"
+#include "cEvent.h"
+#include "cSleep.h"
+#include "cTimer.h"
+#include "cMonster.h"
+#include "cSocket.h"
+#include "cRoot.h"
+#include "cWorld.h"
+#include "cChunk.h"
+#include "cPluginManager.h"
+#include "cGroupManager.h"
+#include "cChatColor.h"
+#include "cPlayer.h"
+#include "cInventory.h"
+#include "cItem.h"
+#include "cRecipeChecker.h"
+#include "cFurnaceRecipe.h"
+#include "cTracer.h"
+#include "cWebAdmin.h"
+
+#include "../iniFile/iniFile.h"
+#include "Vector3f.h"
+
+#include "packets/cPacket_Chat.h"
+
+#ifndef _WIN32
+#include <cstring>
+#include <errno.h>
+#include <semaphore.h>
+#endif
+
+#include <string>
+#include <fstream>
+#include <sstream>
+#include <iostream>
+
+extern "C" {
+ #include "zlib.h"
+}
+
+#ifdef SendMessage
+#undef SendMessage
+#endif
+
+
+bool g_bWaterPhysics = false;
+
+struct cServer::sServerState
+{
+ sServerState()
+ : pListenThread( 0 )
+ , pTickThread( 0 )
+ , bStopListenThread( false )
+ , bStopTickThread( false )
+ {}
+ cSocket SListenClient; // socket listening for client calls
+
+ cThread* pListenThread; bool bStopListenThread;
+ cThread* pTickThread; bool bStopTickThread;
+
+ cEvent RestartEvent;
+ std::string ServerID;
+};
+
+cServer*cServer::GetServer()
+{
+ LOGWARN("WARNING: Using deprecated function cServer::GetServer() use cRoot::Get()->GetServer() instead!");
+ return cRoot::Get()->GetServer();
+}
+
+void cServer::ServerListenThread( void *a_Args )
+{
+ LOG("ServerListenThread");
+ cServer* self = (cServer*)a_Args;
+ sServerState* m_pState = self->m_pState;
+ while( !m_pState->bStopListenThread )
+ {
+ self->StartListenClient();
+ }
+}
+
+std::string GetWSAError()
+{
+#ifdef _WIN32
+ switch( WSAGetLastError() )
+ {
+ case WSANOTINITIALISED:
+ return "WSANOTINITIALISED";
+ case WSAENETDOWN:
+ return "WSAENETDOWN";
+ case WSAEFAULT:
+ return "WSAEFAULT";
+ case WSAENOTCONN:
+ return "WSAENOTCONN";
+ case WSAEINTR:
+ return "WSAEINTR";
+ case WSAEINPROGRESS:
+ return "WSAEINPROGRESS";
+ case WSAENETRESET:
+ return "WSAENETRESET";
+ case WSAENOTSOCK:
+ return "WSAENOTSOCK";
+ case WSAEOPNOTSUPP:
+ return "WSAEOPNOTSUPP";
+ case WSAESHUTDOWN:
+ return "WSAESHUTDOWN";
+ case WSAEWOULDBLOCK:
+ return "WSAEWOULDBLOCK";
+ case WSAEMSGSIZE:
+ return "WSAEMSGSIZE";
+ case WSAEINVAL:
+ return "WSAEINVAL";
+ case WSAECONNABORTED:
+ return "WSAECONNABORTED";
+ case WSAETIMEDOUT:
+ return "WSAETIMEDOUT";
+ case WSAECONNRESET:
+ return "WSAECONNRESET";
+ }
+#endif
+ return "No Error";
+}
+
+bool cServer::InitServer( int a_Port )
+{
+ if( m_bIsConnected )
+ {
+ LOGERROR("ERROR: Trying to initialize server while server is already running!");
+ return false;
+ }
+
+ printf("/============================\\\n");
+ printf("| Minecraft Alpha Server |\n");
+ printf("| Created by Kevin Bansberg |\n");
+ printf("| A.K.A. |\n");
+ printf("| FakeTruth |\n");
+ printf("| Monsters by Alex Sonek |\n");
+ printf("| A.K.A. Duralex |\n");
+ printf("\\============================/\n");
+ printf("More info: WWW.MC-SERVER.ORG\n");
+ printf(" WWW.AE-C.NET\n");
+ printf(" WWW.RBTHINKTANK.COM\n");
+ printf("email: faketruth@gmail.com\n\n");
+
+ LOG("Starting up server.");
+
+#ifdef _WIN32
+ WSADATA wsaData;
+ memset( &wsaData, 0, sizeof( wsaData ) );
+ int wsaret=WSAStartup(/*0x101*/ MAKEWORD(2, 2),&wsaData);
+
+ if(wsaret!=0)
+ {
+ LOG("wsaret != 0");
+ return false;
+ }
+#endif
+
+ sockaddr_in local;
+
+ local.sin_family=AF_INET;
+ local.sin_addr.s_addr=INADDR_ANY;
+ local.sin_port=htons((u_short)a_Port); // 25565
+
+ m_pState->SListenClient = socket(AF_INET,SOCK_STREAM,0);
+
+ if( !m_pState->SListenClient.IsValid() )
+ {
+#ifdef _WIN32
+ LOGERROR("m_SListenClient==INVALID_SOCKET (%s)", GetWSAError().c_str() );
+#else
+ LOGERROR("m_SListenClient==INVALID_SOCKET");
+#endif
+ }
+
+
+#ifdef _WIN32
+ char yes = 1;
+#else
+ int yes = 1;
+#endif
+ if (setsockopt( m_pState->SListenClient, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(int)) == -1) {
+ LOGERROR("setsockopt == -1");
+ return false;
+ }
+
+ if( bind( m_pState->SListenClient, (sockaddr*)&local, sizeof(local)) != 0 )
+ {
+#ifdef _WIN32
+ LOGERROR("bind fail (%s)", GetWSAError().c_str() );
+#else
+ LOGERROR("bind fail (%i)", errno);
+#endif
+ return false;
+ }
+
+
+ if( listen( m_pState->SListenClient , 10 ) != 0)
+ {
+#ifdef _WIN32
+ LOGERROR("listen fail (%s)", GetWSAError().c_str() );
+#else
+ LOGERROR("listen fail (%i)", errno);
+#endif
+ return false;
+ }
+
+ m_iServerPort = a_Port;
+ LOG("Port %i has been bound, server is open for connections", m_iServerPort);
+ m_bIsConnected = true;
+
+ cIniFile IniFile("settings.ini");
+ if( IniFile.ReadFile() )
+ {
+ g_bWaterPhysics = IniFile.GetValueB("Physics", "Water", false );
+ std::string ServerID = IniFile.GetValue("Server", "ServerID");
+ if( ServerID.empty() )
+ {
+ ServerID = "MCServer";
+ IniFile.SetValue("Server", "ServerID", ServerID, true );
+ IniFile.WriteFile();
+ }
+ m_pState->ServerID = ServerID;
+ }
+ return true;
+}
+
+cServer::cServer()
+ : m_pState( new sServerState )
+ , m_Millisecondsf( 0 )
+ , m_Milliseconds( 0 )
+ , m_bIsConnected( false )
+ , m_iServerPort( 0 )
+ , m_bRestarting( false )
+{
+}
+
+cServer::~cServer()
+{
+ if( m_pState->SListenClient ) closesocket( m_pState->SListenClient );
+ m_pState->SListenClient = 0;
+
+ m_pState->bStopListenThread = true;
+ delete m_pState->pListenThread; m_pState->pListenThread = 0;
+ m_pState->bStopTickThread = true;
+ delete m_pState->pTickThread; m_pState->pTickThread = 0;
+
+ delete m_pState;
+}
+
+void cServer::Broadcast( const cPacket & a_Packet, cClientHandle* a_Exclude /* = 0 */ )
+{
+ //m_World->LockClientHandle();
+ cWorld* World = cRoot::Get()->GetWorld();
+ for( cWorld::ClientList::iterator itr = World->GetClients().begin(); itr != World->GetClients().end(); ++itr)
+ {
+ if( *itr == a_Exclude || !(*itr)->IsLoggedIn() ) continue;
+ (*itr)->Send( a_Packet );
+ }
+ //m_World->UnlockClientHandle();
+}
+
+void cServer::SendAllEntitiesTo(cClientHandle* a_Target)
+{
+ cWorld* World = cRoot::Get()->GetWorld();
+ for( cWorld::EntityList::iterator itr = World->GetEntities().begin(); itr != World->GetEntities().end(); ++itr)
+ {
+ (*itr)->SpawnOn( a_Target );
+ }
+}
+
+void cServer::StartListenClient()
+{
+ sockaddr_in from;
+ socklen_t fromlen=sizeof(from);
+
+ cSocket SClient = accept(
+ m_pState->SListenClient,
+ (sockaddr*)&from,
+ &fromlen);
+
+ if( from.sin_addr.s_addr && SClient.IsValid() )
+ {
+ char * ClientIP = 0;
+ if((ClientIP = inet_ntoa(from.sin_addr)) == 0 )
+ return;
+
+ LOG("%s connected!", ClientIP);
+
+ cClientHandle *NewHandle = 0;
+ NewHandle = new cClientHandle( SClient );
+ cWorld* World = cRoot::Get()->GetWorld();
+ World->LockClientHandle();
+ World->AddClient( NewHandle );
+ World->UnlockClientHandle();
+ }
+}
+
+bool cServer::Tick(float a_Dt)
+{
+ //LOG("Tick");
+ if( a_Dt > 100.f ) a_Dt = 100.f; // Don't go over 1/10 second
+
+ cSleep::MilliSleep( 50 ); // Don't tick too much
+
+ m_Millisecondsf += a_Dt;
+ if( m_Millisecondsf > 1.f )
+ {
+ m_Milliseconds += (int)m_Millisecondsf;
+ m_Millisecondsf = m_Millisecondsf - (int)m_Millisecondsf;
+ }
+
+ cWorld* World = cRoot::Get()->GetWorld();
+ World->Tick(a_Dt);
+
+ World->LockClientHandle();
+ for( cWorld::ClientList::iterator itr = World->GetClients().begin(); itr != World->GetClients().end();)
+ {
+ (*itr)->HandlePendingPackets();
+
+ if( (*itr)->IsDestroyed() )
+ {
+
+ cClientHandle* RemoveMe = *itr;
+ ++itr;
+ cRoot::Get()->GetWorld()->RemoveClient( RemoveMe );
+ continue;
+ }
+ (*itr)->Tick(a_Dt);
+ ++itr;
+ }
+ World->UnlockClientHandle();
+
+ cRoot::Get()->GetPluginManager()->Tick( a_Dt );
+
+ if( !m_bRestarting )
+ return true;
+ else
+ {
+ m_bRestarting = false;
+ m_pState->RestartEvent.Set();
+ LOG("<<<<>>>>SIGNALLED SEMAPHORE");
+ return false;
+ }
+}
+
+void ServerTickThread( void * a_Param )
+{
+ LOG("ServerTickThread");
+ cServer *CServerObj = (cServer*)a_Param;
+
+ cTimer Timer;
+
+ long long LastTime = Timer.GetNowTime();
+
+ bool bKeepGoing = true;
+ while( bKeepGoing )
+ {
+ long long NowTime = Timer.GetNowTime();
+ float DeltaTime = (float)(NowTime-LastTime);
+ bKeepGoing = CServerObj->Tick( DeltaTime );
+ LastTime = NowTime;
+ }
+
+ LOG("TICK THREAD STOPPED");
+}
+
+void cServer::StartListenThread()
+{
+ m_pState->pListenThread = new cThread( ServerListenThread, this );
+ m_pState->pTickThread = new cThread( ServerTickThread, this );
+ m_pState->pListenThread->Start( true );
+ m_pState->pTickThread->Start( true );
+}
+
+std::vector< std::string > StringSplit(std::string str, std::string delim)
+{
+ std::vector< std::string > results;
+ size_t cutAt;
+ while( (cutAt = str.find_first_of(delim)) != str.npos )
+ {
+ if(cutAt > 0)
+ {
+ results.push_back(str.substr(0,cutAt));
+ }
+ str = str.substr(cutAt+1);
+ }
+ if(str.length() > 0)
+ {
+ results.push_back(str);
+ }
+ return results;
+}
+
+template <class T>
+bool from_string(T& t,
+ const std::string& s,
+ std::ios_base& (*f)(std::ios_base&))
+{
+ std::istringstream iss(s);
+ return !(iss >> f >> t).fail();
+}
+
+std::string & StrToUpper(std::string& s)
+{
+ std::string::iterator i = s.begin();
+ std::string::iterator end = s.end();
+
+ while (i != end) {
+ *i = (char)toupper(*i);
+ ++i;
+ }
+ return s;
+}
+
+int NoCaseCompare( std::string s1, std::string s2 )
+{
+ return StrToUpper( s1 ).compare( StrToUpper( s2 ) );
+}
+
+bool cServer::Command( cClientHandle & a_Client, const char* a_Cmd )
+{
+ cPluginManager* PM = cRoot::Get()->GetPluginManager();
+ if( PM->CallHook( cPluginManager::E_PLUGIN_CHAT, 2, a_Cmd, a_Client.GetPlayer() ) )
+ return true;
+
+ std::string Command( a_Cmd );
+ if( Command.length() <= 0 ) return false;
+ if( Command[0] != '/' ) return false;
+
+ std::vector< std::string > split = StringSplit( Command, " " );
+ if( split.size() == 0 )
+ return false;
+
+ if( split[0].compare("/coords") == 0 )
+ {
+ char c_Str[128];
+ sprintf_s( c_Str, 128, "[X:%0.2f] [Y:%0.2f] [Z:%0.2f]", a_Client.GetPlayer()->GetPosX(), a_Client.GetPlayer()->GetPosY(), a_Client.GetPlayer()->GetPosZ() );
+ a_Client.Send( cPacket_Chat( cChatColor::Green + c_Str ) );
+ return true;
+ }
+ return false;
+}
+
+void cServer::ServerCommand( const char* a_Cmd )
+{
+ std::string Command( a_Cmd );
+ std::vector< std::string > split = StringSplit( Command, " " );
+ if( split.size() > 0 )
+ {
+ if( split[0].compare( "help" ) == 0 )
+ {
+ printf("===================ALL COMMANDS====================\n");
+ printf("help - Shows this message\n");
+ printf("save-all - Saves all loaded chunks to disk\n");
+ printf("list - Lists all players currently in server\n");
+ printf("numchunks - Shows number of chunks currently loaded\n");
+ printf("say - Sends a chat message to all players\n");
+ printf("restart - Kicks all clients, and saves everything\n");
+ printf(" and clears memory\n");
+ printf("stop - Saves everything and closes server\n");
+ printf("===================================================\n");
+ return;
+ }
+ if( split[0].compare( "stop" ) == 0 || split[0].compare( "restart" ) == 0 )
+ {
+ return;
+ }
+ if( split[0].compare( "save-all" ) == 0 )
+ {
+ cRoot::Get()->GetWorld()->SaveAllChunks();
+ return;
+ }
+ if( split[0].compare( "list" ) == 0 )
+ {
+ cWorld::EntityList Entities = cRoot::Get()->GetWorld()->GetEntities();
+ std::string PlayerString;
+ int NumPlayers = 0;
+ cRoot::Get()->GetWorld()->LockEntities();
+ for( cWorld::EntityList::iterator itr = Entities.begin(); itr != Entities.end(); ++itr)
+ {
+ if( (*itr)->GetEntityType() != cEntity::E_PLAYER ) continue;
+ PlayerString.push_back(' ');
+ PlayerString += ((cPlayer*)*itr)->GetName();
+ NumPlayers++;
+ }
+ cRoot::Get()->GetWorld()->UnlockEntities();
+ printf( "Players (%i):%s\n", NumPlayers, PlayerString.c_str() );
+ return;
+ }
+ if( split[0].compare( "numchunks" ) == 0 )
+ {
+ //printf("Num loaded chunks: %i\n", cRoot::Get()->GetWorld()->GetChunks().size() );
+ return;
+ }
+ if(split[0].compare("monsters") == 0 ){
+ cMonster::ListMonsters();
+ return;
+ }
+ if(split.size() > 1)
+ {
+ if( split[0].compare( "say" ) == 0 )
+ {
+ std::string Message = cChatColor::Purple + "[SERVER] " + Command.substr( Command.find_first_of("say") + 4 );
+ LOG("%s", Message.c_str() );
+ Broadcast( cPacket_Chat(Message) );
+ return;
+ }
+ }
+ printf("Unknown command, type 'help' for all commands.\n");
+ }
+ //LOG("You didn't enter anything? (%s)", a_Cmd.c_str() );
+}
+
+void cServer::SendMessage( const char* a_Message, cPlayer* a_Player /* = 0 */, bool a_bExclude /* = false */ )
+{
+ cPacket_Chat Chat( a_Message );
+ if( a_Player && !a_bExclude )
+ {
+ cClientHandle* Client = a_Player->GetClientHandle();
+ if( Client ) Client->Send( Chat );
+ return;
+ }
+
+ Broadcast( Chat, (a_Player)?a_Player->GetClientHandle():0 );
+}
+
+void cServer::Shutdown()
+{
+ m_bRestarting = true;
+ m_pState->RestartEvent.Wait();
+
+ cRoot::Get()->GetWorld()->SaveAllChunks();
+
+ cWorld* World = cRoot::Get()->GetWorld();
+ World->LockClientHandle();
+ while( World->GetClients().begin() != World->GetClients().end() )
+ {
+ World->RemoveClient( *World->GetClients().begin() );
+ }
+ World->UnlockClientHandle();
+}
+
+
+const char* cServer::GetServerID()
+{
+ return m_pState->ServerID.c_str();
+}
\ No newline at end of file diff --git a/source/cServer.h b/source/cServer.h new file mode 100644 index 000000000..c8a669949 --- /dev/null +++ b/source/cServer.h @@ -0,0 +1,53 @@ +#pragma once
+
+class cEvent;
+class cSemaphore;
+class cCriticalSection;
+class cPlayer;
+class cClientHandle;
+class cPacket;
+class cServer //tolua_export
+{ //tolua_export
+public: //tolua_export
+ static cServer * GetServer(); //tolua_export
+
+ bool InitServer( int a_Port = 25565 );
+
+ int GetPort() { return m_iServerPort; }
+ bool IsConnected(){return m_bIsConnected;} // returns connection status
+ void StartListenClient(); // Listen to client
+ int RecClient(cClientHandle *sRecSocket); // receive message for a particular socket
+
+ void Broadcast( const cPacket & a_Packet, cClientHandle* a_Exclude = 0 );
+ void SendAllEntitiesTo( cClientHandle* a_Target );
+
+ bool Tick(float a_Dt);
+
+ void StartListenThread();
+
+ bool Command( cClientHandle & a_Client, const char* a_Cmd );
+ void ServerCommand( const char* a_Cmd ); //tolua_export
+ void Shutdown();
+
+ void SendMessage( const char* a_Message, cPlayer* a_Player = 0, bool a_bExclude = false ); //tolua_export
+
+ static void ServerListenThread( void* a_Args );
+
+ const char* GetServerID();
+private:
+ friend class cRoot; // so cRoot can create and destroy cServer
+ cServer();
+ ~cServer();
+
+ struct sServerState;
+ sServerState* m_pState;
+
+ // Time since server was started
+ float m_Millisecondsf;
+ unsigned int m_Milliseconds;
+
+ bool m_bIsConnected; // true - connected false - not connected
+ int m_iServerPort;
+
+ bool m_bRestarting;
+}; //tolua_export
diff --git a/source/cSign.h b/source/cSign.h new file mode 100644 index 000000000..ebdeb3031 --- /dev/null +++ b/source/cSign.h @@ -0,0 +1,32 @@ +#pragma once
+
+class cSign //tolua_export
+{ //tolua_export
+public:
+ static char RotationToMetaData( float a_Rotation ) //tolua_export
+ { //tolua_export
+ a_Rotation += 180 + (180/16); // So its not aligned with axis
+ if( a_Rotation > 360.f ) a_Rotation -= 360.f;
+
+ a_Rotation = (a_Rotation/360) * 16;
+
+ return ((char)a_Rotation) % 16;
+ } //tolua_export
+ static char DirectionToMetaData( char a_Direction ) //tolua_export
+ { //tolua_export
+ switch( a_Direction )
+ {
+ case 0x2:
+ return 0x2;
+ case 0x3:
+ return 0x3;
+ case 0x4:
+ return 0x4;
+ case 0x5:
+ return 0x5;
+ default:
+ break;
+ };
+ return 0x2;
+ }
+}; //tolua_export
\ No newline at end of file diff --git a/source/cSignEntity.cpp b/source/cSignEntity.cpp new file mode 100644 index 000000000..883da223e --- /dev/null +++ b/source/cSignEntity.cpp @@ -0,0 +1,136 @@ +#include "cSignEntity.h"
+#include "cMCLogger.h"
+
+#include "cPlayer.h"
+#include "cClientHandle.h"
+#include "cWorld.h"
+#include "cChunk.h"
+#include "cRoot.h"
+
+#include "packets/cPacket_UpdateSign.h"
+
+#include <json/json.h>
+
+cSignEntity::cSignEntity(ENUM_BLOCK_ID a_BlockType, int a_X, int a_Y, int a_Z)
+ : cBlockEntity(a_BlockType, a_X, a_Y, a_Z)
+{
+}
+
+cSignEntity::~cSignEntity()
+{
+}
+
+// It don't do anything when 'used'
+void cSignEntity::UsedBy( cPlayer & a_Player )
+{
+ (void)a_Player;
+}
+
+void cSignEntity::SetLines( const std::string & a_Line1, const std::string & a_Line2, const std::string & a_Line3, const std::string & a_Line4 )
+{
+ m_Line[0] = a_Line1;
+ m_Line[1] = a_Line2;
+ m_Line[2] = a_Line3;
+ m_Line[3] = a_Line4;
+}
+
+void cSignEntity::SetLine( int a_Index, std::string a_Line )
+{
+ if( a_Index < 4 && a_Index > -1 )
+ {
+ m_Line[a_Index] = a_Line;
+ }
+}
+
+std::string cSignEntity::GetLine( int a_Index )
+{
+ if( a_Index < 4 && a_Index > -1 )
+ {
+ return m_Line[a_Index];
+ }
+ return "";
+}
+
+void cSignEntity::SendTo( cClientHandle* a_Client )
+{
+ cPacket_UpdateSign Sign;
+ Sign.m_PosX = m_PosX;
+ Sign.m_PosY = (short)m_PosY;
+ Sign.m_PosZ = m_PosZ;
+ Sign.m_Line1 = m_Line[0];
+ Sign.m_Line2 = m_Line[1];
+ Sign.m_Line3 = m_Line[2];
+ Sign.m_Line4 = m_Line[3];
+
+ if( a_Client ) a_Client->Send( Sign );
+ else // broadcast of a_Client == 0
+ {
+ cWorld* World = cRoot::Get()->GetWorld();
+ cChunk* Chunk = World->GetChunkOfBlock( m_PosX, m_PosY, m_PosZ );
+ Chunk->Broadcast( Sign );
+ }
+}
+
+void cSignEntity::WriteToFile(FILE* a_File)
+{
+ fwrite( &m_BlockType, sizeof( ENUM_BLOCK_ID ), 1, a_File );
+ fwrite( &m_PosX, sizeof( int ), 1, a_File );
+ fwrite( &m_PosY, sizeof( int ), 1, a_File );
+ fwrite( &m_PosZ, sizeof( int ), 1, a_File );
+
+ for( int i = 0; i < 4; i++ )
+ {
+ short Size = (short)m_Line[i].size();
+ fwrite( &Size, sizeof(short), 1, a_File );
+ fwrite( m_Line[i].c_str(), Size * sizeof(char), 1, a_File );
+ }
+}
+
+bool cSignEntity::LoadFromFile(FILE* a_File)
+{
+ if( fread( &m_PosX, sizeof(int), 1, a_File) != 1 ) { LOGERROR("ERROR READING SIGN FROM FILE"); return false; }
+ if( fread( &m_PosY, sizeof(int), 1, a_File) != 1 ) { LOGERROR("ERROR READING SIGN FROM FILE"); return false; }
+ if( fread( &m_PosZ, sizeof(int), 1, a_File) != 1 ) { LOGERROR("ERROR READING SIGN FROM FILE"); return false; }
+
+ for( int i = 0; i < 4; i++ )
+ {
+ short Size = 0;
+ if( fread( &Size, sizeof(short), 1, a_File) != 1 ) { LOGERROR("ERROR READING SIGN FROM FILE"); return false; }
+ if( Size > 0 )
+ {
+ char* c_Str = new char[Size];
+ if( fread( c_Str, Size * sizeof(char), 1, a_File) != 1 ) { LOGERROR("ERROR READING SIGN FROM FILE"); delete [] c_Str; return false; }
+ m_Line[i].assign( c_Str, Size );
+ delete [] c_Str;
+ }
+ LOG("Line %i: %s", i+1, m_Line[i].c_str() );
+ }
+
+ return true;
+}
+
+bool cSignEntity::LoadFromJson( const Json::Value & a_Value )
+{
+ m_PosX = a_Value.get("x", 0).asInt();
+ m_PosY = a_Value.get("y", 0).asInt();
+ m_PosZ = a_Value.get("z", 0).asInt();
+
+ m_Line[0] = a_Value.get("Line1", "").asString();
+ m_Line[1] = a_Value.get("Line2", "").asString();
+ m_Line[2] = a_Value.get("Line3", "").asString();
+ m_Line[3] = a_Value.get("Line4", "").asString();
+
+ return true;
+}
+
+void cSignEntity::SaveToJson( Json::Value & a_Value )
+{
+ a_Value["x"] = m_PosX;
+ a_Value["y"] = m_PosY;
+ a_Value["z"] = m_PosZ;
+
+ a_Value["Line1"] = m_Line[0];
+ a_Value["Line2"] = m_Line[1];
+ a_Value["Line3"] = m_Line[2];
+ a_Value["Line4"] = m_Line[3];
+}
\ No newline at end of file diff --git a/source/cSignEntity.h b/source/cSignEntity.h new file mode 100644 index 000000000..b704fdd3c --- /dev/null +++ b/source/cSignEntity.h @@ -0,0 +1,34 @@ +#pragma once
+
+#include "cBlockEntity.h"
+#include "FileDefine.h"
+
+#include <string>
+
+namespace Json
+{
+ class Value;
+}
+
+class cSignEntity : public cBlockEntity
+{
+public:
+ cSignEntity(ENUM_BLOCK_ID a_BlockType, int a_X, int a_Y, int a_Z);
+ virtual ~cSignEntity();
+
+ void WriteToFile(FILE* a_File);
+ bool LoadFromFile(FILE* a_File);
+
+ bool LoadFromJson( const Json::Value& a_Value );
+ void SaveToJson( Json::Value& a_Value );
+
+ void SetLines( const std::string & a_Line1, const std::string & a_Line2, const std::string & a_Line3, const std::string & a_Line4 );
+ void SetLine( int a_Index, std::string a_Line );
+
+ std::string GetLine( int a_Index );
+
+ virtual void UsedBy( cPlayer & a_Player );
+ virtual void SendTo( cClientHandle* a_Client );
+private:
+ std::string m_Line[4];
+};
\ No newline at end of file diff --git a/source/cSleep.cpp b/source/cSleep.cpp new file mode 100644 index 000000000..920ffaf65 --- /dev/null +++ b/source/cSleep.cpp @@ -0,0 +1,16 @@ +#include "cSleep.h"
+
+#ifdef _WIN32
+#include <Windows.h>
+#else
+#include <unistd.h>
+#endif
+
+void cSleep::MilliSleep( unsigned int a_MilliSeconds )
+{
+#ifdef _WIN32
+ Sleep(a_MilliSeconds); // Don't tick too much
+#else
+ usleep(a_MilliSeconds*1000);
+#endif
+}
diff --git a/source/cSleep.h b/source/cSleep.h new file mode 100644 index 000000000..20ca7fc7d --- /dev/null +++ b/source/cSleep.h @@ -0,0 +1,7 @@ +#pragma once
+
+class cSleep
+{
+public:
+ static void MilliSleep( unsigned int a_MilliSeconds );
+};
\ No newline at end of file diff --git a/source/cSocket.cpp b/source/cSocket.cpp new file mode 100644 index 000000000..d2489d48e --- /dev/null +++ b/source/cSocket.cpp @@ -0,0 +1,30 @@ +#include "cSocket.h"
+
+cSocket::cSocket( xSocket a_Socket )
+ : m_Socket( a_Socket )
+{
+}
+
+cSocket::~cSocket()
+{
+}
+
+cSocket::operator const cSocket::xSocket() const
+{
+ return m_Socket;
+}
+
+cSocket::xSocket cSocket::GetSocket() const
+{
+ return m_Socket;
+}
+
+bool cSocket::IsValid()
+{
+#ifdef _WIN32
+ return ( m_Socket != INVALID_SOCKET);
+#else
+ return ( m_Socket >= 0);
+#endif
+}
+
diff --git a/source/cSocket.h b/source/cSocket.h new file mode 100644 index 000000000..4a58ff2c9 --- /dev/null +++ b/source/cSocket.h @@ -0,0 +1,43 @@ +#pragma once
+
+#ifdef _WIN32
+#include <WinSock.h>
+#define socklen_t int
+#ifdef SendMessage
+#undef SendMessage
+#endif
+#endif
+
+class cSocket
+{
+#ifdef _WIN32
+ typedef SOCKET xSocket;
+#else
+ typedef int xSocket;
+#endif
+
+public:
+ cSocket() : m_Socket( 0 ) {}
+
+ cSocket( xSocket a_Socket );
+ ~cSocket();
+
+ bool IsValid();
+
+ operator const xSocket() const;
+ xSocket GetSocket() const;
+ void SetSocket( xSocket a_Socket );
+
+ inline static bool IsSocketError( int a_ReturnedValue )
+ {
+#ifdef _WIN32
+ return (a_ReturnedValue == SOCKET_ERROR || a_ReturnedValue == 0);
+#else
+ return (a_ReturnedValue <= 0);
+#endif
+ }
+
+
+private:
+ xSocket m_Socket;
+};
\ No newline at end of file diff --git a/source/cSpider.cpp b/source/cSpider.cpp new file mode 100644 index 000000000..00d63c409 --- /dev/null +++ b/source/cSpider.cpp @@ -0,0 +1,92 @@ +#include "cSpider.h"
+
+#include "Vector3f.h"
+#include "Vector3d.h"
+
+#include "Defines.h"
+
+#include "cRoot.h"
+#include "cWorld.h"
+#include "cPickup.h"
+#include "cItem.h"
+#include "cMonsterConfig.h"
+
+#include "cMCLogger.h"
+
+#ifndef _WIN32
+#include <stdlib.h> // rand()
+#include <cstring>
+#endif
+
+cSpider::cSpider() : m_ChaseTime(999999) {
+ m_bBurnable = true;
+ m_EMPersonality = AGGRESSIVE;
+ m_bPassiveAggressive = true;
+ //m_AttackRate = 1;
+ m_MobType = 52;
+ GetMonsterConfig("Spider");
+}
+
+cSpider::~cSpider()
+{
+}
+
+bool cSpider::IsA( const char* a_EntityType )
+{
+ //LOG("IsA( cSpider ) : %s", a_EntityType);
+ if( strcmp( a_EntityType, "cSpider" ) == 0 ) return true;
+ return cMonster::IsA( a_EntityType );
+}
+
+void cSpider::Tick(float a_Dt)
+{
+ cMonster::Tick(a_Dt);
+ m_EMPersonality = (cRoot::Get()->GetWorld()->GetWorldTime() < (12000 + 1000) )? PASSIVE:AGGRESSIVE;
+}
+
+void cSpider::KilledBy( cEntity* a_Killer )
+{
+ if( (rand() % 5) == 0 )
+ {
+ cPickup* Pickup = new cPickup( (int)(m_Pos->x*32), (int)(m_Pos->y*32), (int)(m_Pos->z*32), cItem( E_ITEM_EGG, 1 ) );
+ Pickup->Initialize();
+ }
+ if( (rand() % 1) == 0 )
+ {
+ cPickup* Pickup = new cPickup( (int)(m_Pos->x*32), (int)(m_Pos->y*32), (int)(m_Pos->z*32), cItem( E_ITEM_FEATHER, 1 ) );
+ Pickup->Initialize();
+ }
+ cMonster::KilledBy( a_Killer );
+}
+
+//What to do if in Idle State
+void cSpider::InStateIdle(float a_Dt) {
+ cMonster::InStateIdle(a_Dt);
+}
+
+//What to do if in Chasing State
+void cSpider::InStateChasing(float a_Dt) {
+ cMonster::InStateChasing(a_Dt);
+ m_ChaseTime += a_Dt;
+ if( m_Target )
+ {
+ Vector3f Pos = Vector3f( m_Pos );
+ Vector3f Their = Vector3f( m_Target->GetPosition() );
+ if( (Their - Pos).Length() <= m_AttackRange) {
+ cMonster::Attack(a_Dt);
+ }
+ MoveToPosition( Their + Vector3f(0, 0.65f, 0) );
+ } else if( m_ChaseTime > 5.f ) {
+ m_ChaseTime = 0;
+ m_EMState = IDLE;
+ }
+}
+
+void cSpider::InStateEscaping(float a_Dt) {
+ cMonster::InStateEscaping(a_Dt);
+}
+
+void cSpider::GetMonsterConfig(const char* pm_name) {
+ LOG("I am gettin my attributes: %s", pm_name);
+ cRoot::Get()->GetMonsterConfig()->Get()->AssignAttributes(this,pm_name);
+}
diff --git a/source/cSpider.h b/source/cSpider.h new file mode 100644 index 000000000..23600d330 --- /dev/null +++ b/source/cSpider.h @@ -0,0 +1,22 @@ +#pragma once
+
+#include "cMonster.h"
+
+class cSpider : public cMonster
+{
+public:
+ cSpider();
+ ~cSpider(); + + virtual bool IsA( const char* a_EntityType );
+ virtual void GetMonsterConfig(const char* pm_name);
+
+ virtual void Tick(float a_Dt);
+ virtual void KilledBy( cEntity* a_Killer );
+ virtual void InStateIdle(float a_Dt);
+ virtual void InStateChasing(float a_Dt);
+ virtual void InStateEscaping(float a_Dt);
+ //float m_ChaseTime;
+protected:
+ float m_ChaseTime;
+}; diff --git a/source/cStairs.h b/source/cStairs.h new file mode 100644 index 000000000..6a63b84db --- /dev/null +++ b/source/cStairs.h @@ -0,0 +1,19 @@ +#pragma once
+
+class cStairs //tolua_export
+{ //tolua_export
+public:
+ static char RotationToMetaData( float a_Rotation ) //tolua_export
+ { //tolua_export
+ a_Rotation += 90 + 45; // So its not aligned with axis
+ if( a_Rotation > 360.f ) a_Rotation -= 360.f;
+ if( a_Rotation >= 0.f && a_Rotation < 90.f )
+ return 0x0;
+ else if( a_Rotation >= 180 && a_Rotation < 270 )
+ return 0x1;
+ else if( a_Rotation >= 90 && a_Rotation < 180 )
+ return 0x2;
+ else
+ return 0x3;
+ } //tolua_export
+}; //tolua_export
\ No newline at end of file diff --git a/source/cStringMap.cpp b/source/cStringMap.cpp new file mode 100644 index 000000000..1ddc2197c --- /dev/null +++ b/source/cStringMap.cpp @@ -0,0 +1,16 @@ +#include "cStringMap.h"
+
+unsigned int cStringMap::size() const
+{
+ return m_StringMap.size();
+}
+
+void cStringMap::clear()
+{
+ m_StringMap.clear();
+}
+
+std::string & cStringMap::get( const std::string & index )
+{
+ return m_StringMap[index];
+}
\ No newline at end of file diff --git a/source/cStringMap.h b/source/cStringMap.h new file mode 100644 index 000000000..f83ca5797 --- /dev/null +++ b/source/cStringMap.h @@ -0,0 +1,19 @@ +#pragma once
+
+#include "tolua++.h"
+#include <string>
+#include <map>
+// A std::map<string, string> interface for Lua
+
+class cStringMap // tolua_export
+{ // tolua_export
+public: // tolua_export
+ cStringMap(std::map< std::string, std::string > a_StringMap) : m_StringMap( a_StringMap ) {}
+ void clear(); // tolua_export
+
+ unsigned int size() const; // tolua_export
+
+ std::string & get( const std::string & index ); //tolua_export
+private:
+ std::map< std::string, std::string > m_StringMap;
+}; // tolua_export
\ No newline at end of file diff --git a/source/cTCPLink.cpp b/source/cTCPLink.cpp new file mode 100644 index 000000000..13eb593ef --- /dev/null +++ b/source/cTCPLink.cpp @@ -0,0 +1,146 @@ +#include "cTCPLink.h"
+#include "cSocket.h"
+#include "cEvent.h"
+#include "cThread.h"
+
+#include "cMCLogger.h"
+
+#ifndef _WIN32
+#include <cstring>
+#include <errno.h>
+#endif
+
+#ifdef _WIN32
+#define MSG_NOSIGNAL (0)
+#endif
+#ifdef __MACH__
+#define MSG_NOSIGNAL (0)
+#endif
+
+cTCPLink::cTCPLink()
+ : m_Socket( 0 )
+ , m_StopEvent( new cEvent() )
+{
+}
+
+cTCPLink::~cTCPLink()
+{
+ if( m_Socket )
+ {
+ CloseSocket();
+ m_StopEvent->Wait();
+ }
+ delete m_StopEvent;
+}
+
+void cTCPLink::CloseSocket()
+{
+ if( m_Socket )
+ {
+ closesocket( m_Socket );
+ m_Socket = 0;
+ }
+}
+
+bool cTCPLink::Connect( const char* a_Address, unsigned int a_Port )
+{
+ if( m_Socket )
+ {
+ LOGWARN("WARNING: cTCPLink Connect() called while still connected. ALWAYS disconnect before re-connecting!");
+ }
+
+ struct hostent *hp;
+ unsigned int addr;
+ struct sockaddr_in server;
+
+#ifdef _WIN32
+ WSADATA wsaData;
+ int wsaret=WSAStartup(/*0x101*/ MAKEWORD(2, 2),&wsaData);
+
+ if(wsaret!=0)
+ {
+ LOGERROR("cTCPLink: WSAStartup returned error");
+ return false;
+ }
+#endif
+
+ m_Socket=socket(AF_INET,SOCK_STREAM,0);
+#ifdef _WIN32
+ if( m_Socket==INVALID_SOCKET )
+#else
+ if( m_Socket < 0 )
+#endif
+ {
+ LOGERROR("cTCPLink: Invalid socket");
+ m_Socket = 0;
+ return false;
+ }
+
+
+ addr=inet_addr( a_Address );
+ hp=gethostbyaddr((char*)&addr,sizeof(addr),AF_INET);
+ if(hp==NULL)
+ {
+ //LOGWARN("cTCPLink: gethostbyaddr returned NULL");
+ hp = gethostbyname( a_Address );
+ if( hp == NULL )
+ {
+ LOGWARN("cTCPLink: Could not resolve %s", a_Address);
+ CloseSocket();
+ return false;
+ }
+ }
+
+ server.sin_addr.s_addr=*((unsigned long*)hp->h_addr);
+ server.sin_family=AF_INET;
+ server.sin_port=htons( (unsigned short)a_Port );
+ if( connect( m_Socket, (struct sockaddr*)&server, sizeof(server) ) )
+ {
+ LOGWARN("cTCPLink: No response from server (%i)", errno);
+ CloseSocket();
+ return false;
+ }
+
+ cThread( ReceiveThread, this );
+
+ return true;
+}
+
+int cTCPLink::Send( char* a_Data, unsigned int a_Size, int a_Flags /* = 0 */ )
+{
+ //LOG("TCPLink::Send()");
+ if( !m_Socket )
+ {
+ LOGWARN("cTCPLink: Trying to send data without a valid connection!");
+ return -1;
+ }
+ return send( m_Socket, a_Data, a_Size, a_Flags | MSG_NOSIGNAL );
+}
+
+int cTCPLink::SendMessage( const char* a_Message, int a_Flags /* = 0 */ )
+{
+ //LOG("TCPLink::SendMessage()");
+ if( !m_Socket )
+ {
+ LOGWARN("cTCPLink: Trying to send message without a valid connection!");
+ return -1;
+ }
+ return send( m_Socket, a_Message, strlen(a_Message), a_Flags | MSG_NOSIGNAL );
+}
+
+void cTCPLink::ReceiveThread( void* a_Param)
+{
+ cTCPLink* self = (cTCPLink*)a_Param;
+ SOCKET Socket = self->m_Socket;
+ int Received = 0;
+ do
+ {
+ char Data[256];
+ Received = recv(Socket, Data, 256, 0);
+ self->ReceivedData( Data, (Received>0?Received:-1) );
+ } while ( Received > 0 );
+
+ LOGINFO("cTCPLink Disconnected (%i)", Received );
+
+ if( Socket == self->m_Socket ) self->m_StopEvent->Set();
+}
diff --git a/source/cTCPLink.h b/source/cTCPLink.h new file mode 100644 index 000000000..634c3afd5 --- /dev/null +++ b/source/cTCPLink.h @@ -0,0 +1,23 @@ +#pragma once
+
+#include "cSocket.h"
+
+class cEvent;
+class cTCPLink //tolua_export
+{ //tolua_export
+public: //tolua_export
+ cTCPLink(); //tolua_export
+ ~cTCPLink(); //tolua_export
+
+ bool Connect( const char* a_Address, unsigned int a_Port ); //tolua_export
+ int Send( char* a_Data, unsigned int a_Size, int a_Flags = 0 ); //tolua_export
+ int SendMessage( const char* a_Message, int a_Flags = 0 ); //tolua_export
+ void CloseSocket(); //tolua_export
+protected: //tolua_export
+ virtual void ReceivedData( char a_Data[256], int a_Size ) = 0; //tolua_export
+
+ static void ReceiveThread( void* a_Param );
+
+ cSocket m_Socket;
+ cEvent* m_StopEvent;
+}; //tolua_export
diff --git a/source/cThread.cpp b/source/cThread.cpp new file mode 100644 index 000000000..d0ada2b4e --- /dev/null +++ b/source/cThread.cpp @@ -0,0 +1,75 @@ +#ifndef _WIN32
+#include <cstring>
+#include <semaphore.h>
+#include <errno.h>
+#include <pthread.h>
+#else
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+#endif
+#include "cThread.h"
+#include "cEvent.h"
+#include "cMCLogger.h"
+
+cThread::cThread( ThreadFunc a_ThreadFunction, void* a_Param )
+ : m_ThreadFunction( a_ThreadFunction )
+ , m_Param( a_Param )
+ , m_Event( new cEvent() )
+ , m_StopEvent( 0 )
+{
+}
+
+cThread::~cThread()
+{
+ delete m_Event;
+
+ if( m_StopEvent )
+ {
+ m_StopEvent->Wait();
+ delete m_StopEvent;
+ }
+}
+
+void cThread::Start( bool a_bWaitOnDelete /* = true */ )
+{
+ if( a_bWaitOnDelete )
+ m_StopEvent = new cEvent();
+
+#ifndef _WIN32
+ pthread_t SndThread;
+ if( pthread_create( &SndThread, NULL, MyThread, this) )
+ LOGERROR("ERROR: Could not create thread!");
+#else
+ HANDLE hThread = CreateThread( 0 // security
+ ,0 // stack size
+ , (LPTHREAD_START_ROUTINE) MyThread // function name
+ ,this // parameters
+ ,0 // flags
+ ,0 ); // thread id
+ CloseHandle( hThread );
+#endif
+
+ // Wait until thread has actually been created
+ m_Event->Wait();
+}
+
+#ifdef _WIN32
+unsigned long cThread::MyThread(void* a_Param )
+#else
+void *cThread::MyThread( void *a_Param )
+#endif
+{
+ cThread* self = (cThread*)a_Param;
+ cEvent* StopEvent = self->m_StopEvent;
+
+ ThreadFunc* ThreadFunction = self->m_ThreadFunction;
+ void* ThreadParam = self->m_Param;
+
+ // Set event to let other thread know this thread has been created and it's safe to delete the cThread object
+ self->m_Event->Set();
+
+ ThreadFunction( ThreadParam );
+
+ if( StopEvent ) StopEvent->Set();
+ return 0;
+}
diff --git a/source/cThread.h b/source/cThread.h new file mode 100644 index 000000000..1e9d73c17 --- /dev/null +++ b/source/cThread.h @@ -0,0 +1,25 @@ +#pragma once
+
+class cEvent;
+class cThread
+{
+public:
+ typedef void (ThreadFunc)(void*);
+ cThread( ThreadFunc a_ThreadFunction, void* a_Param );
+ ~cThread();
+
+ void Start( bool a_bWaitOnDelete = true );
+ void WaitForThread();
+private:
+ ThreadFunc* m_ThreadFunction;
+
+#ifdef _WIN32
+ static unsigned long MyThread(void* a_Param );
+#else
+ static void *MyThread( void *lpParam );
+#endif
+
+ void* m_Param;
+ cEvent* m_Event;
+ cEvent* m_StopEvent;
+};
\ No newline at end of file diff --git a/source/cTimer.cpp b/source/cTimer.cpp new file mode 100644 index 000000000..1cdde38ce --- /dev/null +++ b/source/cTimer.cpp @@ -0,0 +1,39 @@ +#include "cTimer.h"
+
+#ifdef _WIN32
+#include <Windows.h>
+#else
+#include <sys/time.h>
+#include <time.h>
+#endif
+
+cTimer::cTimer()
+#ifdef _WIN32
+ : m_TicksPerSecond( new LARGE_INTEGER )
+#endif
+{
+#ifdef _WIN32
+ QueryPerformanceFrequency( (LARGE_INTEGER*)m_TicksPerSecond );
+#endif
+}
+
+cTimer::~cTimer()
+{
+#ifdef _WIN32
+ delete (LARGE_INTEGER*)m_TicksPerSecond;
+#endif
+}
+
+long long cTimer::GetNowTime()
+{
+#ifdef _WIN32
+ LARGE_INTEGER now;
+ QueryPerformanceCounter( &now );
+ LARGE_INTEGER & tps = *((LARGE_INTEGER*)m_TicksPerSecond);
+ return ((now.QuadPart*1000) / tps.QuadPart );
+#else
+ struct timeval now;
+ gettimeofday(&now, NULL);
+ return (long long)(now.tv_sec*1000 + now.tv_usec/1000);
+#endif
+}
\ No newline at end of file diff --git a/source/cTimer.h b/source/cTimer.h new file mode 100644 index 000000000..52afda8bb --- /dev/null +++ b/source/cTimer.h @@ -0,0 +1,15 @@ +#pragma once
+
+class cTimer
+{
+public:
+ cTimer();
+ ~cTimer();
+
+ long long GetNowTime();
+private:
+
+#ifdef _WIN32
+ void* m_TicksPerSecond; // LARGE_INTEGER*
+#endif
+};
\ No newline at end of file diff --git a/source/cTorch.h b/source/cTorch.h new file mode 100644 index 000000000..98f8b86e3 --- /dev/null +++ b/source/cTorch.h @@ -0,0 +1,51 @@ +#pragma once
+
+class cTorch //tolua_export
+{ //tolua_export
+public:
+
+ static char DirectionToMetaData( char a_Direction ) //tolua_export
+ { //tolua_export
+ switch( a_Direction )
+ {
+ case 0x0:
+ return 0x0;
+ case 0x1:
+ return 0x5; //standing on floor
+ case 0x2:
+ return 0x4; // south
+ case 0x3:
+ return 0x3; // north
+ case 0x4:
+ return 0x2; // west
+ case 0x5:
+ return 0x1; // east
+ default:
+ break;
+ };
+ return 0x0;
+ } //tolua_export
+
+ static char MetaDataToDirection( char a_MetaData ) //tolua_export
+ { //tolua_export
+ switch( a_MetaData )
+ {
+ case 0x0:
+ return 0x0;
+ case 0x1:
+ return 0x5;
+ case 0x2:
+ return 0x4;
+ case 0x3:
+ return 0x3;
+ case 0x4:
+ return 0x2;
+ case 0x5:
+ return 0x1;
+ default:
+ break;
+ };
+ return 0x0;
+ } //tolua_export
+
+}; //tolua_export
\ No newline at end of file diff --git a/source/cTracer.cpp b/source/cTracer.cpp new file mode 100644 index 000000000..28e5c49b5 --- /dev/null +++ b/source/cTracer.cpp @@ -0,0 +1,377 @@ +#include "cTracer.h"
+#include "cWorld.h"
+
+#include "Vector3f.h"
+#include "Vector3i.h"
+#include "Vector3d.h"
+
+#include "BlockID.h"
+#include "cMCLogger.h"
+#include "cEntity.h"
+
+#ifndef _WIN32
+#include <stdlib.h> // abs()
+#endif
+
+cTracer::cTracer(cWorld* a_World)
+ : m_World( a_World )
+{
+ m_NormalTable[0] = new Vector3f(-1, 0, 0);
+ m_NormalTable[1] = new Vector3f( 0, 0,-1);
+ m_NormalTable[2] = new Vector3f( 1, 0, 0);
+ m_NormalTable[3] = new Vector3f( 0, 0, 1);
+ m_NormalTable[4] = new Vector3f( 0, 1, 0);
+ m_NormalTable[5] = new Vector3f( 0,-1, 0);
+
+ DotPos = new Vector3f();
+ BoxOffset = new Vector3f();
+ BlockHitPosition = new Vector3f();
+ HitNormal = new Vector3f();
+ RealHit = new Vector3f();
+
+
+ dir = new Vector3f();
+ tDelta = new Vector3f();
+ pos = new Vector3i();
+ end1 = new Vector3i();
+ step = new Vector3i();
+ tMax = new Vector3f();
+}
+
+cTracer::~cTracer()
+{
+ for( int i = 0; i < 6; ++i )
+ {
+ delete m_NormalTable[i];
+ m_NormalTable[i] = 0;
+ }
+
+ delete DotPos; DotPos = 0;
+ delete BoxOffset; BoxOffset = 0;
+ delete BlockHitPosition; BlockHitPosition = 0;
+ delete HitNormal; HitNormal = 0;
+ delete RealHit; RealHit = 0;
+
+ delete dir; dir = 0;
+ delete tDelta; tDelta = 0;
+ delete pos; pos = 0;
+ delete end1; end1 = 0;
+ delete step; step = 0;
+ delete tMax; tMax = 0;
+}
+
+float cTracer::SigNum( float a_Num )
+{
+ if (a_Num < 0.f) return -1.f;
+ if (a_Num > 0.f) return 1.f;
+ return 0.f;
+}
+
+void cTracer::SetValues( const Vector3f & a_Start, const Vector3f & a_Direction )
+{
+ // calculate the direction of the ray (linear algebra)
+ *dir = a_Direction;
+
+ // decide which direction to start walking in
+ step->x = (int) SigNum(dir->x);
+ step->y = (int) SigNum(dir->y);
+ step->z = (int) SigNum(dir->z);
+
+ // normalize the direction vector
+ if( dir->SqrLength() > 0.f ) dir->Normalize();
+
+ // how far we must move in the ray direction before
+ // we encounter a new voxel in x-direction
+ // same but y-direction
+ if( dir->x != 0.f ) tDelta->x = 1/fabs(dir->x);
+ else tDelta->x = 0;
+ if( dir->y != 0.f ) tDelta->y = 1/fabs(dir->y);
+ else tDelta->y = 0;
+ if( dir->z != 0.f ) tDelta->z = 1/fabs(dir->z);
+ else tDelta->z = 0;
+
+ // start voxel coordinates
+ // use your
+ // transformer
+ // function here
+ pos->x = (int)floorf(a_Start.x);
+ pos->y = (int)floorf(a_Start.y);
+ pos->z = (int)floorf(a_Start.z);
+
+ // calculate distance to first intersection in the voxel we start from
+ if(dir->x < 0)
+ {
+ tMax->x = ((float)pos->x - a_Start.x) / dir->x;
+ }
+ else
+ {
+ tMax->x = (((float)pos->x + 1) - a_Start.x) / dir->x;
+ }
+
+ if(dir->y < 0)
+ {
+ tMax->y = ((float)pos->y - a_Start.y) / dir->y;
+ }
+ else
+ {
+ tMax->y = (((float)pos->y + 1) - a_Start.y) / dir->y;
+ }
+
+ if(dir->z < 0)
+ {
+ tMax->z = ((float)pos->z - a_Start.z) / dir->z;
+ }
+ else
+ {
+ tMax->z = (((float)pos->z + 1) - a_Start.z) / dir->z;
+ }
+}
+
+int cTracer::Trace( const Vector3f & a_Start, const Vector3f & a_Direction, int a_Distance)
+{
+ SetValues( a_Start, a_Direction );
+
+ const Vector3f End = a_Start + ((*dir) * (float)a_Distance);
+
+ // end voxel coordinates
+ end1->x = (int)floorf(End.x);
+ end1->y = (int)floorf(End.y);
+ end1->z = (int)floorf(End.z);
+
+ // check if first is occupied
+ if( pos->Equals( end1 ) )
+ {
+ LOG("WARNING: cTracer: Start and end in same block");
+ return 0;
+ }
+
+ bool reachedX = false, reachedY = false, reachedZ = false;
+
+ int Iterations = 0;
+ while ( Iterations < a_Distance )
+ {
+ Iterations++;
+ if(tMax->x < tMax->y && tMax->x < tMax->z)
+ {
+ tMax->x += tDelta->x;
+ pos->x += step->x;
+ }
+ else if(tMax->y < tMax->z)
+ {
+ tMax->y += tDelta->y;
+ pos->y += step->y;
+ }
+ else
+ {
+ tMax->z += tDelta->z;
+ pos->z += step->z;
+ }
+
+ if(step->x > 0.0f)
+ {
+ if(pos->x >= end1->x)
+ {
+ reachedX = true;
+ }
+ }
+ else if(pos->x <= end1->x)
+ {
+ reachedX = true;
+ }
+
+ if(step->y > 0.0f)
+ {
+ if(pos->y >= end1->y)
+ {
+ reachedY = true;
+ }
+ }
+ else if(pos->y <= end1->y)
+ {
+ reachedY = true;
+ }
+
+ if(step->z > 0.0f)
+ {
+ if(pos->z >= end1->z)
+ {
+ reachedZ = true;
+ }
+ }
+ else if(pos->z <= end1->z)
+ {
+ reachedZ = true;
+ }
+
+ if (reachedX && reachedY && reachedZ)
+ {
+ return false;
+ }
+
+ char BlockID = m_World->GetBlock( pos->x, pos->y, pos->z );
+ if ( BlockID != E_BLOCK_AIR )
+ {
+ *BlockHitPosition = pos;
+ int Normal = GetHitNormal(a_Start, End, *pos );
+ if(Normal > 0)
+ {
+ *HitNormal = *m_NormalTable[Normal-1];
+ }
+ return 1;
+ }
+ }
+ return 0;
+}
+
+// return 1 = hit, other is not hit
+int LinesCross(float x0,float y0,float x1,float y1,float x2,float y2,float x3,float y3)
+{
+ //float linx, liny;
+
+ float d=(x1-x0)*(y3-y2)-(y1-y0)*(x3-x2);
+ if (abs(d)<0.001) {return 0;}
+ float AB=((y0-y2)*(x3-x2)-(x0-x2)*(y3-y2))/d;
+ if (AB>=0.0 && AB<=1.0)
+ {
+ float CD=((y0-y2)*(x1-x0)-(x0-x2)*(y1-y0))/d;
+ if (CD>=0.0 && CD<=1.0)
+ {
+ //linx=x0+AB*(x1-x0);
+ //liny=y0+AB*(y1-y0);
+ return 1;
+ }
+ }
+ return 0;
+}
+
+// intersect3D_SegmentPlane(): intersect a segment and a plane
+// Input: a_Ray = a segment, and a_Plane = a plane = {Point V0; Vector n;}
+// Output: *I0 = the intersect point (when it exists)
+// Return: 0 = disjoint (no intersection)
+// 1 = intersection in the unique point *I0
+// 2 = the segment lies in the plane
+int cTracer::intersect3D_SegmentPlane( const Vector3f & a_Origin, const Vector3f & a_End, const Vector3f & a_PlanePos, const Vector3f & a_PlaneNormal )
+{
+ Vector3f u = a_End - a_Origin;//a_Ray.P1 - S.P0;
+ Vector3f w = a_Origin - a_PlanePos;//S.P0 - Pn.V0;
+
+ float D = a_PlaneNormal.Dot( u );//dot(Pn.n, u);
+ float N = -(a_PlaneNormal.Dot( w ) );//-dot(a_Plane.n, w);
+
+ const float EPSILON = 0.0001f;
+ if (fabs(D) < EPSILON) { // segment is parallel to plane
+ if (N == 0) // segment lies in plane
+ return 2;
+ return 0; // no intersection
+ }
+ // they are not parallel
+ // compute intersect param
+ float sI = N / D;
+ if (sI < 0 || sI > 1)
+ return 0; // no intersection
+
+ //Vector3f I ( a_Ray->GetOrigin() + sI * u );//S.P0 + sI * u; // compute segment intersect point
+ *RealHit = a_Origin + u * sI;
+ return 1;
+}
+
+int cTracer::GetHitNormal(const Vector3f & start, const Vector3f & end, const Vector3i & a_BlockPos)
+{
+ Vector3i SmallBlockPos = a_BlockPos;
+ char BlockID = m_World->GetBlock( a_BlockPos.x, a_BlockPos.y, a_BlockPos.z );
+
+ if( BlockID == E_BLOCK_AIR )
+ return 0;
+
+ Vector3f BlockPos;
+ BlockPos = Vector3f(SmallBlockPos);
+
+ Vector3f Look = (end - start);
+ Look.Normalize();
+
+ float dot = Look.Dot( Vector3f(-1, 0, 0) ); // first face normal is x -1
+ if(dot < 0)
+ {
+ int Lines = LinesCross( start.x, start.y, end.x, end.y, BlockPos.x, BlockPos.y, BlockPos.x, BlockPos.y + 1 );
+ if(Lines == 1)
+ {
+ Lines = LinesCross( start.x, start.z, end.x, end.z, BlockPos.x, BlockPos.z, BlockPos.x, BlockPos.z + 1 );
+ if(Lines == 1)
+ {
+ intersect3D_SegmentPlane( start, end, BlockPos, Vector3f(-1, 0, 0) );
+ return 1;
+ }
+ }
+ }
+ dot = Look.Dot( Vector3f(0, 0, -1) ); // second face normal is z -1
+ if(dot < 0)
+ {
+ int Lines = LinesCross( start.z, start.y, end.z, end.y, BlockPos.z, BlockPos.y, BlockPos.z, BlockPos.y + 1 );
+ if(Lines == 1)
+ {
+ Lines = LinesCross( start.z, start.x, end.z, end.x, BlockPos.z, BlockPos.x, BlockPos.z, BlockPos.x + 1 );
+ if(Lines == 1)
+ {
+ intersect3D_SegmentPlane( start, end, BlockPos, Vector3f(0, 0, -1) );
+ return 2;
+ }
+ }
+ }
+ dot = Look.Dot( Vector3f(1, 0, 0) ); // third face normal is x 1
+ if(dot < 0)
+ {
+ int Lines = LinesCross( start.x, start.y, end.x, end.y, BlockPos.x + 1, BlockPos.y, BlockPos.x + 1, BlockPos.y + 1 );
+ if(Lines == 1)
+ {
+ Lines = LinesCross( start.x, start.z, end.x, end.z, BlockPos.x + 1, BlockPos.z, BlockPos.x + 1, BlockPos.z + 1 );
+ if(Lines == 1)
+ {
+ intersect3D_SegmentPlane( start, end, BlockPos + Vector3f(1, 0, 0), Vector3f(1, 0, 0) );
+ return 3;
+ }
+ }
+ }
+ dot = Look.Dot( Vector3f(0, 0, 1) ); // fourth face normal is z 1
+ if(dot < 0)
+ {
+ int Lines = LinesCross( start.z, start.y, end.z, end.y, BlockPos.z + 1, BlockPos.y, BlockPos.z + 1, BlockPos.y + 1 );
+ if(Lines == 1)
+ {
+ Lines = LinesCross( start.z, start.x, end.z, end.x, BlockPos.z + 1, BlockPos.x, BlockPos.z + 1, BlockPos.x + 1 );
+ if(Lines == 1)
+ {
+ intersect3D_SegmentPlane( start, end, BlockPos + Vector3f(0, 0, 1), Vector3f(0, 0, 1) );
+ return 4;
+ }
+ }
+ }
+ dot = Look.Dot( Vector3f(0, 1, 0) ); // fifth face normal is y 1
+ if(dot < 0)
+ {
+ int Lines = LinesCross( start.y, start.x, end.y, end.x, BlockPos.y + 1, BlockPos.x, BlockPos.y + 1, BlockPos.x + 1 );
+ if(Lines == 1)
+ {
+ Lines = LinesCross( start.y, start.z, end.y, end.z, BlockPos.y + 1, BlockPos.z, BlockPos.y + 1, BlockPos.z + 1 );
+ if(Lines == 1)
+ {
+ intersect3D_SegmentPlane( start, end, BlockPos + Vector3f(0, 1, 0), Vector3f(0, 1, 0) );
+ return 5;
+ }
+ }
+ }
+ dot = Look.Dot( Vector3f(0, -1, 0) ); // sixth face normal is y -1
+ if(dot < 0)
+ {
+ int Lines = LinesCross( start.y, start.x, end.y, end.x, BlockPos.y, BlockPos.x, BlockPos.y, BlockPos.x + 1 );
+ if(Lines == 1)
+ {
+ Lines = LinesCross( start.y, start.z, end.y, end.z, BlockPos.y, BlockPos.z, BlockPos.y, BlockPos.z + 1 );
+ if(Lines == 1)
+ {
+ intersect3D_SegmentPlane( start, end, BlockPos, Vector3f(0, -1, 0) );
+ return 6;
+ }
+ }
+ }
+ return 0;
+}
diff --git a/source/cTracer.h b/source/cTracer.h new file mode 100644 index 000000000..3b7cd32c1 --- /dev/null +++ b/source/cTracer.h @@ -0,0 +1,32 @@ +#pragma once
+
+class cWorld;
+class Vector3i;
+class Vector3f;
+class cTracer //tolua_export
+{ //tolua_export
+public: //tolua_export
+ Vector3f* DotPos;
+ Vector3f* BoxOffset;
+ cTracer( cWorld* a_World); //tolua_export
+ ~cTracer(); //tolua_export
+ int Trace( const Vector3f & a_Start, const Vector3f & a_Direction, int a_Distance ); //tolua_export
+ void SetValues( const Vector3f & a_Start, const Vector3f & a_Direction ); //tolua_export
+ Vector3f* BlockHitPosition; //tolua_export
+ Vector3f* HitNormal; //tolua_export
+ Vector3f* RealHit; //tolua_export
+private:
+ int intersect3D_SegmentPlane( const Vector3f & a_Origin, const Vector3f & a_End, const Vector3f & a_PlanePos, const Vector3f & a_PlaneNormal );
+ int GetHitNormal( const Vector3f & start, const Vector3f & end, const Vector3i & a_BlockPos);
+ float SigNum( float a_Num );
+ cWorld* m_World;
+
+ Vector3f* m_NormalTable[6];
+
+ Vector3f* dir;
+ Vector3f* tDelta;
+ Vector3i* pos;
+ Vector3i* end1;
+ Vector3i* step;
+ Vector3f* tMax;
+}; //tolua_export
\ No newline at end of file diff --git a/source/cWaterSimulator.cpp b/source/cWaterSimulator.cpp new file mode 100644 index 000000000..888ff69c4 --- /dev/null +++ b/source/cWaterSimulator.cpp @@ -0,0 +1,216 @@ +#include "cWaterSimulator.h"
+#include "cWorld.h"
+#include "Vector3i.h"
+#include "BlockID.h"
+#include <vector>
+
+class cWaterSimulator::WaterData
+{
+public:
+ WaterData( cWorld* a_World )
+ : m_ActiveWater( new std::vector< Vector3i >() )
+ , m_Buffer( new std::vector< Vector3i >() )
+ , m_World( a_World )
+ {}
+
+ std::vector< Vector3i > GetLowestPoints( int a_X, int a_Y, int a_Z )
+ {
+ std::vector< Vector3i > Points;
+ if( m_World->GetBlock(a_X, a_Y-1, a_Z) == E_BLOCK_AIR )
+ {
+ Points.push_back( Vector3i( a_X, a_Y-1, a_Z ) );
+ return Points;
+ }
+
+ Vector3i LowerPoints [] = {
+ Vector3i( a_X-1, a_Y-1, a_Z ),
+ Vector3i( a_X+1, a_Y-1, a_Z ),
+ Vector3i( a_X, a_Y-1, a_Z-1 ),
+ Vector3i( a_X, a_Y-1, a_Z+1 ),
+ };
+ bool bWaterFound = false;
+ for( int i = 0; i < 4; ++i )
+ {
+ char Block1 = m_World->GetBlock( LowerPoints[i].x, LowerPoints[i].y, LowerPoints[i].z );
+ char Block2 = m_World->GetBlock( LowerPoints[i].x, a_Y, LowerPoints[i].z );
+ if( Block1 == E_BLOCK_AIR && Block2 == E_BLOCK_AIR )
+ {
+ Points.push_back( LowerPoints[i] );
+ LowerPoints[i].y = a_Y;
+ Points.push_back( LowerPoints[i] );
+ }
+ else if( (Block2 == E_BLOCK_WATER || Block2 == E_BLOCK_STATIONARY_WATER ) && ( Block1 == E_BLOCK_AIR || Block1 == E_BLOCK_WATER || Block1 == E_BLOCK_STATIONARY_WATER ) )
+ {
+ bWaterFound = true;
+ }
+ }
+
+ if( Points.size() == 0 && !bWaterFound )
+ {
+ Vector3i LevelPoints [] = {
+ Vector3i( a_X-1, a_Y, a_Z ),
+ Vector3i( a_X+1, a_Y, a_Z ),
+ Vector3i( a_X, a_Y, a_Z-1 ),
+ Vector3i( a_X, a_Y, a_Z+1 ),
+ };
+ for( int i = 0; i < 4; ++i )
+ {
+ char Block = m_World->GetBlock( LevelPoints[i].x, a_Y, LevelPoints[i].z );
+ if( Block == E_BLOCK_AIR || Block == E_BLOCK_WATER || Block == E_BLOCK_STATIONARY_WATER )
+ Points.push_back( LevelPoints[i] );
+ }
+ }
+ return Points;
+ }
+
+ std::vector< Vector3i >* m_ActiveWater;
+ std::vector< Vector3i >* m_Buffer;
+ cWorld* m_World;
+};
+
+cWaterSimulator::cWaterSimulator( cWorld* a_World )
+ : m_World( a_World )
+ , m_Data( new WaterData( a_World ) )
+{
+}
+
+cWaterSimulator::~cWaterSimulator()
+{
+}
+
+void cWaterSimulator::WakeUp( int a_X, int a_Y, int a_Z )
+{
+ AddBlock( a_X, a_Y, a_Z );
+ AddBlock( a_X-1, a_Y, a_Z );
+ AddBlock( a_X+1, a_Y, a_Z );
+ AddBlock( a_X, a_Y-1, a_Z );
+ AddBlock( a_X, a_Y+1, a_Z );
+ AddBlock( a_X, a_Y, a_Z-1 );
+ AddBlock( a_X, a_Y, a_Z+1 );
+}
+
+void cWaterSimulator::AddBlock( int a_X, int a_Y, int a_Z )
+{
+ // Check for duplicates
+ std::vector< Vector3i > & ActiveWater = *m_Data->m_ActiveWater;
+ for( std::vector< Vector3i >::iterator itr = ActiveWater.begin(); itr != ActiveWater.end(); ++itr )
+ {
+ Vector3i & pos = *itr;
+ if( pos.x == a_X && pos.y == a_Y && pos.z == a_Z )
+ return;
+ }
+
+ ActiveWater.push_back( Vector3i( a_X, a_Y, a_Z ) );
+}
+
+char cWaterSimulator::GetHighestLevelAround( int a_X, int a_Y, int a_Z )
+{
+ char Max = 8;
+#define __HIGHLEVEL_CHECK__( x, y, z ) \
+ if( IsWaterBlock( m_World->GetBlock( x, y, z ) ) ) \
+ { \
+ char Meta; \
+ if( (Meta = m_World->GetBlockMeta( x, y, z ) ) < Max ) Max = Meta; \
+ else if( Meta == 8 ) Max = 0; \
+ if( Max == 0 ) return 0; \
+ }
+
+ __HIGHLEVEL_CHECK__( a_X-1, a_Y, a_Z );
+ __HIGHLEVEL_CHECK__( a_X+1, a_Y, a_Z );
+ __HIGHLEVEL_CHECK__( a_X, a_Y, a_Z-1 );
+ __HIGHLEVEL_CHECK__( a_X, a_Y, a_Z+1 );
+
+ return Max;
+}
+
+void cWaterSimulator::Simulate( float a_Dt )
+{
+ m_Timer += a_Dt;
+
+ std::swap( m_Data->m_ActiveWater, m_Data->m_Buffer ); // Swap so blocks can be added to empty ActiveWater array
+ m_Data->m_ActiveWater->clear();
+
+ std::vector< Vector3i > & WaterBlocks = *m_Data->m_Buffer;
+ for( std::vector< Vector3i >::iterator itr = WaterBlocks.begin(); itr != WaterBlocks.end(); ++itr )
+ {
+ Vector3i & pos = *itr;
+ char BlockID = m_World->GetBlock( pos.x, pos.y, pos.z );
+ if( IsWaterBlock( BlockID ) ) // only care about water
+ {
+ bool bIsFed = false;
+ char Meta = m_World->GetBlockMeta( pos.x, pos.y, pos.z );
+ char Feed = Meta;
+ if( Meta == 8 ) // Falling water
+ {
+ if( IsWaterBlock( m_World->GetBlock(pos.x, pos.y+1, pos.z) ) ) // Block above is water
+ {
+ bIsFed = true;
+ Meta = 0; // Make it a full block
+ }
+ }
+ else if( Meta == 0 ) // It's a full block, so it's always fed
+ {
+ bIsFed = true;
+ }
+ else
+ {
+ if( (Feed = GetHighestLevelAround( pos.x, pos.y, pos.z )) < Meta )
+ bIsFed = true;
+ }
+
+
+ if( bIsFed )
+ {
+ char DownID = m_World->GetBlock( pos.x, pos.y-1, pos.z );
+ if( DownID == E_BLOCK_AIR || IsWaterBlock( DownID ) ) // free for water
+ {
+ m_World->FastSetBlock( pos.x, pos.y-1, pos.z, E_BLOCK_WATER, 8 ); // falling
+ AddBlock( pos.x, pos.y-1, pos.z );
+ }
+ else // Not falling water
+ {
+ if( Feed+1 < Meta )
+ {
+ m_World->FastSetBlock( pos.x, pos.y, pos.z, E_BLOCK_WATER, Feed+1 );
+ AddBlock( pos.x, pos.y, pos.z );
+ }
+ else if( Meta < 7 ) // 7 is only 1 unit high, so it cannot spread, lower than 7 can though.
+ {
+ std::vector< Vector3i > Points = m_Data->GetLowestPoints( pos.x, pos.y, pos.z );
+ for( std::vector< Vector3i >::iterator itr = Points.begin(); itr != Points.end(); ++itr )
+ {
+ Vector3i & p = *itr;
+ char BlockID = m_World->GetBlock( p.x, p.y, p.z );
+ if( !IsWaterBlock( BlockID ) )
+ {
+ if( p.y == pos.y )
+ m_World->FastSetBlock(p.x, p.y, p.z, E_BLOCK_WATER, Meta+1);
+ else
+ m_World->FastSetBlock(p.x, p.y, p.z, E_BLOCK_WATER, 8);
+ AddBlock( p.x, p.y, p.z );
+ }
+ else // it's water
+ {
+ char PointMeta = m_World->GetBlockMeta( p.x, p.y, p.z );
+ if( PointMeta > Meta+1 )
+ {
+ AddBlock( p.x, p.y, p.z );
+ }
+ }
+ }
+ }
+ }
+ }
+ else // not fed
+ {
+ m_World->FastSetBlock( pos.x, pos.y, pos.z, E_BLOCK_AIR, 0 );
+ WakeUp( pos.x, pos.y, pos.z );
+ }
+ }
+ }
+}
+
+bool cWaterSimulator::IsWaterBlock( char a_BlockID )
+{
+ return a_BlockID == E_BLOCK_WATER || a_BlockID == E_BLOCK_STATIONARY_WATER;
+}
\ No newline at end of file diff --git a/source/cWaterSimulator.h b/source/cWaterSimulator.h new file mode 100644 index 000000000..1e45256f8 --- /dev/null +++ b/source/cWaterSimulator.h @@ -0,0 +1,25 @@ +#pragma once
+
+class Vector3i;
+class cWorld;
+class cWaterSimulator
+{
+public:
+ cWaterSimulator( cWorld* a_World );
+ ~cWaterSimulator();
+
+ void Simulate( float a_Dt );
+ void WakeUp( int a_X, int a_Y, int a_Z );
+
+private:
+ void AddBlock( int a_X, int a_Y, int a_Z);
+ char GetHighestLevelAround( int a_X, int a_Y, int a_Z );
+
+ bool IsWaterBlock( char a_BlockID );
+
+ float m_Timer;
+ cWorld* m_World;
+
+ class WaterData;
+ WaterData* m_Data;
+};
\ No newline at end of file diff --git a/source/cWebAdmin.cpp b/source/cWebAdmin.cpp new file mode 100644 index 000000000..d6881c55f --- /dev/null +++ b/source/cWebAdmin.cpp @@ -0,0 +1,309 @@ +#include "cWebAdmin.h"
+#include "cMCLogger.h"
+#include "cStringMap.h"
+
+#include "cWebPlugin.h"
+
+#include "cPluginManager.h"
+#include "cPlugin.h"
+
+#include "cEvent.h"
+#include "cWorld.h"
+#include "cPlayer.h"
+#include "cServer.h"
+#include "cRoot.h"
+
+#include <vector>
+
+#include "../iniFile/iniFile.h"
+
+#include "MemoryLeak.h"
+#ifdef _WIN32
+#include <psapi.h>
+#else
+#include <sys/resource.h>
+#endif
+
+extern std::vector<std::string> StringSplit(std::string str, std::string delim);
+
+cWebAdmin* WebAdmin = 0;
+
+cWebAdmin::cWebAdmin( int a_Port /* = 8080 */ )
+ : m_Port( a_Port )
+ , m_bConnected( false )
+{
+ WebAdmin = this;
+ m_Event = new cEvent();
+ Init( m_Port );
+}
+
+cWebAdmin::~cWebAdmin()
+{
+ WebAdmin = 0;
+ m_WebServer->Stop();
+
+ while( m_Plugins.begin() != m_Plugins.end() )
+ {
+ delete *m_Plugins.begin();
+ //m_Plugins.remove( *m_Plugins.begin() );
+ }
+ delete m_WebServer;
+ delete m_IniFile;
+
+ m_Event->Wait();
+ delete m_Event;
+}
+
+void ReplaceString( std::string & a_HayStack, const std::string & a_Needle, const std::string & a_ReplaceWith )
+{
+ size_t pos1 = a_HayStack.find( a_Needle );
+ a_HayStack.replace( pos1, a_Needle.size(), a_ReplaceWith );
+}
+
+void cWebAdmin::AddPlugin( cWebPlugin* a_Plugin )
+{
+ m_Plugins.remove( a_Plugin );
+ m_Plugins.push_back( a_Plugin );
+}
+
+void cWebAdmin::RemovePlugin( cWebPlugin* a_Plugin )
+{
+ m_Plugins.remove( a_Plugin );
+}
+
+void cWebAdmin::Request_Handler(webserver::http_request* r)
+{
+ if( WebAdmin == 0 ) return;
+ LOG("Path: %s", r->path_.c_str() );
+
+ std::vector< std::string > Split = StringSplit( r->path_, "/" );
+
+ if(r->path_ == "/")
+ {
+ r->answer_ += "<center>";
+ r->answer_ += "MCServer WebAdmin";
+ r->answer_ += "<br>";
+ r->answer_ += "<form method='get' action='webadmin/'>";
+ r->answer_ += "<input type='submit' value='Log in'>";
+ r->answer_ += "</form>";
+ r->answer_ += "</center>";
+ return;
+ }
+ else if( Split.size() > 0 && Split[0] == "webadmin" )
+ {
+ if( r->authentication_given_ )
+ {
+ std::string UserPassword = WebAdmin->m_IniFile->GetValue( "User:"+r->username_, "Password", "");
+ if (UserPassword != "" && r->password_ == UserPassword)
+ {
+ std::string Menu;
+ std::string Content;
+ std::string Template = WebAdmin->GetTemplate();
+
+ Content += "<h3>Current Game</h3>";
+ Content += "<h4>Server Name:</h4>";
+ Content += "<p>" + std::string( cRoot::Get()->GetServer()->GetServerID() ) + "</p>";
+
+ Content += "<h4>Plugins:</h4><p>";
+ cPluginManager* PM = cRoot::Get()->GetPluginManager();
+ const cPluginManager::PluginList & List = PM->GetAllPlugins();
+ for( cPluginManager::PluginList::const_iterator itr = List.begin(); itr != List.end(); ++itr )
+ {
+ Content += (*itr)->GetName() + "<br>";
+ }
+ Content += "</p>";
+ Content += "<h4>Players:</h4><p>";
+
+ cWorld* World = cRoot::Get()->GetWorld();
+ cWorld::PlayerList PlayerList = World->GetAllPlayers();
+ for( cWorld::PlayerList::iterator itr = PlayerList.begin(); itr != PlayerList.end(); ++itr )
+ {
+ Content += std::string( (*itr)->GetName() ) + "<br>";
+ }
+ Content += "</p>";
+
+ for( PluginList::iterator itr = WebAdmin->m_Plugins.begin(); itr != WebAdmin->m_Plugins.end(); ++itr )
+ {
+ Menu += "<li><a href='" + (*itr)->GetName() + "'>" + (*itr)->GetName() + "</a></li>";
+ }
+
+ HTTPRequest Request;
+ Request.Username = r->username_;
+ Request.Method = r->method_;
+ Request.Params = new cStringMap(r->params_);
+ Request.Path = r->path_;
+
+ if( Split.size() > 1 )
+ {
+ std::string FoundPlugin = "";
+ for( PluginList::iterator itr = WebAdmin->m_Plugins.begin(); itr != WebAdmin->m_Plugins.end(); ++itr )
+ {
+ if( (*itr)->GetName() == Split[1] )
+ {
+ Content = (*itr)->HandleRequest( &Request );
+ FoundPlugin = (*itr)->GetName();
+ break;
+ }
+ }
+
+ if( FoundPlugin.compare("") != 0 ) // Add some header
+ {
+ Content = "<h3>" + FoundPlugin + "</h3>\n<p>" + Content + "</p>";
+ }
+ }
+
+ delete Request.Params;
+
+ if( Split.size() > 1 )
+ {
+ Content += "\n<p><a href='";
+ for( unsigned int i = 0; i < Split.size(); i++)
+ {
+ Content += "../";
+ }
+ Content += "webadmin/";
+ Content += "'>Go back</a></p>";
+ }
+
+ // mem usage
+#ifndef _WIN32
+ rusage resource_usage;
+ if (getrusage(RUSAGE_SELF, &resource_usage) != 0)
+ {
+ ReplaceString( Template, std::string("{MEM}"), "Error :(" );
+ }
+ else
+ {
+ char MemUsage[32];
+ sprintf( MemUsage, "%0.2f", ((double)resource_usage.ru_maxrss / 1024 / 1024) );
+ ReplaceString( Template, std::string("{MEM}"), MemUsage );
+ }
+#else
+ HANDLE hProcess = GetCurrentProcess();
+ PROCESS_MEMORY_COUNTERS pmc;
+ if( GetProcessMemoryInfo( hProcess, &pmc, sizeof(pmc) ) )
+ {
+ char MemUsage[32];
+ sprintf( MemUsage, "%0.2f", (pmc.WorkingSetSize / 1024.f / 1024.f) );
+ ReplaceString( Template, std::string("{MEM}"), MemUsage );
+ }
+#endif
+ // end mem usage
+
+ ReplaceString( Template, std::string("{USERNAME}"), r->username_ );
+ ReplaceString( Template, std::string("{MENU}"), Menu );
+ ReplaceString( Template, std::string("{CONTENT}"), Content );
+ ReplaceString( Template, std::string("{TITLE}"), "MCServer" );
+
+ r->answer_ = Template;
+ }
+ else
+ {
+ r->answer_ += "Wrong username/password";
+ r->auth_realm_ = "MCServer WebAdmin";
+ }
+ }
+ else
+ {
+ r->answer_ += "no auth";
+ r->auth_realm_ = "MCServer WebAdmin";
+ }
+ }
+}
+
+bool cWebAdmin::Init( int a_Port )
+{
+ m_Port = a_Port;
+
+ m_IniFile = new cIniFile("webadmin.ini");
+ if( m_IniFile->ReadFile() )
+ {
+ m_Port = m_IniFile->GetValueI("WebAdmin", "Port", 8080 );
+ }
+
+ LOG("Starting WebAdmin on port %i", m_Port);
+
+#ifdef _WIN32
+ HANDLE hThread = CreateThread(
+ NULL, // default security
+ 0, // default stack size
+ ListenThread, // name of the thread function
+ this, // thread parameters
+ 0, // default startup flags
+ NULL);
+ CloseHandle( hThread ); // Just close the handle immediately
+#else
+ pthread_t LstnThread;
+ pthread_create( &LstnThread, 0, ListenThread, this);
+#endif
+
+ return true;
+}
+
+#ifdef _WIN32
+DWORD WINAPI cWebAdmin::ListenThread(LPVOID lpParam)
+#else
+void *cWebAdmin::ListenThread( void *lpParam )
+#endif
+{
+ cWebAdmin* self = (cWebAdmin*)lpParam;
+
+ self->m_WebServer = new webserver(self->m_Port, Request_Handler );
+ self->m_WebServer->Begin();
+
+ self->m_Event->Set();
+ return 0;
+}
+
+std::string cWebAdmin::GetTemplate()
+{
+ std::string retVal = "";
+
+ char SourceFile[] = "webadmin/template.html";
+
+ FILE* f;
+#ifdef _WIN32
+ if( fopen_s(&f, SourceFile, "rb" ) == 0 ) // no error
+#else
+ if( (f = fopen(SourceFile, "rb" ) ) != 0 ) // no error
+#endif
+ {
+ // obtain file size:
+ fseek (f , 0 , SEEK_END);
+ long lSize = ftell (f);
+ rewind (f);
+
+ // allocate memory to contain the whole file:
+ char* buffer = (char*) malloc (sizeof(char)*lSize);
+
+ // copy the file into the buffer:
+ size_t result = fread (buffer, 1, lSize, f);
+ if ((long)result != lSize)
+ {
+ LOG ("WEBADMIN: Could not read file %s", SourceFile);
+ free( buffer );
+ return "";
+ }
+
+ retVal.assign( buffer, lSize );
+
+ free( buffer );
+ fclose(f);
+ }
+ return retVal;
+}
+
+
+void cWebAdmin::RemovePlugin( lua_State* L )
+{
+ for( PluginList::iterator itr = m_Plugins.begin(); itr != m_Plugins.end(); )
+ {
+ if( (*itr)->GetLuaState() == L )
+ {
+ PluginList::iterator prev = itr++;
+ delete *prev; // deleting a dereferenced iterator also takes it out of the list, so no need for erase()
+ }
+ else
+ ++itr;
+ }
+}
diff --git a/source/cWebAdmin.h b/source/cWebAdmin.h new file mode 100644 index 000000000..e58eab24e --- /dev/null +++ b/source/cWebAdmin.h @@ -0,0 +1,60 @@ +#pragma once
+
+#include <list>
+#include "../WebServer/WebServer.h"
+#include "cSocket.h"
+
+class cStringMap;
+//tolua_begin
+struct HTTPRequest
+{
+ std::string Method;
+ std::string Path;
+ cStringMap* Params;
+ std::string Username;
+};
+//tolua_end
+
+struct lua_State;
+class cEvent;
+class cIniFile;
+class cWebPlugin;
+class cWebAdmin
+{
+public:
+ cWebAdmin( int a_Port = 8080 );
+ ~cWebAdmin();
+
+ bool Init( int a_Port );
+
+ void AddPlugin( cWebPlugin* a_Plugin );
+ void RemovePlugin( cWebPlugin* a_Plugin );
+
+ typedef std::list< cWebPlugin* > PluginList;
+ PluginList GetPlugins() { return m_Plugins; }
+
+ static void Request_Handler(webserver::http_request* r);
+
+ void RemovePlugin( lua_State* L );
+private:
+
+#ifdef _WIN32
+ static DWORD WINAPI ListenThread(LPVOID lpParam);
+#else
+ static void *ListenThread( void *lpParam );
+#endif
+
+ std::string GetTemplate();
+
+ int m_Port;
+
+ bool m_bConnected;
+ cSocket m_ListenSocket;
+
+ cIniFile* m_IniFile;
+ PluginList m_Plugins;
+
+ cEvent* m_Event;
+
+ webserver* m_WebServer;
+};
\ No newline at end of file diff --git a/source/cWebPlugin.cpp b/source/cWebPlugin.cpp new file mode 100644 index 000000000..43e5e5e54 --- /dev/null +++ b/source/cWebPlugin.cpp @@ -0,0 +1,22 @@ +#include "cWebPlugin.h"
+#include "cWebAdmin.h"
+#include "cServer.h"
+#include "cMCLogger.h"
+#include "cRoot.h"
+
+#include "MemoryLeak.h"
+
+cWebPlugin::cWebPlugin( lua_State* L )
+{
+ LOG("cWebPlugin::cWebPlugin()");
+ m_LuaState = L;
+ cWebAdmin* WebAdmin = cRoot::Get()->GetWebAdmin();
+ if( WebAdmin ) WebAdmin->AddPlugin( this );
+}
+
+cWebPlugin::~cWebPlugin()
+{
+ LOG("~cWebPlugin::cWebPlugin()");
+ cWebAdmin* WebAdmin = cRoot::Get()->GetWebAdmin();
+ if( WebAdmin ) WebAdmin->RemovePlugin( this );
+}
\ No newline at end of file diff --git a/source/cWebPlugin.h b/source/cWebPlugin.h new file mode 100644 index 000000000..397f3ea81 --- /dev/null +++ b/source/cWebPlugin.h @@ -0,0 +1,25 @@ +#pragma once
+
+#include <string>
+
+struct lua_State;
+struct HTTPRequest;
+//tolua_begin
+class cWebPlugin
+{
+public:
+ cWebPlugin( lua_State* L );
+ virtual ~cWebPlugin();
+
+ void SetName( std::string a_Name ) { m_Name = a_Name; }
+ std::string GetName() { return m_Name; }
+
+ virtual std::string HandleRequest( HTTPRequest* a_Request ) = 0;
+ virtual void Initialize() = 0;
+ //tolua_end
+
+ lua_State* GetLuaState() { return m_LuaState; }
+private:
+ lua_State* m_LuaState;
+ std::string m_Name;
+}; //tolua_export
\ No newline at end of file diff --git a/source/cWindow.cpp b/source/cWindow.cpp new file mode 100644 index 000000000..f3caa628c --- /dev/null +++ b/source/cWindow.cpp @@ -0,0 +1,235 @@ +#include "cWindow.h"
+#include "cItem.h"
+#include "cMCLogger.h"
+#include "cClientHandle.h"
+#include "cPlayer.h"
+#include "cInventory.h"
+#include "cWindowOwner.h"
+
+#include "packets/cPacket_WindowClick.h"
+#include "packets/cPacket_WholeInventory.h"
+#include "packets/cPacket_WindowOpen.h"
+#include "packets/cPacket_WindowClose.h"
+
+#include <list>
+
+cWindow::cWindow( cWindowOwner* a_Owner, bool a_bInventoryVisible )
+ : m_WindowID( 0 )
+ , m_WindowType( 0 )
+ , m_Owner( a_Owner )
+ , m_bInventoryVisible( a_bInventoryVisible )
+ , m_NumSlots( 0 )
+ , m_Slots( 0 )
+ , m_DraggingItem( 0 )
+{
+ if( !m_bInventoryVisible ) m_DraggingItem = new cItem();
+}
+
+cWindow::~cWindow()
+{
+ if( !m_bInventoryVisible && m_DraggingItem )
+ {
+ delete m_DraggingItem;
+ m_DraggingItem = 0;
+ }
+}
+
+cItem* cWindow::GetSlot( int a_Slot )
+{
+ if(a_Slot > -1 && a_Slot < m_NumSlots)
+ {
+ return (m_Slots + a_Slot);
+ }
+ return 0;
+}
+
+cItem* cWindow::GetDraggingItem( cPlayer * a_Player /* = 0 */ )
+{
+ if( m_bInventoryVisible && a_Player )
+ {
+ cWindow* Window = a_Player->GetInventory().GetWindow();
+ if( Window )
+ {
+ return Window->GetDraggingItem();
+ }
+ }
+ return m_DraggingItem;
+}
+
+void cWindow::Clicked( cPacket_WindowClick* a_ClickPacket, cPlayer & a_Player )
+{
+ //LOG("cWindow click");
+ if( a_ClickPacket->m_WindowID != m_WindowID )
+ {
+ LOG("WRONG WINDOW ID!");
+ return;
+ }
+
+ if( m_bInventoryVisible )
+ {
+ cWindow* Window = a_Player.GetInventory().GetWindow();
+ if( Window )
+ {
+ m_DraggingItem = Window->GetDraggingItem();
+ }
+ }
+ bool bAsync = false;
+ if( a_ClickPacket->m_SlotNum == -999 ) // Outside window click
+ {
+ if( a_ClickPacket->m_RightMouse )
+ a_Player.TossItem( true );
+ else
+ a_Player.TossItem( true, m_DraggingItem->m_ItemCount );
+ }
+ else if( GetSlot( a_ClickPacket->m_SlotNum ) != 0 )
+ {
+ cItem* Item = GetSlot( a_ClickPacket->m_SlotNum );
+ if( a_ClickPacket->m_ItemID != Item->m_ItemID
+ || a_ClickPacket->m_ItemCount != Item->m_ItemCount
+ || a_ClickPacket->m_ItemUses != Item->m_ItemHealth )
+ {
+ if( !((a_ClickPacket->m_ItemID == -1 || a_ClickPacket->m_ItemID == 0) && (Item->m_ItemID == -1 || Item->m_ItemID == 0 )) )
+ {
+ LOG("My ID: %i Their ID: %i", Item->m_ItemID, a_ClickPacket->m_ItemID );
+ LOG("My Count: %i Their Count: %i", Item->m_ItemCount, a_ClickPacket->m_ItemCount );
+ LOG("My Uses: %i Their Uses: %i", Item->m_ItemHealth, a_ClickPacket->m_ItemUses );
+ bAsync = true;
+ }
+ }
+ }
+ if( m_DraggingItem && a_ClickPacket->m_SlotNum > -1 && a_ClickPacket->m_SlotNum < m_NumSlots )
+ {
+ if( a_ClickPacket->m_RightMouse == 0 )
+ {
+ if( !m_DraggingItem->Equals( m_Slots[a_ClickPacket->m_SlotNum] ) )
+ {
+ cItem tmp( *m_DraggingItem );
+ *m_DraggingItem = m_Slots[a_ClickPacket->m_SlotNum];
+ m_Slots[a_ClickPacket->m_SlotNum] = tmp; // Switch contents
+ }
+ else
+ {
+ int FreeSlots = 64 - m_Slots[a_ClickPacket->m_SlotNum].m_ItemCount;
+ int Filling = (FreeSlots > m_DraggingItem->m_ItemCount) ? m_DraggingItem->m_ItemCount : FreeSlots;
+ m_Slots[a_ClickPacket->m_SlotNum].m_ItemCount += (char)Filling;
+ m_DraggingItem->m_ItemCount -= (char)Filling;
+ if( m_DraggingItem->m_ItemCount <= 0 )
+ m_DraggingItem->Empty();
+ }
+ }
+ else // Right clicked
+ {
+ if( m_DraggingItem->m_ItemID <= 0 ) // Empty?
+ {
+ m_DraggingItem->m_ItemCount = (char)(((float)m_Slots[a_ClickPacket->m_SlotNum].m_ItemCount)/2.f + 0.5f);
+ m_Slots[a_ClickPacket->m_SlotNum].m_ItemCount -= m_DraggingItem->m_ItemCount;
+ m_DraggingItem->m_ItemID = m_Slots[a_ClickPacket->m_SlotNum].m_ItemID;
+ m_DraggingItem->m_ItemHealth = m_Slots[a_ClickPacket->m_SlotNum].m_ItemHealth;
+
+ if( m_Slots[a_ClickPacket->m_SlotNum].m_ItemCount <= 0 )
+ {
+ m_Slots[a_ClickPacket->m_SlotNum].Empty();
+ }
+ }
+ else if( m_Slots[a_ClickPacket->m_SlotNum].m_ItemID <= 0 || m_DraggingItem->Equals( m_Slots[a_ClickPacket->m_SlotNum] ) )
+ { // Drop one item in slot
+ if( m_DraggingItem->m_ItemCount > 0 && m_Slots[a_ClickPacket->m_SlotNum].m_ItemCount < 64 )
+ {
+ m_Slots[a_ClickPacket->m_SlotNum].m_ItemID = m_DraggingItem->m_ItemID;
+ m_Slots[a_ClickPacket->m_SlotNum].m_ItemCount++;
+ m_Slots[a_ClickPacket->m_SlotNum].m_ItemHealth = m_DraggingItem->m_ItemHealth;
+ m_DraggingItem->m_ItemCount--;
+ }
+ if( m_DraggingItem->m_ItemCount <= 0 )
+ {
+ m_DraggingItem->Empty();
+ }
+ }
+ else if( !m_DraggingItem->Equals( m_Slots[a_ClickPacket->m_SlotNum]) ) // Swap contents
+ {
+ cItem tmp( *m_DraggingItem );
+ *m_DraggingItem = m_Slots[a_ClickPacket->m_SlotNum];
+ m_Slots[a_ClickPacket->m_SlotNum] = tmp; // Switch contents
+ }
+ }
+ if( bAsync )
+ {
+ LOG("Window is not synchonous with client. Sending whole window. ID: %i", m_WindowID);
+ for( std::list< cPlayer* >::iterator itr = m_OpenedBy.begin(); itr != m_OpenedBy.end(); ++itr )
+ {
+ SendWholeWindow( (*itr)->GetClientHandle() );
+ }
+ if( m_bInventoryVisible || m_OpenedBy.size() == 0 )
+ {
+ a_Player.GetInventory().SendWholeInventory( a_Player.GetClientHandle() );
+ }
+ }
+ }
+ else if( m_bInventoryVisible ) // Click in player inventory
+ {
+ a_ClickPacket->m_WindowID = 0;
+ a_ClickPacket->m_SlotNum -= (short)(m_NumSlots - 9);
+ cWindow* Window = a_Player.GetInventory().GetWindow();
+ if( Window )
+ {
+ Window->Clicked( a_ClickPacket, a_Player );
+ }
+ }
+ if( m_DraggingItem ) LOG("Dragging: %i", m_DraggingItem->m_ItemCount );
+}
+
+void cWindow::Open( cPlayer & a_Player )
+{
+ // If player is already in OpenedBy remove player first
+ m_OpenedBy.remove( &a_Player );
+ // Then add player
+ m_OpenedBy.push_back( &a_Player );
+
+ cPacket_WindowOpen WindowOpen;
+ WindowOpen.m_WindowID = (char)m_WindowID;
+ WindowOpen.m_InventoryType = (char)m_WindowType;
+ WindowOpen.m_WindowTitle = m_WindowTitle;
+ WindowOpen.m_NumSlots = (char)m_NumSlots;
+ a_Player.GetClientHandle()->Send( WindowOpen );
+}
+
+void cWindow::Close( cPlayer & a_Player )
+{
+ cPacket_WindowClose WindowClose;
+ WindowClose.m_Close = (char)m_WindowID;
+ cClientHandle* ClientHandle = a_Player.GetClientHandle();
+ if( ClientHandle ) ClientHandle->Send( WindowClose );
+
+ m_OpenedBy.remove( &a_Player );
+ if( m_OpenedBy.size() == 0 )
+ {
+ Destroy();
+ }
+}
+
+void cWindow::OwnerDestroyed()
+{
+ m_Owner = 0;
+ while( m_OpenedBy.size() > 1 )
+ {
+ (*m_OpenedBy.begin() )->CloseWindow();
+ }
+ (*m_OpenedBy.begin() )->CloseWindow();
+}
+
+void cWindow::Destroy()
+{
+ LOG("DESTROY WINDOW");
+ if( m_Owner )
+ {
+ m_Owner->CloseWindow();
+ m_Owner = 0;
+ }
+ delete this;
+}
+
+void cWindow::SendWholeWindow( cClientHandle* a_Client )
+{
+ cPacket_WholeInventory Inventory( this );
+ a_Client->Send( Inventory );
+}
diff --git a/source/cWindow.h b/source/cWindow.h new file mode 100644 index 000000000..888a11b98 --- /dev/null +++ b/source/cWindow.h @@ -0,0 +1,67 @@ +#pragma once
+
+#include "MemoryLeak.h"
+#include <list>
+#include <string>
+
+class cPacket_WindowClick;
+class cPlayer;
+class cItem;
+class cWindowOwner;
+class cClientHandle;
+class cWindow
+{
+public:
+ cWindow( cWindowOwner* a_Owner, bool a_bInventoryVisible );
+ ~cWindow();
+
+ int GetWindowID() { return m_WindowID; }
+ void SetWindowID( int a_WindowID ) { m_WindowID = a_WindowID; }
+
+ int GetWindowType() { return m_WindowType; }
+ void SetWindowType( int a_WindowType ) { m_WindowType = a_WindowType; }
+
+ cItem* GetSlots() { return m_Slots; }
+ int GetNumSlots() { return m_NumSlots; }
+
+ cItem* GetSlot( int a_Slot );
+
+ cItem* GetDraggingItem( cPlayer * a_Player = 0 );
+
+ // a_Slots is an array of slots of size a_NumSlots
+ void SetSlots(cItem* a_Slots, int a_NumSlots) { m_Slots = a_Slots; m_NumSlots = a_NumSlots; }
+
+ bool IsInventoryVisible() { return m_bInventoryVisible; }
+ void SetInventoryVisible( bool a_bVisible ) { m_bInventoryVisible = a_bVisible; }
+
+ virtual void Clicked( cPacket_WindowClick* a_ClickPacket, cPlayer & a_Player );
+
+ virtual void Open( cPlayer & a_Player );
+ virtual void Close( cPlayer & a_Player );
+
+ cWindowOwner* GetOwner() { return m_Owner; }
+ void SetOwner( cWindowOwner* a_Owner ) { m_Owner = a_Owner; }
+
+ void SendWholeWindow( cClientHandle* a_Client );
+
+ const std::string & GetWindowTitle() const { return m_WindowTitle; }
+ void SetWindowTitle( const std::string & a_WindowTitle ) { m_WindowTitle = a_WindowTitle; }
+
+ const std::list<cPlayer*> & GetOpenedBy() const { return m_OpenedBy; }
+
+ void OwnerDestroyed();
+private:
+ void Destroy();
+
+ int m_WindowID;
+ int m_WindowType;
+ std::string m_WindowTitle;
+
+ cWindowOwner* m_Owner;
+
+ std::list<cPlayer*> m_OpenedBy;
+ bool m_bInventoryVisible;
+ int m_NumSlots;
+ cItem* m_Slots;
+ cItem* m_DraggingItem;
+};
\ No newline at end of file diff --git a/source/cWindowOwner.h b/source/cWindowOwner.h new file mode 100644 index 000000000..b60b97b6c --- /dev/null +++ b/source/cWindowOwner.h @@ -0,0 +1,16 @@ +#pragma once
+
+#include "MemoryLeak.h"
+
+class cWindow;
+class cWindowOwner
+{
+public:
+ cWindowOwner() : m_Window( 0 ) {}
+ void CloseWindow() { m_Window = 0; }
+ void OpenWindow( cWindow* a_Window ) { m_Window = a_Window; }
+
+ cWindow* GetWindow() { return m_Window; }
+private:
+ cWindow* m_Window;
+};
\ No newline at end of file diff --git a/source/cWorld.cpp b/source/cWorld.cpp new file mode 100644 index 000000000..e634ea112 --- /dev/null +++ b/source/cWorld.cpp @@ -0,0 +1,764 @@ +#include "BlockID.h"
+#include "cWorld.h"
+#include "cChunk.h"
+#include "cClientHandle.h"
+#include "cPickup.h"
+#include "cBlockToPickup.h"
+#include "cMCLogger.h"
+#include "cPlayer.h"
+#include "cServer.h"
+#include "cCriticalSection.h"
+#include "cItem.h"
+#include "cRoot.h"
+#include "../iniFile/iniFile.h"
+#include "cChunkMap.h"
+#include "cWaterSimulator.h"
+#include "cChicken.h"
+#include "cSpider.h"
+#include "cGenSettings.h"
+
+
+#include "packets/cPacket_TimeUpdate.h"
+
+#include "Vector3d.h"
+
+#include <time.h>
+
+#include "tolua++.h"
+
+#ifndef _WIN32
+#include <stdlib.h>
+#include <sys/stat.h> // for mkdir
+#include <sys/types.h>
+#endif
+
+float cWorld::m_Time = 0.f;
+
+char g_BlockLightValue[128];
+char g_BlockSpreadLightFalloff[128];
+bool g_BlockTransparent[128];
+bool g_BlockOneHitDig[128];
+
+#define RECI_RAND_MAX (1.f/RAND_MAX)
+inline float fRadRand( float a_Radius )
+{
+ return ((float)rand() * RECI_RAND_MAX)*a_Radius - a_Radius*0.5f;
+}
+
+struct cWorld::sWorldState
+{
+ cWorld::EntityList m_RemoveEntityQueue;
+ cWorld::EntityList m_AllEntities;
+ cWorld::ClientList m_Clients;
+ cWorld::PlayerList m_Players;
+
+ static const unsigned int CHUNKBUFFER_SIZE = 5;
+ std::vector< unsigned int > m_ChunkBuffer;
+
+ cWorld::ChunkList m_SpreadQueue;
+};
+
+cWorld* cWorld::GetWorld()
+{
+ LOGWARN("WARNING: Using deprecated function cWorld::GetWorld() use cRoot::Get()->GetWorld() instead!");
+ return cRoot::Get()->GetWorld();
+}
+
+cWorld::~cWorld()
+{
+ LockEntities();
+ while( m_pState->m_AllEntities.begin() != m_pState->m_AllEntities.end() )
+ {
+ cEntity* Entity = *m_pState->m_AllEntities.begin();
+ m_pState->m_AllEntities.remove( Entity );
+ RemoveEntity( Entity );
+ }
+ UnlockEntities();
+
+ delete m_WaterSimulator;
+
+ UnloadUnusedChunks();
+ delete m_ChunkMap;
+
+ delete m_ClientHandleCriticalSection; m_ClientHandleCriticalSection = 0;
+ delete m_EntitiesCriticalSection; m_EntitiesCriticalSection = 0;
+ delete m_ChunksCriticalSection; m_ChunksCriticalSection = 0;
+ delete m_pState;
+}
+
+cWorld::cWorld()
+ : m_pState( new sWorldState )
+ , m_SpawnMonsterTime( 0.f )
+{
+ LOG("cWorld::cWorld()");
+
+#ifdef _WIN32
+ {
+ SECURITY_ATTRIBUTES Attrib;
+ Attrib.nLength = sizeof(SECURITY_ATTRIBUTES);
+ Attrib.lpSecurityDescriptor = NULL;
+ Attrib.bInheritHandle = false;
+ ::CreateDirectory("world", &Attrib);
+ }
+#else
+ {
+ mkdir("world", S_IRWXU | S_IRWXG | S_IRWXO);
+ }
+#endif
+
+ srand( (unsigned int) time(0) );
+ m_SpawnX = (double)((rand()%10000)-5000);
+ m_SpawnY = 128;
+ m_SpawnZ = (double)((rand()%10000)-5000);
+ m_WorldSeed = rand();
+
+ cIniFile IniFile("world/world.ini");
+ if( IniFile.ReadFile() )
+ {
+ m_SpawnX = IniFile.GetValueF("SpawnPosition", "X", m_SpawnX );
+ m_SpawnY = IniFile.GetValueF("SpawnPosition", "Y", m_SpawnY );
+ m_SpawnZ = IniFile.GetValueF("SpawnPosition", "Z", m_SpawnZ );
+ m_WorldSeed = IniFile.GetValueI("Seed", "Seed", m_WorldSeed );
+ }
+ else
+ {
+ IniFile.SetValueF("SpawnPosition", "X", m_SpawnX );
+ IniFile.SetValueF("SpawnPosition", "Y", m_SpawnY );
+ IniFile.SetValueF("SpawnPosition", "Z", m_SpawnZ );
+ IniFile.SetValueI("Seed", "Seed", m_WorldSeed );
+ if( !IniFile.WriteFile() )
+ {
+ LOG("WARNING: Could not write to world/world.ini");
+ }
+ }
+ LOGINFO("Seed: %i", m_WorldSeed );
+
+ cIniFile GenSettings("terrain.ini");
+ if( GenSettings.ReadFile() )
+ {
+#define READ_INI_TERRAIN_VAL( var, type ) cGenSettings::var = (type)GenSettings.GetValueF("Terrain", #var, cGenSettings::var )
+ READ_INI_TERRAIN_VAL( HeightFreq1, float );
+ READ_INI_TERRAIN_VAL( HeightFreq2, float );
+ READ_INI_TERRAIN_VAL( HeightFreq3, float );
+ READ_INI_TERRAIN_VAL( HeightAmp1, float );
+ READ_INI_TERRAIN_VAL( HeightAmp2, float );
+ READ_INI_TERRAIN_VAL( HeightAmp3, float );
+ }
+ else
+ {
+#define SET_INI_TERRAIN_VAL( var ) GenSettings.SetValueF("Terrain", #var, cGenSettings::var )
+ SET_INI_TERRAIN_VAL( HeightFreq1 );
+ SET_INI_TERRAIN_VAL( HeightFreq2 );
+ SET_INI_TERRAIN_VAL( HeightFreq3 );
+ SET_INI_TERRAIN_VAL( HeightAmp1 );
+ SET_INI_TERRAIN_VAL( HeightAmp2 );
+ SET_INI_TERRAIN_VAL( HeightAmp3 );
+ GenSettings.WriteFile();
+ }
+
+ m_bAnimals = true;
+ m_SpawnMonsterRate = 10;
+ cIniFile IniFile2("settings.ini");
+ if( IniFile2.ReadFile() )
+ {
+ m_bAnimals = IniFile2.GetValueB("Monsters", "AnimalsOn", true );
+ m_SpawnMonsterRate = (float)IniFile2.GetValueF("Monsters", "AnimalSpawnInterval", 10 );
+ }
+
+ m_ChunkMap = new cChunkMap( 32, 32 );
+
+ m_Time = 0;
+ m_WorldTimeFraction = 0.f;
+ m_WorldTime = 0;
+ m_LastSave = 0;
+ m_LastUnload = 0;
+ m_ClientHandleCriticalSection = new cCriticalSection();
+ m_EntitiesCriticalSection = new cCriticalSection();
+ m_ChunksCriticalSection = new cCriticalSection();
+
+ m_WaterSimulator = new cWaterSimulator( this );
+
+ memset( g_BlockLightValue, 0x0, 128 );
+ memset( g_BlockSpreadLightFalloff, 0xf, 128 ); // 0xf means total falloff
+ memset( g_BlockTransparent, 0x0, 128 );
+ memset( g_BlockOneHitDig, 0x0, 128 );
+
+ // Emissive blocks
+ g_BlockLightValue[ E_BLOCK_TORCH ] = 14;
+ g_BlockLightValue[ E_BLOCK_FIRE ] = 15;
+ g_BlockLightValue[ E_BLOCK_LAVA ] = 15;
+ g_BlockLightValue[ E_BLOCK_STATIONARY_LAVA ] = 15;
+ g_BlockLightValue[ E_BLOCK_GLOWSTONE ] = 15;
+
+ // Spread blocks
+ g_BlockSpreadLightFalloff[ E_BLOCK_AIR ] = 1;
+ g_BlockSpreadLightFalloff[ E_BLOCK_TORCH ] = 1;
+ g_BlockSpreadLightFalloff[ E_BLOCK_FIRE ] = 1;
+ g_BlockSpreadLightFalloff[ E_BLOCK_LAVA ] = 1;
+ g_BlockSpreadLightFalloff[ E_BLOCK_STATIONARY_LAVA ] = 1;
+ g_BlockSpreadLightFalloff[ E_BLOCK_WATER ] = 4; // Light in water dissapears faster
+ g_BlockSpreadLightFalloff[ E_BLOCK_STATIONARY_WATER ] = 4;
+ g_BlockSpreadLightFalloff[ E_BLOCK_LEAVES ] = 1;
+ g_BlockSpreadLightFalloff[ E_BLOCK_GLASS ] = 1;
+ g_BlockSpreadLightFalloff[ E_BLOCK_GLOWSTONE ] = 1;
+ g_BlockSpreadLightFalloff[ E_BLOCK_SIGN_POST ] = 1;
+ g_BlockSpreadLightFalloff[ E_BLOCK_WALLSIGN ] = 1;
+
+ // Transparent blocks
+ g_BlockTransparent[ E_BLOCK_AIR ] = true;
+ g_BlockTransparent[ E_BLOCK_GLASS ] = true;
+ g_BlockTransparent[ E_BLOCK_FIRE ] = true;
+ g_BlockTransparent[ E_BLOCK_ICE ] = true;
+ g_BlockTransparent[ E_BLOCK_TORCH ] = true;
+ g_BlockTransparent[ E_BLOCK_SIGN_POST ] = true;
+ g_BlockTransparent[ E_BLOCK_WALLSIGN ] = true;
+
+ // One hit break blocks
+ g_BlockOneHitDig[ E_BLOCK_SAPLING ] = true;
+ g_BlockOneHitDig[ E_BLOCK_YELLOW_FLOWER ] = true;
+ g_BlockOneHitDig[ E_BLOCK_RED_ROSE ] = true;
+ g_BlockOneHitDig[ E_BLOCK_BROWN_MUSHROOM ] = true;
+ g_BlockOneHitDig[ E_BLOCK_RED_MUSHROOM ] = true;
+ g_BlockOneHitDig[ E_BLOCK_TNT ] = true;
+ g_BlockOneHitDig[ E_BLOCK_TORCH ] = true;
+ g_BlockOneHitDig[ E_BLOCK_REDSTONE_WIRE ] = true;
+ g_BlockOneHitDig[ E_BLOCK_CROPS ] = true;
+ g_BlockOneHitDig[ E_BLOCK_REDSTONE_TORCH_OFF ] = true;
+ g_BlockOneHitDig[ E_BLOCK_REDSTONE_TORCH_ON ] = true;
+ g_BlockOneHitDig[ E_BLOCK_REEDS ] = true;
+ g_BlockOneHitDig[ E_BLOCK_REDSTONE_WIRE ] = true;
+ g_BlockOneHitDig[ E_BLOCK_REDSTONE_REPEATER_OFF ] = true;
+ g_BlockOneHitDig[ E_BLOCK_REDSTONE_REPEATER_ON ] = true;
+ g_BlockOneHitDig[ E_BLOCK_LOCKED_CHEST ] = true;
+
+}
+
+void cWorld::InitializeSpawn()
+{
+ int ChunkX = 0, ChunkY = 0, ChunkZ = 0;
+ BlockToChunk( (int)m_SpawnX, (int)m_SpawnY, (int)m_SpawnZ, ChunkX, ChunkY, ChunkZ );
+ int ViewDist = cClientHandle::VIEWDISTANCE;
+ LOG("Loading spawn area");
+ for(int x = 0; x < ViewDist; x++)
+ {
+ for(int z = 0; z < ViewDist; z++)
+ {
+ GetChunk( x + ChunkX-(ViewDist-1)/2, 0, z + ChunkZ-(ViewDist-1)/2 );
+ }
+ LOG("Loaded %0.2f", ((float)x / (float)ViewDist)*100 );
+ }
+}
+
+void cWorld::Tick(float a_Dt)
+{
+ m_Time+=a_Dt/1000.f;
+
+ bool bSendTime = false;
+ m_WorldTimeFraction+=a_Dt/1000.f;
+ while( m_WorldTimeFraction > 1.f )
+ {
+ m_WorldTimeFraction-=1.f;
+ m_WorldTime+=20;
+ m_WorldTime %= 24000; // 24000 units in a day
+ bSendTime = true;
+ }
+ if( bSendTime ) cRoot::Get()->GetServer()->Broadcast( cPacket_TimeUpdate( (m_WorldTime) ) );
+
+ LockEntities();
+ for( cWorld::EntityList::iterator itr = GetEntities().begin(); itr != GetEntities().end();)
+ {
+ if( (*itr)->IsDestroyed() )
+ {
+ LOG("Destroy that entity! %i", (*itr)->GetUniqueID() );
+ cEntity* RemoveMe = *itr;
+ itr++;
+ AddToRemoveEntityQueue( *RemoveMe );
+ continue;
+ }
+ (*itr)->Tick(a_Dt);
+ itr++;
+ }
+ UnlockEntities();
+
+ LockChunks();
+
+ while( !m_pState->m_SpreadQueue.empty() )
+ {
+ cChunk* Chunk = (*m_pState->m_SpreadQueue.begin());
+ //LOG("Spreading: %p", Chunk );
+ Chunk->SpreadLight( Chunk->pGetSkyLight() );
+ Chunk->SpreadLight( Chunk->pGetLight() );
+ m_pState->m_SpreadQueue.remove( &*Chunk );
+ }
+
+ m_ChunkMap->Tick(a_Dt);
+ m_WaterSimulator->Simulate(a_Dt);
+ UnlockChunks();
+
+ if( m_Time - m_LastSave > 60*5 ) // Save each 5 minutes
+ {
+ SaveAllChunks();
+ }
+
+ if( m_Time - m_LastUnload > 10 ) // Unload each minute
+ {
+ UnloadUnusedChunks();
+ }
+
+ while( !m_pState->m_RemoveEntityQueue.empty() )
+ {
+ RemoveEntity( *m_pState->m_RemoveEntityQueue.begin() );
+ }
+
+
+ if( m_bAnimals && ( m_Time - m_SpawnMonsterTime > m_SpawnMonsterRate ) ) // 10 seconds
+ {
+ m_SpawnMonsterTime = m_Time;
+ if( m_pState->m_Players.size() > 0 )
+ {
+ cChicken *Chicken;
+ cSpider *Spider;
+ int RandomPlayerIdx = rand() & m_pState->m_Players.size();
+ PlayerList::iterator itr = m_pState->m_Players.begin();
+ for( int i = 1; i < RandomPlayerIdx; i++ )
+ itr++;
+
+ cPlayer* Player = *itr;
+ Vector3d SpawnPos = Player->GetPosition();
+ SpawnPos += Vector3d( (double)(rand()%64)-32, (double)(rand()%64)-32, (double)(rand()%64)-32 );
+ char Height = GetHeight( (int)SpawnPos.x, (int)SpawnPos.z );
+
+ //cMonster* Monster = new cChicken();
+ if(m_WorldTime >= 12000 + 1000) {
+ Spider = new cSpider();
+ Spider->Initialize();
+ Spider->TeleportTo( SpawnPos.x, (double)(Height)+2, SpawnPos.z );
+ Spider->SpawnOn( 0 );
+ } else {
+ Chicken = new cChicken();
+ Chicken->Initialize();
+ Chicken->TeleportTo( SpawnPos.x, (double)(Height)+2, SpawnPos.z );
+ Chicken->SpawnOn( 0 );
+ }
+ //Monster->TeleportTo( SpawnPos.x, (double)(Height)+2, SpawnPos.z );
+ //Monster->SpawnOn( 0 );
+ }
+ }
+}
+
+void cWorld::GrowTree( int a_X, int a_Y, int a_Z )
+{
+ // new tree code, looks much better
+ // with help from seanj
+ // converted from php to lua then lua to c++
+
+ // build trunk
+ int trunk = rand() % (7 - 5 + 1) + 5;
+ for (int i = 0; i < trunk; i++)
+ {
+
+ if( GetBlock( a_X, a_Y + i, a_Z ) == E_BLOCK_AIR )
+ FastSetBlock( a_X, a_Y + i, a_Z, E_BLOCK_LOG, 0 );
+ }
+
+ // build tree
+ for (int j = 0; j < trunk; j++) {
+ int radius = trunk - j;
+ if (radius < 4) {
+ if (radius > 2) {
+ radius = 2;
+ }
+ for (int i = a_X - radius; i <= a_X + radius; i++) {
+ for (int k = a_Z-radius; k <= a_Z + radius; k++) {
+ // small chance to be missing a block to add a little random
+ if (k != a_Z || i != a_X && (rand() % 100 + 1) > 20) {
+
+ if( GetBlock( i, a_Y + j, k ) == E_BLOCK_AIR )
+ FastSetBlock(i, a_Y+j, k, E_BLOCK_LEAVES, 0 );
+ }
+ else {
+ //if( m_BlockType[ MakeIndex(i, TopY+j, k) ] == E_BLOCK_AIR )
+ // m_BlockType[ MakeIndex(i, TopY+j, k) ] = E_BLOCK_LEAVES;
+ }
+ }
+ }
+ if( GetBlock( a_X, a_Y+j, a_Z ) == E_BLOCK_AIR )
+ FastSetBlock( a_X, a_Y+j, a_Z, E_BLOCK_LOG, 0 );
+
+ }
+ }
+
+ // do the top
+ if( GetBlock( a_X+1, a_Y+trunk, a_Z ) == E_BLOCK_AIR )
+ FastSetBlock( a_X+1, a_Y+trunk, a_Z, E_BLOCK_LEAVES, 0 );
+
+ if( GetBlock( a_X-1, a_Y+trunk, a_Z ) == E_BLOCK_AIR )
+ FastSetBlock( a_X-1, a_Y+trunk, a_Z, E_BLOCK_LEAVES, 0 );
+
+ if( GetBlock( a_X, a_Y+trunk, a_Z+1 ) == E_BLOCK_AIR )
+ FastSetBlock( a_X, a_Y+trunk, a_Z+1, E_BLOCK_LEAVES, 0 );
+
+ if( GetBlock( a_X, a_Y+trunk, a_Z-1 ) == E_BLOCK_AIR )
+ FastSetBlock( a_X, a_Y+trunk, a_Z-1, E_BLOCK_LEAVES, 0 );
+
+ if( GetBlock( a_X, a_Y+trunk, a_Z ) == E_BLOCK_AIR )
+ FastSetBlock( a_X, a_Y+trunk, a_Z, E_BLOCK_LEAVES, 0 );
+
+ // end new tree code
+}
+
+void cWorld::UnloadUnusedChunks()
+{
+ m_LastUnload = m_Time;
+
+ LockChunks();
+ m_ChunkMap->UnloadUnusedChunks();
+ UnlockChunks();
+}
+
+cChunk* cWorld::GetChunk( int a_X, int a_Y, int a_Z )
+{
+ cChunk* Chunk = GetChunkUnreliable( a_X, a_Y, a_Z );
+ if( Chunk )
+ {
+ return Chunk;
+ }
+
+ // Found nothing, create a chunk
+ Chunk = new cChunk( a_X, a_Y, a_Z );
+ if(Chunk)
+ {
+ LOGWARN("Created new chunk! %i %i", a_X, a_Z);
+ LockChunks();
+ m_ChunkMap->AddChunk( Chunk );
+ UnlockChunks();
+ Chunk->Initialize();
+ return Chunk;
+ }
+
+ // This should never happen, but yeah
+ return 0;
+}
+
+cChunk* cWorld::GetChunkUnreliable( int a_X, int a_Y, int a_Z )
+{
+ LockChunks();
+ cChunk* Chunk = m_ChunkMap->GetChunk( a_X, a_Y, a_Z );
+ UnlockChunks();
+ if( Chunk ) return Chunk;
+ return 0;
+}
+
+cChunk* cWorld::GetChunkOfBlock( int a_X, int a_Y, int a_Z )
+{
+ int ChunkX, ChunkY, ChunkZ;
+ AbsoluteToRelative( a_X, a_Y, a_Z, ChunkX, ChunkY, ChunkZ );
+ return GetChunk( ChunkX, ChunkY, ChunkZ );
+}
+
+void cWorld::SetBlock( int a_X, int a_Y, int a_Z, char a_BlockType, char a_BlockMeta )
+{
+ m_WaterSimulator->WakeUp( a_X, a_Y, a_Z );
+
+ int ChunkX, ChunkY, ChunkZ;
+ AbsoluteToRelative( a_X, a_Y, a_Z, ChunkX, ChunkY, ChunkZ );
+
+ GetChunk( ChunkX, ChunkY, ChunkZ )->SetBlock(a_X, a_Y, a_Z, a_BlockType, a_BlockMeta );
+}
+
+void cWorld::FastSetBlock( int a_X, int a_Y, int a_Z, char a_BlockType, char a_BlockMeta )
+{
+ int ChunkX, ChunkY, ChunkZ;
+
+ AbsoluteToRelative( a_X, a_Y, a_Z, ChunkX, ChunkY, ChunkZ );
+
+ GetChunk( ChunkX, ChunkY, ChunkZ )->FastSetBlock(a_X, a_Y, a_Z, a_BlockType, a_BlockMeta );
+}
+
+char cWorld::GetBlock( int a_X, int a_Y, int a_Z )
+{
+ int ChunkX, ChunkY, ChunkZ;
+
+ AbsoluteToRelative( a_X, a_Y, a_Z, ChunkX, ChunkY, ChunkZ );
+
+ return GetChunk( ChunkX, ChunkY, ChunkZ )->GetBlock(a_X, a_Y, a_Z);
+}
+
+char cWorld::GetBlockMeta( int a_X, int a_Y, int a_Z )
+{
+ int ChunkX, ChunkY, ChunkZ;
+
+ AbsoluteToRelative( a_X, a_Y, a_Z, ChunkX, ChunkY, ChunkZ );
+
+ cChunk* Chunk = GetChunk( ChunkX, ChunkY, ChunkZ );
+ return Chunk->GetLight( Chunk->pGetMeta(), a_X, a_Y, a_Z );
+}
+
+void cWorld::SetBlockMeta( int a_X, int a_Y, int a_Z, char a_MetaData )
+{
+ int ChunkX, ChunkY, ChunkZ;
+
+ AbsoluteToRelative( a_X, a_Y, a_Z, ChunkX, ChunkY, ChunkZ );
+
+ cChunk* Chunk = GetChunk( ChunkX, ChunkY, ChunkZ );
+ Chunk->SetLight( Chunk->pGetMeta(), a_X, a_Y, a_Z, a_MetaData );
+ Chunk->SendBlockTo( a_X, a_Y, a_Z, 0 );
+}
+
+bool cWorld::DigBlock( int a_X, int a_Y, int a_Z, cItem & a_PickupItem )
+{
+ int PosX = a_X, PosY = a_Y, PosZ = a_Z, ChunkX, ChunkY, ChunkZ;
+
+ AbsoluteToRelative( PosX, PosY, PosZ, ChunkX, ChunkY, ChunkZ );
+
+ cChunk* DestChunk = GetChunk( ChunkX, ChunkY, ChunkZ );
+ if(DestChunk)
+ {
+ DestChunk->SetBlock(PosX, PosY, PosZ, 0, 0 );
+ m_WaterSimulator->WakeUp( a_X, a_Y, a_Z );
+
+ if( !a_PickupItem.IsEmpty() )
+ {
+ cPickup* Pickup = new cPickup( a_X*32 + 16 + (int)fRadRand(16.f), a_Y*32 + 16 + (int)fRadRand(16.f), a_Z*32 + 16 + (int)fRadRand(16.f), a_PickupItem );
+ Pickup->Initialize();
+ }
+ }
+
+ return true;
+}
+
+void cWorld::SendBlockTo( int a_X, int a_Y, int a_Z, cPlayer* a_Player )
+{
+ int ChunkX, ChunkY, ChunkZ;
+ AbsoluteToRelative( a_X, a_Y, a_Z, ChunkX, ChunkY, ChunkZ );
+ cChunk* Chunk = GetChunk( ChunkX, ChunkY, ChunkZ );
+ Chunk->SendBlockTo( a_X, a_Y, a_Z, a_Player->GetClientHandle() );
+}
+
+cBlockEntity* cWorld::GetBlockEntity( int a_X, int a_Y, int a_Z )
+{
+ int PosX = a_X, PosY = a_Y, PosZ = a_Z, ChunkX, ChunkY, ChunkZ;
+
+ AbsoluteToRelative( PosX, PosY, PosZ, ChunkX, ChunkY, ChunkZ );
+
+ cChunk* Chunk = GetChunk( ChunkX, ChunkY, ChunkZ );
+ if( !Chunk ) return 0;
+
+ return Chunk->GetBlockEntity( a_X, a_Y, a_Z );
+}
+
+char cWorld::GetHeight( int a_X, int a_Z )
+{
+ int PosX = a_X, PosY = 0, PosZ = a_Z, ChunkX, ChunkY, ChunkZ;
+ AbsoluteToRelative( PosX, PosY, PosZ, ChunkX, ChunkY, ChunkZ );
+ cChunk* Chunk = GetChunk( ChunkX, ChunkY, ChunkZ );
+ return Chunk->GetHeight( PosX, PosZ );
+}
+
+const double & cWorld::GetSpawnY()
+{
+ m_SpawnY = (double)GetHeight( (int)m_SpawnX, (int)m_SpawnZ ) + 1.6f; // +1.6f eye height
+ return m_SpawnY;
+}
+
+void cWorld::AddPlayer( cPlayer* a_Player )
+{
+ m_pState->m_Players.remove( a_Player );
+ m_pState->m_Players.push_back( a_Player );
+}
+
+void cWorld::RemovePlayer( cPlayer* a_Player )
+{
+ m_pState->m_Players.remove( a_Player );
+}
+
+void cWorld::GetAllPlayers( lua_State* L )
+{
+ lua_createtable(L, m_pState->m_Players.size(), 0);
+ int newTable = lua_gettop(L);
+ int index = 1;
+ PlayerList::const_iterator iter = m_pState->m_Players.begin();
+ while(iter != m_pState->m_Players.end()) {
+ tolua_pushusertype( L, (*iter), "cPlayer" );
+ lua_rawseti(L, newTable, index);
+ ++iter;
+ ++index;
+ }
+}
+
+cPlayer* cWorld::GetPlayer( const char* a_PlayerName )
+{
+ cPlayer* BestMatch = 0;
+ unsigned int MatchedLetters = 0;
+ unsigned int NumMatches = 0;
+ bool bPerfectMatch = false;
+
+ unsigned int NameLength = strlen( a_PlayerName );
+ for( PlayerList::iterator itr = m_pState->m_Players.begin(); itr != m_pState->m_Players.end(); itr++ )
+ {
+ std::string Name = (*itr)->GetName();
+ if( NameLength > Name.length() ) continue; // Definitely not a match
+
+ for(unsigned int i = 0; i < NameLength; i++)
+ {
+ char c1 = (char)toupper( a_PlayerName[i] );
+ char c2 = (char)toupper( Name[i] );
+ if( c1 == c2 )
+ {
+ if( i+1 > MatchedLetters )
+ {
+ MatchedLetters = i+1;
+ BestMatch = *itr;
+ }
+ if( i+1 == NameLength )
+ {
+ NumMatches++;
+ if( NameLength == Name.length() )
+ {
+ bPerfectMatch = true;
+ break;
+ }
+ }
+ }
+ else
+ {
+ if( BestMatch == *itr ) BestMatch = 0;
+ break;
+ }
+ if( bPerfectMatch )
+ break;
+ }
+ }
+ if( NumMatches == 1 )
+ return BestMatch;
+
+ // More than one matches, so it's undefined. Return 0 instead
+ return 0;
+}
+
+cEntity* cWorld::GetEntity( int a_UniqueID )
+{
+ for( EntityList::iterator itr = m_pState->m_AllEntities.begin(); itr != m_pState->m_AllEntities.end(); ++itr )
+ {
+ if( (*itr)->GetUniqueID() == a_UniqueID )
+ return *itr;
+ }
+ return 0;
+}
+
+void cWorld::RemoveClient( cClientHandle* a_Client )
+{
+ m_pState->m_Clients.remove( a_Client );
+ if( a_Client )
+ {
+ delete a_Client;
+ a_Client = 0;
+ }
+}
+
+void cWorld::RemoveEntity( cEntity* a_Entity )
+{
+ m_pState->m_RemoveEntityQueue.remove( a_Entity );
+ if( a_Entity )
+ {
+ delete a_Entity;
+ a_Entity = 0;
+ }
+}
+
+bool cWorld::RemoveEntityFromChunk( cEntity & a_Entity, cChunk* a_CalledFrom /* = 0 */ )
+{
+ LockChunks();
+ bool retVal = m_ChunkMap->RemoveEntityFromChunk( a_Entity, a_CalledFrom );
+ UnlockChunks();
+ return retVal;
+}
+
+void cWorld::SaveAllChunks()
+{
+ LOG("Saving all chunks...");
+ m_LastSave = m_Time;
+ LockChunks();
+ m_ChunkMap->SaveAllChunks();
+ UnlockChunks();
+ LOG("Done saving chunks");
+}
+
+void cWorld::LockClientHandle()
+{
+ m_ClientHandleCriticalSection->Lock();
+}
+
+void cWorld::UnlockClientHandle()
+{
+ m_ClientHandleCriticalSection->Unlock();
+}
+
+void cWorld::LockEntities()
+{
+ m_EntitiesCriticalSection->Lock();
+}
+
+void cWorld::UnlockEntities()
+{
+ m_EntitiesCriticalSection->Unlock();
+}
+
+void cWorld::LockChunks()
+{
+ m_ChunksCriticalSection->Lock();
+}
+
+void cWorld::UnlockChunks()
+{
+ m_ChunksCriticalSection->Unlock();
+}
+
+void cWorld::ReSpreadLighting( cChunk* a_Chunk )
+{
+ LockChunks();
+ m_pState->m_SpreadQueue.remove( a_Chunk );
+ m_pState->m_SpreadQueue.push_back( a_Chunk );
+ UnlockChunks();
+}
+
+void cWorld::RemoveSpread( cChunk* a_Chunk )
+{
+ LockChunks();
+ m_pState->m_SpreadQueue.remove( a_Chunk );
+ UnlockChunks();
+}
+
+
+/************************************************************************/
+/* Get and set */
+/************************************************************************/
+void cWorld::AddClient( cClientHandle* a_Client )
+{
+ m_pState->m_Clients.push_back( a_Client );
+}
+cWorld::ClientList & cWorld::GetClients()
+{
+ return m_pState->m_Clients;
+}
+cWorld::EntityList & cWorld::GetEntities()
+{
+ return m_pState->m_AllEntities;
+}
+void cWorld::AddEntity( cEntity* a_Entity )
+{
+ m_pState->m_AllEntities.push_back( a_Entity );
+}
+cWorld::PlayerList & cWorld::GetAllPlayers()
+{
+ return m_pState->m_Players;
+}
+unsigned int cWorld::GetNumPlayers()
+{
+ return m_pState->m_Players.size();
+}
+void cWorld::AddToRemoveEntityQueue( cEntity & a_Entity )
+{
+ m_pState->m_AllEntities.remove( &a_Entity);
+ m_pState->m_RemoveEntityQueue.push_back( &a_Entity );
+}
\ No newline at end of file diff --git a/source/cWorld.h b/source/cWorld.h new file mode 100644 index 000000000..0b2f8ec85 --- /dev/null +++ b/source/cWorld.h @@ -0,0 +1,158 @@ +#pragma once
+
+#ifndef _WIN32
+#include "BlockID.h"
+#else
+enum ENUM_ITEM_ID;
+#endif
+
+#include <list>
+
+class cWaterSimulator;
+class cChunkMap;
+class cItem;
+class cCriticalSection;
+class cPlayer;
+class cClientHandle;
+class cChunk;
+class cEntity;
+class cBlockEntity;
+class cWorld //tolua_export
+{ //tolua_export
+public:
+ typedef std::list< cClientHandle* > ClientList;
+ typedef std::list< cEntity* > EntityList;
+ typedef std::list< cChunk* > ChunkList;
+ typedef std::list< cPlayer* > PlayerList;
+
+ static cWorld* GetWorld(); //tolua_export
+
+ // Return time in seconds
+ inline static float GetTime() //tolua_export
+ {
+ return m_Time;
+ }
+ long long GetWorldTime() { return m_WorldTime; } //tolua_export
+ void SetWorldTime(long long a_WorldTime) { m_WorldTime = a_WorldTime; } //tolua_export
+
+ cChunk* GetChunk( int a_X, int a_Y, int a_Z );
+ cChunk* GetChunkUnreliable( int a_X, int a_Y, int a_Z );
+ cChunk* GetChunkOfBlock( int a_X, int a_Y, int a_Z );
+ char GetHeight( int a_X, int a_Z ); //tolua_export
+
+ void AddClient( cClientHandle* a_Client );
+ void RemoveClient( cClientHandle* a_Client );
+ ClientList & GetClients();
+
+ void AddPlayer( cPlayer* a_Player );
+ void RemovePlayer( cPlayer* a_Player );
+ PlayerList & GetAllPlayers();
+ typedef struct lua_State lua_State;
+ void GetAllPlayers( lua_State* L ); // >> EXPORTED IN MANUALBINDINGS <<
+ unsigned int GetNumPlayers(); //tolua_export
+ cPlayer* GetPlayer( const char* a_PlayerName ); //tolua_export
+
+ void AddEntity( cEntity* a_Entity );
+ void AddToRemoveEntityQueue( cEntity & a_Entity );
+ bool RemoveEntityFromChunk( cEntity & a_Entity, cChunk* a_CalledFrom = 0 );
+ EntityList & GetEntities();
+
+ cEntity* GetEntity( int a_UniqueID ); //tolua_export
+
+ void SetBlock( int a_X, int a_Y, int a_Z, char a_BlockType, char a_BlockMeta ); //tolua_export
+ void FastSetBlock( int a_X, int a_Y, int a_Z, char a_BlockType, char a_BlockMeta ); //tolua_export
+ char GetBlock( int a_X, int a_Y, int a_Z ); //tolua_export
+ char GetBlockMeta( int a_X, int a_Y, int a_Z ); //tolua_export
+ void SetBlockMeta( int a_X, int a_Y, int a_Z, char a_MetaData ); //tolua_export
+ bool DigBlock( int a_X, int a_Y, int a_Z, cItem & a_PickupItem ); //tolua_export
+ void SendBlockTo( int a_X, int a_Y, int a_Z, cPlayer* a_Player ); //tolua_export
+
+ const double & GetSpawnX() { return m_SpawnX; } //tolua_export
+ const double & GetSpawnY(); //tolua_export
+ const double & GetSpawnZ() { return m_SpawnZ; } //tolua_export
+
+ cBlockEntity* GetBlockEntity( int a_X, int a_Y, int a_Z ); //tolua_export
+
+ void GrowTree( int a_X, int a_Y, int a_Z ); //tolua_export
+
+ unsigned int GetWorldSeed() { return m_WorldSeed; } //tolua_export
+
+ inline static void AbsoluteToRelative( int & a_X, int & a_Y, int & a_Z, int & a_ChunkX, int & a_ChunkY, int & a_ChunkZ )
+ {
+ (void)a_Y; // not unused anymore
+ a_ChunkX = a_X/16;
+ if(a_X < 0 && a_X % 16 != 0) a_ChunkX--;
+ a_ChunkY = 0;
+ a_ChunkZ = a_Z/16;
+ if(a_Z < 0 && a_Z % 16 != 0) a_ChunkZ--;
+
+ a_X = a_X - a_ChunkX*16;
+ //a_Y = a_Y - a_ChunkY*16;
+ a_Z = a_Z - a_ChunkZ*16;
+ }
+ inline static void BlockToChunk( int a_X, int a_Y, int a_Z, int & a_ChunkX, int & a_ChunkY, int & a_ChunkZ )
+ {
+ (void)a_Y; // not unused anymore
+ a_ChunkX = a_X/16;
+ if(a_X < 0 && a_X % 16 != 0) a_ChunkX--;
+ a_ChunkY = 0;
+ a_ChunkZ = a_Z/16;
+ if(a_Z < 0 && a_Z % 16 != 0) a_ChunkZ--;
+ }
+
+ void SaveAllChunks();
+
+ void Tick(float a_Dt);
+
+ void LockClientHandle();
+ void UnlockClientHandle();
+
+ void LockEntities();
+ void UnlockEntities();
+
+ void LockChunks();
+ void UnlockChunks();
+
+ void ReSpreadLighting( cChunk* a_Chunk );
+ void RemoveSpread( cChunk* a_Chunk );
+
+ void InitializeSpawn();
+private:
+ friend class cRoot;
+ cWorld();
+ ~cWorld();
+
+ struct sWorldState;
+ sWorldState* m_pState;
+
+ void RemoveEntity( cEntity* a_Entity );
+ void UnloadUnusedChunks();
+
+ double m_SpawnX;
+ double m_SpawnY;
+ double m_SpawnZ;
+
+ float m_LastUnload;
+ float m_LastSave;
+ static float m_Time; // Time in seconds
+ long long m_WorldTime; // Time in seconds*20, this is sent to clients (is wrapped)
+ float m_WorldTimeFraction; // When this > 1.f m_WorldTime is incremented by 20
+
+ cWaterSimulator* m_WaterSimulator;
+
+ cCriticalSection* m_ClientHandleCriticalSection;
+ cCriticalSection* m_EntitiesCriticalSection;
+ cCriticalSection* m_ChunksCriticalSection;
+
+
+
+ cChunkMap* m_ChunkMap;
+
+
+
+ bool m_bAnimals;
+ float m_SpawnMonsterTime;
+ float m_SpawnMonsterRate;
+
+ unsigned int m_WorldSeed;
+}; //tolua_export
diff --git a/source/main.cpp b/source/main.cpp new file mode 100644 index 000000000..393db121e --- /dev/null +++ b/source/main.cpp @@ -0,0 +1,36 @@ +// Mem leak detection
+#include "MemoryLeak.h"
+
+#include "cRoot.h"
+#include "cMCLogger.h"
+
+#ifdef _WIN32
+#include <exception>
+#endif
+
+int main( int argc, char **argv )
+{
+ (void)argc;
+ (void)argv;
+#ifdef _DEBUG
+ _CrtSetDbgFlag ( _CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF );
+#endif
+
+ try
+ {
+ cRoot Root;
+ Root.Start();
+ }
+ catch( std::exception& e )
+ {
+ LOGERROR("Standard exception: %s", e.what() );
+ }
+ catch( ... )
+ {
+ LOGERROR("Unknown exception!");
+ }
+#ifdef _DEBUG
+ _CrtDumpMemoryLeaks();
+#endif
+ return 0;
+}
diff --git a/source/md5/md5.cpp b/source/md5/md5.cpp new file mode 100644 index 000000000..21bec8f12 --- /dev/null +++ b/source/md5/md5.cpp @@ -0,0 +1,366 @@ +/* MD5
+ converted to C++ class by Frank Thilo (thilo@unix-ag.org)
+ for bzflag (http://www.bzflag.org)
+
+ based on:
+
+ md5.h and md5.c
+ reference implemantion of RFC 1321
+
+ Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
+rights reserved.
+
+License to copy and use this software is granted provided that it
+is identified as the "RSA Data Security, Inc. MD5 Message-Digest
+Algorithm" in all material mentioning or referencing this software
+or this function.
+
+License is also granted to make and use derivative works provided
+that such works are identified as "derived from the RSA Data
+Security, Inc. MD5 Message-Digest Algorithm" in all material
+mentioning or referencing the derived work.
+
+RSA Data Security, Inc. makes no representations concerning either
+the merchantability of this software or the suitability of this
+software for any particular purpose. It is provided "as is"
+without express or implied warranty of any kind.
+
+These notices must be retained in any copies of any part of this
+documentation and/or software.
+
+*/
+
+/* interface header */
+#include "md5.h"
+
+/* system implementation headers */
+#include <stdio.h>
+
+#ifndef _WIN32
+#include <cstring>
+#endif
+
+
+// Constants for MD5Transform routine.
+#define S11 7
+#define S12 12
+#define S13 17
+#define S14 22
+#define S21 5
+#define S22 9
+#define S23 14
+#define S24 20
+#define S31 4
+#define S32 11
+#define S33 16
+#define S34 23
+#define S41 6
+#define S42 10
+#define S43 15
+#define S44 21
+
+///////////////////////////////////////////////
+
+// F, G, H and I are basic MD5 functions.
+inline MD5::uint4 MD5::F(uint4 x, uint4 y, uint4 z) {
+ return x&y | ~x&z;
+}
+
+inline MD5::uint4 MD5::G(uint4 x, uint4 y, uint4 z) {
+ return x&z | y&~z;
+}
+
+inline MD5::uint4 MD5::H(uint4 x, uint4 y, uint4 z) {
+ return x^y^z;
+}
+
+inline MD5::uint4 MD5::I(uint4 x, uint4 y, uint4 z) {
+ return y ^ (x | ~z);
+}
+
+// rotate_left rotates x left n bits.
+inline MD5::uint4 MD5::rotate_left(uint4 x, int n) {
+ return (x << n) | (x >> (32-n));
+}
+
+// FF, GG, HH, and II transformations for rounds 1, 2, 3, and 4.
+// Rotation is separate from addition to prevent recomputation.
+inline void MD5::FF(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
+ a = rotate_left(a+ F(b,c,d) + x + ac, s) + b;
+}
+
+inline void MD5::GG(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
+ a = rotate_left(a + G(b,c,d) + x + ac, s) + b;
+}
+
+inline void MD5::HH(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
+ a = rotate_left(a + H(b,c,d) + x + ac, s) + b;
+}
+
+inline void MD5::II(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac) {
+ a = rotate_left(a + I(b,c,d) + x + ac, s) + b;
+}
+
+//////////////////////////////////////////////
+
+// default ctor, just initailize
+MD5::MD5()
+{
+ init();
+}
+
+//////////////////////////////////////////////
+
+// nifty shortcut ctor, compute MD5 for string and finalize it right away
+MD5::MD5(const std::string &text)
+{
+ init();
+ update(text.c_str(), text.length());
+ finalize();
+}
+
+//////////////////////////////
+
+void MD5::init()
+{
+ finalized=false;
+
+ count[0] = 0;
+ count[1] = 0;
+
+ // load magic initialization constants.
+ state[0] = 0x67452301;
+ state[1] = 0xefcdab89;
+ state[2] = 0x98badcfe;
+ state[3] = 0x10325476;
+}
+
+//////////////////////////////
+
+// decodes input (unsigned char) into output (uint4). Assumes len is a multiple of 4.
+void MD5::decode(uint4 output[], const uint1 input[], size_type len)
+{
+ for (unsigned int i = 0, j = 0; j < len; i++, j += 4)
+ output[i] = ((uint4)input[j]) | (((uint4)input[j+1]) << 8) |
+ (((uint4)input[j+2]) << 16) | (((uint4)input[j+3]) << 24);
+}
+
+//////////////////////////////
+
+// encodes input (uint4) into output (unsigned char). Assumes len is
+// a multiple of 4.
+void MD5::encode(uint1 output[], const uint4 input[], size_type len)
+{
+ for (size_type i = 0, j = 0; j < len; i++, j += 4) {
+ output[j] = input[i] & 0xff;
+ output[j+1] = (input[i] >> 8) & 0xff;
+ output[j+2] = (input[i] >> 16) & 0xff;
+ output[j+3] = (input[i] >> 24) & 0xff;
+ }
+}
+
+//////////////////////////////
+
+// apply MD5 algo on a block
+void MD5::transform(const uint1 block[blocksize])
+{
+ uint4 a = state[0], b = state[1], c = state[2], d = state[3], x[16];
+ decode (x, block, blocksize);
+
+ /* Round 1 */
+ FF (a, b, c, d, x[ 0], S11, 0xd76aa478); /* 1 */
+ FF (d, a, b, c, x[ 1], S12, 0xe8c7b756); /* 2 */
+ FF (c, d, a, b, x[ 2], S13, 0x242070db); /* 3 */
+ FF (b, c, d, a, x[ 3], S14, 0xc1bdceee); /* 4 */
+ FF (a, b, c, d, x[ 4], S11, 0xf57c0faf); /* 5 */
+ FF (d, a, b, c, x[ 5], S12, 0x4787c62a); /* 6 */
+ FF (c, d, a, b, x[ 6], S13, 0xa8304613); /* 7 */
+ FF (b, c, d, a, x[ 7], S14, 0xfd469501); /* 8 */
+ FF (a, b, c, d, x[ 8], S11, 0x698098d8); /* 9 */
+ FF (d, a, b, c, x[ 9], S12, 0x8b44f7af); /* 10 */
+ FF (c, d, a, b, x[10], S13, 0xffff5bb1); /* 11 */
+ FF (b, c, d, a, x[11], S14, 0x895cd7be); /* 12 */
+ FF (a, b, c, d, x[12], S11, 0x6b901122); /* 13 */
+ FF (d, a, b, c, x[13], S12, 0xfd987193); /* 14 */
+ FF (c, d, a, b, x[14], S13, 0xa679438e); /* 15 */
+ FF (b, c, d, a, x[15], S14, 0x49b40821); /* 16 */
+
+ /* Round 2 */
+ GG (a, b, c, d, x[ 1], S21, 0xf61e2562); /* 17 */
+ GG (d, a, b, c, x[ 6], S22, 0xc040b340); /* 18 */
+ GG (c, d, a, b, x[11], S23, 0x265e5a51); /* 19 */
+ GG (b, c, d, a, x[ 0], S24, 0xe9b6c7aa); /* 20 */
+ GG (a, b, c, d, x[ 5], S21, 0xd62f105d); /* 21 */
+ GG (d, a, b, c, x[10], S22, 0x2441453); /* 22 */
+ GG (c, d, a, b, x[15], S23, 0xd8a1e681); /* 23 */
+ GG (b, c, d, a, x[ 4], S24, 0xe7d3fbc8); /* 24 */
+ GG (a, b, c, d, x[ 9], S21, 0x21e1cde6); /* 25 */
+ GG (d, a, b, c, x[14], S22, 0xc33707d6); /* 26 */
+ GG (c, d, a, b, x[ 3], S23, 0xf4d50d87); /* 27 */
+ GG (b, c, d, a, x[ 8], S24, 0x455a14ed); /* 28 */
+ GG (a, b, c, d, x[13], S21, 0xa9e3e905); /* 29 */
+ GG (d, a, b, c, x[ 2], S22, 0xfcefa3f8); /* 30 */
+ GG (c, d, a, b, x[ 7], S23, 0x676f02d9); /* 31 */
+ GG (b, c, d, a, x[12], S24, 0x8d2a4c8a); /* 32 */
+
+ /* Round 3 */
+ HH (a, b, c, d, x[ 5], S31, 0xfffa3942); /* 33 */
+ HH (d, a, b, c, x[ 8], S32, 0x8771f681); /* 34 */
+ HH (c, d, a, b, x[11], S33, 0x6d9d6122); /* 35 */
+ HH (b, c, d, a, x[14], S34, 0xfde5380c); /* 36 */
+ HH (a, b, c, d, x[ 1], S31, 0xa4beea44); /* 37 */
+ HH (d, a, b, c, x[ 4], S32, 0x4bdecfa9); /* 38 */
+ HH (c, d, a, b, x[ 7], S33, 0xf6bb4b60); /* 39 */
+ HH (b, c, d, a, x[10], S34, 0xbebfbc70); /* 40 */
+ HH (a, b, c, d, x[13], S31, 0x289b7ec6); /* 41 */
+ HH (d, a, b, c, x[ 0], S32, 0xeaa127fa); /* 42 */
+ HH (c, d, a, b, x[ 3], S33, 0xd4ef3085); /* 43 */
+ HH (b, c, d, a, x[ 6], S34, 0x4881d05); /* 44 */
+ HH (a, b, c, d, x[ 9], S31, 0xd9d4d039); /* 45 */
+ HH (d, a, b, c, x[12], S32, 0xe6db99e5); /* 46 */
+ HH (c, d, a, b, x[15], S33, 0x1fa27cf8); /* 47 */
+ HH (b, c, d, a, x[ 2], S34, 0xc4ac5665); /* 48 */
+
+ /* Round 4 */
+ II (a, b, c, d, x[ 0], S41, 0xf4292244); /* 49 */
+ II (d, a, b, c, x[ 7], S42, 0x432aff97); /* 50 */
+ II (c, d, a, b, x[14], S43, 0xab9423a7); /* 51 */
+ II (b, c, d, a, x[ 5], S44, 0xfc93a039); /* 52 */
+ II (a, b, c, d, x[12], S41, 0x655b59c3); /* 53 */
+ II (d, a, b, c, x[ 3], S42, 0x8f0ccc92); /* 54 */
+ II (c, d, a, b, x[10], S43, 0xffeff47d); /* 55 */
+ II (b, c, d, a, x[ 1], S44, 0x85845dd1); /* 56 */
+ II (a, b, c, d, x[ 8], S41, 0x6fa87e4f); /* 57 */
+ II (d, a, b, c, x[15], S42, 0xfe2ce6e0); /* 58 */
+ II (c, d, a, b, x[ 6], S43, 0xa3014314); /* 59 */
+ II (b, c, d, a, x[13], S44, 0x4e0811a1); /* 60 */
+ II (a, b, c, d, x[ 4], S41, 0xf7537e82); /* 61 */
+ II (d, a, b, c, x[11], S42, 0xbd3af235); /* 62 */
+ II (c, d, a, b, x[ 2], S43, 0x2ad7d2bb); /* 63 */
+ II (b, c, d, a, x[ 9], S44, 0xeb86d391); /* 64 */
+
+ state[0] += a;
+ state[1] += b;
+ state[2] += c;
+ state[3] += d;
+
+ // Zeroize sensitive information.
+ memset(x, 0, sizeof x);
+}
+
+//////////////////////////////
+
+// MD5 block update operation. Continues an MD5 message-digest
+// operation, processing another message block
+void MD5::update(const unsigned char input[], size_type length)
+{
+ // compute number of bytes mod 64
+ size_type index = count[0] / 8 % blocksize;
+
+ // Update number of bits
+ if ((count[0] += (length << 3)) < (length << 3))
+ count[1]++;
+ count[1] += (length >> 29);
+
+ // number of bytes we need to fill in buffer
+ size_type firstpart = 64 - index;
+
+ size_type i;
+
+ // transform as many times as possible.
+ if (length >= firstpart)
+ {
+ // fill buffer first, transform
+ memcpy(&buffer[index], input, firstpart);
+ transform(buffer);
+
+ // transform chunks of blocksize (64 bytes)
+ for (i = firstpart; i + blocksize <= length; i += blocksize)
+ transform(&input[i]);
+
+ index = 0;
+ }
+ else
+ i = 0;
+
+ // buffer remaining input
+ memcpy(&buffer[index], &input[i], length-i);
+}
+
+//////////////////////////////
+
+// for convenience provide a verson with signed char
+void MD5::update(const char input[], size_type length)
+{
+ update((const unsigned char*)input, length);
+}
+
+//////////////////////////////
+
+// MD5 finalization. Ends an MD5 message-digest operation, writing the
+// the message digest and zeroizing the context.
+MD5& MD5::finalize()
+{
+ static unsigned char padding[64] = {
+ 0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+ };
+
+ if (!finalized) {
+ // Save number of bits
+ unsigned char bits[8];
+ encode(bits, count, 8);
+
+ // pad out to 56 mod 64.
+ size_type index = count[0] / 8 % 64;
+ size_type padLen = (index < 56) ? (56 - index) : (120 - index);
+ update(padding, padLen);
+
+ // Append length (before padding)
+ update(bits, 8);
+
+ // Store state in digest
+ encode(digest, state, 16);
+
+ // Zeroize sensitive information.
+ memset(buffer, 0, sizeof buffer);
+ memset(count, 0, sizeof count);
+
+ finalized=true;
+ }
+
+ return *this;
+}
+
+//////////////////////////////
+
+// return hex representation of digest as string
+std::string MD5::hexdigest() const
+{
+ if (!finalized)
+ return "";
+
+ char buf[33];
+ for (int i=0; i<16; i++)
+ sprintf(buf+i*2, "%02x", digest[i]);
+ buf[32]=0;
+
+ return std::string(buf);
+}
+
+//////////////////////////////
+
+std::ostream& operator<<(std::ostream& out, MD5 md5)
+{
+ return out << md5.hexdigest();
+}
+
+//////////////////////////////
+
+std::string md5(const std::string & str)
+{
+ MD5 md5 = MD5(str);
+
+ return md5.hexdigest();
+}
diff --git a/source/md5/md5.h b/source/md5/md5.h new file mode 100644 index 000000000..140ad1f14 --- /dev/null +++ b/source/md5/md5.h @@ -0,0 +1,93 @@ +/* MD5
+ converted to C++ class by Frank Thilo (thilo@unix-ag.org)
+ for bzflag (http://www.bzflag.org)
+
+ based on:
+
+ md5.h and md5.c
+ reference implementation of RFC 1321
+
+ Copyright (C) 1991-2, RSA Data Security, Inc. Created 1991. All
+rights reserved.
+
+License to copy and use this software is granted provided that it
+is identified as the "RSA Data Security, Inc. MD5 Message-Digest
+Algorithm" in all material mentioning or referencing this software
+or this function.
+
+License is also granted to make and use derivative works provided
+that such works are identified as "derived from the RSA Data
+Security, Inc. MD5 Message-Digest Algorithm" in all material
+mentioning or referencing the derived work.
+
+RSA Data Security, Inc. makes no representations concerning either
+the merchantability of this software or the suitability of this
+software for any particular purpose. It is provided "as is"
+without express or implied warranty of any kind.
+
+These notices must be retained in any copies of any part of this
+documentation and/or software.
+
+*/
+
+#ifndef BZF_MD5_H
+#define BZF_MD5_H
+
+#include <string>
+#include <iostream>
+
+
+// a small class for calculating MD5 hashes of strings or byte arrays
+// it is not meant to be fast or secure
+//
+// usage: 1) feed it blocks of uchars with update()
+// 2) finalize()
+// 3) get hexdigest() string
+// or
+// MD5(std::string).hexdigest()
+//
+// assumes that char is 8 bit and int is 32 bit
+class MD5
+{
+public:
+ typedef unsigned int size_type; // must be 32bit
+
+ MD5();
+ MD5(const std::string& text);
+ void update(const unsigned char *buf, size_type length);
+ void update(const char *buf, size_type length);
+ MD5& finalize();
+ std::string hexdigest() const;
+ friend std::ostream& operator<<(std::ostream&, MD5 md5);
+
+private:
+ void init();
+ typedef unsigned char uint1; // 8bit
+ typedef unsigned int uint4; // 32bit
+ enum {blocksize = 64}; // VC6 won't eat a const static int here
+
+ void transform(const uint1 block[blocksize]);
+ static void decode(uint4 output[], const uint1 input[], size_type len);
+ static void encode(uint1 output[], const uint4 input[], size_type len);
+
+ bool finalized;
+ uint1 buffer[blocksize]; // bytes that didn't fit in last 64 byte chunk
+ uint4 count[2]; // 64bit counter for number of bits (lo, hi)
+ uint4 state[4]; // digest so far
+ uint1 digest[16]; // the result
+
+ // low level logic operations
+ static inline uint4 F(uint4 x, uint4 y, uint4 z);
+ static inline uint4 G(uint4 x, uint4 y, uint4 z);
+ static inline uint4 H(uint4 x, uint4 y, uint4 z);
+ static inline uint4 I(uint4 x, uint4 y, uint4 z);
+ static inline uint4 rotate_left(uint4 x, int n);
+ static inline void FF(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
+ static inline void GG(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
+ static inline void HH(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
+ static inline void II(uint4 &a, uint4 b, uint4 c, uint4 d, uint4 x, uint4 s, uint4 ac);
+};
+
+std::string md5(const std::string & str);
+
+#endif
\ No newline at end of file diff --git a/source/packets/cPacket.cpp b/source/packets/cPacket.cpp new file mode 100644 index 000000000..e49c3e016 --- /dev/null +++ b/source/packets/cPacket.cpp @@ -0,0 +1,223 @@ +#include "cPacket.h"
+#include "cMCLogger.h"
+#include "Endianness.h"
+
+#ifdef _WIN32
+#define MSG_NOSIGNAL (0)
+#endif
+
+#ifdef __MAC_NA
+#define MSG_NOSIGNAL (0)
+#endif
+
+//*****************************************************************************
+// Blocking receive all function
+//*****************************************************************************
+int cPacket::RecvAll( SOCKET a_Socket, char* a_Data, unsigned int a_Size, int a_Options )
+{
+ unsigned int RequestSize = a_Size;
+ while(a_Size != 0)
+ {
+ int Num = recv(a_Socket, a_Data, a_Size, a_Options);
+ if( cSocket::IsSocketError( Num ) )
+ return Num;
+ a_Size -= Num;
+ a_Data += Num;
+ }
+ return RequestSize - a_Size;
+}
+
+//*****************************************************************************
+// Own implementation of send()
+//*****************************************************************************
+int cPacket::SendData( SOCKET a_Socket, const char* a_Message, unsigned int a_Size, int a_Options )
+{
+ return send(a_Socket, a_Message, a_Size, a_Options | MSG_NOSIGNAL );
+}
+
+
+//*****************************************************************************
+// New packets
+//*****************************************************************************
+
+bool cPacket::ReadString( std::string & a_OutString )
+{
+ short StrLen;
+ if(!ReadShort( StrLen )) return false;
+
+ if( StrLen == 0 )
+ {
+ a_OutString.clear();
+ return true;
+ }
+
+ char* cString = new char[StrLen];
+ if( cSocket::IsSocketError( RecvAll( m_Socket, cString, StrLen, 0 ) ) ) return false;
+
+ a_OutString.assign( cString, StrLen );
+
+ //printf("Discoved string: %s size: %i\n", a_OutString.c_str(), a_OutString.size() );
+ delete [] cString;
+ return true;
+}
+
+bool cPacket::ReadString16( std::string & a_OutString )
+{
+ short StrLen;
+ if(!ReadShort( StrLen )) return false;
+
+ a_OutString.clear();
+ if( StrLen == 0 )
+ {
+ return true;
+ }
+
+ char* UTF16 = new char[StrLen*sizeof( short )];
+ if( cSocket::IsSocketError( RecvAll( m_Socket, UTF16, StrLen * sizeof( short ), 0 ) ) ) return false;
+
+ for( int i = 0; i < StrLen; ++i )
+ a_OutString.push_back( (char)UTF16[i*sizeof( short )+1] );
+
+ //printf("Discoved string: %s size: %i\n", a_OutString.c_str(), a_OutString.size() );
+ delete [] UTF16;
+ return true;
+}
+
+bool cPacket::ReadShort( short & a_OutShort )
+{
+ if( cSocket::IsSocketError( RecvAll( m_Socket, (char*)&a_OutShort, sizeof(short), 0 ) ) ) return false;
+ a_OutShort = ntohs(a_OutShort);
+ return true;
+}
+
+bool cPacket::ReadInteger( int & a_OutInteger )
+{
+ if( cSocket::IsSocketError( RecvAll( m_Socket, (char*)&a_OutInteger, sizeof(int), 0 ) ) ) return false;
+ a_OutInteger = ntohl(a_OutInteger);
+ return true;
+}
+
+bool cPacket::ReadInteger( unsigned int & a_OutInteger )
+{
+ if( cSocket::IsSocketError( RecvAll( m_Socket, (char*)&a_OutInteger, sizeof(unsigned int), 0 ) ) ) return false;
+ a_OutInteger = ntohl(a_OutInteger);
+ return true;
+}
+
+bool cPacket::ReadFloat( float & a_OutFloat )
+{
+ if( cSocket::IsSocketError( RecvAll( m_Socket, (char*)&a_OutFloat, sizeof(float), 0 ) ) ) return false;
+ a_OutFloat = NetworkToHostFloat4( &a_OutFloat );
+ return true;
+}
+
+bool cPacket::ReadDouble( double & a_OutDouble )
+{
+ if( cSocket::IsSocketError( RecvAll( m_Socket, (char*)&a_OutDouble, sizeof(double), 0 ) ) ) return false;
+ a_OutDouble = NetworkToHostDouble8( &a_OutDouble );
+ return true;
+}
+
+bool cPacket::ReadByte( char & a_OutByte )
+{
+ return !cSocket::IsSocketError( RecvAll( m_Socket, (char*)&a_OutByte, sizeof(char), 0 ) );
+}
+
+bool cPacket::ReadByte( unsigned char & a_OutByte )
+{
+ return !cSocket::IsSocketError(RecvAll( m_Socket, (char*)&a_OutByte, sizeof(char), 0 ) );
+}
+
+bool cPacket::ReadLong( long long & a_OutLong )
+{
+ if( cSocket::IsSocketError( RecvAll( m_Socket, (char*)&a_OutLong, sizeof(long long), 0 ) ) ) return false;
+ a_OutLong = NetworkToHostLong8( &a_OutLong );
+ return true;
+}
+
+bool cPacket::ReadBool( bool & a_OutBool )
+{
+ if( cSocket::IsSocketError(RecvAll( m_Socket, (char*)&a_OutBool, sizeof(bool), 0 ) ) ) return false;
+ return true;
+}
+
+//*****************************************************************************
+// Append variables to a c-String
+//*****************************************************************************
+void cPacket::AppendString( std::string & a_String, char* a_Dst, unsigned int & a_Iterator )
+{
+ AppendShort( (unsigned short)a_String.size(), a_Dst, a_Iterator );
+ memcpy( a_Dst + a_Iterator, a_String.c_str(), a_String.size() ); a_Iterator += a_String.size();
+}
+
+void cPacket::AppendString16( std::string & a_String, char* a_Dst, unsigned int & a_Iterator )
+{
+ AppendShort( (unsigned short)a_String.size(), a_Dst, a_Iterator );
+ char* UTF16 = new char[ a_String.size() * sizeof( short ) ];
+ for( unsigned int i = 0; i < a_String.size(); ++i )
+ {
+ UTF16[i*sizeof( short )] = 0x00;//a_String[i];
+ UTF16[i*sizeof( short )+1] = a_String[i];
+ }
+ memcpy( a_Dst + a_Iterator, UTF16, a_String.size() * sizeof( short ) ); a_Iterator += a_String.size() * sizeof( short );
+ delete [] UTF16;
+}
+
+void cPacket::AppendShort( short a_Short, char *a_Dst, unsigned int &a_Iterator )
+{
+ short ConvertedShort = htons( a_Short );
+ memcpy( a_Dst + a_Iterator, &ConvertedShort, sizeof( short ) ); a_Iterator+=sizeof( short );
+}
+
+void cPacket::AppendShort( unsigned short a_Short, char *a_Dst, unsigned int &a_Iterator )
+{
+ short ConvertedShort = htons( a_Short );
+ memcpy( a_Dst + a_Iterator, &ConvertedShort, sizeof( unsigned short ) ); a_Iterator+=sizeof( unsigned short );
+}
+
+
+void cPacket::AppendInteger( int a_Integer, char* a_Dst, unsigned int & a_Iterator )
+{
+ int ConvertedInt = htonl( a_Integer );
+ memcpy( a_Dst + a_Iterator, &ConvertedInt, sizeof( int ) ); a_Iterator+=sizeof( int );
+}
+
+void cPacket::AppendInteger( unsigned int a_Integer, char* a_Dst, unsigned int & a_Iterator )
+{
+ unsigned int ConvertedInt = htonl( a_Integer );
+ memcpy( a_Dst + a_Iterator, &ConvertedInt, sizeof( unsigned int ) ); a_Iterator+=sizeof( unsigned int );
+}
+
+void cPacket::AppendFloat( float a_Float, char* a_Dst, unsigned int & a_Iterator )
+{
+ unsigned int ConvertedFloat = HostToNetwork4(&a_Float);
+ memcpy( a_Dst + a_Iterator, &ConvertedFloat, sizeof(float) ); a_Iterator += sizeof(float);
+}
+
+void cPacket::AppendDouble( double & a_Double, char* a_Dst, unsigned int & a_Iterator )
+{
+ unsigned long long ConvertedDouble = HostToNetwork8(&a_Double);
+ memcpy( a_Dst + a_Iterator, &ConvertedDouble, sizeof(double) ); a_Iterator += sizeof(double);
+}
+
+void cPacket::AppendByte( char a_Byte, char* a_Dst, unsigned int & a_Iterator )
+{
+ a_Dst[a_Iterator] = a_Byte; a_Iterator+=sizeof(char);
+}
+
+void cPacket::AppendLong( long long & a_Long, char* a_Dst, unsigned int & a_Iterator )
+{
+ unsigned long long ConvertedLong = HostToNetwork8(&a_Long);
+ memcpy( a_Dst + a_Iterator, &ConvertedLong, sizeof(long long) );
+ a_Iterator += sizeof( long long );
+}
+
+void cPacket::AppendBool( bool a_Bool, char* a_Dst, unsigned int & a_Iterator )
+{
+ a_Dst[a_Iterator] = (char)a_Bool; a_Iterator+=sizeof(bool);
+}
+
+void cPacket::AppendData( char* a_Data, unsigned int a_Size, char* a_Dst, unsigned int & a_Iterator )
+{
+ memcpy( a_Dst + a_Iterator, a_Data, a_Size ); a_Iterator += a_Size;
+}
diff --git a/source/packets/cPacket.h b/source/packets/cPacket.h new file mode 100644 index 000000000..3cab5f222 --- /dev/null +++ b/source/packets/cPacket.h @@ -0,0 +1,56 @@ +#pragma once
+
+#include "cSocket.h"
+#ifdef _WIN32
+#include <xstring>
+#else
+#include <cstring> // Silly Linux doesn't have xstring...
+#include <string>
+#include <cstdio>
+#endif
+
+class cSocket;
+class cPacket
+{
+public:
+ cPacket()
+ : m_PacketID( 0 )
+ {}
+ virtual ~cPacket() {}
+
+ virtual bool Parse( cSocket & a_Socket) { a_Socket=0; printf("ERROR: Undefined NEW Parse function %x\n", m_PacketID ); return false; }
+ virtual bool Send( cSocket & a_Socket) { a_Socket=0; printf("ERROR: Undefined NEW Send function %x\n", m_PacketID ); return false; }
+ virtual cPacket* Clone() const = 0;
+
+ unsigned char m_PacketID;
+ cSocket m_Socket; // Current socket being used
+protected:
+ bool ReadString ( std::string & a_OutString );
+ bool ReadString16( std::string & a_OutString );
+ bool ReadShort ( short & a_Short );
+ bool ReadInteger(int & a_OutInteger );
+ bool ReadInteger(unsigned int & a_OutInteger );
+ bool ReadFloat ( float & a_OutFloat );
+ bool ReadDouble ( double & a_OutDouble );
+ bool ReadByte ( char & a_OutByte );
+ bool ReadByte ( unsigned char & a_OutByte );
+ bool ReadLong ( long long & a_OutLong );
+ bool ReadBool ( bool & a_OutBool );
+
+ void AppendString ( std::string & a_String, char* a_Dst, unsigned int & a_Iterator );
+ void AppendString16 ( std::string & a_String, char* a_Dst, unsigned int & a_Iterator );
+ void AppendShort ( short a_Short, char* a_Dst, unsigned int & a_Iterator );
+ void AppendShort ( unsigned short a_Short, char* a_Dst, unsigned int & a_Iterator );
+ void AppendInteger ( int a_Integer, char* a_Dst, unsigned int & a_Iterator );
+ void AppendInteger ( unsigned int a_Integer, char* a_Dst, unsigned int & a_Iterator );
+ void AppendFloat ( float a_Float, char* a_Dst, unsigned int & a_Iterator );
+ void AppendDouble ( double & a_Double, char* a_Dst, unsigned int & a_Iterator );
+ void AppendByte ( char a_Byte, char* a_Dst, unsigned int & a_Iterator );
+ void AppendLong ( long long & a_Long, char* a_Dst, unsigned int & a_Iterator );
+ void AppendBool ( bool a_Bool, char* a_Dst, unsigned int & a_Iterator );
+ void AppendData ( char* a_Data, unsigned int a_Size, char* a_Dst, unsigned int & a_Iterator );
+
+public:
+ static int SendData( SOCKET a_Socket, const char* a_Message, unsigned int a_Size, int a_Options );
+ static int RecvAll( SOCKET a_Socket, char* a_Data, unsigned int a_Size, int a_Options );
+};
diff --git a/source/packets/cPacket_13.cpp b/source/packets/cPacket_13.cpp new file mode 100644 index 000000000..5e649fbd9 --- /dev/null +++ b/source/packets/cPacket_13.cpp @@ -0,0 +1,10 @@ +#include "cPacket_13.h"
+
+bool cPacket_13::Parse(cSocket & a_Socket)
+{
+ m_Socket = a_Socket;
+
+ if( !ReadInteger( m_EntityID ) ) return false;
+ if( !ReadByte ( m_ActionID ) ) return false;
+ return true;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_13.h b/source/packets/cPacket_13.h new file mode 100644 index 000000000..ec9aedc3c --- /dev/null +++ b/source/packets/cPacket_13.h @@ -0,0 +1,30 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_13 : public cPacket
+{
+public:
+ enum ENUM_ACTION
+ {
+ ACTION_CROUCH = 1,
+ ACTION_UNCROUCH = 2,
+ ACTION_LEAVEBED = 3,
+ ACTION_STARTSPRINTING = 4,
+ ACTION_STOPSPRINTING = 5,
+ };
+
+ cPacket_13()
+ : m_EntityID( 0 )
+ , m_ActionID( 0 )
+ { m_PacketID = E_PACKET_13; }
+ virtual cPacket* Clone() const { return new cPacket_13( *this ); }
+
+ bool Parse(cSocket & a_Socket);
+
+ int m_EntityID;
+ char m_ActionID;
+
+ static const unsigned int c_Size = 1;
+};
\ No newline at end of file diff --git a/source/packets/cPacket_AddToInventory.cpp b/source/packets/cPacket_AddToInventory.cpp new file mode 100644 index 000000000..5d3274229 --- /dev/null +++ b/source/packets/cPacket_AddToInventory.cpp @@ -0,0 +1,17 @@ +#include "cPacket_AddToInventory.h"
+
+bool cPacket_AddToInventory::Send( cSocket & a_Socket )
+{
+ unsigned int TotalSize = c_Size;
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendShort ( m_ItemType, Message, i );
+ AppendByte ( m_Count, Message, i );
+ AppendShort ( m_Life, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_AddToInventory.h b/source/packets/cPacket_AddToInventory.h new file mode 100644 index 000000000..8029a53d0 --- /dev/null +++ b/source/packets/cPacket_AddToInventory.h @@ -0,0 +1,23 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_AddToInventory : public cPacket
+{
+public:
+ cPacket_AddToInventory()
+ : m_ItemType( 0 )
+ , m_Count( 0 )
+ , m_Life( 0 )
+ { m_PacketID = E_ADD_TO_INV; }
+ virtual cPacket* Clone() const { return new cPacket_AddToInventory(*this); }
+
+ bool Parse( cSocket & a_Socket );
+ bool Send( cSocket & a_Socket );
+
+ short m_ItemType;
+ char m_Count;
+ short m_Life;
+ static const unsigned int c_Size = 1 + 2 + 1 + 2;
+};
\ No newline at end of file diff --git a/source/packets/cPacket_ArmAnim.cpp b/source/packets/cPacket_ArmAnim.cpp new file mode 100644 index 000000000..f0a662f27 --- /dev/null +++ b/source/packets/cPacket_ArmAnim.cpp @@ -0,0 +1,24 @@ +#include "cPacket_ArmAnim.h"
+
+bool cPacket_ArmAnim::Parse( cSocket & a_Socket )
+{
+ m_Socket = a_Socket;
+ if(!ReadInteger(m_EntityID) ) return false;
+ if(!ReadByte(m_Animation) ) return false;
+ return true;
+}
+
+bool cPacket_ArmAnim::Send( cSocket & a_Socket )
+{
+ unsigned int TotalSize = c_Size;
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendInteger( m_EntityID, Message, i );
+ AppendByte ( m_Animation, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_ArmAnim.h b/source/packets/cPacket_ArmAnim.h new file mode 100644 index 000000000..e22d88506 --- /dev/null +++ b/source/packets/cPacket_ArmAnim.h @@ -0,0 +1,21 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_ArmAnim : public cPacket
+{
+public:
+ cPacket_ArmAnim()
+ : m_EntityID( 0 )
+ , m_Animation( 0 )
+ { m_PacketID = E_ANIMATION; }
+ virtual cPacket* Clone() const { return new cPacket_ArmAnim(*this); }
+
+ bool Parse(cSocket & a_Socket);
+ bool Send(cSocket & a_Socket);
+
+ int m_EntityID;
+ char m_Animation;
+ static const unsigned int c_Size = 1 + 4 + 1;
+};
\ No newline at end of file diff --git a/source/packets/cPacket_BlockChange.cpp b/source/packets/cPacket_BlockChange.cpp new file mode 100644 index 000000000..44b389a14 --- /dev/null +++ b/source/packets/cPacket_BlockChange.cpp @@ -0,0 +1,19 @@ +#include "cPacket_BlockChange.h"
+
+bool cPacket_BlockChange::Send(cSocket & a_Socket)
+{
+ unsigned int TotalSize = c_Size;
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendInteger( m_PosX, Message, i );
+ AppendByte ( m_PosY, Message, i );
+ AppendInteger( m_PosZ, Message, i );
+ AppendByte ( m_BlockType, Message, i );
+ AppendByte ( m_BlockMeta, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_BlockChange.h b/source/packets/cPacket_BlockChange.h new file mode 100644 index 000000000..0cd6cfb6f --- /dev/null +++ b/source/packets/cPacket_BlockChange.h @@ -0,0 +1,26 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_BlockChange : public cPacket
+{
+public:
+ cPacket_BlockChange()
+ : m_PosX( 0 )
+ , m_PosY( 0 )
+ , m_PosZ( 0 )
+ , m_BlockType( 0 )
+ , m_BlockMeta( 0 )
+ { m_PacketID = E_BLOCK_CHANGE; }
+ virtual cPacket* Clone() const { return new cPacket_BlockChange(*this); }
+
+ bool Send(cSocket & a_Socket);
+
+ int m_PosX;
+ char m_PosY;
+ int m_PosZ;
+ char m_BlockType;
+ char m_BlockMeta;
+ static const unsigned int c_Size = 1 + 4 + 1 + 4 + 1 + 1;
+};
\ No newline at end of file diff --git a/source/packets/cPacket_BlockDig.cpp b/source/packets/cPacket_BlockDig.cpp new file mode 100644 index 000000000..c6092f9cd --- /dev/null +++ b/source/packets/cPacket_BlockDig.cpp @@ -0,0 +1,29 @@ +#include "cPacket_BlockDig.h"
+
+bool cPacket_BlockDig::Send(cSocket & a_Socket)
+{
+ unsigned int TotalSize = c_Size;
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendInteger( m_PosX, Message, i );
+ AppendByte ( m_PosY, Message, i );
+ AppendInteger( m_PosZ, Message, i );
+ AppendByte ( m_Direction, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
+
+bool cPacket_BlockDig::Parse(cSocket & a_Socket)
+{
+ m_Socket = a_Socket;
+ if( !ReadByte ( m_Status ) ) return false;
+ if( !ReadInteger( m_PosX ) ) return false;
+ if( !ReadByte ( m_PosY ) ) return false;
+ if( !ReadInteger( m_PosZ ) ) return false;
+ if( !ReadByte ( m_Direction ) ) return false;
+ return true;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_BlockDig.h b/source/packets/cPacket_BlockDig.h new file mode 100644 index 000000000..7ea847aa1 --- /dev/null +++ b/source/packets/cPacket_BlockDig.h @@ -0,0 +1,27 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_BlockDig : public cPacket //tolua_export
+{ //tolua_export
+public:
+ cPacket_BlockDig() //tolua_export
+ : m_Status( 0 )
+ , m_PosX( 0 )
+ , m_PosY( 0 )
+ , m_PosZ( 0 )
+ , m_Direction( 0 )
+ { m_PacketID = E_BLOCK_DIG; } //tolua_export
+ virtual cPacket* Clone() const { return new cPacket_BlockDig(*this); } //tolua_export
+
+ bool Parse(cSocket & a_Socket);
+ bool Send(cSocket & a_Socket);
+
+ char m_Status; //tolua_export
+ int m_PosX; //tolua_export
+ char m_PosY; //tolua_export
+ int m_PosZ; //tolua_export
+ char m_Direction; //tolua_export
+ static const unsigned int c_Size = 12;
+}; //tolua_export
\ No newline at end of file diff --git a/source/packets/cPacket_BlockPlace.cpp b/source/packets/cPacket_BlockPlace.cpp new file mode 100644 index 000000000..08bc1c40c --- /dev/null +++ b/source/packets/cPacket_BlockPlace.cpp @@ -0,0 +1,18 @@ +#include "cPacket_BlockPlace.h"
+
+bool cPacket_BlockPlace::Parse(cSocket & a_Socket)
+{
+ m_Socket = a_Socket;
+ if( !ReadInteger( m_PosX ) ) return false;
+ if( !ReadByte ( m_PosY ) ) return false;
+ if( !ReadInteger( m_PosZ ) ) return false;
+ if( !ReadByte ( m_Direction ) ) return false;
+
+ if( !ReadShort ( m_ItemType ) ) return false;
+ if( m_ItemType > -1 )
+ {
+ if( !ReadByte ( m_Count ) ) return false;
+ if( !ReadShort ( m_Uses ) ) return false;
+ }
+ return true;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_BlockPlace.h b/source/packets/cPacket_BlockPlace.h new file mode 100644 index 000000000..c7f72bacf --- /dev/null +++ b/source/packets/cPacket_BlockPlace.h @@ -0,0 +1,32 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_BlockPlace : public cPacket //tolua_export
+{ //tolua_export
+public:
+ cPacket_BlockPlace()
+ : m_PosX( 0 )
+ , m_PosY( 0 )
+ , m_PosZ( 0 )
+ , m_Direction( 0 )
+ , m_ItemType( 0 )
+ , m_Count( 0 )
+ , m_Uses( 0 )
+ { m_PacketID = E_BLOCK_PLACE; }
+ virtual cPacket* Clone() const { return new cPacket_BlockPlace(*this); }
+
+ bool Parse(cSocket & a_Socket);
+
+ int m_PosX; //tolua_export
+ char m_PosY; //tolua_export
+ int m_PosZ; //tolua_export
+ char m_Direction; //tolua_export
+
+ short m_ItemType; //tolua_export
+ char m_Count; //tolua_export
+ short m_Uses; //tolua_export
+
+ static const unsigned int c_Size = 1 + 4 + 1 + 4 + 1 + 2;// ( + 2 )
+}; //tolua_export
\ No newline at end of file diff --git a/source/packets/cPacket_Chat.cpp b/source/packets/cPacket_Chat.cpp new file mode 100644 index 000000000..d948c5deb --- /dev/null +++ b/source/packets/cPacket_Chat.cpp @@ -0,0 +1,23 @@ +#include "cPacket_Chat.h"
+
+
+bool cPacket_Chat::Parse( cSocket & a_Socket )
+{
+ m_Socket = a_Socket;
+ if( !ReadString16( m_Message ) ) return false;
+ return true;
+}
+
+bool cPacket_Chat::Send( cSocket & a_Socket )
+{
+ unsigned int TotalSize = c_Size + m_Message.size() * sizeof( short );
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendString16 ( m_Message, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_Chat.h b/source/packets/cPacket_Chat.h new file mode 100644 index 000000000..0de5c9343 --- /dev/null +++ b/source/packets/cPacket_Chat.h @@ -0,0 +1,18 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_Chat : public cPacket
+{
+public:
+ cPacket_Chat() { m_PacketID = E_CHAT; }
+ cPacket_Chat( const std::string & a_Message ) : m_Message( a_Message) { m_PacketID = E_CHAT; }
+ virtual cPacket* Clone() const { return new cPacket_Chat(*this); }
+
+ bool Parse(cSocket & a_Socket);
+ bool Send(cSocket & a_Socket);
+
+ std::string m_Message;
+ static const unsigned int c_Size = 3; // Minimum size
+};
\ No newline at end of file diff --git a/source/packets/cPacket_CollectItem.cpp b/source/packets/cPacket_CollectItem.cpp new file mode 100644 index 000000000..0ad92ddad --- /dev/null +++ b/source/packets/cPacket_CollectItem.cpp @@ -0,0 +1,16 @@ +#include "cPacket_CollectItem.h"
+
+bool cPacket_CollectItem::Send( cSocket & a_Socket )
+{
+ unsigned int TotalSize = c_Size;
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendInteger( m_CollectedID, Message, i );
+ AppendInteger( m_CollectorID, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_CollectItem.h b/source/packets/cPacket_CollectItem.h new file mode 100644 index 000000000..5f11500b5 --- /dev/null +++ b/source/packets/cPacket_CollectItem.h @@ -0,0 +1,20 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_CollectItem : public cPacket
+{
+public:
+ cPacket_CollectItem()
+ : m_CollectedID( 0 )
+ , m_CollectorID( 0 )
+ { m_PacketID = E_COLLECT_ITEM; }
+ virtual cPacket* Clone() const { return new cPacket_CollectItem(*this); }
+
+ bool Send( cSocket & a_Socket );
+
+ int m_CollectedID;
+ int m_CollectorID;
+ static const unsigned int c_Size = 1 + 4 + 4;
+};
\ No newline at end of file diff --git a/source/packets/cPacket_DestroyEntity.cpp b/source/packets/cPacket_DestroyEntity.cpp new file mode 100644 index 000000000..e0ee22c76 --- /dev/null +++ b/source/packets/cPacket_DestroyEntity.cpp @@ -0,0 +1,23 @@ +#include "cPacket_DestroyEntity.h"
+#include "cEntity.h"
+
+cPacket_DestroyEntity::cPacket_DestroyEntity(cEntity* a_Entity)
+{
+ m_PacketID = E_DESTROY_ENT;
+
+ m_UniqueID = a_Entity->GetUniqueID();
+}
+
+bool cPacket_DestroyEntity::Send( cSocket & a_Socket )
+{
+ unsigned int TotalSize = c_Size;
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendInteger( m_UniqueID, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
diff --git a/source/packets/cPacket_DestroyEntity.h b/source/packets/cPacket_DestroyEntity.h new file mode 100644 index 000000000..0b852e727 --- /dev/null +++ b/source/packets/cPacket_DestroyEntity.h @@ -0,0 +1,20 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cEntity;
+class cPacket_DestroyEntity : public cPacket
+{
+public:
+ cPacket_DestroyEntity()
+ : m_UniqueID( 0 )
+ { m_PacketID = E_DESTROY_ENT; }
+ cPacket_DestroyEntity(cEntity* a_Entity);
+ virtual cPacket* Clone() const { return new cPacket_DestroyEntity(*this); }
+
+ bool Send( cSocket & a_Socket );
+
+ int m_UniqueID;
+ static const unsigned int c_Size = 1 + 4;
+};
diff --git a/source/packets/cPacket_Disconnect.cpp b/source/packets/cPacket_Disconnect.cpp new file mode 100644 index 000000000..c2a0e3be6 --- /dev/null +++ b/source/packets/cPacket_Disconnect.cpp @@ -0,0 +1,22 @@ +#include "cPacket_Disconnect.h"
+
+bool cPacket_Disconnect::Parse( cSocket & a_Socket )
+{
+ m_Socket = a_Socket;
+ if( !ReadString16(m_Reason) ) return false;
+ return true;
+}
+
+bool cPacket_Disconnect::Send( cSocket & a_Socket )
+{
+ unsigned int TotalSize = c_Size + m_Reason.size()*sizeof(short);
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendString16 ( m_Reason, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
diff --git a/source/packets/cPacket_Disconnect.h b/source/packets/cPacket_Disconnect.h new file mode 100644 index 000000000..0711851f4 --- /dev/null +++ b/source/packets/cPacket_Disconnect.h @@ -0,0 +1,18 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_Disconnect : public cPacket
+{
+public:
+ cPacket_Disconnect() { m_PacketID = E_DISCONNECT; }
+ cPacket_Disconnect(const std::string & a_Reason) { m_PacketID = E_DISCONNECT; m_Reason = a_Reason; }
+ virtual cPacket* Clone() const { return new cPacket_Disconnect(*this); }
+
+ bool Parse( cSocket & a_Socket );
+ bool Send( cSocket & a_Socket );
+
+ std::string m_Reason;
+ static const unsigned int c_Size = 3; // Minimum size
+};
\ No newline at end of file diff --git a/source/packets/cPacket_EntityEquipment.cpp b/source/packets/cPacket_EntityEquipment.cpp new file mode 100644 index 000000000..afd2e7678 --- /dev/null +++ b/source/packets/cPacket_EntityEquipment.cpp @@ -0,0 +1,42 @@ +#include "cPacket_EntityEquipment.h"
+
+cPacket_EntityEquipment::cPacket_EntityEquipment( const cPacket_EntityEquipment & a_Copy )
+{
+ m_PacketID = E_ENTITY_EQUIPMENT;
+ m_UniqueID = a_Copy.m_UniqueID;
+ m_Slot = a_Copy.m_Slot;
+ m_ItemID = a_Copy.m_ItemID;
+ m_Short = 0;
+}
+
+bool cPacket_EntityEquipment::Parse(cSocket & a_Socket)
+{
+ m_Socket = a_Socket;
+ if( !ReadInteger( m_UniqueID ) ) return false;
+ if( !ReadShort ( m_Slot ) ) return false;
+ if( !ReadShort ( m_ItemID ) ) return false;
+ if( !ReadShort ( m_Short ) ) return false;
+ return true;
+}
+
+bool cPacket_EntityEquipment::Send(cSocket & a_Socket)
+{
+ //LOG("InventoryChange:");
+ unsigned int TotalSize = c_Size;
+ char* Message = new char[TotalSize];
+
+ if( m_ItemID <= 0 ) m_ItemID = -1; // Fix, to make sure no invalid values are sent.
+ // WARNING: HERE ITS -1, BUT IN NAMED ENTITY SPAWN PACKET ITS 0 !!
+ //LOG("cPacket_EntityEquipment: Sending equipped item ID: %i", m_ItemID );
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendInteger( m_UniqueID, Message, i );
+ AppendShort ( m_Slot, Message, i );
+ AppendShort ( m_ItemID, Message, i );
+ AppendShort ( m_Short, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_EntityEquipment.h b/source/packets/cPacket_EntityEquipment.h new file mode 100644 index 000000000..253786140 --- /dev/null +++ b/source/packets/cPacket_EntityEquipment.h @@ -0,0 +1,27 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_EntityEquipment : public cPacket
+{
+public:
+ cPacket_EntityEquipment()
+ : m_UniqueID( 0 )
+ , m_Slot( 0 )
+ , m_ItemID( 0 )
+ , m_Short( 0 )
+ { m_PacketID = E_ENTITY_EQUIPMENT; m_Short = 0; }
+ cPacket_EntityEquipment( const cPacket_EntityEquipment & a_Copy );
+ virtual cPacket* Clone() const { return new cPacket_EntityEquipment(*this); }
+
+ bool Parse(cSocket & a_Socket);
+ bool Send(cSocket & a_Socket);
+
+ int m_UniqueID;
+ short m_Slot; // 0 = hold 1-4 = armor
+ short m_ItemID;
+ short m_Short;
+
+ static const unsigned int c_Size = 1 + 4 + 2 + 2 + 2;
+};
\ No newline at end of file diff --git a/source/packets/cPacket_EntityLook.cpp b/source/packets/cPacket_EntityLook.cpp new file mode 100644 index 000000000..7dcbf61c2 --- /dev/null +++ b/source/packets/cPacket_EntityLook.cpp @@ -0,0 +1,28 @@ +#include "cPacket_EntityLook.h"
+
+#include "cEntity.h"
+
+cPacket_EntityLook::cPacket_EntityLook(cEntity* a_Entity)
+{
+ m_PacketID = E_ENT_LOOK;
+
+ m_UniqueID = a_Entity->GetUniqueID();
+ m_Rotation = (char)((a_Entity->GetRotation()/360.f)*256);
+ m_Pitch = (char)((a_Entity->GetPitch()/360.f)*256);
+}
+
+bool cPacket_EntityLook::Send( cSocket & a_Socket )
+{
+ unsigned int TotalSize = c_Size;
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendInteger( m_UniqueID, Message, i );
+ AppendByte ( m_Rotation, Message, i );
+ AppendByte ( m_Pitch, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
diff --git a/source/packets/cPacket_EntityLook.h b/source/packets/cPacket_EntityLook.h new file mode 100644 index 000000000..215620f07 --- /dev/null +++ b/source/packets/cPacket_EntityLook.h @@ -0,0 +1,25 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cEntity;
+class cPacket_EntityLook : public cPacket
+{
+public:
+ cPacket_EntityLook()
+ : m_UniqueID( 0 )
+ , m_Rotation( 0 )
+ , m_Pitch( 0 )
+ { m_PacketID = E_ENT_LOOK; }
+ cPacket_EntityLook(cEntity* a_Entity);
+ virtual cPacket* Clone() const { return new cPacket_EntityLook(*this); }
+
+ bool Send( cSocket & a_Socket );
+
+ int m_UniqueID;
+ char m_Rotation;
+ char m_Pitch;
+
+ static const unsigned int c_Size = 1 + 4 + 1 + 1;
+};
diff --git a/source/packets/cPacket_EntityStatus.cpp b/source/packets/cPacket_EntityStatus.cpp new file mode 100644 index 000000000..41d94b6c2 --- /dev/null +++ b/source/packets/cPacket_EntityStatus.cpp @@ -0,0 +1,17 @@ +#include "cPacket_EntityStatus.h"
+
+bool cPacket_EntityStatus::Send(cSocket & a_Socket)
+{
+ unsigned int TotalSize = c_Size;
+
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendInteger ( m_UniqueID, Message, i );
+ AppendByte ( m_Status, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_EntityStatus.h b/source/packets/cPacket_EntityStatus.h new file mode 100644 index 000000000..2511e2935 --- /dev/null +++ b/source/packets/cPacket_EntityStatus.h @@ -0,0 +1,24 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_EntityStatus : public cPacket
+{
+public:
+ cPacket_EntityStatus()
+ : m_UniqueID( 0 )
+ , m_Status( 0 )
+ { m_PacketID = E_ENT_STATUS; }
+ virtual cPacket* Clone() const { return new cPacket_EntityStatus( *this ); }
+
+ bool Send(cSocket & a_Socket);
+
+ static const char STATUS_TAKEDAMAGE = 2;
+ static const char STATUS_DIE = 3;
+
+ int m_UniqueID;
+ char m_Status;
+
+ static const unsigned int c_Size = 1 + 4 + 1;
+};
diff --git a/source/packets/cPacket_Flying.cpp b/source/packets/cPacket_Flying.cpp new file mode 100644 index 000000000..b8cab1de1 --- /dev/null +++ b/source/packets/cPacket_Flying.cpp @@ -0,0 +1,8 @@ +#include "cPacket_Flying.h"
+
+bool cPacket_Flying::Parse(cSocket & a_Socket)
+{
+ m_Socket = a_Socket;
+ if( !ReadBool( m_bFlying ) ) return false;
+ return true;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_Flying.h b/source/packets/cPacket_Flying.h new file mode 100644 index 000000000..7e30ebd73 --- /dev/null +++ b/source/packets/cPacket_Flying.h @@ -0,0 +1,19 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_Flying : public cPacket
+{
+public:
+ // The BS packet
+ cPacket_Flying()
+ : m_bFlying( false )
+ { m_PacketID = E_FLYING; }
+ virtual cPacket* Clone() const { return new cPacket_Flying(*this); }
+
+ bool Parse(cSocket & a_Socket);
+
+ bool m_bFlying;
+ static const unsigned int c_Size = 2;
+};
diff --git a/source/packets/cPacket_Handshake.cpp b/source/packets/cPacket_Handshake.cpp new file mode 100644 index 000000000..2513ab33d --- /dev/null +++ b/source/packets/cPacket_Handshake.cpp @@ -0,0 +1,24 @@ +#include "cPacket_Handshake.h"
+
+bool cPacket_Handshake::Parse(cSocket & a_Socket)
+{
+ //printf("Parse: NEW Handshake\n");
+ m_Socket = a_Socket;
+ if( !ReadString16( m_Username ) ) return false;
+ return true;
+}
+
+bool cPacket_Handshake::Send(cSocket & a_Socket)
+{
+ //LOG("Send: NEW Handshake %s", m_Username.c_str() );
+ unsigned int TotalSize = c_Size + m_Username.size() * sizeof(short);
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendString16( m_Username, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( cPacket::SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_Handshake.h b/source/packets/cPacket_Handshake.h new file mode 100644 index 000000000..b14d829f4 --- /dev/null +++ b/source/packets/cPacket_Handshake.h @@ -0,0 +1,17 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_Handshake : public cPacket
+{
+public:
+ cPacket_Handshake() { m_PacketID = E_HANDSHAKE; }
+ virtual cPacket* Clone() const { return new cPacket_Handshake(*this); }
+
+ virtual bool Parse(cSocket & a_Socket);
+ virtual bool Send(cSocket & a_Socket);
+
+ std::string m_Username;
+ static const unsigned int c_Size = 3; // Minimal size
+};
\ No newline at end of file diff --git a/source/packets/cPacket_InventoryProgressBar.cpp b/source/packets/cPacket_InventoryProgressBar.cpp new file mode 100644 index 000000000..c8d7b0383 --- /dev/null +++ b/source/packets/cPacket_InventoryProgressBar.cpp @@ -0,0 +1,18 @@ +#include "cPacket_InventoryProgressBar.h"
+
+bool cPacket_InventoryProgressBar::Send(cSocket & a_Socket)
+{
+ unsigned int TotalSize = c_Size;
+
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendByte ( m_WindowID, Message, i );
+ AppendShort ( m_ProgressBar, Message, i );
+ AppendShort ( m_Value, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_InventoryProgressBar.h b/source/packets/cPacket_InventoryProgressBar.h new file mode 100644 index 000000000..c9b5e196e --- /dev/null +++ b/source/packets/cPacket_InventoryProgressBar.h @@ -0,0 +1,23 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_InventoryProgressBar : public cPacket
+{
+public:
+ cPacket_InventoryProgressBar()
+ : m_WindowID( 0 )
+ , m_ProgressBar( 0 )
+ , m_Value( 0 )
+ { m_PacketID = E_INVENTORY_PROGRESS; }
+ virtual cPacket* Clone() const { return new cPacket_InventoryProgressBar(*this); }
+
+ bool Send(cSocket & a_Socket);
+
+ char m_WindowID;
+ short m_ProgressBar;
+ short m_Value;
+
+ static const unsigned int c_Size = 1 + 1 + 2 + 2;
+};
\ No newline at end of file diff --git a/source/packets/cPacket_InventorySlot.cpp b/source/packets/cPacket_InventorySlot.cpp new file mode 100644 index 000000000..13b41b7b1 --- /dev/null +++ b/source/packets/cPacket_InventorySlot.cpp @@ -0,0 +1,23 @@ +#include "cPacket_InventorySlot.h"
+
+bool cPacket_InventorySlot::Send(cSocket & a_Socket)
+{
+ unsigned int TotalSize = c_Size;
+ if( m_ItemID > -1 ) TotalSize += 1 + 2;
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendByte ( m_WindowID, Message, i );
+ AppendShort ( m_SlotNum, Message, i );
+ AppendShort ( m_ItemID, Message, i );
+ if( m_ItemID > -1 )
+ {
+ AppendByte ( m_ItemCount, Message, i );
+ AppendShort ( m_ItemUses, Message, i );
+ }
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_InventorySlot.h b/source/packets/cPacket_InventorySlot.h new file mode 100644 index 000000000..95711c98d --- /dev/null +++ b/source/packets/cPacket_InventorySlot.h @@ -0,0 +1,34 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_InventorySlot : public cPacket // Set item [S -> C] ?
+{
+public:
+ cPacket_InventorySlot()
+ : m_WindowID( 0 )
+ , m_SlotNum( 0 )
+ , m_ItemID( 0 )
+ , m_ItemCount( 0 )
+ , m_ItemUses( 0 )
+ { m_PacketID = E_INVENTORY_SLOT; }
+ virtual cPacket* Clone() const { return new cPacket_InventorySlot(*this); }
+
+ bool Send(cSocket & a_Socket);
+
+ char m_WindowID;
+ short m_SlotNum; // Slot
+ // 0 = craft result
+ // 1-4 = crafting table
+ // 5-8 = armor
+ // 9-35 = inventory
+ // 36-44 = Hot bar
+
+ // Below = item
+ short m_ItemID; // if this is -1 the next stuff dont exist
+ char m_ItemCount;
+ short m_ItemUses;
+
+ static const unsigned int c_Size = 1 + 1 + 2 + 2; // Minimal size ( +1+1 = max)
+};
\ No newline at end of file diff --git a/source/packets/cPacket_ItemSwitch.cpp b/source/packets/cPacket_ItemSwitch.cpp new file mode 100644 index 000000000..39c61833e --- /dev/null +++ b/source/packets/cPacket_ItemSwitch.cpp @@ -0,0 +1,23 @@ +#include "cPacket_ItemSwitch.h"
+
+bool cPacket_ItemSwitch::Parse( cSocket & a_Socket )
+{
+ m_Socket = a_Socket;
+
+ if( !ReadShort ( m_SlotNum ) ) return false;
+ return true;
+}
+
+bool cPacket_ItemSwitch::Send( cSocket & a_Socket )
+{
+ unsigned int TotalSize = c_Size;
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendShort ( m_SlotNum, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_ItemSwitch.h b/source/packets/cPacket_ItemSwitch.h new file mode 100644 index 000000000..8fee397c7 --- /dev/null +++ b/source/packets/cPacket_ItemSwitch.h @@ -0,0 +1,19 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_ItemSwitch : public cPacket
+{
+public:
+ cPacket_ItemSwitch()
+ : m_SlotNum( 0 )
+ { m_PacketID = E_ITEM_SWITCH; }
+ virtual cPacket* Clone() const { return new cPacket_ItemSwitch(*this); }
+
+ bool Parse(cSocket & a_Socket);
+ bool Send(cSocket & a_Socket);
+
+ short m_SlotNum;
+ static const unsigned int c_Size = 1 + 2;
+};
\ No newline at end of file diff --git a/source/packets/cPacket_KeepAlive.cpp b/source/packets/cPacket_KeepAlive.cpp new file mode 100644 index 000000000..8dcd9092f --- /dev/null +++ b/source/packets/cPacket_KeepAlive.cpp @@ -0,0 +1,22 @@ +#include "cPacket_KeepAlive.h"
+
+bool cPacket_KeepAlive::Send(cSocket & a_Socket)
+{
+ unsigned int TotalSize = c_Size;
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendInteger( m_KeepAliveID, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
+
+bool cPacket_KeepAlive::Parse(cSocket & a_Socket)
+{
+ m_Socket = a_Socket;
+ if( !ReadInteger( m_KeepAliveID ) ) return false;
+ return true;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_KeepAlive.h b/source/packets/cPacket_KeepAlive.h new file mode 100644 index 000000000..833947bfb --- /dev/null +++ b/source/packets/cPacket_KeepAlive.h @@ -0,0 +1,18 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_KeepAlive : public cPacket
+{
+public:
+ cPacket_KeepAlive() { m_PacketID = E_KEEP_ALIVE; }
+ virtual cPacket* Clone() const { return new cPacket_KeepAlive(*this); }
+
+ virtual bool Parse(cSocket & a_Socket);
+ virtual bool Send(cSocket & a_Socket);
+
+ int m_KeepAliveID;
+
+ static const unsigned int c_Size = 1 + 4;
+};
\ No newline at end of file diff --git a/source/packets/cPacket_Login.cpp b/source/packets/cPacket_Login.cpp new file mode 100644 index 000000000..f0a9aaf30 --- /dev/null +++ b/source/packets/cPacket_Login.cpp @@ -0,0 +1,41 @@ +#include "cPacket_Login.h"
+
+bool cPacket_Login::Parse( cSocket & a_Socket )
+{
+ //printf("Parse: NEW Login\n");
+ m_Socket = a_Socket;
+
+ m_Username.clear();
+
+ if( !ReadInteger( m_ProtocolVersion ) ) return false;
+ if( !ReadString16( m_Username ) ) return false;
+ if( !ReadLong ( m_MapSeed ) ) return false;
+ if( !ReadInteger( m_ServerMode ) ) return false;
+ if( !ReadByte ( m_Dimension ) ) return false;
+ if( !ReadByte ( m_Difficulty ) ) return false;
+ if( !ReadByte ( m_WorldHeight ) ) return false;
+ if( !ReadByte ( m_MaxPlayers ) ) return false;
+ return true;
+}
+
+bool cPacket_Login::Send( cSocket & a_Socket )
+{
+ //printf("Send: NEW Login\n");
+ unsigned int TotalSize = c_Size + m_Username.size() * sizeof(short);
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendInteger( m_ProtocolVersion, Message, i );
+ AppendString16 ( m_Username, Message, i );
+ AppendLong ( m_MapSeed, Message, i );
+ AppendInteger( m_ServerMode, Message, i );
+ AppendByte ( m_Dimension, Message, i );
+ AppendByte ( m_Difficulty, Message, i );
+ AppendByte ( m_WorldHeight, Message, i );
+ AppendByte ( m_MaxPlayers, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( cPacket::SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_Login.h b/source/packets/cPacket_Login.h new file mode 100644 index 000000000..91919a799 --- /dev/null +++ b/source/packets/cPacket_Login.h @@ -0,0 +1,33 @@ +#pragma once
+
+#include "cPacket.h"
+#include <string>
+#include "PacketID.h"
+
+class cPacket_Login : public cPacket //tolua_export
+{ //tolua_export
+public:
+ cPacket_Login()
+ : m_ProtocolVersion( 0 )
+ , m_MapSeed( 0 )
+ , m_ServerMode( 0 )
+ , m_Dimension( 0 )
+ , m_Difficulty( 0 )
+ , m_WorldHeight( 0 )
+ , m_MaxPlayers( 0 )
+ { m_PacketID = E_LOGIN; }
+ virtual cPacket* Clone() const { return new cPacket_Login(*this); }
+
+ virtual bool Parse(cSocket & a_Socket);
+ virtual bool Send(cSocket & a_Socket);
+
+ int m_ProtocolVersion; //tolua_export
+ std::string m_Username; //tolua_export
+ long long m_MapSeed; //tolua_export
+ int m_ServerMode; //tolua_export
+ char m_Dimension; //tolua_export
+ char m_Difficulty; //tolua_export
+ unsigned char m_WorldHeight; //tolua_export
+ unsigned char m_MaxPlayers; //tolua_export
+ static const unsigned int c_Size = 1 + 4 + 2 + 8 + 4 + 1 + 1 + 1 + 1; // Minimal size
+}; //tolua_export
diff --git a/source/packets/cPacket_MapChunk.cpp b/source/packets/cPacket_MapChunk.cpp new file mode 100644 index 000000000..08681494c --- /dev/null +++ b/source/packets/cPacket_MapChunk.cpp @@ -0,0 +1,69 @@ +#include "cPacket_MapChunk.h"
+#include "../cChunk.h"
+
+#include "zlib.h"
+
+cPacket_MapChunk::~cPacket_MapChunk()
+{
+ if( m_CompressedData )
+ {
+ delete [] m_CompressedData;
+ }
+}
+
+cPacket_MapChunk::cPacket_MapChunk(cChunk* a_Chunk)
+{
+ m_PacketID = E_MAP_CHUNK;
+
+ m_PosX = a_Chunk->GetPosX() * 16; // It has to be block coordinates
+ m_PosY = (short)(a_Chunk->GetPosY() * 128);
+ m_PosZ = a_Chunk->GetPosZ() * 16;
+
+ m_SizeX = 15;
+ m_SizeY = 127;
+ m_SizeZ = 15;
+
+ uLongf CompressedSize = compressBound( cChunk::c_BlockDataSize );
+ char* CompressedBlockData = new char[CompressedSize];
+
+ compress2( (Bytef*)CompressedBlockData, &CompressedSize, (const Bytef*)a_Chunk->pGetBlockData(), cChunk::c_BlockDataSize, Z_DEFAULT_COMPRESSION);
+
+ m_CompressedData = CompressedBlockData;
+ m_CompressedSize = CompressedSize;
+}
+
+cPacket_MapChunk::cPacket_MapChunk( const cPacket_MapChunk & a_Copy )
+{
+ m_PacketID = E_MAP_CHUNK;
+ m_PosX = a_Copy.m_PosX;
+ m_PosY = a_Copy.m_PosY;
+ m_PosZ = a_Copy.m_PosZ;
+ m_SizeX = a_Copy.m_SizeX;
+ m_SizeY = a_Copy.m_SizeY;
+ m_SizeZ = a_Copy.m_SizeZ;
+
+ m_CompressedSize = a_Copy.m_CompressedSize;
+ m_CompressedData = new char[m_CompressedSize];
+ memcpy( m_CompressedData, a_Copy.m_CompressedData, m_CompressedSize );
+}
+
+bool cPacket_MapChunk::Send(cSocket & a_Socket)
+{
+ unsigned int TotalSize = c_Size + m_CompressedSize;
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendInteger ( m_PosX, Message, i );
+ AppendShort ( m_PosY, Message, i );
+ AppendInteger ( m_PosZ, Message, i );
+ AppendByte ( m_SizeX, Message, i );
+ AppendByte ( m_SizeY, Message, i );
+ AppendByte ( m_SizeZ, Message, i );
+ AppendInteger ( m_CompressedSize, Message, i );
+ AppendData ( m_CompressedData, m_CompressedSize, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_MapChunk.h b/source/packets/cPacket_MapChunk.h new file mode 100644 index 000000000..48e2cbf1f --- /dev/null +++ b/source/packets/cPacket_MapChunk.h @@ -0,0 +1,37 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cChunk;
+class cPacket_MapChunk : public cPacket
+{
+public:
+ cPacket_MapChunk()
+ : m_PosX( 0 )
+ , m_PosY( 0 )
+ , m_PosZ( 0 )
+ , m_SizeX( 0 )
+ , m_SizeY( 0 )
+ , m_SizeZ( 0 )
+ , m_CompressedSize( 0 )
+ , m_CompressedData( 0 )
+ { m_PacketID = E_MAP_CHUNK; m_CompressedData = 0; }
+ cPacket_MapChunk(cChunk* a_Chunk);
+ cPacket_MapChunk( const cPacket_MapChunk & a_Copy );
+ ~cPacket_MapChunk();
+ virtual cPacket* Clone() const { return new cPacket_MapChunk(*this); }
+
+ bool Send(cSocket & a_Socket);
+
+ int m_PosX; // In block coordinates
+ short m_PosY;
+ int m_PosZ;
+ char m_SizeX; // Is actually size-1 (when size is 128, this is 127)
+ char m_SizeY;
+ char m_SizeZ;
+ int m_CompressedSize;
+ static const unsigned int c_Size = 1 + 4 + 2 + 4 + 1 + 1 + 1 + 4;
+
+ char* m_CompressedData;
+};
\ No newline at end of file diff --git a/source/packets/cPacket_Metadata.cpp b/source/packets/cPacket_Metadata.cpp new file mode 100644 index 000000000..3d3df3b9c --- /dev/null +++ b/source/packets/cPacket_Metadata.cpp @@ -0,0 +1,65 @@ +#include "cPacket_Metadata.h" + +cPacket_Metadata::cPacket_Metadata(int s, int id) + : EMetaState( (MetaState)s ) + , m_UniqueID( id ) + , m_Type( 0 ) + , m_MetaData( 0 ) +{ + m_PacketID = E_METADATA; + FormPacket(); +} + +cPacket_Metadata::cPacket_Metadata() + : EMetaState(NORMAL) + , m_UniqueID( 0 ) + , m_Type( 0 ) + , m_MetaData( 0 ) +{ + m_PacketID = E_METADATA; + FormPacket(); +} + +cPacket_Metadata::~cPacket_Metadata() { + //if( m_MetaData ) delete [] m_MetaData; +} + +void cPacket_Metadata::FormPacket() { + if( m_MetaData ) delete [] m_MetaData; + m_MetaData = new char[3]; + m_MetaDataSize = 3; + //m_UniqueID = GetUniqueID(); + m_MetaData[0] = 0x00; + //m_MetaData[1] = 0x01; //Burning + m_MetaData[2] = 0x7f; + switch(EMetaState) { + case NORMAL: + m_MetaData[1] = 0x00; + break; + case BURNING: + m_MetaData[1] = 0x01; + break; + case CROUCHED: + m_MetaData[1] = 0x02; + break; + case RIDING: + m_MetaData[1] = 0x04; + break; + default: + m_MetaData[1] = 0x00; + break; + } +} + +bool cPacket_Metadata::Send(cSocket & a_Socket) { + unsigned int TotalSize = c_Size + m_MetaDataSize; + char* Message = new char[TotalSize]; + unsigned int i = 0; + + AppendByte ( (char)m_PacketID, Message, i ); + AppendInteger ( m_UniqueID, Message, i ); + AppendData ( m_MetaData, m_MetaDataSize, Message, i ); + + bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) ); + return RetVal; +} diff --git a/source/packets/cPacket_Metadata.h b/source/packets/cPacket_Metadata.h new file mode 100644 index 000000000..f96178a2c --- /dev/null +++ b/source/packets/cPacket_Metadata.h @@ -0,0 +1,23 @@ +#pragma once +#include "cPacket.h" +#include "PacketID.h" + +class cPacket_Metadata : public cPacket +{ +public: + cPacket_Metadata(int s, int id); + cPacket_Metadata(); + ~cPacket_Metadata(); + + bool Send(cSocket & a_Socket); + void FormPacket(); + virtual cPacket* Clone() const { return new cPacket_Metadata( *this ); } + + enum MetaState{NORMAL,BURNING,CROUCHED,RIDING} EMetaState; + + static const unsigned int c_Size = 4 + 1; + int m_UniqueID; + char m_Type; + unsigned int m_MetaDataSize; + char* m_MetaData; +}; diff --git a/source/packets/cPacket_MultiBlock.cpp b/source/packets/cPacket_MultiBlock.cpp new file mode 100644 index 000000000..ef396874f --- /dev/null +++ b/source/packets/cPacket_MultiBlock.cpp @@ -0,0 +1,42 @@ +#include "cPacket_MultiBlock.h"
+
+cPacket_MultiBlock::cPacket_MultiBlock( const cPacket_MultiBlock & a_Copy )
+{
+ m_PacketID = E_MULTI_BLOCK;
+ m_ChunkX = a_Copy.m_ChunkX;
+ m_ChunkZ = a_Copy.m_ChunkZ;
+ m_NumBlocks = a_Copy.m_NumBlocks;
+ m_BlockCoordinates = new unsigned short[m_NumBlocks];
+ memcpy( m_BlockCoordinates, a_Copy.m_BlockCoordinates, sizeof(short)*m_NumBlocks );
+ m_BlockTypes = new char[m_NumBlocks];
+ memcpy( m_BlockTypes, a_Copy.m_BlockTypes, m_NumBlocks );
+ m_BlockMetas = new char[m_NumBlocks];
+ memcpy( m_BlockMetas, a_Copy.m_BlockMetas, m_NumBlocks );
+}
+
+cPacket_MultiBlock::~cPacket_MultiBlock()
+{
+ if( m_BlockCoordinates ) delete [] m_BlockCoordinates;
+ if( m_BlockTypes ) delete [] m_BlockTypes;
+ if( m_BlockMetas ) delete [] m_BlockMetas;
+}
+
+bool cPacket_MultiBlock::Send(cSocket & a_Socket)
+{
+ unsigned int TotalSize = c_Size + m_NumBlocks * ( sizeof(short) + 2*sizeof(char) );
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendInteger ( m_ChunkX, Message, i );
+ AppendInteger ( m_ChunkZ, Message, i );
+ AppendShort ( m_NumBlocks, Message, i );
+
+ AppendData ( (char*)m_BlockCoordinates,sizeof(short)*m_NumBlocks, Message, i );
+ AppendData ( m_BlockTypes, sizeof(char)*m_NumBlocks, Message, i );
+ AppendData ( m_BlockMetas, sizeof(char)*m_NumBlocks, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_MultiBlock.h b/source/packets/cPacket_MultiBlock.h new file mode 100644 index 000000000..fb5e50d93 --- /dev/null +++ b/source/packets/cPacket_MultiBlock.h @@ -0,0 +1,32 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_MultiBlock : public cPacket
+{
+public:
+ cPacket_MultiBlock()
+ : m_ChunkX( 0 )
+ , m_ChunkZ( 0 )
+ , m_NumBlocks( 0 )
+ , m_BlockCoordinates( 0 )
+ , m_BlockTypes( 0 )
+ , m_BlockMetas( 0 )
+ { m_PacketID = E_MULTI_BLOCK; }
+ cPacket_MultiBlock( const cPacket_MultiBlock & a_Copy );
+ ~cPacket_MultiBlock();
+ virtual cPacket* Clone() const { return new cPacket_MultiBlock(*this); }
+
+ bool Send(cSocket & a_Socket);
+
+ int m_ChunkX;
+ int m_ChunkZ;
+ short m_NumBlocks;
+
+ static const unsigned int c_Size = 1 + 4 + 4 + 2; // Minimum size (when NumBlocks == 0)
+
+ unsigned short* m_BlockCoordinates; // x<<12 | z<<8 | y
+ char* m_BlockTypes;
+ char* m_BlockMetas;
+};
\ No newline at end of file diff --git a/source/packets/cPacket_NamedEntitySpawn.cpp b/source/packets/cPacket_NamedEntitySpawn.cpp new file mode 100644 index 000000000..222711119 --- /dev/null +++ b/source/packets/cPacket_NamedEntitySpawn.cpp @@ -0,0 +1,26 @@ +#include "cPacket_NamedEntitySpawn.h"
+
+
+bool cPacket_NamedEntitySpawn::Send( cSocket & a_Socket )
+{
+ unsigned int TotalSize = c_Size + m_PlayerName.size() * sizeof( short );
+ char* Message = new char[TotalSize];
+
+ if( m_CurrentItem <= 0 ) m_CurrentItem = 0; // Fix, to make sure no invalid values are sent.
+ // WARNING: HERE ITS 0, BUT IN EQUIP PACKET ITS -1 !!
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendInteger( m_UniqueID, Message, i );
+ AppendString16( m_PlayerName, Message, i );
+ AppendInteger( m_PosX, Message, i );
+ AppendInteger( m_PosY, Message, i );
+ AppendInteger( m_PosZ, Message, i );
+ AppendByte ( m_Rotation, Message, i );
+ AppendByte ( m_Pitch, Message, i );
+ AppendShort ( m_CurrentItem, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
diff --git a/source/packets/cPacket_NamedEntitySpawn.h b/source/packets/cPacket_NamedEntitySpawn.h new file mode 100644 index 000000000..1a404f693 --- /dev/null +++ b/source/packets/cPacket_NamedEntitySpawn.h @@ -0,0 +1,32 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_NamedEntitySpawn : public cPacket
+{
+public:
+ cPacket_NamedEntitySpawn()
+ : m_UniqueID( 0 )
+ , m_PosX( 0 )
+ , m_PosY( 0 )
+ , m_PosZ( 0 )
+ , m_Rotation( 0 )
+ , m_Pitch( 0 )
+ , m_CurrentItem( 0 )
+ { m_PacketID = E_NAMED_ENTITY_SPAWN; }
+ virtual cPacket* Clone() const { return new cPacket_NamedEntitySpawn(*this); }
+
+ bool Send( cSocket & a_Socket );
+
+ int m_UniqueID;
+ std::string m_PlayerName;
+ int m_PosX; // Pixel position, devide by 32 for block position
+ int m_PosY;
+ int m_PosZ;
+ char m_Rotation;
+ char m_Pitch;
+ short m_CurrentItem;
+
+ static const unsigned int c_Size = 1 + 4 + 2 + 4 + 4 + 4 + 1 + 1 + 2; // Minimum size
+};
diff --git a/source/packets/cPacket_PickupSpawn.cpp b/source/packets/cPacket_PickupSpawn.cpp new file mode 100644 index 000000000..73f4e3846 --- /dev/null +++ b/source/packets/cPacket_PickupSpawn.cpp @@ -0,0 +1,40 @@ +#include "cPacket_PickupSpawn.h"
+
+bool cPacket_PickupSpawn::Parse( cSocket & a_Socket )
+{
+ m_Socket = a_Socket;
+ if( !ReadInteger( m_UniqueID ) ) return false;
+ if( !ReadShort ( m_Item ) ) return false;
+ if( !ReadByte ( m_Count ) ) return false;
+ if( !ReadShort ( m_Health ) ) return false;
+ if( !ReadInteger( m_PosX ) ) return false;
+ if( !ReadInteger( m_PosY ) ) return false;
+ if( !ReadInteger( m_PosZ ) ) return false;
+ if( !ReadByte ( m_Rotation ) ) return false;
+ if( !ReadByte ( m_Pitch ) ) return false;
+ if( !ReadByte ( m_Roll ) ) return false;
+ return true;
+}
+
+bool cPacket_PickupSpawn::Send( cSocket & a_Socket )
+{
+ unsigned int TotalSize = c_Size;
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendInteger( m_UniqueID, Message, i );
+ AppendShort ( m_Item, Message, i );
+ AppendByte ( m_Count, Message, i );
+ AppendShort ( m_Health, Message, i );
+ AppendInteger( m_PosX, Message, i );
+ AppendInteger( m_PosY, Message, i );
+ AppendInteger( m_PosZ, Message, i );
+ AppendByte ( m_Rotation, Message, i );
+ AppendByte ( m_Pitch, Message, i );
+ AppendByte ( m_Roll, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_PickupSpawn.h b/source/packets/cPacket_PickupSpawn.h new file mode 100644 index 000000000..c4152eedd --- /dev/null +++ b/source/packets/cPacket_PickupSpawn.h @@ -0,0 +1,38 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_PickupSpawn : public cPacket
+{
+public:
+ cPacket_PickupSpawn()
+ : m_UniqueID( 0 )
+ , m_Item( 0 )
+ , m_Count( 0 )
+ , m_Health( 0 )
+ , m_PosX( 0 )
+ , m_PosY( 0 )
+ , m_PosZ( 0 )
+ , m_Rotation( 0 )
+ , m_Pitch( 0 )
+ , m_Roll( 0 )
+ { m_PacketID = E_PICKUP_SPAWN; }
+ virtual cPacket* Clone() const { return new cPacket_PickupSpawn(*this); }
+
+ bool Parse( cSocket & a_Socket );
+ bool Send( cSocket & a_Socket );
+
+ int m_UniqueID;
+ short m_Item;
+ char m_Count;
+ short m_Health;
+ int m_PosX;
+ int m_PosY;
+ int m_PosZ;
+ char m_Rotation;
+ char m_Pitch;
+ char m_Roll;
+
+ static const unsigned int c_Size = 1 + 4 + 2 + 1 + 2 + 4 + 4 + 4 + 1 + 1 + 1;
+};
diff --git a/source/packets/cPacket_Ping.h b/source/packets/cPacket_Ping.h new file mode 100644 index 000000000..abab822a4 --- /dev/null +++ b/source/packets/cPacket_Ping.h @@ -0,0 +1,16 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_Ping : public cPacket
+{
+public:
+ cPacket_Ping()
+ { m_PacketID = E_PING; }
+ virtual cPacket* Clone() const { return new cPacket_Ping(*this); }
+
+ bool Parse(cSocket & a_Socket) { (void)a_Socket; return true; }
+
+ static const unsigned int c_Size = 1;
+};
\ No newline at end of file diff --git a/source/packets/cPacket_PlayerLook.cpp b/source/packets/cPacket_PlayerLook.cpp new file mode 100644 index 000000000..2660ccf92 --- /dev/null +++ b/source/packets/cPacket_PlayerLook.cpp @@ -0,0 +1,36 @@ +#include "cPacket_PlayerLook.h"
+#include "../cPlayer.h"
+
+cPacket_PlayerLook::cPacket_PlayerLook( cPlayer* a_Player )
+{
+ m_PacketID = E_PLAYERLOOK;
+
+ m_Rotation = a_Player->GetRotation();
+ m_Pitch = a_Player->GetPitch();
+ m_bFlying = a_Player->GetFlying();
+}
+
+bool cPacket_PlayerLook::Parse( cSocket & a_Socket )
+{
+ m_Socket = a_Socket;
+ if( !ReadFloat( m_Rotation ) ) return false;
+ if( !ReadFloat( m_Pitch ) ) return false;
+ if( !ReadBool ( m_bFlying ) ) return false;
+ return true;
+}
+
+bool cPacket_PlayerLook::Send( cSocket & a_Socket )
+{
+ unsigned int TotalSize = c_Size;
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendFloat ( m_Rotation, Message, i );
+ AppendFloat ( m_Pitch, Message, i );
+ AppendBool ( m_bFlying, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( cPacket::SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_PlayerLook.h b/source/packets/cPacket_PlayerLook.h new file mode 100644 index 000000000..1f315a78b --- /dev/null +++ b/source/packets/cPacket_PlayerLook.h @@ -0,0 +1,25 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPlayer;
+class cPacket_PlayerLook : public cPacket
+{
+public:
+ cPacket_PlayerLook()
+ : m_Rotation( 0 )
+ , m_Pitch( 0 )
+ , m_bFlying( false )
+ { m_PacketID = E_PLAYERLOOK; }
+ cPacket_PlayerLook( cPlayer* a_Player );
+ virtual cPacket* Clone() const { return new cPacket_PlayerLook(*this); }
+
+ bool Parse( cSocket & a_Socket );
+ bool Send( cSocket & a_Socket );
+
+ float m_Rotation;
+ float m_Pitch;
+ bool m_bFlying; // Yeah.. wtf
+ static const unsigned int c_Size = 10;
+};
\ No newline at end of file diff --git a/source/packets/cPacket_PlayerMoveLook.cpp b/source/packets/cPacket_PlayerMoveLook.cpp new file mode 100644 index 000000000..f1d67478c --- /dev/null +++ b/source/packets/cPacket_PlayerMoveLook.cpp @@ -0,0 +1,50 @@ +#include "cPacket_PlayerMoveLook.h"
+#include "../cPlayer.h"
+
+cPacket_PlayerMoveLook::cPacket_PlayerMoveLook( cPlayer* a_Player )
+{
+ m_PacketID = E_PLAYERMOVELOOK;
+
+
+ m_PosX = a_Player->GetPosX();
+ m_PosY = a_Player->GetPosY() + 1.65;
+ m_PosZ = a_Player->GetPosZ();
+ m_Stance = a_Player->GetStance();
+ m_Rotation = a_Player->GetRotation();
+ m_Pitch = a_Player->GetPitch();
+ m_bFlying = a_Player->GetFlying();
+}
+
+bool cPacket_PlayerMoveLook::Parse( cSocket & a_Socket )
+{
+ m_Socket = a_Socket;
+
+ if( !ReadDouble( m_PosX ) ) return false;
+ if( !ReadDouble( m_PosY ) ) return false;
+ if( !ReadDouble( m_Stance ) ) return false;
+ if( !ReadDouble( m_PosZ ) ) return false;
+ if( !ReadFloat ( m_Rotation ) ) return false;
+ if( !ReadFloat ( m_Pitch ) ) return false;
+ if( !ReadBool ( m_bFlying ) ) return false;
+ return true;
+}
+
+bool cPacket_PlayerMoveLook::Send( cSocket & a_Socket )
+{
+ unsigned int TotalSize = c_Size;
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendDouble( m_PosX, Message, i );
+ AppendDouble( m_PosY, Message, i );
+ AppendDouble( m_Stance, Message, i );
+ AppendDouble( m_PosZ, Message, i );
+ AppendFloat ( m_Rotation, Message, i );
+ AppendFloat ( m_Pitch, Message, i );
+ AppendBool ( m_bFlying, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_PlayerMoveLook.h b/source/packets/cPacket_PlayerMoveLook.h new file mode 100644 index 000000000..3711e0e58 --- /dev/null +++ b/source/packets/cPacket_PlayerMoveLook.h @@ -0,0 +1,33 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPlayer;
+class cPacket_PlayerMoveLook : public cPacket
+{
+public:
+ cPacket_PlayerMoveLook()
+ : m_PosX( 0.0 )
+ , m_PosY( 0.0 )
+ , m_Stance( 0.0 )
+ , m_PosZ( 0.0 )
+ , m_Rotation( 0.f )
+ , m_Pitch( 0.f )
+ , m_bFlying( false )
+ { m_PacketID = E_PLAYERMOVELOOK; }
+ cPacket_PlayerMoveLook( cPlayer* a_Player );
+ virtual cPacket* Clone() const { return new cPacket_PlayerMoveLook(*this); }
+
+ virtual bool Parse(cSocket & a_Socket);
+ virtual bool Send(cSocket & a_Socket);
+
+ double m_PosX;
+ double m_PosY;
+ double m_Stance;
+ double m_PosZ;
+ float m_Rotation;
+ float m_Pitch;
+ bool m_bFlying; // Yeah.. wtf
+ static const unsigned int c_Size = 42;
+};
\ No newline at end of file diff --git a/source/packets/cPacket_PlayerPosition.cpp b/source/packets/cPacket_PlayerPosition.cpp new file mode 100644 index 000000000..eb17bc7e5 --- /dev/null +++ b/source/packets/cPacket_PlayerPosition.cpp @@ -0,0 +1,42 @@ +#include "cPacket_PlayerPosition.h"
+#include "cPlayer.h"
+
+cPacket_PlayerPosition::cPacket_PlayerPosition( cPlayer* a_Player )
+{
+ m_PacketID = E_PLAYERPOS;
+
+ m_PosX = a_Player->GetPosX();
+ m_PosY = a_Player->GetPosY() + 1.65;
+ m_PosZ = a_Player->GetPosZ();
+ m_Stance = a_Player->GetStance();
+ m_bFlying = a_Player->GetFlying();
+}
+
+bool cPacket_PlayerPosition::Parse(cSocket & a_Socket)
+{
+ m_Socket = a_Socket;
+ if( !ReadDouble( m_PosX ) ) return false;
+ if( !ReadDouble( m_PosY ) ) return false;
+ if( !ReadDouble( m_Stance ) ) return false;
+ if( !ReadDouble( m_PosZ ) ) return false;
+ if( !ReadBool( m_bFlying ) ) return false;
+ return true;
+}
+
+bool cPacket_PlayerPosition::Send(cSocket & a_Socket)
+{
+ unsigned int TotalSize = c_Size;
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendDouble ( m_PosX, Message, i );
+ AppendDouble ( m_PosY, Message, i );
+ AppendDouble ( m_Stance, Message, i );
+ AppendDouble ( m_PosZ, Message, i );
+ AppendBool ( m_bFlying, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_PlayerPosition.h b/source/packets/cPacket_PlayerPosition.h new file mode 100644 index 000000000..d9c68a2e6 --- /dev/null +++ b/source/packets/cPacket_PlayerPosition.h @@ -0,0 +1,29 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPlayer;
+class cPacket_PlayerPosition : public cPacket
+{
+public:
+ cPacket_PlayerPosition( cPlayer* a_Player );
+ cPacket_PlayerPosition()
+ : m_PosX( 0.0 )
+ , m_PosY( 0.0 )
+ , m_Stance( 0.0 )
+ , m_PosZ( 0.0 )
+ , m_bFlying( false )
+ { m_PacketID = E_PLAYERPOS; }
+ virtual cPacket* Clone() const { return new cPacket_PlayerPosition(*this); }
+
+ virtual bool Parse(cSocket & a_Socket);
+ virtual bool Send(cSocket & a_Socket);
+
+ double m_PosX;
+ double m_PosY;
+ double m_Stance;
+ double m_PosZ;
+ bool m_bFlying; // Yeah.. wtf
+ static const unsigned int c_Size = 34;
+};
\ No newline at end of file diff --git a/source/packets/cPacket_PreChunk.cpp b/source/packets/cPacket_PreChunk.cpp new file mode 100644 index 000000000..686984a1e --- /dev/null +++ b/source/packets/cPacket_PreChunk.cpp @@ -0,0 +1,17 @@ +#include "cPacket_PreChunk.h"
+
+bool cPacket_PreChunk::Send(cSocket & a_Socket)
+{
+ unsigned int TotalSize = c_Size;
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendInteger( m_PosX, Message, i );
+ AppendInteger( m_PosZ, Message, i );
+ AppendBool ( m_bLoad, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
diff --git a/source/packets/cPacket_PreChunk.h b/source/packets/cPacket_PreChunk.h new file mode 100644 index 000000000..a6bd4897e --- /dev/null +++ b/source/packets/cPacket_PreChunk.h @@ -0,0 +1,22 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_PreChunk: public cPacket
+{
+public:
+ cPacket_PreChunk()
+ : m_PosX( 0 )
+ , m_PosZ( 0 )
+ , m_bLoad( false )
+ { m_PacketID = E_PRE_CHUNK; }
+ virtual cPacket* Clone() const { return new cPacket_PreChunk(*this); }
+
+ bool Send(cSocket & a_Socket);
+
+ int m_PosX;
+ int m_PosZ;
+ bool m_bLoad;
+ static const unsigned int c_Size = 10;
+};
\ No newline at end of file diff --git a/source/packets/cPacket_RelativeEntityMove.cpp b/source/packets/cPacket_RelativeEntityMove.cpp new file mode 100644 index 000000000..4a1dc56b2 --- /dev/null +++ b/source/packets/cPacket_RelativeEntityMove.cpp @@ -0,0 +1,18 @@ +#include "cPacket_RelativeEntityMove.h"
+
+bool cPacket_RelativeEntityMove::Send( cSocket & a_Socket )
+{
+ unsigned int TotalSize = c_Size;
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendInteger( m_UniqueID, Message, i );
+ AppendByte ( m_MoveX, Message, i );
+ AppendByte ( m_MoveY, Message, i );
+ AppendByte ( m_MoveZ, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
diff --git a/source/packets/cPacket_RelativeEntityMove.h b/source/packets/cPacket_RelativeEntityMove.h new file mode 100644 index 000000000..03d895b38 --- /dev/null +++ b/source/packets/cPacket_RelativeEntityMove.h @@ -0,0 +1,25 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_RelativeEntityMove : public cPacket
+{
+public:
+ cPacket_RelativeEntityMove()
+ : m_UniqueID( 0 )
+ , m_MoveX( 0 )
+ , m_MoveY( 0 )
+ , m_MoveZ( 0 )
+ { m_PacketID = E_REL_ENT_MOVE; }
+ virtual cPacket* Clone() const { return new cPacket_RelativeEntityMove(*this); }
+
+ bool Send( cSocket & a_Socket );
+
+ int m_UniqueID;
+ char m_MoveX; // Pixels, devide by 32 for block
+ char m_MoveY;
+ char m_MoveZ;
+
+ static const unsigned int c_Size = 1 + 4 + 1 + 1 + 1;
+};
diff --git a/source/packets/cPacket_RelativeEntityMoveLook.cpp b/source/packets/cPacket_RelativeEntityMoveLook.cpp new file mode 100644 index 000000000..e879870cd --- /dev/null +++ b/source/packets/cPacket_RelativeEntityMoveLook.cpp @@ -0,0 +1,20 @@ +#include "cPacket_RelativeEntityMoveLook.h"
+
+bool cPacket_RelativeEntityMoveLook::Send( cSocket & a_Socket )
+{
+ unsigned int TotalSize = c_Size;
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendInteger( m_UniqueID, Message, i );
+ AppendByte ( m_MoveX, Message, i );
+ AppendByte ( m_MoveY, Message, i );
+ AppendByte ( m_MoveZ, Message, i );
+ AppendByte ( m_Yaw, Message, i );
+ AppendByte ( m_Pitch, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
diff --git a/source/packets/cPacket_RelativeEntityMoveLook.h b/source/packets/cPacket_RelativeEntityMoveLook.h new file mode 100644 index 000000000..cb54db159 --- /dev/null +++ b/source/packets/cPacket_RelativeEntityMoveLook.h @@ -0,0 +1,29 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_RelativeEntityMoveLook : public cPacket
+{
+public:
+ cPacket_RelativeEntityMoveLook()
+ : m_UniqueID( 0 )
+ , m_MoveX( 0 )
+ , m_MoveY( 0 )
+ , m_MoveZ( 0 )
+ , m_Yaw( 0 )
+ , m_Pitch( 0 )
+ { m_PacketID = E_REL_ENT_MOVE_LOOK; }
+ virtual cPacket* Clone() const { return new cPacket_RelativeEntityMoveLook(*this); }
+
+ bool Send( cSocket & a_Socket );
+
+ int m_UniqueID;
+ char m_MoveX; // Pixels, divide by 32 for block
+ char m_MoveY;
+ char m_MoveZ;
+ char m_Yaw;
+ char m_Pitch;
+
+ static const unsigned int c_Size = 1 + 4 + 1 + 1 + 1 + 1 + 1;
+};
diff --git a/source/packets/cPacket_Respawn.cpp b/source/packets/cPacket_Respawn.cpp new file mode 100644 index 000000000..e12ea1ace --- /dev/null +++ b/source/packets/cPacket_Respawn.cpp @@ -0,0 +1,31 @@ +#include "cPacket_Respawn.h"
+
+bool cPacket_Respawn::Send(cSocket & a_Socket)
+{
+ unsigned int TotalSize = c_Size;
+
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendByte ( m_World, Message, i );
+ AppendByte ( m_Difficulty, Message, i );
+ AppendByte ( m_CreativeMode, Message, i );
+ AppendShort ( m_WorldHeight, Message, i );
+ AppendLong ( m_MapSeed, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
+
+bool cPacket_Respawn::Parse(cSocket & a_Socket)
+{
+ m_Socket = a_Socket;
+ if( !ReadByte( m_World ) ) return false;
+ if( !ReadByte( m_Difficulty ) ) return false;
+ if( !ReadByte( m_CreativeMode ) ) return false;
+ if( !ReadShort( m_WorldHeight ) ) return false;
+ if( !ReadLong( m_MapSeed ) ) return false;
+ return true;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_Respawn.h b/source/packets/cPacket_Respawn.h new file mode 100644 index 000000000..ab8fbe72a --- /dev/null +++ b/source/packets/cPacket_Respawn.h @@ -0,0 +1,28 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_Respawn : public cPacket
+{
+public:
+ cPacket_Respawn()
+ : m_World( 0 )
+ , m_Difficulty( 0 )
+ , m_CreativeMode( 0 )
+ , m_WorldHeight( 0 )
+ , m_MapSeed( 0 )
+ { m_PacketID = E_RESPAWN; }
+ virtual cPacket* Clone() const { return new cPacket_Respawn( *this ); }
+
+ bool Send(cSocket & a_Socket);
+ bool Parse(cSocket & a_Socket);
+
+ char m_World;
+ char m_Difficulty;
+ char m_CreativeMode;
+ short m_WorldHeight;
+ long long m_MapSeed;
+
+ static const unsigned int c_Size = 1 + 1 + 1 + 1 + 2 + 8;
+};
diff --git a/source/packets/cPacket_SpawnMob.cpp b/source/packets/cPacket_SpawnMob.cpp new file mode 100644 index 000000000..8de03f04b --- /dev/null +++ b/source/packets/cPacket_SpawnMob.cpp @@ -0,0 +1,60 @@ +#include "cPacket_SpawnMob.h"
+#include "Vector3i.h"
+
+#include "cMCLogger.h"
+
+cPacket_SpawnMob::~cPacket_SpawnMob()
+{
+ if( m_MetaData ) delete [] m_MetaData;
+ delete m_Pos;
+}
+
+cPacket_SpawnMob::cPacket_SpawnMob()
+ : m_UniqueID( 0 )
+ , m_Type( 0 )
+ , m_Pos( new Vector3i() )
+ , m_Yaw( 0 )
+ , m_Pitch( 0 )
+ , m_MetaDataSize( 0 )
+ , m_MetaData( 0 )
+{
+ m_PacketID = E_SPAWN_MOB;
+}
+
+cPacket_SpawnMob::cPacket_SpawnMob( const cPacket_SpawnMob & a_Clone )
+{
+ m_Pos = new Vector3i();
+
+ m_PacketID = E_SPAWN_MOB;
+ m_UniqueID = a_Clone.m_UniqueID;
+ m_Type = a_Clone.m_Type;
+ *m_Pos = *a_Clone.m_Pos;
+ m_Yaw = a_Clone.m_Yaw;
+ m_Pitch = a_Clone.m_Pitch;
+
+ m_MetaDataSize = a_Clone.m_MetaDataSize;
+ m_MetaData = new char[m_MetaDataSize];
+ memcpy( m_MetaData, a_Clone.m_MetaData, sizeof( char ) * m_MetaDataSize );
+}
+
+bool cPacket_SpawnMob::Send(cSocket & a_Socket)
+{
+ unsigned int TotalSize = c_Size + m_MetaDataSize;
+
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendInteger ( m_UniqueID, Message, i );
+ AppendByte ( m_Type, Message, i );
+ AppendInteger ( m_Pos->x, Message, i );
+ AppendInteger ( m_Pos->y, Message, i );
+ AppendInteger ( m_Pos->z, Message, i );
+ AppendByte ( m_Yaw, Message, i );
+ AppendByte ( m_Pitch, Message, i );
+ AppendData ( m_MetaData, m_MetaDataSize, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
diff --git a/source/packets/cPacket_SpawnMob.h b/source/packets/cPacket_SpawnMob.h new file mode 100644 index 000000000..bd7c75464 --- /dev/null +++ b/source/packets/cPacket_SpawnMob.h @@ -0,0 +1,27 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class Vector3i;
+class cPacket_SpawnMob : public cPacket
+{
+public:
+ cPacket_SpawnMob();
+ cPacket_SpawnMob( const cPacket_SpawnMob & a_Clone );
+ virtual cPacket* Clone() const { return new cPacket_SpawnMob( *this ); }
+ ~cPacket_SpawnMob();
+
+ bool Send(cSocket & a_Socket);
+
+ int m_UniqueID;
+ char m_Type;
+ Vector3i* m_Pos;
+ char m_Yaw;
+ char m_Pitch;
+
+ static const unsigned int c_Size = 1 + 4 + 1 + 4 + 4 + 4 + 1 + 1; // + metadata
+
+ unsigned int m_MetaDataSize;
+ char* m_MetaData;
+};
diff --git a/source/packets/cPacket_TeleportEntity.cpp b/source/packets/cPacket_TeleportEntity.cpp new file mode 100644 index 000000000..73c7c0524 --- /dev/null +++ b/source/packets/cPacket_TeleportEntity.cpp @@ -0,0 +1,34 @@ +#include "cPacket_TeleportEntity.h"
+
+#include "cEntity.h"
+
+cPacket_TeleportEntity::cPacket_TeleportEntity(cEntity* a_Client)
+{
+ m_PacketID = E_ENT_TELEPORT;
+
+ m_UniqueID = a_Client->GetUniqueID();
+ m_PosX = (int)(a_Client->GetPosX() * 32);
+ m_PosY = (int)(a_Client->GetPosY() * 32);
+ m_PosZ = (int)(a_Client->GetPosZ() * 32);
+ m_Rotation = (char)((a_Client->GetRotation()/360.f)*256);
+ m_Pitch = (char)((a_Client->GetPitch()/360.f)*256);
+}
+
+bool cPacket_TeleportEntity::Send( cSocket & a_Socket )
+{
+ unsigned int TotalSize = c_Size;
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendInteger( m_UniqueID, Message, i );
+ AppendInteger( m_PosX, Message, i );
+ AppendInteger( m_PosY, Message, i );
+ AppendInteger( m_PosZ, Message, i );
+ AppendByte ( m_Rotation, Message, i );
+ AppendByte ( m_Pitch, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
diff --git a/source/packets/cPacket_TeleportEntity.h b/source/packets/cPacket_TeleportEntity.h new file mode 100644 index 000000000..da1f61c60 --- /dev/null +++ b/source/packets/cPacket_TeleportEntity.h @@ -0,0 +1,31 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cEntity;
+class cPacket_TeleportEntity : public cPacket
+{
+public:
+ cPacket_TeleportEntity()
+ : m_UniqueID( 0 )
+ , m_PosX( 0 )
+ , m_PosY( 0 )
+ , m_PosZ( 0 )
+ , m_Rotation( 0 )
+ , m_Pitch( 0 )
+ { m_PacketID = E_ENT_TELEPORT; }
+ virtual cPacket* Clone() const { return new cPacket_TeleportEntity(*this); }
+ cPacket_TeleportEntity(cEntity* a_Client);
+
+ bool Send( cSocket & a_Socket );
+
+ int m_UniqueID;
+ int m_PosX; // Pixel position, divide by 32 for block position
+ int m_PosY;
+ int m_PosZ;
+ char m_Rotation;
+ char m_Pitch;
+
+ static const unsigned int c_Size = 1 + 4 + 4 + 4 + 4 + 1 + 1;
+};
diff --git a/source/packets/cPacket_TimeUpdate.cpp b/source/packets/cPacket_TimeUpdate.cpp new file mode 100644 index 000000000..09a9ca66a --- /dev/null +++ b/source/packets/cPacket_TimeUpdate.cpp @@ -0,0 +1,22 @@ +#include "cPacket_TimeUpdate.h"
+
+bool cPacket_TimeUpdate::Parse(cSocket & a_Socket)
+{
+ m_Socket = a_Socket;
+ if( !ReadLong(m_Time) ) return false;
+ return true;
+}
+
+bool cPacket_TimeUpdate::Send(cSocket & a_Socket)
+{
+ unsigned int TotalSize = c_Size;
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendLong ( m_Time, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_TimeUpdate.h b/source/packets/cPacket_TimeUpdate.h new file mode 100644 index 000000000..9913eba2c --- /dev/null +++ b/source/packets/cPacket_TimeUpdate.h @@ -0,0 +1,20 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_TimeUpdate : public cPacket
+{
+public:
+ cPacket_TimeUpdate()
+ : m_Time( 0 )
+ { m_PacketID = E_UPDATE_TIME; }
+ cPacket_TimeUpdate( long long a_Time ) { m_PacketID = E_UPDATE_TIME; m_Time = a_Time; }
+ virtual cPacket* Clone() const { return new cPacket_TimeUpdate(*this); }
+
+ bool Parse(cSocket & a_Socket);
+ bool Send(cSocket & a_Socket);
+
+ long long m_Time;
+ static const unsigned int c_Size = 1 + 8;
+};
\ No newline at end of file diff --git a/source/packets/cPacket_UpdateHealth.cpp b/source/packets/cPacket_UpdateHealth.cpp new file mode 100644 index 000000000..f46d159ad --- /dev/null +++ b/source/packets/cPacket_UpdateHealth.cpp @@ -0,0 +1,20 @@ +#include "cPacket_UpdateHealth.h"
+
+#include "cMCLogger.h"
+
+bool cPacket_UpdateHealth::Send(cSocket & a_Socket)
+{
+ unsigned int TotalSize = c_Size;
+
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendShort ( m_Health, Message, i );
+ AppendShort ( m_Food, Message, i );
+ AppendFloat ( m_Saturation, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
diff --git a/source/packets/cPacket_UpdateHealth.h b/source/packets/cPacket_UpdateHealth.h new file mode 100644 index 000000000..97081e645 --- /dev/null +++ b/source/packets/cPacket_UpdateHealth.h @@ -0,0 +1,24 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_UpdateHealth : public cPacket
+{
+public:
+ cPacket_UpdateHealth()
+ : m_Health( 0 )
+ , m_Food( 0 )
+ , m_Saturation( 0.f )
+ { m_PacketID = E_UPDATE_HEALTH; }
+ cPacket_UpdateHealth( short a_Health ) { m_Health = a_Health; m_PacketID = E_UPDATE_HEALTH; }
+ virtual cPacket* Clone() const { return new cPacket_UpdateHealth( *this ); }
+
+ bool Send(cSocket & a_Socket);
+
+ short m_Health;
+ short m_Food;
+ float m_Saturation;
+
+ static const unsigned int c_Size = 1 + 2 + 2 + 4;
+};
diff --git a/source/packets/cPacket_UpdateSign.cpp b/source/packets/cPacket_UpdateSign.cpp new file mode 100644 index 000000000..f7d3f8618 --- /dev/null +++ b/source/packets/cPacket_UpdateSign.cpp @@ -0,0 +1,41 @@ +#include "cPacket_UpdateSign.h"
+
+bool cPacket_UpdateSign::Parse( cSocket & a_Socket )
+{
+ m_Socket = a_Socket;
+
+ if( !ReadInteger( m_PosX ) ) return false;
+ if( !ReadShort ( m_PosY ) ) return false;
+ if( !ReadInteger( m_PosZ ) ) return false;
+ if( !ReadString16 ( m_Line1 ) ) return false;
+ if( !ReadString16 ( m_Line2 ) ) return false;
+ if( !ReadString16 ( m_Line3 ) ) return false;
+ if( !ReadString16 ( m_Line4 ) ) return false;
+
+ return true;
+}
+
+bool cPacket_UpdateSign::Send( cSocket & a_Socket )
+{
+ unsigned int TotalSize = c_Size;
+ TotalSize += m_Line1.size() * sizeof( short );
+ TotalSize += m_Line2.size() * sizeof( short );
+ TotalSize += m_Line3.size() * sizeof( short );
+ TotalSize += m_Line4.size() * sizeof( short );
+
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendInteger ( m_PosX, Message, i );
+ AppendShort ( m_PosY, Message, i );
+ AppendInteger ( m_PosZ, Message, i );
+ AppendString16 ( m_Line1, Message, i );
+ AppendString16 ( m_Line2, Message, i );
+ AppendString16 ( m_Line3, Message, i );
+ AppendString16 ( m_Line4, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_UpdateSign.h b/source/packets/cPacket_UpdateSign.h new file mode 100644 index 000000000..f23da1540 --- /dev/null +++ b/source/packets/cPacket_UpdateSign.h @@ -0,0 +1,28 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_UpdateSign : public cPacket
+{
+public:
+ cPacket_UpdateSign()
+ : m_PosX( 0 )
+ , m_PosY( 0 )
+ , m_PosZ( 0 )
+ { m_PacketID = E_UPDATE_SIGN; }
+ virtual cPacket* Clone() const { return new cPacket_UpdateSign( *this ); }
+
+ bool Parse( cSocket & a_Socket );
+ bool Send( cSocket & a_Socket );
+
+ int m_PosX;
+ short m_PosY;
+ int m_PosZ;
+ std::string m_Line1;
+ std::string m_Line2;
+ std::string m_Line3;
+ std::string m_Line4;
+
+ static const unsigned int c_Size = 1 + 4 + 2 + 4 + 2 + 2 + 2 + 2; // minimum size
+};
diff --git a/source/packets/cPacket_UseEntity.cpp b/source/packets/cPacket_UseEntity.cpp new file mode 100644 index 000000000..bbe22d3ec --- /dev/null +++ b/source/packets/cPacket_UseEntity.cpp @@ -0,0 +1,10 @@ +#include "cPacket_UseEntity.h"
+
+bool cPacket_UseEntity::Parse(cSocket & a_Socket)
+{
+ m_Socket = a_Socket;
+ if( !ReadInteger(m_UniqueID) ) return false;
+ if( !ReadInteger(m_TargetID) ) return false;
+ if( !ReadBool (m_bLeftClick) ) return false;
+ return true;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_UseEntity.h b/source/packets/cPacket_UseEntity.h new file mode 100644 index 000000000..cd7b45e79 --- /dev/null +++ b/source/packets/cPacket_UseEntity.h @@ -0,0 +1,23 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_UseEntity : public cPacket
+{
+public:
+ cPacket_UseEntity()
+ : m_UniqueID( 0 )
+ , m_TargetID( 0 )
+ , m_bLeftClick( false )
+ { m_PacketID = E_USE_ENTITY; }
+ virtual cPacket* Clone() const { return new cPacket_UseEntity(*this); }
+
+ bool Parse(cSocket & a_Socket);
+
+ int m_UniqueID;
+ int m_TargetID;
+ bool m_bLeftClick;
+
+ static const unsigned int c_Size = 1 + 4 + 4 + 1;
+};
\ No newline at end of file diff --git a/source/packets/cPacket_WholeInventory.cpp b/source/packets/cPacket_WholeInventory.cpp new file mode 100644 index 000000000..3ee047239 --- /dev/null +++ b/source/packets/cPacket_WholeInventory.cpp @@ -0,0 +1,68 @@ +#include "cPacket_WholeInventory.h"
+#include "../cItem.h"
+#include "../cInventory.h"
+#include "../cWindow.h"
+
+cPacket_WholeInventory::cPacket_WholeInventory( const cPacket_WholeInventory & a_Clone )
+{
+ m_PacketID = E_INVENTORY_WHOLE;
+ m_WindowID = a_Clone.m_WindowID;
+ m_Count = a_Clone.m_Count;
+ m_Items = new cItem[m_Count];
+ memcpy( m_Items, a_Clone.m_Items, sizeof(cItem)*m_Count );
+}
+
+cPacket_WholeInventory::cPacket_WholeInventory( cInventory* a_Inventory )
+{
+ m_PacketID = E_INVENTORY_WHOLE;
+ m_WindowID = 0;
+ m_Count = a_Inventory->c_NumSlots;
+ m_Items = new cItem[m_Count];
+ memcpy( m_Items, a_Inventory->GetSlots(), sizeof(cItem)*m_Count );
+}
+
+cPacket_WholeInventory::cPacket_WholeInventory( cWindow* a_Window )
+{
+ m_PacketID = E_INVENTORY_WHOLE;
+ m_WindowID = (char)a_Window->GetWindowID();
+ m_Count = (short)a_Window->GetNumSlots();
+ m_Items = new cItem[m_Count];
+ memcpy( m_Items, a_Window->GetSlots(), sizeof(cItem)*m_Count );
+}
+
+cPacket_WholeInventory::~cPacket_WholeInventory()
+{
+ delete [] m_Items;
+}
+
+bool cPacket_WholeInventory::Send(cSocket & a_Socket)
+{
+ unsigned int TotalSize = c_Size;
+
+ for(int i = 0; i < m_Count; i++)
+ {
+ if( m_Items[i].m_ItemID > -1 )
+ TotalSize+=3;
+ TotalSize+=2;
+ }
+
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendByte ( m_WindowID, Message, i );
+ AppendShort ( m_Count, Message, i );
+ for(int j = 0; j < m_Count; j++)
+ {
+ AppendShort ( (short)m_Items[j].m_ItemID, Message, i );
+ if( m_Items[j].m_ItemID > -1 )
+ {
+ AppendByte ( m_Items[j].m_ItemCount, Message, i );
+ AppendShort ( m_Items[j].m_ItemHealth, Message, i );
+ }
+ }
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_WholeInventory.h b/source/packets/cPacket_WholeInventory.h new file mode 100644 index 000000000..a2e76658e --- /dev/null +++ b/source/packets/cPacket_WholeInventory.h @@ -0,0 +1,31 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cInventory;
+class cWindow;
+class cItem;
+class cPacket_WholeInventory : public cPacket // full inventory [S -> C] ?
+{
+public:
+ cPacket_WholeInventory( const cPacket_WholeInventory & a_Clone );
+ cPacket_WholeInventory( cInventory* a_Inventory );
+ cPacket_WholeInventory( cWindow* a_Window );
+ ~cPacket_WholeInventory();
+ cPacket_WholeInventory()
+ : m_WindowID( 0 )
+ , m_Count( 0 )
+ , m_Items( 0 )
+ { m_PacketID = E_INVENTORY_WHOLE; }
+ virtual cPacket* Clone() const { return new cPacket_WholeInventory(*this); }
+
+ bool Send(cSocket & a_Socket);
+
+ char m_WindowID; // WTF?
+ short m_Count; // Number of items
+
+ cItem* m_Items; // Array of m_Count items
+
+ static const unsigned int c_Size = 1 + 1 + 2; // Minimal size
+};
\ No newline at end of file diff --git a/source/packets/cPacket_WindowClick.cpp b/source/packets/cPacket_WindowClick.cpp new file mode 100644 index 000000000..6b295b4d5 --- /dev/null +++ b/source/packets/cPacket_WindowClick.cpp @@ -0,0 +1,36 @@ +#include "cPacket_WindowClick.h"
+
+
+bool cPacket_WindowClick::Parse(cSocket & a_Socket)
+{
+// LOG("-----------INV66-----------");
+ m_Socket = a_Socket;
+
+ if( !ReadByte(m_WindowID) ) return false;
+ if( !ReadShort(m_SlotNum) ) return false;
+ if( !ReadByte(m_RightMouse) ) return false;
+ if( !ReadShort(m_NumClicks) ) return false;
+ if( !ReadBool(m_Bool) ) return false;
+
+// LOG("WindowID : %i", m_Type );
+// LOG("FromSlot: %i", m_SlotNum );
+// LOG("Right/Le: %i", m_RightMouse );
+// LOG("NumClick: %i", m_NumClicks );
+
+ if( !ReadShort(m_ItemID) ) return false;
+// LOG("ItemID: %i", m_ItemID );
+ if( m_ItemID > -1 )
+ {
+ if( !ReadByte(m_ItemCount) ) return false;
+ if( !ReadShort(m_ItemUses) ) return false;
+// LOG("Count : %i", m_ItemCount );
+// LOG("Uses : %i", m_ItemUses );
+ }
+ else
+ {
+ m_ItemCount = 0;
+ m_ItemUses = 0;
+ }
+
+ return true;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_WindowClick.h b/source/packets/cPacket_WindowClick.h new file mode 100644 index 000000000..d6f38e9ab --- /dev/null +++ b/source/packets/cPacket_WindowClick.h @@ -0,0 +1,41 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_WindowClick : public cPacket // [C -> S]
+{
+public:
+ cPacket_WindowClick()
+ : m_WindowID( 0 )
+ , m_SlotNum( 0 )
+ , m_RightMouse( 0 )
+ , m_NumClicks( 0 )
+ , m_Bool( false )
+ , m_ItemID( 0 )
+ , m_ItemCount( 0 )
+ , m_ItemUses( 0 )
+ { m_PacketID = E_WINDOW_CLICK; }
+ virtual cPacket* Clone() const { return new cPacket_WindowClick(*this); }
+
+ bool Parse(cSocket & a_Socket);
+
+ char m_WindowID;
+ short m_SlotNum; // Slot
+ // 0 = craft result
+ // 1-4 = crafting table
+ // 5-8 = armor
+ // 9-35 = inventory
+ // 36-44 = Hot bar
+
+ char m_RightMouse; // 0 = left 1 = Right mb
+ short m_NumClicks; // Num clicks
+ bool m_Bool; // unkown????????????
+
+ // Below = item
+ short m_ItemID; // if this is -1 the next stuff dont exist
+ char m_ItemCount;
+ short m_ItemUses;
+
+ static const unsigned int c_Size = 1 + 1 + 2 + 1 + 2 + 2; // Minimal size ( +1+1 = max)
+};
\ No newline at end of file diff --git a/source/packets/cPacket_WindowClose.cpp b/source/packets/cPacket_WindowClose.cpp new file mode 100644 index 000000000..0881fb703 --- /dev/null +++ b/source/packets/cPacket_WindowClose.cpp @@ -0,0 +1,27 @@ +#include "cPacket_WindowClose.h"
+
+bool cPacket_WindowClose::Parse(cSocket & a_Socket)
+{
+ //LOG("CLOSE INVENTORY PACKET");
+ m_Socket = a_Socket;
+
+ if( !ReadByte(m_Close) ) return false;
+
+ //LOG("Closed inventory?: %i", m_Close );
+
+ return true;
+}
+
+bool cPacket_WindowClose::Send(cSocket & a_Socket)
+{
+ unsigned int TotalSize = c_Size;
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendByte ( m_Close, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_WindowClose.h b/source/packets/cPacket_WindowClose.h new file mode 100644 index 000000000..1940eec0a --- /dev/null +++ b/source/packets/cPacket_WindowClose.h @@ -0,0 +1,20 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_WindowClose : public cPacket
+{
+public:
+ cPacket_WindowClose()
+ : m_Close( 0 )
+ { m_PacketID = E_WINDOW_CLOSE; }
+ virtual cPacket* Clone() const { return new cPacket_WindowClose(*this); }
+
+ bool Parse(cSocket & a_Socket);
+ bool Send(cSocket & a_Socket);
+
+ char m_Close; // 1 = close
+
+ static const unsigned int c_Size = 1 + 1;
+};
\ No newline at end of file diff --git a/source/packets/cPacket_WindowOpen.cpp b/source/packets/cPacket_WindowOpen.cpp new file mode 100644 index 000000000..5d1299acd --- /dev/null +++ b/source/packets/cPacket_WindowOpen.cpp @@ -0,0 +1,18 @@ +#include "cPacket_WindowOpen.h"
+
+bool cPacket_WindowOpen::Send(cSocket & a_Socket)
+{
+ unsigned int TotalSize = c_Size + m_WindowTitle.size() * sizeof( short );
+ char* Message = new char[TotalSize];
+
+ unsigned int i = 0;
+ AppendByte ( (char)m_PacketID, Message, i );
+ AppendByte ( m_WindowID, Message, i );
+ AppendByte ( m_InventoryType, Message, i );
+ AppendString16( m_WindowTitle, Message, i );
+ AppendByte ( m_NumSlots, Message, i );
+
+ bool RetVal = !cSocket::IsSocketError( SendData( a_Socket, Message, TotalSize, 0 ) );
+ delete [] Message;
+ return RetVal;
+}
\ No newline at end of file diff --git a/source/packets/cPacket_WindowOpen.h b/source/packets/cPacket_WindowOpen.h new file mode 100644 index 000000000..df05799d5 --- /dev/null +++ b/source/packets/cPacket_WindowOpen.h @@ -0,0 +1,24 @@ +#pragma once
+
+#include "cPacket.h"
+#include "PacketID.h"
+
+class cPacket_WindowOpen : public cPacket
+{
+public:
+ cPacket_WindowOpen()
+ : m_WindowID( 0 )
+ , m_InventoryType( 0 )
+ , m_NumSlots( 0 )
+ { m_PacketID = E_WINDOW_OPEN; }
+ virtual cPacket* Clone() const { return new cPacket_WindowOpen(*this); }
+
+ bool Send(cSocket & a_Socket);
+
+ char m_WindowID;
+ char m_InventoryType;
+ std::string m_WindowTitle;
+ char m_NumSlots;
+
+ static const unsigned int c_Size = 1 + 1 + 1 + 2 + 1; // + sizeof(string)
+};
\ No newline at end of file diff --git a/source/tolua++.exe b/source/tolua++.exe Binary files differnew file mode 100644 index 000000000..c39968dbf --- /dev/null +++ b/source/tolua++.exe diff --git a/source/tolua++.h b/source/tolua++.h new file mode 100644 index 000000000..ed5344926 --- /dev/null +++ b/source/tolua++.h @@ -0,0 +1,186 @@ +/* tolua +** Support code for Lua bindings. +** Written by Waldemar Celes +** TeCGraf/PUC-Rio +** Apr 2003 +** $Id: $ +*/ + +/* This code is free software; you can redistribute it and/or modify it. +** The software provided hereunder is on an "as is" basis, and +** the author has no obligation to provide maintenance, support, updates, +** enhancements, or modifications. +*/ + + +#ifndef TOLUA_H +#define TOLUA_H + +#ifndef TOLUA_API +#define TOLUA_API extern +#endif + +#define TOLUA_VERSION "tolua++-1.0.92" + +#ifdef __cplusplus +extern "C" { +#endif + +#define tolua_pushcppstring(x,y) tolua_pushstring(x,y.c_str()) +#define tolua_iscppstring tolua_isstring + +#define tolua_iscppstringarray tolua_isstringarray +#define tolua_pushfieldcppstring(L,lo,idx,s) tolua_pushfieldstring(L, lo, idx, s.c_str()) + +#ifndef TEMPLATE_BIND + #define TEMPLATE_BIND(p) +#endif + +#define TOLUA_TEMPLATE_BIND(p) + +#define TOLUA_PROTECTED_DESTRUCTOR +#define TOLUA_PROPERTY_TYPE(p) + +typedef int lua_Object; + +#include "lua.h" +#include "lauxlib.h" + +struct tolua_Error +{ + int index; + int array; + const char* type; +}; +typedef struct tolua_Error tolua_Error; + +#define TOLUA_NOPEER LUA_REGISTRYINDEX /* for lua 5.1 */ + +TOLUA_API const char* tolua_typename (lua_State* L, int lo); +TOLUA_API void tolua_error (lua_State* L, const char* msg, tolua_Error* err); +TOLUA_API int tolua_isnoobj (lua_State* L, int lo, tolua_Error* err); +TOLUA_API int tolua_isvalue (lua_State* L, int lo, int def, tolua_Error* err); +TOLUA_API int tolua_isvaluenil (lua_State* L, int lo, tolua_Error* err); +TOLUA_API int tolua_isboolean (lua_State* L, int lo, int def, tolua_Error* err); +TOLUA_API int tolua_isnumber (lua_State* L, int lo, int def, tolua_Error* err); +TOLUA_API int tolua_isstring (lua_State* L, int lo, int def, tolua_Error* err); +TOLUA_API int tolua_istable (lua_State* L, int lo, int def, tolua_Error* err); +TOLUA_API int tolua_isusertable (lua_State* L, int lo, const char* type, int def, tolua_Error* err); +TOLUA_API int tolua_isuserdata (lua_State* L, int lo, int def, tolua_Error* err); +TOLUA_API int tolua_isusertype (lua_State* L, int lo, const char* type, int def, tolua_Error* err); +TOLUA_API int tolua_isvaluearray + (lua_State* L, int lo, int dim, int def, tolua_Error* err); +TOLUA_API int tolua_isbooleanarray + (lua_State* L, int lo, int dim, int def, tolua_Error* err); +TOLUA_API int tolua_isnumberarray + (lua_State* L, int lo, int dim, int def, tolua_Error* err); +TOLUA_API int tolua_isstringarray + (lua_State* L, int lo, int dim, int def, tolua_Error* err); +TOLUA_API int tolua_istablearray + (lua_State* L, int lo, int dim, int def, tolua_Error* err); +TOLUA_API int tolua_isuserdataarray + (lua_State* L, int lo, int dim, int def, tolua_Error* err); +TOLUA_API int tolua_isusertypearray + (lua_State* L, int lo, const char* type, int dim, int def, tolua_Error* err); + +TOLUA_API void tolua_open (lua_State* L); + +TOLUA_API void* tolua_copy (lua_State* L, void* value, unsigned int size); +TOLUA_API int tolua_register_gc (lua_State* L, int lo); +TOLUA_API int tolua_default_collect (lua_State* tolua_S); + +TOLUA_API void tolua_usertype (lua_State* L, const char* type); +TOLUA_API void tolua_beginmodule (lua_State* L, const char* name); +TOLUA_API void tolua_endmodule (lua_State* L); +TOLUA_API void tolua_module (lua_State* L, const char* name, int hasvar); +TOLUA_API void tolua_class (lua_State* L, const char* name, const char* base); +TOLUA_API void tolua_cclass (lua_State* L, const char* lname, const char* name, const char* base, lua_CFunction col); +TOLUA_API void tolua_function (lua_State* L, const char* name, lua_CFunction func); +TOLUA_API void tolua_constant (lua_State* L, const char* name, lua_Number value); +TOLUA_API void tolua_variable (lua_State* L, const char* name, lua_CFunction get, lua_CFunction set); +TOLUA_API void tolua_array (lua_State* L,const char* name, lua_CFunction get, lua_CFunction set); + +/* TOLUA_API void tolua_set_call_event(lua_State* L, lua_CFunction func, char* type); */ +/* TOLUA_API void tolua_addbase(lua_State* L, char* name, char* base); */ + +TOLUA_API void tolua_pushvalue (lua_State* L, int lo); +TOLUA_API void tolua_pushboolean (lua_State* L, int value); +TOLUA_API void tolua_pushnumber (lua_State* L, lua_Number value); +TOLUA_API void tolua_pushstring (lua_State* L, const char* value); +TOLUA_API void tolua_pushuserdata (lua_State* L, void* value); +TOLUA_API void tolua_pushusertype (lua_State* L, void* value, const char* type); +TOLUA_API void tolua_pushusertype_and_takeownership(lua_State* L, void* value, const char* type); +TOLUA_API void tolua_pushfieldvalue (lua_State* L, int lo, int index, int v); +TOLUA_API void tolua_pushfieldboolean (lua_State* L, int lo, int index, int v); +TOLUA_API void tolua_pushfieldnumber (lua_State* L, int lo, int index, lua_Number v); +TOLUA_API void tolua_pushfieldstring (lua_State* L, int lo, int index, const char* v); +TOLUA_API void tolua_pushfielduserdata (lua_State* L, int lo, int index, void* v); +TOLUA_API void tolua_pushfieldusertype (lua_State* L, int lo, int index, void* v, const char* type); +TOLUA_API void tolua_pushfieldusertype_and_takeownership (lua_State* L, int lo, int index, void* v, const char* type); + +TOLUA_API lua_Number tolua_tonumber (lua_State* L, int narg, lua_Number def); +TOLUA_API const char* tolua_tostring (lua_State* L, int narg, const char* def); +TOLUA_API void* tolua_touserdata (lua_State* L, int narg, void* def); +TOLUA_API void* tolua_tousertype (lua_State* L, int narg, void* def); +TOLUA_API int tolua_tovalue (lua_State* L, int narg, int def); +TOLUA_API int tolua_toboolean (lua_State* L, int narg, int def); +TOLUA_API lua_Number tolua_tofieldnumber (lua_State* L, int lo, int index, lua_Number def); +TOLUA_API const char* tolua_tofieldstring (lua_State* L, int lo, int index, const char* def); +TOLUA_API void* tolua_tofielduserdata (lua_State* L, int lo, int index, void* def); +TOLUA_API void* tolua_tofieldusertype (lua_State* L, int lo, int index, void* def); +TOLUA_API int tolua_tofieldvalue (lua_State* L, int lo, int index, int def); +TOLUA_API int tolua_getfieldboolean (lua_State* L, int lo, int index, int def); + +TOLUA_API void tolua_dobuffer(lua_State* L, char* B, unsigned int size, const char* name); + +TOLUA_API int class_gc_event (lua_State* L); + +#ifdef __cplusplus +static inline const char* tolua_tocppstring (lua_State* L, int narg, const char* def) { + + const char* s = tolua_tostring(L, narg, def); + return s?s:""; +}; + +static inline const char* tolua_tofieldcppstring (lua_State* L, int lo, int index, const char* def) { + + const char* s = tolua_tofieldstring(L, lo, index, def); + return s?s:""; +}; + +#else +#define tolua_tocppstring tolua_tostring +#define tolua_tofieldcppstring tolua_tofieldstring +#endif + +TOLUA_API int tolua_fast_isa(lua_State *L, int mt_indexa, int mt_indexb, int super_index); + +#ifndef Mtolua_new +#define Mtolua_new(EXP) new EXP +#endif + +#ifndef Mtolua_delete +#define Mtolua_delete(EXP) delete EXP +#endif + +#ifndef Mtolua_new_dim +#define Mtolua_new_dim(EXP, len) new EXP[len] +#endif + +#ifndef Mtolua_delete_dim +#define Mtolua_delete_dim(EXP) delete [] EXP +#endif + +#ifndef tolua_outside +#define tolua_outside +#endif + +#ifndef tolua_owned +#define tolua_owned +#endif + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/source/tolua_base.h b/source/tolua_base.h new file mode 100644 index 000000000..28ab9d41d --- /dev/null +++ b/source/tolua_base.h @@ -0,0 +1,125 @@ +#ifndef TOLUA_BASE_H
+#define TOLUA_BASE_H
+
+#pragma warning(disable:4800) // This file is ONLY included by Bindings.cpp and it throws lots of C4800 warnings
+
+#include "tolua++.h"
+#include "cMCLogger.h"
+
+class ToluaBase {
+
+ int lua_instance;
+
+protected:
+
+ lua_State* lua_state;
+
+ void lua_stacktrace(lua_State* L) const
+ {
+ lua_Debug entry;
+ int depth = 0;
+
+ while (lua_getstack(L, depth, &entry))
+ {
+ lua_getinfo(L, "Sln", &entry);
+
+ LOGERROR("%s(%d): %s", entry.short_src, entry.currentline, entry.name ? entry.name : "?");
+ depth++;
+ }
+ }
+
+
+ bool report_errors(int status) const
+ {
+ if ( status!=0 )
+ {
+ const char* s = lua_tostring(lua_state, -1);
+ LOGERROR("-- %s", s );
+ //lua_pop(lua_state, 1);
+ LOGERROR("Stack:");
+ lua_stacktrace( lua_state );
+ return true;
+ }
+ return false;
+ }
+
+ bool push_method(const char* name, lua_CFunction f) const {
+
+ if (!lua_state) return false;
+
+ lua_getref(lua_state, lua_instance);
+ lua_pushstring(lua_state, name);
+ //LOGINFO("1. push_method() Stack size: %i", lua_gettop( lua_state ) );
+ lua_gettable(lua_state, -2);
+ //LOGINFO("2. push_method() Stack size: %i", lua_gettop( lua_state ) );
+
+ if (lua_isnil(lua_state, -1)) {
+
+ // pop the table
+ lua_pop(lua_state, 2);
+ return false;
+
+ } else {
+
+ if (f) {
+ if (lua_iscfunction(lua_state, -1)) {
+ lua_pop(lua_state, 2);
+ return false;
+ };
+ /* // not for now
+ lua_pushcfunction(lua_state, f);
+ if (lua_rawequal(lua_state, -1, -2)) {
+
+ // avoid recursion, pop both functions and the table
+ lua_pop(lua_state, 3);
+ return false;
+ };
+
+ // pop f
+ lua_pop(lua_state, 1);
+ */
+ };
+
+ // swap table with function
+ lua_insert(lua_state, -2);
+ };
+
+ return true;
+ };
+
+ void dbcall(lua_State* L, int nargs, int nresults) const {
+
+ // using lua_call for now
+ int s = lua_pcall(L, nargs, nresults, 0);
+ report_errors( s );
+ };
+public:
+
+ int GetInstance() { return lua_instance; }
+ lua_State* GetLuaState() { return lua_state; }
+
+ void tolua__set_instance(lua_State* L, lua_Object lo) {
+
+ lua_state = L;
+
+ lua_pushvalue(L, lo);
+ lua_instance = lua_ref(lua_state, 1);
+ };
+
+ ToluaBase() {
+
+ lua_state = NULL;
+ };
+
+ ~ToluaBase() {
+
+ if (lua_state) {
+
+ lua_unref(lua_state, lua_instance);
+ };
+ };
+};
+
+#endif
+
+
diff --git a/source/virtual_method_hooks.lua b/source/virtual_method_hooks.lua new file mode 100644 index 000000000..71b0e4cf8 --- /dev/null +++ b/source/virtual_method_hooks.lua @@ -0,0 +1,506 @@ +-- flags
+local disable_virtual_hooks = false
+local enable_pure_virtual = true
+local default_private_access = false
+
+local access = {public = 0, protected = 1, private = 2}
+
+function preparse_hook(p)
+
+ if default_private_access then
+ -- we need to make all structs 'public' by default
+ p.code = string.gsub(p.code, "(struct[^;]*{)", "%1\npublic:\n")
+ end
+end
+
+
+function parser_hook(s)
+
+ local container = classContainer.curr -- get the current container
+
+ if default_private_access then
+ if not container.curr_member_access and container.classtype == 'class' then
+ -- default access for classes is private
+ container.curr_member_access = access.private
+ end
+ end
+
+ -- try labels (public, private, etc)
+ do
+ local b,e,label = string.find(s, "^%s*(%w*)%s*:[^:]") -- we need to check for [^:], otherwise it would match 'namespace::type'
+ if b then
+
+ -- found a label, get the new access value from the global 'access' table
+ if access[label] then
+ container.curr_member_access = access[label]
+ end -- else ?
+
+ return strsub(s, e) -- normally we would use 'e+1', but we need to preserve the [^:]
+ end
+ end
+
+
+ local ret = nil
+
+ if disable_virtual_hooks then
+
+ return ret
+ end
+
+ local b,e,decl,arg = string.find(s, "^%s*virtual%s+([^%({~]+)(%b())")
+ local const
+ if b then
+ local ret = string.sub(s, e+1)
+ if string.find(ret, "^%s*const") then
+ const = "const"
+ ret = string.gsub(ret, "^%s*const", "")
+ end
+ local purev = false
+ if string.find(ret, "^%s*=%s*0") then
+ purev = true
+ ret = string.gsub(ret, "^%s*=%s*0", "")
+ end
+ ret = string.gsub(ret, "^%s*%b{}", "")
+
+ local func = Function(decl, arg, const)
+ func.pure_virtual = purev
+ --func.access = access
+ func.original_sig = decl
+
+ local curflags = classContainer.curr.flags
+ if not curflags.virtual_class then
+
+ curflags.virtual_class = VirtualClass()
+ end
+ curflags.virtual_class:add(func)
+ curflags.pure_virtual = curflags.pure_virtual or purev
+
+ return ret
+ end
+
+ return ret
+end
+
+
+-- class VirtualClass
+classVirtualClass = {
+ classtype = 'class',
+ name = '',
+ base = '',
+ type = '',
+ btype = '',
+ ctype = '',
+}
+classVirtualClass.__index = classVirtualClass
+setmetatable(classVirtualClass,classClass)
+
+function classVirtualClass:add(f)
+
+ local parent = classContainer.curr
+ pop()
+
+ table.insert(self.methods, {f=f})
+
+ local name,sig
+
+ -- doble negative means positive
+ if f.name == 'new' and ((not self.flags.parent_object.flags.pure_virtual) or (enable_pure_virtual)) then
+
+ name = self.original_name
+ elseif f.name == 'delete' then
+ name = '~'..self.original_name
+ else
+ if f.access ~= 2 and (not f.pure_virtual) and f.name ~= 'new' and f.name ~= 'delete' then
+ name = f.mod.." "..f.type..f.ptr.." "..self.flags.parent_object.lname.."__"..f.name
+ end
+ end
+
+ if name then
+ sig = name..self:get_arg_list(f, true)..";\n"
+ push(self)
+ sig = preprocess(sig)
+ self:parse(sig)
+ pop()
+ end
+
+ push(parent)
+end
+
+function preprocess(sig)
+
+ sig = gsub(sig,"([^%w_])void%s*%*","%1_userdata ") -- substitute 'void*'
+ sig = gsub(sig,"([^%w_])void%s*%*","%1_userdata ") -- substitute 'void*'
+ sig = gsub(sig,"([^%w_])char%s*%*","%1_cstring ") -- substitute 'char*'
+ sig = gsub(sig,"([^%w_])lua_State%s*%*","%1_lstate ") -- substitute 'lua_State*'
+
+ return sig
+end
+
+function classVirtualClass:get_arg_list(f, decl)
+
+ local ret = ""
+ local sep = ""
+ local i=1
+ while f.args[i] do
+
+ local arg = f.args[i]
+ if decl then
+ local ptr
+ if arg.ret ~= '' then
+ ptr = arg.ret
+ else
+ ptr = arg.ptr
+ end
+ local def = ""
+ if arg.def and arg.def ~= "" then
+
+ def = " = "..arg.def
+ end
+ ret = ret..sep..arg.mod.." "..arg.type..ptr.." "..arg.name..def
+ else
+ ret = ret..sep..arg.name
+ end
+
+ sep = ","
+ i = i+1
+ end
+
+ return "("..ret..")"
+end
+
+function classVirtualClass:add_parent_virtual_methods(parent)
+
+ parent = parent or _global_classes[self.flags.parent_object.btype]
+
+ if not parent then return end
+
+ if parent.flags.virtual_class then
+
+ local vclass = parent.flags.virtual_class
+ for k,v in ipairs(vclass.methods) do
+ if v.f.name ~= 'new' and v.f.name ~= 'delete' and (not self:has_method(v.f)) then
+ table.insert(self.methods, {f=v.f})
+ end
+ end
+ end
+
+ parent = _global_classes[parent.btype]
+ if parent then
+ self:add_parent_virtual_methods(parent)
+ end
+end
+
+function classVirtualClass:has_method(f)
+
+ for k,v in pairs(self.methods) do
+ -- just match name for now
+ if v.f.name == f.name then
+ return true
+ end
+ end
+
+ return false
+end
+
+function classVirtualClass:add_constructors()
+
+ local i=1
+ while self.flags.parent_object[i] do
+
+ local v = self.flags.parent_object[i]
+ if getmetatable(v) == classFunction and (v.name == 'new' or v.name == 'delete') then
+
+ self:add(v)
+ end
+
+ i = i+1
+ end
+
+end
+
+--[[
+function classVirtualClass:requirecollection(t)
+
+ self:add_constructors()
+ local req = classClass.requirecollection(self, t)
+ if req then
+ output('class ',self.name,";")
+ end
+ return req
+end
+--]]
+
+function classVirtualClass:supcode()
+
+ -- pure virtual classes can have no default constructors on gcc 4
+
+ if self.flags.parent_object.flags.pure_virtual and not enable_pure_virtual then
+ output('#if (__GNUC__ == 4) || (__GNUC__ > 4 ) // I hope this works on Microsoft Visual studio .net server 2003 XP Compiler\n')
+ end
+
+ local ns
+ if self.prox.classtype == 'namespace' then
+ output('namespace ',self.prox.name, " {")
+ ns = true
+ end
+
+ output("class "..self.original_name.." : public "..self.btype..", public ToluaBase {")
+
+ output("public:\n")
+
+ self:add_parent_virtual_methods()
+
+ self:output_methods(self.btype)
+ self:output_parent_methods()
+
+ self:add_constructors()
+
+ -- no constructor for pure virtual classes
+ if (not self.flags.parent_object.flags.pure_virtual) or enable_pure_virtual then
+
+ self:output_constructors()
+ end
+
+ output("};\n\n")
+
+ if ns then
+ output("};")
+ end
+
+ classClass.supcode(self)
+
+ if self.flags.parent_object.flags.pure_virtual and not enable_pure_virtual then
+ output('#endif // __GNUC__ >= 4\n')
+ end
+
+ -- output collector for custom class if required
+ if self:requirecollection(_collect) and _collect[self.type] then
+
+ output('\n')
+ output('/* function to release collected object via destructor */')
+ output('#ifdef __cplusplus\n')
+ --for i,v in pairs(collect) do
+ i,v = self.type, _collect[self.type]
+ output('\nstatic int '..v..' (lua_State* tolua_S)')
+ output('{')
+ output(' '..i..'* self = ('..i..'*) tolua_tousertype(tolua_S,1,0);')
+ output(' delete self;')
+ output(' return 0;')
+ output('}')
+ --end
+ output('#endif\n\n')
+ end
+
+end
+
+function classVirtualClass:register(pre)
+
+ -- pure virtual classes can have no default constructors on gcc 4
+ if self.flags.parent_object.flags.pure_virtual and not enable_pure_virtual then
+ output('#if (__GNUC__ == 4) || (__GNUC__ > 4 )\n')
+ end
+
+ classClass.register(self, pre)
+
+ if self.flags.parent_object.flags.pure_virtual and not enable_pure_virtual then
+ output('#endif // __GNUC__ >= 4\n')
+ end
+end
+
+
+--function classVirtualClass:requirecollection(_c)
+-- if self.flags.parent_object.flags.pure_virtual then
+-- return false
+-- end
+-- return classClass.requirecollection(self, _c)
+--end
+
+function classVirtualClass:output_parent_methods()
+
+ for k,v in ipairs(self.methods) do
+
+ if v.f.access ~= 2 and (not v.f.pure_virtual) and v.f.name ~= 'new' and v.f.name ~= 'delete' then
+
+ local rettype = v.f.mod.." "..v.f.type..v.f.ptr.." "
+ local parent_name = rettype..self.btype.."__"..v.f.name
+
+ local par_list = self:get_arg_list(v.f, true)
+ local var_list = self:get_arg_list(v.f, false)
+
+ -- the parent's virtual function
+ output("\t"..parent_name..par_list.." {")
+
+ output("\t\treturn (",rettype,")"..self.btype.."::"..v.f.name..var_list..";")
+ output("\t};")
+ end
+ end
+end
+
+function classVirtualClass:output_methods(btype)
+
+ for k,v in ipairs(self.methods) do
+
+ if v.f.name ~= 'new' and v.f.name ~= 'delete' then
+
+ self:output_method(v.f, btype)
+ end
+ end
+ output("\n")
+end
+
+function classVirtualClass:output_constructors()
+
+ for k,v in ipairs(self.methods) do
+
+ if v.f.name == 'new' then
+
+ local par_list = self:get_arg_list(v.f, true)
+ local var_list = self:get_arg_list(v.f, false)
+
+ output("\t",self.original_name,par_list,":",self.btype,var_list,"{};")
+ end
+ end
+end
+
+function classVirtualClass:output_method(f, btype)
+
+ if f.access == 2 then -- private
+ return
+ end
+
+ local ptr
+ if f.ret ~= '' then
+ ptr = f.ret
+ else
+ ptr = f.ptr
+ end
+
+ local rettype = f.mod.." "..f.type..f.ptr.." "
+ local par_list = self:get_arg_list(f, true)
+ local var_list = self:get_arg_list(f, false)
+
+ if string.find(rettype, "%s*LuaQtGenericFlags%s*") then
+
+ _,_,rettype = string.find(f.original_sig, "^%s*([^%s]+)%s+")
+ end
+
+ -- the caller of the lua method
+ output("\t"..rettype.." "..f.name..par_list..f.const.." {")
+ local fn = f.cname
+ if f.access == 1 then
+ fn = "NULL"
+ end
+ output('\t\tif (push_method("',f.lname,'", ',fn,')) {')
+
+ --if f.type ~= 'void' then
+ -- output("\t\t\tint top = lua_gettop(lua_state)-1;")
+ --end
+
+ -- push the parameters
+ local argn = 0
+ for i,arg in ipairs(f.args) do
+ if arg.type ~= 'void' then
+ local t,ct = isbasic(arg.type)
+ if t and t ~= '' then
+ if arg.ret == "*" then
+ t = 'userdata'
+ ct = 'void*'
+ end
+ output("\t\t\ttolua_push"..t.."(lua_state, ("..ct..")"..arg.name..");");
+ else
+ local m = arg.ptr
+ if m and m~= "" then
+ if m == "*" then m = "" end
+ output("\t\t\ttolua_pushusertype(lua_state, (void*)"..m..arg.name..", \""..arg.type.."\");")
+ else
+ output("\t\t\tvoid* tolua_obj = (void*)new "..arg.type.."("..arg.name..");\n")
+ output('\t\t\ttolua_pushusertype_and_takeownership(lua_state, tolua_obj, "'..arg.type..'");\n')
+ end
+ end
+ argn = argn+1
+ end
+ end
+
+ -- call the function
+ output("\t\t\tToluaBase::dbcall(lua_state, ",argn+1,", ")
+
+ -- return value
+ if f.type ~= 'void' then
+ output("1);")
+
+ local t,ct = isbasic(f.type)
+ if t and t ~= '' then
+ --output("\t\t\treturn ("..rettype..")tolua_to"..t.."(lua_state, top, 0);")
+ output("\t\t\t",rettype,"tolua_ret = ("..rettype..")tolua_to"..t.."(lua_state, -1, 0);")
+ else
+
+ local mod = ""
+ if f.ptr ~= "*" then
+ mod = "*("..f.type.."*)"
+ end
+
+ --output("\t\t\treturn ("..rettype..")"..mod.."tolua_tousertype(lua_state, top, 0);")
+ output("\t\t\t",rettype,"tolua_ret = ("..rettype..")"..mod.."tolua_tousertype(lua_state, -1, 0);")
+ end
+ output("\t\t\tlua_pop(lua_state, 1);")
+ output("\t\t\treturn tolua_ret;")
+ else
+ output("0);")
+ end
+
+ -- handle non-implemeted function
+ output("\t\t} else {")
+
+ if f.pure_virtual then
+
+ output('\t\t\tif (lua_state)')
+ --output('\t\t\t\ttolua_error(lua_state, "pure-virtual method '..btype.."::"..f.name..' not implemented.", NULL);')
+ output('\t\t\t\tLOG("pure-virtual method '..btype.."::"..f.name..' not implemented.");')
+ output('\t\t\telse {')
+ output('\t\t\t\tLOG("pure-virtual method '..btype.."::"..f.name..' called with no lua_state. Aborting");')
+ output('\t\t\t\t::abort();')
+ output('\t\t\t};')
+ if( rettype == " std::string " ) then
+ output('\t\t\treturn "";')
+ else
+ output('\t\t\treturn (',rettype,')0;')
+ end
+ else
+
+ output('\t\t\treturn (',rettype,')',btype,'::',f.name,var_list,';')
+ end
+
+ output("\t\t};")
+
+ output("\t};")
+end
+
+function VirtualClass()
+
+ local parent = classContainer.curr
+ pop()
+
+ local name = "Lua__"..parent.original_name
+
+ local c = _Class(_Container{name=name, base=parent.name, extra_bases=nil})
+ setmetatable(c, classVirtualClass)
+
+ local ft = getnamespace(c.parent)..c.original_name
+ append_global_type(ft, c)
+
+ push(parent)
+
+ c.flags.parent_object = parent
+ c.methods = {}
+
+ push(c)
+ c:parse("\nvoid tolua__set_instance(_lstate L, lua_Object lo);\n")
+ pop()
+
+ return c
+end
+
+
+
+
+
|