From 386d58b5862d8b76925c6523721594887606e82a Mon Sep 17 00:00:00 2001 From: faketruth Date: Mon, 3 Oct 2011 18:41:19 +0000 Subject: MCServer c++ source files git-svn-id: http://mc-server.googlecode.com/svn/trunk@3 0a769ca7-a7f5-676a-18bf-c427514a06d6 --- source/AllToLua.bat | 3 + source/AllToLua.pkg | 41 + source/Bindings.cpp | 15468 ++++++++++++++++++++ source/Bindings.h | 8 + source/BlockID.h | 151 + source/Defines.h | 129 + source/Endianness.h | 51 + source/FileDefine.h | 21 + source/LuaFunctions.h | 17 + source/MCSocket.h | 41 + source/ManualBindings.cpp | 229 + source/ManualBindings.h | 8 + source/Matrix4f.cpp | 0 source/Matrix4f.h | 111 + source/MemoryLeak.h | 18 + source/PacketID.h | 52 + source/Vector3d.cpp | 16 + source/Vector3d.h | 40 + source/Vector3f.cpp | 31 + source/Vector3f.h | 47 + source/Vector3i.cpp | 9 + source/Vector3i.h | 37 + source/cAuthenticator.cpp | 194 + source/cAuthenticator.h | 13 + source/cBlockEntity.h | 34 + source/cBlockToPickup.cpp | 37 + source/cBlockToPickup.h | 13 + source/cBlockingTCPLink.cpp | 137 + source/cBlockingTCPLink.h | 21 + source/cChatColor.cpp | 25 + source/cChatColor.h | 32 + source/cChestEntity.cpp | 185 + source/cChestEntity.h | 42 + source/cChicken.cpp | 90 + source/cChicken.h | 21 + source/cChunk.cpp | 1388 ++ source/cChunk.h | 127 + source/cChunkLoader.cpp | 364 + source/cChunkLoader.h | 32 + source/cChunkMap.cpp | 714 + source/cChunkMap.h | 91 + source/cClientHandle.cpp | 1082 ++ source/cClientHandle.h | 70 + source/cCraftingWindow.cpp | 103 + source/cCraftingWindow.h | 13 + source/cCriticalSection.cpp | 60 + source/cCriticalSection.h | 16 + source/cCuboid.cpp | 10 + source/cCuboid.h | 40 + source/cEntity.cpp | 283 + source/cEntity.h | 108 + source/cEvent.cpp | 112 + source/cEvent.h | 18 + source/cFurnaceEntity.cpp | 372 + source/cFurnaceEntity.h | 43 + source/cFurnaceRecipe.cpp | 214 + source/cFurnaceRecipe.h | 34 + source/cFurnaceWindow.cpp | 42 + source/cFurnaceWindow.h | 16 + source/cGenSettings.cpp | 10 + source/cGenSettings.h | 9 + source/cGroup.cpp | 34 + source/cGroup.h | 39 + source/cGroupManager.cpp | 104 + source/cGroupManager.h | 17 + source/cHeartBeat.cpp | 119 + source/cHeartBeat.h | 21 + source/cInventory.cpp | 364 + source/cInventory.h | 67 + source/cItem.h | 33 + source/cLadder.h | 43 + source/cLog.cpp | 136 + source/cLog.h | 30 + source/cLuaCommandBinder.cpp | 106 + source/cLuaCommandBinder.h | 36 + source/cMCLogger.cpp | 155 + source/cMCLogger.h | 39 + source/cMakeDir.cpp | 24 + source/cMakeDir.h | 7 + source/cMonster.cpp | 609 + source/cMonster.h | 85 + source/cMonsterConfig.cpp | 93 + source/cMonsterConfig.h | 18 + source/cNoise.cpp | 253 + source/cNoise.h | 33 + source/cPawn.cpp | 96 + source/cPawn.h | 31 + source/cPickup.cpp | 229 + source/cPickup.h | 34 + source/cPlayer.cpp | 713 + source/cPlayer.h | 96 + source/cPlugin.cpp | 78 + source/cPlugin.h | 76 + source/cPluginManager.cpp | 423 + source/cPluginManager.h | 68 + source/cPlugin_Lua.cpp | 97 + source/cPlugin_Lua.h | 34 + source/cRecipeChecker.cpp | 458 + source/cRecipeChecker.h | 39 + source/cReferenceManager.cpp | 36 + source/cReferenceManager.h | 22 + source/cRoot.cpp | 162 + source/cRoot.h | 52 + source/cSemaphore.cpp | 96 + source/cSemaphore.h | 17 + source/cServer.cpp | 553 + source/cServer.h | 53 + source/cSign.h | 32 + source/cSignEntity.cpp | 136 + source/cSignEntity.h | 34 + source/cSleep.cpp | 16 + source/cSleep.h | 7 + source/cSocket.cpp | 30 + source/cSocket.h | 43 + source/cSpider.cpp | 92 + source/cSpider.h | 22 + source/cStairs.h | 19 + source/cStringMap.cpp | 16 + source/cStringMap.h | 19 + source/cTCPLink.cpp | 146 + source/cTCPLink.h | 23 + source/cThread.cpp | 75 + source/cThread.h | 25 + source/cTimer.cpp | 39 + source/cTimer.h | 15 + source/cTorch.h | 51 + source/cTracer.cpp | 377 + source/cTracer.h | 32 + source/cWaterSimulator.cpp | 216 + source/cWaterSimulator.h | 25 + source/cWebAdmin.cpp | 309 + source/cWebAdmin.h | 60 + source/cWebPlugin.cpp | 22 + source/cWebPlugin.h | 25 + source/cWindow.cpp | 235 + source/cWindow.h | 67 + source/cWindowOwner.h | 16 + source/cWorld.cpp | 764 + source/cWorld.h | 158 + source/main.cpp | 36 + source/md5/md5.cpp | 366 + source/md5/md5.h | 93 + source/packets/cPacket.cpp | 223 + source/packets/cPacket.h | 56 + source/packets/cPacket_13.cpp | 10 + source/packets/cPacket_13.h | 30 + source/packets/cPacket_AddToInventory.cpp | 17 + source/packets/cPacket_AddToInventory.h | 23 + source/packets/cPacket_ArmAnim.cpp | 24 + source/packets/cPacket_ArmAnim.h | 21 + source/packets/cPacket_BlockChange.cpp | 19 + source/packets/cPacket_BlockChange.h | 26 + source/packets/cPacket_BlockDig.cpp | 29 + source/packets/cPacket_BlockDig.h | 27 + source/packets/cPacket_BlockPlace.cpp | 18 + source/packets/cPacket_BlockPlace.h | 32 + source/packets/cPacket_Chat.cpp | 23 + source/packets/cPacket_Chat.h | 18 + source/packets/cPacket_CollectItem.cpp | 16 + source/packets/cPacket_CollectItem.h | 20 + source/packets/cPacket_DestroyEntity.cpp | 23 + source/packets/cPacket_DestroyEntity.h | 20 + source/packets/cPacket_Disconnect.cpp | 22 + source/packets/cPacket_Disconnect.h | 18 + source/packets/cPacket_EntityEquipment.cpp | 42 + source/packets/cPacket_EntityEquipment.h | 27 + source/packets/cPacket_EntityLook.cpp | 28 + source/packets/cPacket_EntityLook.h | 25 + source/packets/cPacket_EntityStatus.cpp | 17 + source/packets/cPacket_EntityStatus.h | 24 + source/packets/cPacket_Flying.cpp | 8 + source/packets/cPacket_Flying.h | 19 + source/packets/cPacket_Handshake.cpp | 24 + source/packets/cPacket_Handshake.h | 17 + source/packets/cPacket_InventoryProgressBar.cpp | 18 + source/packets/cPacket_InventoryProgressBar.h | 23 + source/packets/cPacket_InventorySlot.cpp | 23 + source/packets/cPacket_InventorySlot.h | 34 + source/packets/cPacket_ItemSwitch.cpp | 23 + source/packets/cPacket_ItemSwitch.h | 19 + source/packets/cPacket_KeepAlive.cpp | 22 + source/packets/cPacket_KeepAlive.h | 18 + source/packets/cPacket_Login.cpp | 41 + source/packets/cPacket_Login.h | 33 + source/packets/cPacket_MapChunk.cpp | 69 + source/packets/cPacket_MapChunk.h | 37 + source/packets/cPacket_Metadata.cpp | 65 + source/packets/cPacket_Metadata.h | 23 + source/packets/cPacket_MultiBlock.cpp | 42 + source/packets/cPacket_MultiBlock.h | 32 + source/packets/cPacket_NamedEntitySpawn.cpp | 26 + source/packets/cPacket_NamedEntitySpawn.h | 32 + source/packets/cPacket_PickupSpawn.cpp | 40 + source/packets/cPacket_PickupSpawn.h | 38 + source/packets/cPacket_Ping.h | 16 + source/packets/cPacket_PlayerLook.cpp | 36 + source/packets/cPacket_PlayerLook.h | 25 + source/packets/cPacket_PlayerMoveLook.cpp | 50 + source/packets/cPacket_PlayerMoveLook.h | 33 + source/packets/cPacket_PlayerPosition.cpp | 42 + source/packets/cPacket_PlayerPosition.h | 29 + source/packets/cPacket_PreChunk.cpp | 17 + source/packets/cPacket_PreChunk.h | 22 + source/packets/cPacket_RelativeEntityMove.cpp | 18 + source/packets/cPacket_RelativeEntityMove.h | 25 + source/packets/cPacket_RelativeEntityMoveLook.cpp | 20 + source/packets/cPacket_RelativeEntityMoveLook.h | 29 + source/packets/cPacket_Respawn.cpp | 31 + source/packets/cPacket_Respawn.h | 28 + source/packets/cPacket_SpawnMob.cpp | 60 + source/packets/cPacket_SpawnMob.h | 27 + source/packets/cPacket_TeleportEntity.cpp | 34 + source/packets/cPacket_TeleportEntity.h | 31 + source/packets/cPacket_TimeUpdate.cpp | 22 + source/packets/cPacket_TimeUpdate.h | 20 + source/packets/cPacket_UpdateHealth.cpp | 20 + source/packets/cPacket_UpdateHealth.h | 24 + source/packets/cPacket_UpdateSign.cpp | 41 + source/packets/cPacket_UpdateSign.h | 28 + source/packets/cPacket_UseEntity.cpp | 10 + source/packets/cPacket_UseEntity.h | 23 + source/packets/cPacket_WholeInventory.cpp | 68 + source/packets/cPacket_WholeInventory.h | 31 + source/packets/cPacket_WindowClick.cpp | 36 + source/packets/cPacket_WindowClick.h | 41 + source/packets/cPacket_WindowClose.cpp | 27 + source/packets/cPacket_WindowClose.h | 20 + source/packets/cPacket_WindowOpen.cpp | 18 + source/packets/cPacket_WindowOpen.h | 24 + source/tolua++.exe | Bin 0 -> 192000 bytes source/tolua++.h | 186 + source/tolua_base.h | 125 + source/virtual_method_hooks.lua | 506 + 233 files changed, 35759 insertions(+) create mode 100644 source/AllToLua.bat create mode 100644 source/AllToLua.pkg create mode 100644 source/Bindings.cpp create mode 100644 source/Bindings.h create mode 100644 source/BlockID.h create mode 100644 source/Defines.h create mode 100644 source/Endianness.h create mode 100644 source/FileDefine.h create mode 100644 source/LuaFunctions.h create mode 100644 source/MCSocket.h create mode 100644 source/ManualBindings.cpp create mode 100644 source/ManualBindings.h create mode 100644 source/Matrix4f.cpp create mode 100644 source/Matrix4f.h create mode 100644 source/MemoryLeak.h create mode 100644 source/PacketID.h create mode 100644 source/Vector3d.cpp create mode 100644 source/Vector3d.h create mode 100644 source/Vector3f.cpp create mode 100644 source/Vector3f.h create mode 100644 source/Vector3i.cpp create mode 100644 source/Vector3i.h create mode 100644 source/cAuthenticator.cpp create mode 100644 source/cAuthenticator.h create mode 100644 source/cBlockEntity.h create mode 100644 source/cBlockToPickup.cpp create mode 100644 source/cBlockToPickup.h create mode 100644 source/cBlockingTCPLink.cpp create mode 100644 source/cBlockingTCPLink.h create mode 100644 source/cChatColor.cpp create mode 100644 source/cChatColor.h create mode 100644 source/cChestEntity.cpp create mode 100644 source/cChestEntity.h create mode 100644 source/cChicken.cpp create mode 100644 source/cChicken.h create mode 100644 source/cChunk.cpp create mode 100644 source/cChunk.h create mode 100644 source/cChunkLoader.cpp create mode 100644 source/cChunkLoader.h create mode 100644 source/cChunkMap.cpp create mode 100644 source/cChunkMap.h create mode 100644 source/cClientHandle.cpp create mode 100644 source/cClientHandle.h create mode 100644 source/cCraftingWindow.cpp create mode 100644 source/cCraftingWindow.h create mode 100644 source/cCriticalSection.cpp create mode 100644 source/cCriticalSection.h create mode 100644 source/cCuboid.cpp create mode 100644 source/cCuboid.h create mode 100644 source/cEntity.cpp create mode 100644 source/cEntity.h create mode 100644 source/cEvent.cpp create mode 100644 source/cEvent.h create mode 100644 source/cFurnaceEntity.cpp create mode 100644 source/cFurnaceEntity.h create mode 100644 source/cFurnaceRecipe.cpp create mode 100644 source/cFurnaceRecipe.h create mode 100644 source/cFurnaceWindow.cpp create mode 100644 source/cFurnaceWindow.h create mode 100644 source/cGenSettings.cpp create mode 100644 source/cGenSettings.h create mode 100644 source/cGroup.cpp create mode 100644 source/cGroup.h create mode 100644 source/cGroupManager.cpp create mode 100644 source/cGroupManager.h create mode 100644 source/cHeartBeat.cpp create mode 100644 source/cHeartBeat.h create mode 100644 source/cInventory.cpp create mode 100644 source/cInventory.h create mode 100644 source/cItem.h create mode 100644 source/cLadder.h create mode 100644 source/cLog.cpp create mode 100644 source/cLog.h create mode 100644 source/cLuaCommandBinder.cpp create mode 100644 source/cLuaCommandBinder.h create mode 100644 source/cMCLogger.cpp create mode 100644 source/cMCLogger.h create mode 100644 source/cMakeDir.cpp create mode 100644 source/cMakeDir.h create mode 100644 source/cMonster.cpp create mode 100644 source/cMonster.h create mode 100644 source/cMonsterConfig.cpp create mode 100644 source/cMonsterConfig.h create mode 100644 source/cNoise.cpp create mode 100644 source/cNoise.h create mode 100644 source/cPawn.cpp create mode 100644 source/cPawn.h create mode 100644 source/cPickup.cpp create mode 100644 source/cPickup.h create mode 100644 source/cPlayer.cpp create mode 100644 source/cPlayer.h create mode 100644 source/cPlugin.cpp create mode 100644 source/cPlugin.h create mode 100644 source/cPluginManager.cpp create mode 100644 source/cPluginManager.h create mode 100644 source/cPlugin_Lua.cpp create mode 100644 source/cPlugin_Lua.h create mode 100644 source/cRecipeChecker.cpp create mode 100644 source/cRecipeChecker.h create mode 100644 source/cReferenceManager.cpp create mode 100644 source/cReferenceManager.h create mode 100644 source/cRoot.cpp create mode 100644 source/cRoot.h create mode 100644 source/cSemaphore.cpp create mode 100644 source/cSemaphore.h create mode 100644 source/cServer.cpp create mode 100644 source/cServer.h create mode 100644 source/cSign.h create mode 100644 source/cSignEntity.cpp create mode 100644 source/cSignEntity.h create mode 100644 source/cSleep.cpp create mode 100644 source/cSleep.h create mode 100644 source/cSocket.cpp create mode 100644 source/cSocket.h create mode 100644 source/cSpider.cpp create mode 100644 source/cSpider.h create mode 100644 source/cStairs.h create mode 100644 source/cStringMap.cpp create mode 100644 source/cStringMap.h create mode 100644 source/cTCPLink.cpp create mode 100644 source/cTCPLink.h create mode 100644 source/cThread.cpp create mode 100644 source/cThread.h create mode 100644 source/cTimer.cpp create mode 100644 source/cTimer.h create mode 100644 source/cTorch.h create mode 100644 source/cTracer.cpp create mode 100644 source/cTracer.h create mode 100644 source/cWaterSimulator.cpp create mode 100644 source/cWaterSimulator.h create mode 100644 source/cWebAdmin.cpp create mode 100644 source/cWebAdmin.h create mode 100644 source/cWebPlugin.cpp create mode 100644 source/cWebPlugin.h create mode 100644 source/cWindow.cpp create mode 100644 source/cWindow.h create mode 100644 source/cWindowOwner.h create mode 100644 source/cWorld.cpp create mode 100644 source/cWorld.h create mode 100644 source/main.cpp create mode 100644 source/md5/md5.cpp create mode 100644 source/md5/md5.h create mode 100644 source/packets/cPacket.cpp create mode 100644 source/packets/cPacket.h create mode 100644 source/packets/cPacket_13.cpp create mode 100644 source/packets/cPacket_13.h create mode 100644 source/packets/cPacket_AddToInventory.cpp create mode 100644 source/packets/cPacket_AddToInventory.h create mode 100644 source/packets/cPacket_ArmAnim.cpp create mode 100644 source/packets/cPacket_ArmAnim.h create mode 100644 source/packets/cPacket_BlockChange.cpp create mode 100644 source/packets/cPacket_BlockChange.h create mode 100644 source/packets/cPacket_BlockDig.cpp create mode 100644 source/packets/cPacket_BlockDig.h create mode 100644 source/packets/cPacket_BlockPlace.cpp create mode 100644 source/packets/cPacket_BlockPlace.h create mode 100644 source/packets/cPacket_Chat.cpp create mode 100644 source/packets/cPacket_Chat.h create mode 100644 source/packets/cPacket_CollectItem.cpp create mode 100644 source/packets/cPacket_CollectItem.h create mode 100644 source/packets/cPacket_DestroyEntity.cpp create mode 100644 source/packets/cPacket_DestroyEntity.h create mode 100644 source/packets/cPacket_Disconnect.cpp create mode 100644 source/packets/cPacket_Disconnect.h create mode 100644 source/packets/cPacket_EntityEquipment.cpp create mode 100644 source/packets/cPacket_EntityEquipment.h create mode 100644 source/packets/cPacket_EntityLook.cpp create mode 100644 source/packets/cPacket_EntityLook.h create mode 100644 source/packets/cPacket_EntityStatus.cpp create mode 100644 source/packets/cPacket_EntityStatus.h create mode 100644 source/packets/cPacket_Flying.cpp create mode 100644 source/packets/cPacket_Flying.h create mode 100644 source/packets/cPacket_Handshake.cpp create mode 100644 source/packets/cPacket_Handshake.h create mode 100644 source/packets/cPacket_InventoryProgressBar.cpp create mode 100644 source/packets/cPacket_InventoryProgressBar.h create mode 100644 source/packets/cPacket_InventorySlot.cpp create mode 100644 source/packets/cPacket_InventorySlot.h create mode 100644 source/packets/cPacket_ItemSwitch.cpp create mode 100644 source/packets/cPacket_ItemSwitch.h create mode 100644 source/packets/cPacket_KeepAlive.cpp create mode 100644 source/packets/cPacket_KeepAlive.h create mode 100644 source/packets/cPacket_Login.cpp create mode 100644 source/packets/cPacket_Login.h create mode 100644 source/packets/cPacket_MapChunk.cpp create mode 100644 source/packets/cPacket_MapChunk.h create mode 100644 source/packets/cPacket_Metadata.cpp create mode 100644 source/packets/cPacket_Metadata.h create mode 100644 source/packets/cPacket_MultiBlock.cpp create mode 100644 source/packets/cPacket_MultiBlock.h create mode 100644 source/packets/cPacket_NamedEntitySpawn.cpp create mode 100644 source/packets/cPacket_NamedEntitySpawn.h create mode 100644 source/packets/cPacket_PickupSpawn.cpp create mode 100644 source/packets/cPacket_PickupSpawn.h create mode 100644 source/packets/cPacket_Ping.h create mode 100644 source/packets/cPacket_PlayerLook.cpp create mode 100644 source/packets/cPacket_PlayerLook.h create mode 100644 source/packets/cPacket_PlayerMoveLook.cpp create mode 100644 source/packets/cPacket_PlayerMoveLook.h create mode 100644 source/packets/cPacket_PlayerPosition.cpp create mode 100644 source/packets/cPacket_PlayerPosition.h create mode 100644 source/packets/cPacket_PreChunk.cpp create mode 100644 source/packets/cPacket_PreChunk.h create mode 100644 source/packets/cPacket_RelativeEntityMove.cpp create mode 100644 source/packets/cPacket_RelativeEntityMove.h create mode 100644 source/packets/cPacket_RelativeEntityMoveLook.cpp create mode 100644 source/packets/cPacket_RelativeEntityMoveLook.h create mode 100644 source/packets/cPacket_Respawn.cpp create mode 100644 source/packets/cPacket_Respawn.h create mode 100644 source/packets/cPacket_SpawnMob.cpp create mode 100644 source/packets/cPacket_SpawnMob.h create mode 100644 source/packets/cPacket_TeleportEntity.cpp create mode 100644 source/packets/cPacket_TeleportEntity.h create mode 100644 source/packets/cPacket_TimeUpdate.cpp create mode 100644 source/packets/cPacket_TimeUpdate.h create mode 100644 source/packets/cPacket_UpdateHealth.cpp create mode 100644 source/packets/cPacket_UpdateHealth.h create mode 100644 source/packets/cPacket_UpdateSign.cpp create mode 100644 source/packets/cPacket_UpdateSign.h create mode 100644 source/packets/cPacket_UseEntity.cpp create mode 100644 source/packets/cPacket_UseEntity.h create mode 100644 source/packets/cPacket_WholeInventory.cpp create mode 100644 source/packets/cPacket_WholeInventory.h create mode 100644 source/packets/cPacket_WindowClick.cpp create mode 100644 source/packets/cPacket_WindowClick.h create mode 100644 source/packets/cPacket_WindowClose.cpp create mode 100644 source/packets/cPacket_WindowClose.h create mode 100644 source/packets/cPacket_WindowOpen.cpp create mode 100644 source/packets/cPacket_WindowOpen.h create mode 100644 source/tolua++.exe create mode 100644 source/tolua++.h create mode 100644 source/tolua_base.h create mode 100644 source/virtual_method_hooks.lua 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 +#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 +#ifdef _WIN32 +#include +#else +#include +#include +#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(&buf); +} + +inline float NetworkToHostFloat4( void* a_Value ) +{ + u_long buf = *(u_long*)a_Value; + buf = ntohl( buf ); + return *(float*)reinterpret_cast(&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 +#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 +// 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 +#define socklen_t int +#ifdef SendMessage +#undef SendMessage +#endif +#else + +// Linux threads http://www.yolinux.com/TUTORIALS/LinuxTutorialPosixThreads.html + +#include +#include +#include +#include +#include +#include +#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 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 Split = StringSplit( str, delim ); + + lua_createtable(tolua_S, Split.size(), 0); + int newTable = lua_gettop(tolua_S); + int index = 1; + std::vector::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 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 +#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 +#include + +#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 + +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 + +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 + +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 +#endif + +#include +#include + +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 + +#include "cMCLogger.h" + +#ifndef _WIN32 +#include +#include +#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 + +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 + +// 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 +#include "cClientHandle.h" +#include "cMCLogger.h" +#include "cPlayer.h" +#include "cWindow.h" +#include "cPickup.h" +#include "cMCLogger.h" + +#include + +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 // rand() +#include +#endif + +#include + + + +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 +#include +#include +#include // for mkdir +#include +#endif +#include "cChunk.h" +#include "cWorld.h" +#include "cClientHandle.h" +#include "cServer.h" +#include "zlib.h" +#include "Defines.h" +#include // 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 + +#include +#include +#include + +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::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::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::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::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 + +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 +#ifndef _WIN32 +#include +#include +#include +#include // for mkdir +#include +#else +#include +#endif + +#include + +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::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 // memcpy +#include // abs +#endif + +#include "zlib.h" +#include + +#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 +#include +#include +#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 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(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(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(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(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(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(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(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(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(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(a_Packet); + PacketData->m_EntityID = m_Player->GetUniqueID(); + cRoot::Get()->GetServer()->Broadcast( *PacketData, this ); + } + break; + case E_ITEM_SWITCH: + { + cPacket_ItemSwitch* PacketData = reinterpret_cast(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(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(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(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(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(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::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 +#else +#include +#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 // 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 +#else +#include +#include +#include +#include +#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 + +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 +#include + +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 + +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 +#include +#include + +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 + +#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 + +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 //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 +#include +#include + +#ifdef _WIN32 +#include +#else +#include // for mkdir +#include + +#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 + +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 +#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 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 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::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 +#include +#include + +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 +#include +#include + +#ifndef _WIN32 +#define sprintf_s(buffer, buffer_size, stringbuffer, ...) (sprintf(buffer, stringbuffer, __VA_ARGS__)) +#else +#include +#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 +#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 // If something is missing, uncomment some of these! +//#include +//#include +#include // for mkdir +//#include +#else +#include +#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 // rand +#include +#include +#endif + +#include + + +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 +#include +#include +//#include "../source/cprintf.h" +#include +using namespace std; + +extern std::vector 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 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::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 + +#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 +#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 +#include +#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(*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 + +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 + +#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 +#include + +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 + +#include "../iniFile/iniFile.h" + +extern std::vector 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 + +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 +#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 +#include + +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 +#include +#include +#include +#include + +#ifndef _WIN32 +#include +#include +#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 + +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 +#include +#include + +#ifndef _WIN32 +#include +#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 +#else +#include +#include +#include +#include +#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 +#include +#include +#endif + +#include +#include +#include +#include + +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 +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 + +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 + +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 +#else +#include +#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 +#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 // rand() +#include +#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 +#include +// A std::map 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 +#include +#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 +#include +#include +#include +#else +#define WIN32_LEAN_AND_MEAN +#include +#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 +#else +#include +#include +#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 // 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 + +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 + +#include "../iniFile/iniFile.h" + +#include "MemoryLeak.h" +#ifdef _WIN32 +#include +#else +#include +#endif + +extern std::vector 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_ += "
"; + r->answer_ += "MCServer WebAdmin"; + r->answer_ += "
"; + r->answer_ += "
"; + r->answer_ += ""; + r->answer_ += "
"; + r->answer_ += "
"; + 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 += "

Current Game

"; + Content += "

Server Name:

"; + Content += "

" + std::string( cRoot::Get()->GetServer()->GetServerID() ) + "

"; + + Content += "

Plugins:

"; + 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() + "
"; + } + Content += "

"; + Content += "

Players:

"; + + 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() ) + "
"; + } + Content += "

"; + + for( PluginList::iterator itr = WebAdmin->m_Plugins.begin(); itr != WebAdmin->m_Plugins.end(); ++itr ) + { + Menu += "
  • " + (*itr)->GetName() + "
    • "; + } + + 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 = "

    " + FoundPlugin + "

    \n

    " + Content + "

    "; + } + } + + delete Request.Params; + + if( Split.size() > 1 ) + { + Content += "\n

    Go back

    "; + } + + // 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 +#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 + +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 + +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 +#include + +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 & 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 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 + +#include "tolua++.h" + +#ifndef _WIN32 +#include +#include // for mkdir +#include +#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 + +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 +#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 + +#ifndef _WIN32 +#include +#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 +#include + + +// 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 +#else +#include // Silly Linux doesn't have xstring... +#include +#include +#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 +#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 new file mode 100644 index 000000000..c39968dbf Binary files /dev/null and b/source/tolua++.exe differ 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 + + + + + -- cgit v1.2.3