flewkey
/
cuberite-2a
1
0
Fork 0
Code Releases Activity

Merge remote-tracking branch 'upstream/master' into playerxp

This commit is contained in:
Daniel O'Brien 2013-11-15 18:25:20 +11:00
parent f6e16ce150 d665bc8806
commit af17faac45
17 changed files with 827 additions and 219 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
VC2008/MCServer.vcproj
View File

@ -2671,6 +2671,10 @@
<Filter
Name="BlockEntities"
>
<File
RelativePath="..\source\BlockEntities\BlockEntity.cpp"
>
</File>
<File
RelativePath="..\source\BlockEntities\BlockEntity.h"
>

3
source/AllToLua.pkg
View File

@ -47,6 +47,9 @@ $cfile "BlockEntities/DispenserEntity.h"
$cfile "BlockEntities/DropperEntity.h"
$cfile "BlockEntities/FurnaceEntity.h"
$cfile "BlockEntities/HopperEntity.h"
$cfile "BlockEntities/JukeboxEntity.h"
$cfile "BlockEntities/NoteEntity.h"
$cfile "BlockEntities/SignEntity.h"
$cfile "WebAdmin.h"
$cfile "WebPlugin.h"
$cfile "Root.h"

622
source/Bindings.cpp
View File

@ -1,6 +1,6 @@
/*
** Lua binding: AllToLua
** Generated automatically by tolua++-1.0.92 on 11/14/13 16:18:41.
** Generated automatically by tolua++-1.0.92 on 11/14/13 17:13:46.
*/
#ifndef __cplusplus
@ -46,6 +46,9 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S);
#include "BlockEntities/DropperEntity.h"
#include "BlockEntities/FurnaceEntity.h"
#include "BlockEntities/HopperEntity.h"
#include "BlockEntities/JukeboxEntity.h"
#include "BlockEntities/NoteEntity.h"
#include "BlockEntities/SignEntity.h"
#include "WebAdmin.h"
#include "WebPlugin.h"
#include "Root.h"
@ -74,9 +77,9 @@ static int tolua_collect_cItem (lua_State* tolua_S)
return 0;
}
static int tolua_collect_Vector3f (lua_State* tolua_S)
static int tolua_collect_cFurnaceEntity (lua_State* tolua_S)
{
Vector3f* self = (Vector3f*) tolua_tousertype(tolua_S,1,0);
cFurnaceEntity* self = (cFurnaceEntity*) tolua_tousertype(tolua_S,1,0);
Mtolua_delete(self);
return 0;
}
@ -130,6 +133,13 @@ static int tolua_collect_cLuaWindow (lua_State* tolua_S)
return 0;
}
static int tolua_collect_cCraftingGrid (lua_State* tolua_S)
{
cCraftingGrid* self = (cCraftingGrid*) tolua_tousertype(tolua_S,1,0);
Mtolua_delete(self);
return 0;
}
static int tolua_collect_cDropperEntity (lua_State* tolua_S)
{
cDropperEntity* self = (cDropperEntity*) tolua_tousertype(tolua_S,1,0);
@ -144,16 +154,9 @@ static int tolua_collect_cPickup (lua_State* tolua_S)
return 0;
}
static int tolua_collect_cItems (lua_State* tolua_S)
static int tolua_collect_sWebAdminPage (lua_State* tolua_S)
{
cItems* self = (cItems*) tolua_tousertype(tolua_S,1,0);
Mtolua_delete(self);
return 0;
}
static int tolua_collect_cCraftingGrid (lua_State* tolua_S)
{
cCraftingGrid* self = (cCraftingGrid*) tolua_tousertype(tolua_S,1,0);
sWebAdminPage* self = (sWebAdminPage*) tolua_tousertype(tolua_S,1,0);
Mtolua_delete(self);
return 0;
}
@ -172,16 +175,23 @@ static int tolua_collect_cBoundingBox (lua_State* tolua_S)
return 0;
}
static int tolua_collect_sWebAdminPage (lua_State* tolua_S)
static int tolua_collect_cHopperEntity (lua_State* tolua_S)
{
sWebAdminPage* self = (sWebAdminPage*) tolua_tousertype(tolua_S,1,0);
cHopperEntity* self = (cHopperEntity*) tolua_tousertype(tolua_S,1,0);
Mtolua_delete(self);
return 0;
}
static int tolua_collect_cHopperEntity (lua_State* tolua_S)
static int tolua_collect_Vector3f (lua_State* tolua_S)
{
cHopperEntity* self = (cHopperEntity*) tolua_tousertype(tolua_S,1,0);
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;
}
@ -193,16 +203,16 @@ static int tolua_collect_Vector3i (lua_State* tolua_S)
return 0;
}
static int tolua_collect_cFurnaceEntity (lua_State* tolua_S)
static int tolua_collect_cItems (lua_State* tolua_S)
{
cFurnaceEntity* self = (cFurnaceEntity*) tolua_tousertype(tolua_S,1,0);
cItems* self = (cItems*) tolua_tousertype(tolua_S,1,0);
Mtolua_delete(self);
return 0;
}
static int tolua_collect_cIniFile (lua_State* tolua_S)
static int tolua_collect_cSignEntity (lua_State* tolua_S)
{
cIniFile* self = (cIniFile*) tolua_tousertype(tolua_S,1,0);
cSignEntity* self = (cSignEntity*) tolua_tousertype(tolua_S,1,0);
Mtolua_delete(self);
return 0;
}
@ -237,6 +247,7 @@ static void tolua_reg_types (lua_State* tolua_S)
tolua_usertype(tolua_S,"cPluginManager");
tolua_usertype(tolua_S,"Vector3f");
tolua_usertype(tolua_S,"cCraftingRecipes");
tolua_usertype(tolua_S,"cJukeboxEntity");
tolua_usertype(tolua_S,"cChestEntity");
tolua_usertype(tolua_S,"cDispenserEntity");
tolua_usertype(tolua_S,"cGhastFireballEntity");
@ -254,34 +265,36 @@ static void tolua_reg_types (lua_State* tolua_S)
tolua_usertype(tolua_S,"cHopperEntity");
tolua_usertype(tolua_S,"std::vector<AString>");
tolua_usertype(tolua_S,"cBlockEntityWithItems");
tolua_usertype(tolua_S,"HTTPFormData");
tolua_usertype(tolua_S,"cTracer");
tolua_usertype(tolua_S,"cWindow");
tolua_usertype(tolua_S,"cCraftingGrid");
tolua_usertype(tolua_S,"cItem");
tolua_usertype(tolua_S,"cBlockArea");
tolua_usertype(tolua_S,"cArrowEntity");
tolua_usertype(tolua_S,"cDropSpenserEntity");
tolua_usertype(tolua_S,"cWindow");
tolua_usertype(tolua_S,"cBlockArea");
tolua_usertype(tolua_S,"cCraftingGrid");
tolua_usertype(tolua_S,"cPlayer");
tolua_usertype(tolua_S,"cGroup");
tolua_usertype(tolua_S,"cTracer");
tolua_usertype(tolua_S,"cBoundingBox");
tolua_usertype(tolua_S,"cNoteEntity");
tolua_usertype(tolua_S,"Vector3i");
tolua_usertype(tolua_S,"cBlockEntity");
tolua_usertype(tolua_S,"cCriticalSection");
tolua_usertype(tolua_S,"HTTPTemplateRequest");
tolua_usertype(tolua_S,"cPlayer");
tolua_usertype(tolua_S,"cServer");
tolua_usertype(tolua_S,"cBoundingBox");
tolua_usertype(tolua_S,"Vector3i");
tolua_usertype(tolua_S,"cSignEntity");
tolua_usertype(tolua_S,"cFile");
tolua_usertype(tolua_S,"cItems");
tolua_usertype(tolua_S,"cClientHandle");
tolua_usertype(tolua_S,"cIniFile");
tolua_usertype(tolua_S,"cChatColor");
tolua_usertype(tolua_S,"cWebPlugin");
tolua_usertype(tolua_S,"cChatColor");
tolua_usertype(tolua_S,"cPawn");
tolua_usertype(tolua_S,"cThrownEggEntity");
tolua_usertype(tolua_S,"cGroupManager");
tolua_usertype(tolua_S,"cWebAdmin");
tolua_usertype(tolua_S,"cItem");
tolua_usertype(tolua_S,"cProjectileEntity");
tolua_usertype(tolua_S,"HTTPRequest");
tolua_usertype(tolua_S,"cProjectileEntity");
tolua_usertype(tolua_S,"HTTPFormData");
tolua_usertype(tolua_S,"cItemGrid::cListener");
tolua_usertype(tolua_S,"cDropperEntity");
}
@ -17607,6 +17620,46 @@ tolua_lerror:
}
#endif //#ifndef TOLUA_DISABLE
/* method: CreateByBlockType of class cBlockEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockEntity_CreateByBlockType00
static int tolua_AllToLua_cBlockEntity_CreateByBlockType00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertable(tolua_S,1,"cBlockEntity",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_isusertype(tolua_S,7,"cWorld",1,&tolua_err) ||
!tolua_isnoobj(tolua_S,8,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
unsigned char a_BlockType = (( unsigned char) tolua_tonumber(tolua_S,2,0));
unsigned char a_BlockMeta = (( unsigned char) tolua_tonumber(tolua_S,3,0));
int a_BlockX = ((int) tolua_tonumber(tolua_S,4,0));
int a_BlockY = ((int) tolua_tonumber(tolua_S,5,0));
int a_BlockZ = ((int) tolua_tonumber(tolua_S,6,0));
cWorld* a_World = ((cWorld*) tolua_tousertype(tolua_S,7,NULL));
{
cBlockEntity* tolua_ret = (cBlockEntity*) cBlockEntity::CreateByBlockType(a_BlockType,a_BlockMeta,a_BlockX,a_BlockY,a_BlockZ,a_World);
tolua_pushusertype(tolua_S,(void*)tolua_ret,"cBlockEntity");
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'CreateByBlockType'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: GetPosX of class cBlockEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cBlockEntity_GetPosX00
static int tolua_AllToLua_cBlockEntity_GetPosX00(lua_State* tolua_S)
@ -18841,6 +18894,446 @@ static int tolua_AllToLua_cHopperEntity_new00_local(lua_State* tolua_S)
}
#endif //#ifndef TOLUA_DISABLE
/* method: GetRecord of class cJukeboxEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cJukeboxEntity_GetRecord00
static int tolua_AllToLua_cJukeboxEntity_GetRecord00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"cJukeboxEntity",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
cJukeboxEntity* self = (cJukeboxEntity*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetRecord'", NULL);
#endif
{
int tolua_ret = (int) self->GetRecord();
tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'GetRecord'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: SetRecord of class cJukeboxEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cJukeboxEntity_SetRecord00
static int tolua_AllToLua_cJukeboxEntity_SetRecord00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"cJukeboxEntity",0,&tolua_err) ||
!tolua_isnumber(tolua_S,2,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
cJukeboxEntity* self = (cJukeboxEntity*) tolua_tousertype(tolua_S,1,0);
int a_Record = ((int) tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetRecord'", NULL);
#endif
{
self->SetRecord(a_Record);
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'SetRecord'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: PlayRecord of class cJukeboxEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cJukeboxEntity_PlayRecord00
static int tolua_AllToLua_cJukeboxEntity_PlayRecord00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"cJukeboxEntity",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
cJukeboxEntity* self = (cJukeboxEntity*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'PlayRecord'", NULL);
#endif
{
self->PlayRecord();
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'PlayRecord'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: EjectRecord of class cJukeboxEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cJukeboxEntity_EjectRecord00
static int tolua_AllToLua_cJukeboxEntity_EjectRecord00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"cJukeboxEntity",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
cJukeboxEntity* self = (cJukeboxEntity*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'EjectRecord'", NULL);
#endif
{
self->EjectRecord();
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'EjectRecord'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: GetPitch of class cNoteEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cNoteEntity_GetPitch00
static int tolua_AllToLua_cNoteEntity_GetPitch00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"cNoteEntity",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
cNoteEntity* self = (cNoteEntity*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetPitch'", NULL);
#endif
{
char tolua_ret = (char) 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: SetPitch of class cNoteEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cNoteEntity_SetPitch00
static int tolua_AllToLua_cNoteEntity_SetPitch00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"cNoteEntity",0,&tolua_err) ||
!tolua_isnumber(tolua_S,2,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
cNoteEntity* self = (cNoteEntity*) tolua_tousertype(tolua_S,1,0);
char a_Pitch = ((char) 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: IncrementPitch of class cNoteEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cNoteEntity_IncrementPitch00
static int tolua_AllToLua_cNoteEntity_IncrementPitch00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"cNoteEntity",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
cNoteEntity* self = (cNoteEntity*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'IncrementPitch'", NULL);
#endif
{
self->IncrementPitch();
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'IncrementPitch'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: MakeSound of class cNoteEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cNoteEntity_MakeSound00
static int tolua_AllToLua_cNoteEntity_MakeSound00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"cNoteEntity",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
cNoteEntity* self = (cNoteEntity*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'MakeSound'", NULL);
#endif
{
self->MakeSound();
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'MakeSound'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: new of class cSignEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cSignEntity_new00
static int tolua_AllToLua_cSignEntity_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertable(tolua_S,1,"cSignEntity",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
{
unsigned char a_BlockType = (( unsigned char) tolua_tonumber(tolua_S,2,0));
int a_BlockX = ((int) tolua_tonumber(tolua_S,3,0));
int a_BlockY = ((int) tolua_tonumber(tolua_S,4,0));
int a_BlockZ = ((int) tolua_tonumber(tolua_S,5,0));
{
cSignEntity* tolua_ret = (cSignEntity*) Mtolua_new((cSignEntity)(a_BlockType,a_BlockX,a_BlockY,a_BlockZ));
tolua_pushusertype(tolua_S,(void*)tolua_ret,"cSignEntity");
}
}
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 cSignEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cSignEntity_new00_local
static int tolua_AllToLua_cSignEntity_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertable(tolua_S,1,"cSignEntity",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
{
unsigned char a_BlockType = (( unsigned char) tolua_tonumber(tolua_S,2,0));
int a_BlockX = ((int) tolua_tonumber(tolua_S,3,0));
int a_BlockY = ((int) tolua_tonumber(tolua_S,4,0));
int a_BlockZ = ((int) tolua_tonumber(tolua_S,5,0));
{
cSignEntity* tolua_ret = (cSignEntity*) Mtolua_new((cSignEntity)(a_BlockType,a_BlockX,a_BlockY,a_BlockZ));
tolua_pushusertype(tolua_S,(void*)tolua_ret,"cSignEntity");
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: SetLines of class cSignEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cSignEntity_SetLines00
static int tolua_AllToLua_cSignEntity_SetLines00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"cSignEntity",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_iscppstring(tolua_S,5,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,6,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
cSignEntity* self = (cSignEntity*) tolua_tousertype(tolua_S,1,0);
const AString a_Line1 = ((const AString) tolua_tocppstring(tolua_S,2,0));
const AString a_Line2 = ((const AString) tolua_tocppstring(tolua_S,3,0));
const AString a_Line3 = ((const AString) tolua_tocppstring(tolua_S,4,0));
const AString a_Line4 = ((const AString) tolua_tocppstring(tolua_S,5,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetLines'", NULL);
#endif
{
self->SetLines(a_Line1,a_Line2,a_Line3,a_Line4);
tolua_pushcppstring(tolua_S,(const char*)a_Line1);
tolua_pushcppstring(tolua_S,(const char*)a_Line2);
tolua_pushcppstring(tolua_S,(const char*)a_Line3);
tolua_pushcppstring(tolua_S,(const char*)a_Line4);
}
}
return 4;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'SetLines'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: SetLine of class cSignEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cSignEntity_SetLine00
static int tolua_AllToLua_cSignEntity_SetLine00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"cSignEntity",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
{
cSignEntity* self = (cSignEntity*) tolua_tousertype(tolua_S,1,0);
int a_Index = ((int) tolua_tonumber(tolua_S,2,0));
const AString a_Line = ((const AString) tolua_tocppstring(tolua_S,3,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetLine'", NULL);
#endif
{
self->SetLine(a_Index,a_Line);
tolua_pushcppstring(tolua_S,(const char*)a_Line);
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'SetLine'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: GetLine of class cSignEntity */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cSignEntity_GetLine00
static int tolua_AllToLua_cSignEntity_GetLine00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"const cSignEntity",0,&tolua_err) ||
!tolua_isnumber(tolua_S,2,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
const cSignEntity* self = (const cSignEntity*) tolua_tousertype(tolua_S,1,0);
int a_Index = ((int) tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetLine'", NULL);
#endif
{
AString tolua_ret = (AString) self->GetLine(a_Index);
tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'GetLine'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* get function: Name of class HTTPFormData */
#ifndef TOLUA_DISABLE_tolua_get_HTTPFormData_Name
static int tolua_get_HTTPFormData_Name(lua_State* tolua_S)
@ -27889,6 +28382,44 @@ tolua_lerror:
}
#endif //#ifndef TOLUA_DISABLE
/* method: GetBlockEntity of class cChunkDesc */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cChunkDesc_GetBlockEntity00
static int tolua_AllToLua_cChunkDesc_GetBlockEntity00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"cChunkDesc",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
{
cChunkDesc* self = (cChunkDesc*) tolua_tousertype(tolua_S,1,0);
int a_RelX = ((int) tolua_tonumber(tolua_S,2,0));
int a_RelY = ((int) tolua_tonumber(tolua_S,3,0));
int a_RelZ = ((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_RelX,a_RelY,a_RelZ);
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: new of class cCraftingGrid */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cCraftingGrid_new00
static int tolua_AllToLua_cCraftingGrid_new00(lua_State* tolua_S)
@ -30869,6 +31400,7 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S)
tolua_cclass(tolua_S,"cBlockEntity","cBlockEntity","",NULL);
#endif
tolua_beginmodule(tolua_S,"cBlockEntity");
tolua_function(tolua_S,"CreateByBlockType",tolua_AllToLua_cBlockEntity_CreateByBlockType00);
tolua_function(tolua_S,"GetPosX",tolua_AllToLua_cBlockEntity_GetPosX00);
tolua_function(tolua_S,"GetPosY",tolua_AllToLua_cBlockEntity_GetPosY00);
tolua_function(tolua_S,"GetPosZ",tolua_AllToLua_cBlockEntity_GetPosZ00);
@ -30965,6 +31497,33 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S)
tolua_function(tolua_S,"new_local",tolua_AllToLua_cHopperEntity_new00_local);
tolua_function(tolua_S,".call",tolua_AllToLua_cHopperEntity_new00_local);
tolua_endmodule(tolua_S);
tolua_cclass(tolua_S,"cJukeboxEntity","cJukeboxEntity","cBlockEntity",NULL);
tolua_beginmodule(tolua_S,"cJukeboxEntity");
tolua_function(tolua_S,"GetRecord",tolua_AllToLua_cJukeboxEntity_GetRecord00);
tolua_function(tolua_S,"SetRecord",tolua_AllToLua_cJukeboxEntity_SetRecord00);
tolua_function(tolua_S,"PlayRecord",tolua_AllToLua_cJukeboxEntity_PlayRecord00);
tolua_function(tolua_S,"EjectRecord",tolua_AllToLua_cJukeboxEntity_EjectRecord00);
tolua_endmodule(tolua_S);
tolua_cclass(tolua_S,"cNoteEntity","cNoteEntity","cBlockEntity",NULL);
tolua_beginmodule(tolua_S,"cNoteEntity");
tolua_function(tolua_S,"GetPitch",tolua_AllToLua_cNoteEntity_GetPitch00);
tolua_function(tolua_S,"SetPitch",tolua_AllToLua_cNoteEntity_SetPitch00);
tolua_function(tolua_S,"IncrementPitch",tolua_AllToLua_cNoteEntity_IncrementPitch00);
tolua_function(tolua_S,"MakeSound",tolua_AllToLua_cNoteEntity_MakeSound00);
tolua_endmodule(tolua_S);
#ifdef __cplusplus
tolua_cclass(tolua_S,"cSignEntity","cSignEntity","cBlockEntity",tolua_collect_cSignEntity);
#else
tolua_cclass(tolua_S,"cSignEntity","cSignEntity","cBlockEntity",NULL);
#endif
tolua_beginmodule(tolua_S,"cSignEntity");
tolua_function(tolua_S,"new",tolua_AllToLua_cSignEntity_new00);
tolua_function(tolua_S,"new_local",tolua_AllToLua_cSignEntity_new00_local);
tolua_function(tolua_S,".call",tolua_AllToLua_cSignEntity_new00_local);
tolua_function(tolua_S,"SetLines",tolua_AllToLua_cSignEntity_SetLines00);
tolua_function(tolua_S,"SetLine",tolua_AllToLua_cSignEntity_SetLine00);
tolua_function(tolua_S,"GetLine",tolua_AllToLua_cSignEntity_GetLine00);
tolua_endmodule(tolua_S);
tolua_cclass(tolua_S,"HTTPFormData","HTTPFormData","",NULL);
tolua_beginmodule(tolua_S,"HTTPFormData");
tolua_variable(tolua_S,"Name",tolua_get_HTTPFormData_Name,tolua_set_HTTPFormData_Name);
@ -31345,6 +31904,7 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S)
tolua_function(tolua_S,"FloorRelCuboid",tolua_AllToLua_cChunkDesc_FloorRelCuboid01);
tolua_function(tolua_S,"RandomFillRelCuboid",tolua_AllToLua_cChunkDesc_RandomFillRelCuboid00);
tolua_function(tolua_S,"RandomFillRelCuboid",tolua_AllToLua_cChunkDesc_RandomFillRelCuboid01);
tolua_function(tolua_S,"GetBlockEntity",tolua_AllToLua_cChunkDesc_GetBlockEntity00);
tolua_endmodule(tolua_S);
#ifdef __cplusplus
tolua_cclass(tolua_S,"cCraftingGrid","cCraftingGrid","",tolua_collect_cCraftingGrid);

2
source/Bindings.h
View File

@ -1,6 +1,6 @@
/*
** Lua binding: AllToLua
** Generated automatically by tolua++-1.0.92 on 11/14/13 16:18:41.
** Generated automatically by tolua++-1.0.92 on 11/14/13 17:13:47.
*/
/* Exported function */

44
source/BlockEntities/BlockEntity.cpp Normal file
View File

@ -0,0 +1,44 @@
// BlockEntity.cpp
// Implements the cBlockEntity class that is the common ancestor for all block entities
#include "Globals.h"
#include "BlockEntity.h"
#include "ChestEntity.h"
#include "DispenserEntity.h"
#include "DropperEntity.h"
#include "FurnaceEntity.h"
#include "HopperEntity.h"
#include "JukeboxEntity.h"
#include "NoteEntity.h"
#include "SignEntity.h"
cBlockEntity * cBlockEntity::CreateByBlockType(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World)
{
switch (a_BlockType)
{
case E_BLOCK_CHEST: return new cChestEntity (a_BlockX, a_BlockY, a_BlockZ, a_World);
case E_BLOCK_DISPENSER: return new cDispenserEntity(a_BlockX, a_BlockY, a_BlockZ, a_World);
case E_BLOCK_DROPPER: return new cDropperEntity (a_BlockX, a_BlockY, a_BlockZ, a_World);
case E_BLOCK_LIT_FURNACE: return new cFurnaceEntity (a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta, a_World);
case E_BLOCK_FURNACE: return new cFurnaceEntity (a_BlockX, a_BlockY, a_BlockZ, a_BlockType, a_BlockMeta, a_World);
case E_BLOCK_HOPPER: return new cHopperEntity (a_BlockX, a_BlockY, a_BlockZ, a_World);
case E_BLOCK_SIGN_POST: return new cSignEntity (a_BlockType, a_BlockX, a_BlockY, a_BlockZ, a_World);
case E_BLOCK_WALLSIGN: return new cSignEntity (a_BlockType, a_BlockX, a_BlockY, a_BlockZ, a_World);
case E_BLOCK_NOTE_BLOCK: return new cNoteEntity (a_BlockX, a_BlockY, a_BlockZ, a_World);
case E_BLOCK_JUKEBOX: return new cJukeboxEntity (a_BlockX, a_BlockY, a_BlockZ, a_World);
}
LOGD("%s: Requesting creation of an unknown block entity - block type %d (%s)",
__FUNCTION__, a_BlockType, ItemTypeToString(a_BlockType).c_str()
);
return NULL;
}

5
source/BlockEntities/BlockEntity.h
View File

@ -49,6 +49,11 @@ public:
// tolua_begin
/// Creates a new block entity for the specified block type
/// If a_World is valid, then the entity is created bound to that world
/// Returns NULL for unknown block types
static cBlockEntity * CreateByBlockType(BLOCKTYPE a_BlockType, NIBBLETYPE a_BlockMeta, int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World = NULL);
// Position, in absolute block coordinates:
int GetPosX(void) const { return m_PosX; }
int GetPosY(void) const { return m_PosY; }

34
source/BlockEntities/JukeboxEntity.cpp
View File

@ -9,9 +9,9 @@
cJukeboxEntity::cJukeboxEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World)
: cBlockEntity(E_BLOCK_JUKEBOX, a_BlockX, a_BlockY, a_BlockZ, a_World)
, m_Record( 0 )
cJukeboxEntity::cJukeboxEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World) :
super(E_BLOCK_JUKEBOX, a_BlockX, a_BlockY, a_BlockZ, a_World),
m_Record(0)
{
}
@ -21,11 +21,7 @@ cJukeboxEntity::cJukeboxEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cWorld
cJukeboxEntity::~cJukeboxEntity()
{
if (m_Record >= 2256 && m_Record <= 2267)
{
EjectRecord();
m_Record = 0;
}
EjectRecord();
}
@ -44,10 +40,9 @@ void cJukeboxEntity::UsedBy(cPlayer * a_Player)
PlayRecord();
}
}
else if (m_Record >= 2256 && m_Record <= 2267)
else
{
EjectRecord();
m_Record = 0;
}
}
@ -55,7 +50,7 @@ void cJukeboxEntity::UsedBy(cPlayer * a_Player)
void cJukeboxEntity::PlayRecord( void )
void cJukeboxEntity::PlayRecord(void)
{
m_World->BroadcastSoundParticleEffect(1005, m_PosX, m_PosY, m_PosZ, m_Record);
}
@ -64,19 +59,26 @@ void cJukeboxEntity::PlayRecord( void )
void cJukeboxEntity::EjectRecord( void )
void cJukeboxEntity::EjectRecord(void)
{
if ((m_Record < E_ITEM_FIRST_DISC) || (m_Record > E_ITEM_LAST_DISC))
{
// There's no record here
return;
}
cItems Drops;
Drops.push_back(cItem(m_Record, 1, 0));
m_World->SpawnItemPickups(Drops, m_PosX + 0.5, m_PosY + 1, m_PosZ + 0.5, 8);
m_World->BroadcastSoundParticleEffect(1005, m_PosX, m_PosY, m_PosZ, 0);
m_Record = 0;
}
int cJukeboxEntity::GetRecord( void )
int cJukeboxEntity::GetRecord(void)
{
return m_Record;
}
@ -85,7 +87,7 @@ int cJukeboxEntity::GetRecord( void )
void cJukeboxEntity::SetRecord( int a_Record )
void cJukeboxEntity::SetRecord(int a_Record)
{
m_Record = a_Record;
}
@ -94,7 +96,7 @@ void cJukeboxEntity::SetRecord( int a_Record )
bool cJukeboxEntity::LoadFromJson( const Json::Value & a_Value )
bool cJukeboxEntity::LoadFromJson(const Json::Value & a_Value)
{
m_PosX = a_Value.get("x", 0).asInt();
m_PosY = a_Value.get("y", 0).asInt();
@ -109,7 +111,7 @@ bool cJukeboxEntity::LoadFromJson( const Json::Value & a_Value )
void cJukeboxEntity::SaveToJson( Json::Value & a_Value )
void cJukeboxEntity::SaveToJson(Json::Value & a_Value)
{
a_Value["x"] = m_PosX;
a_Value["y"] = m_PosY;

29
source/BlockEntities/JukeboxEntity.h
View File

@ -17,26 +17,39 @@ namespace Json
// tolua_begin
class cJukeboxEntity :
public cBlockEntity
{
typedef cBlockEntity super;
public:
// tolua_end
cJukeboxEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World);
virtual ~cJukeboxEntity();
bool LoadFromJson( const Json::Value& a_Value );
virtual void SaveToJson( Json::Value& a_Value ) override;
bool LoadFromJson(const Json::Value & a_Value);
virtual void SaveToJson(Json::Value & a_Value) override;
int GetRecord( void );
void SetRecord( int a_Record );
void PlayRecord( void );
void EjectRecord( void );
virtual void UsedBy( cPlayer * a_Player ) override;
// tolua_begin
int GetRecord(void);
void SetRecord(int a_Record);
void PlayRecord(void);
/// Ejects the currently held record as a pickup. Does nothing when no record inserted.
void EjectRecord(void);
// tolua_end
virtual void UsedBy(cPlayer * a_Player) override;
virtual void SendTo(cClientHandle & a_Client) override { };
private:
int m_Record;
};
} ; // tolua_end

33
source/BlockEntities/NoteEntity.cpp
View File

@ -6,9 +6,12 @@
#include <json/json.h>
cNoteEntity::cNoteEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World)
: cBlockEntity(E_BLOCK_NOTE_BLOCK, a_BlockX, a_BlockY, a_BlockZ, a_World)
, m_Pitch( 0 )
cNoteEntity::cNoteEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_World) :
super(E_BLOCK_NOTE_BLOCK, a_BlockX, a_BlockY, a_BlockZ, a_World),
m_Pitch(0)
{
}
@ -16,15 +19,7 @@ cNoteEntity::cNoteEntity(int a_BlockX, int a_BlockY, int a_BlockZ, cWorld * a_Wo
cNoteEntity::~cNoteEntity()
{
}
void cNoteEntity::UsedBy( cPlayer * a_Player )
void cNoteEntity::UsedBy(cPlayer * a_Player)
{
IncrementPitch();
MakeSound();
@ -34,7 +29,7 @@ void cNoteEntity::UsedBy( cPlayer * a_Player )
void cNoteEntity::MakeSound( void )
void cNoteEntity::MakeSound(void)
{
char instrument;
AString sampleName;
@ -102,7 +97,7 @@ void cNoteEntity::MakeSound( void )
char cNoteEntity::GetPitch( void )
char cNoteEntity::GetPitch(void)
{
return m_Pitch;
}
@ -111,7 +106,7 @@ char cNoteEntity::GetPitch( void )
void cNoteEntity::SetPitch( char a_Pitch )
void cNoteEntity::SetPitch(char a_Pitch)
{
m_Pitch = a_Pitch % 25;
}
@ -120,16 +115,16 @@ void cNoteEntity::SetPitch( char a_Pitch )
void cNoteEntity::IncrementPitch( void )
void cNoteEntity::IncrementPitch(void)
{
SetPitch( m_Pitch + 1 );
SetPitch(m_Pitch + 1);
}
bool cNoteEntity::LoadFromJson( const Json::Value & a_Value )
bool cNoteEntity::LoadFromJson(const Json::Value & a_Value)
{
m_PosX = a_Value.get("x", 0).asInt();
@ -145,7 +140,7 @@ bool cNoteEntity::LoadFromJson( const Json::Value & a_Value )
void cNoteEntity::SaveToJson( Json::Value & a_Value )
void cNoteEntity::SaveToJson(Json::Value & a_Value)
{
a_Value["x"] = m_PosX;
a_Value["y"] = m_PosY;

31
source/BlockEntities/NoteEntity.h
View File

@ -26,26 +26,37 @@ enum ENUM_NOTE_INSTRUMENTS
// tolua_begin
class cNoteEntity :
public cBlockEntity
{
typedef cBlockEntity super;
public:
// tolua_end
/// Creates a new note entity. a_World may be NULL
cNoteEntity(int a_X, int a_Y, int a_Z, cWorld * a_World);
virtual ~cNoteEntity();
bool LoadFromJson( const Json::Value& a_Value );
virtual void SaveToJson( Json::Value& a_Value ) override;
bool LoadFromJson(const Json::Value & a_Value);
virtual void SaveToJson(Json::Value & a_Value) override;
char GetPitch( void );
void SetPitch( char a_Pitch );
void IncrementPitch( void );
void MakeSound( void );
virtual void UsedBy( cPlayer * a_Player ) override;
// tolua_begin
char GetPitch(void);
void SetPitch(char a_Pitch);
void IncrementPitch(void);
void MakeSound(void);
// tolua_end
virtual void UsedBy(cPlayer * a_Player) override;
virtual void SendTo(cClientHandle & a_Client) override { };
private:
unsigned char m_Pitch;
};
char m_Pitch;
} ; // tolua_export

64
source/BlockEntities/SignEntity.cpp
View File

@ -1,21 +1,19 @@
// SignEntity.cpp
// Implements the cSignEntity class representing a single sign in the world
#include "Globals.h" // NOTE: MSVC stupidness requires this to be the same across all modules
#include "SignEntity.h"
#include "../Entities/Player.h"
// #include "ClientHandle.h"
// #include "World.h"
// #include "Root.h"
#include <json/json.h>
#include "SignEntity.h"
#include "../Entities/Player.h"
cSignEntity::cSignEntity(BLOCKTYPE a_BlockType, int a_X, int a_Y, int a_Z, cWorld * a_World)
: cBlockEntity(a_BlockType, a_X, a_Y, a_Z, a_World)
cSignEntity::cSignEntity(BLOCKTYPE a_BlockType, int a_BlockX, int a_BlockY, int a_BlockZ) :
super(a_BlockType, a_BlockX, a_BlockY, a_BlockZ, NULL)
{
}
@ -23,7 +21,8 @@ cSignEntity::cSignEntity(BLOCKTYPE a_BlockType, int a_X, int a_Y, int a_Z, cWorl
cSignEntity::~cSignEntity()
cSignEntity::cSignEntity(BLOCKTYPE a_BlockType, int a_X, int a_Y, int a_Z, cWorld * a_World) :
super(a_BlockType, a_X, a_Y, a_Z, a_World)
{
}
@ -32,16 +31,16 @@ cSignEntity::~cSignEntity()
// It don't do anything when 'used'
void cSignEntity::UsedBy( cPlayer * a_Player )
void cSignEntity::UsedBy(cPlayer * a_Player)
{
(void)a_Player;
UNUSED(a_Player);
}
void cSignEntity::SetLines( const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4 )
void cSignEntity::SetLines(const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4)
{
m_Line[0] = a_Line1;
m_Line[1] = a_Line2;
@ -53,25 +52,28 @@ void cSignEntity::SetLines( const AString & a_Line1, const AString & a_Line2, co
void cSignEntity::SetLine( int a_Index, const AString & a_Line )
void cSignEntity::SetLine(int a_Index, const AString & a_Line)
{
if( a_Index < 4 && a_Index > -1 )
if ((a_Index < 0) || (a_Index >= ARRAYCOUNT(m_Line)))
{
m_Line[a_Index] = a_Line;
LOGWARNING("%s: setting a non-existent line %d (value \"%s\"", __FUNCTION__, a_Index, a_Line.c_str());
return;
}
m_Line[a_Index] = a_Line;
}
AString cSignEntity::GetLine( int a_Index ) const
AString cSignEntity::GetLine(int a_Index) const
{
if( a_Index < 4 && a_Index > -1 )
if ((a_Index < 0) || (a_Index >= ARRAYCOUNT(m_Line)))
{
return m_Line[a_Index];
LOGWARNING("%s: requesting a non-existent line %d", __FUNCTION__, a_Index);
return "";
}
return "";
return m_Line[a_Index];
}
@ -87,19 +89,7 @@ void cSignEntity::SendTo(cClientHandle & a_Client)
#define READ(File, Var) \
if (File.Read(&Var, sizeof(Var)) != sizeof(Var)) \
{ \
LOGERROR("ERROR READING cSignEntity %s FROM FILE (line %d)", #Var, __LINE__); \
return false; \
}
bool cSignEntity::LoadFromJson( const Json::Value & a_Value )
bool cSignEntity::LoadFromJson(const Json::Value & a_Value)
{
m_PosX = a_Value.get("x", 0).asInt();
m_PosY = a_Value.get("y", 0).asInt();
@ -113,7 +103,11 @@ bool cSignEntity::LoadFromJson( const Json::Value & a_Value )
return true;
}
void cSignEntity::SaveToJson( Json::Value & a_Value )
void cSignEntity::SaveToJson(Json::Value & a_Value)
{
a_Value["x"] = m_PosX;
a_Value["y"] = m_PosY;

43
source/BlockEntities/SignEntity.h
View File

@ -1,4 +1,12 @@
// SignEntity.h
// Declares the cSignEntity class representing a single sign in the world
#pragma once
#include "BlockEntity.h"
@ -13,28 +21,49 @@ namespace Json
}
// tolua_begin
class cSignEntity :
public cBlockEntity
{
typedef cBlockEntity super;
public:
/// Creates a new empty sign entity at the specified block coords and block type (wall or standing)
/// Used mainly by plugins while generating chunks
cSignEntity(BLOCKTYPE a_BlockType, int a_BlockX, int a_BlockY, int a_BlockZ);
// tolua_end
cSignEntity(BLOCKTYPE a_BlockType, int a_X, int a_Y, int a_Z, cWorld * a_World);
virtual ~cSignEntity();
bool LoadFromJson( const Json::Value& a_Value );
virtual void SaveToJson(Json::Value& a_Value ) override;
void SetLines( const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4 );
void SetLine( int a_Index, const AString & a_Line );
// tolua_begin
/// Sets all the sign's lines
void SetLines(const AString & a_Line1, const AString & a_Line2, const AString & a_Line3, const AString & a_Line4);
/// Sets individual line (zero-based index)
void SetLine(int a_Index, const AString & a_Line);
AString GetLine( int a_Index ) const;
virtual void UsedBy( cPlayer * a_Player ) override;
/// Retrieves individual line (zero-based index)
AString GetLine(int a_Index) const;
// tolua_end
virtual void UsedBy(cPlayer * a_Player) override;
virtual void SendTo(cClientHandle & a_Client) override;
private:
AString m_Line[4];
};
} ; // tolua_export

6
source/Blocks/BlockCrops.h
View File

@ -79,6 +79,12 @@ public:
{
NIBBLETYPE Meta = a_World->GetBlockMeta(a_BlockX, a_BlockY, a_BlockZ);
NIBBLETYPE Light = a_World->GetBlockBlockLight(a_BlockX, a_BlockY, a_BlockZ);
NIBBLETYPE SkyLight = a_World->GetBlockSkyLight(a_BlockX, a_BlockY, a_BlockZ);
if (SkyLight > Light)
{
Light = SkyLight;
}
if ((Meta < 7) && (Light > 8))
{

91
source/Chunk.cpp
View File

@ -1261,75 +1261,22 @@ void cChunk::CreateBlockEntities(void)
switch (BlockType)
{
case E_BLOCK_CHEST:
{
if (!HasBlockEntityAt(x + m_PosX * Width, y + m_PosY * Height, z + m_PosZ * Width))
{
m_BlockEntities.push_back(new cChestEntity(x + m_PosX * Width, y + m_PosY * Height, z + m_PosZ * Width, m_World));
}
break;
}
case E_BLOCK_DISPENSER:
{
if (!HasBlockEntityAt(x + m_PosX * Width, y + m_PosY * Height, z + m_PosZ * Width))
{
m_BlockEntities.push_back(new cDispenserEntity(x + m_PosX * Width, y + m_PosY * Height, z + m_PosZ * Width, m_World));
}
break;
}
case E_BLOCK_DROPPER:
{
if (!HasBlockEntityAt(x + m_PosX * Width, y + m_PosY * Height, z + m_PosZ * Width))
{
m_BlockEntities.push_back(new cDropperEntity(x + m_PosX * Width, y + m_PosY * Height, z + m_PosZ * Width, m_World));
}
break;
}
case E_BLOCK_LIT_FURNACE:
case E_BLOCK_FURNACE:
{
if (!HasBlockEntityAt(x + m_PosX * Width, y + m_PosY * Height, z + m_PosZ * Width))
{
NIBBLETYPE BlockMeta = cChunkDef::GetNibble(m_BlockMeta, x, y, z);
m_BlockEntities.push_back(new cFurnaceEntity(x + m_PosX * Width, y + m_PosY * Height, z + m_PosZ * Width, BlockType, BlockMeta, m_World));
}
break;
}
case E_BLOCK_HOPPER:
{
if (!HasBlockEntityAt(x + m_PosX * Width, y + m_PosY * Height, z + m_PosZ * Width))
{
m_BlockEntities.push_back(new cHopperEntity(x + m_PosX * Width, y + m_PosY * Height, z + m_PosZ * Width, m_World));
}
}
case E_BLOCK_SIGN_POST:
case E_BLOCK_WALLSIGN:
{
if (!HasBlockEntityAt(x + m_PosX * Width, y + m_PosY * Height, z + m_PosZ * Width))
{
m_BlockEntities.push_back( new cSignEntity(BlockType, x + m_PosX * Width, y + m_PosY * Height, z + m_PosZ * Width, m_World));
}
break;
}
case E_BLOCK_NOTE_BLOCK:
{
if (!HasBlockEntityAt(x + m_PosX * Width, y + m_PosY * Height, z + m_PosZ * Width))
{
m_BlockEntities.push_back(new cNoteEntity(x + m_PosX * Width, y + m_PosY * Height, z + m_PosZ * Width, m_World));
}
break;
}
case E_BLOCK_JUKEBOX:
{
if (!HasBlockEntityAt(x + m_PosX * Width, y + m_PosY * Height, z + m_PosZ * Width))
{
m_BlockEntities.push_back(new cJukeboxEntity(x + m_PosX * Width, y + m_PosY * Height, z + m_PosZ * Width, m_World));
m_BlockEntities.push_back(cBlockEntity::CreateByBlockType(
BlockType, GetMeta(x, y, z),
x + m_PosX * Width, y + m_PosY * Height, z + m_PosZ * Width, m_World
));
}
break;
}
@ -1426,45 +1373,17 @@ void cChunk::SetBlock(int a_RelX, int a_RelY, int a_RelZ, BLOCKTYPE a_BlockType,
switch (a_BlockType)
{
case E_BLOCK_CHEST:
{
AddBlockEntity(new cChestEntity(WorldPos.x, WorldPos.y, WorldPos.z, m_World));
break;
}
case E_BLOCK_DISPENSER:
{
AddBlockEntity(new cDispenserEntity(WorldPos.x, WorldPos.y, WorldPos.z, m_World));
break;
}
case E_BLOCK_DROPPER:
{
AddBlockEntity(new cDropperEntity(WorldPos.x, WorldPos.y, WorldPos.z, m_World));
break;
}
case E_BLOCK_LIT_FURNACE:
case E_BLOCK_FURNACE:
{
AddBlockEntity(new cFurnaceEntity(WorldPos.x, WorldPos.y, WorldPos.z, a_BlockType, a_BlockMeta, m_World));
break;
}
case E_BLOCK_HOPPER:
{
AddBlockEntity(new cHopperEntity(WorldPos.x, WorldPos.y, WorldPos.z, m_World));
break;
}
case E_BLOCK_SIGN_POST:
case E_BLOCK_WALLSIGN:
{
AddBlockEntity(new cSignEntity(a_BlockType, WorldPos.x, WorldPos.y, WorldPos.z, m_World));
break;
}
case E_BLOCK_NOTE_BLOCK:
{
AddBlockEntity(new cNoteEntity(WorldPos.x, WorldPos.y, WorldPos.z, m_World));
break;
}
case E_BLOCK_JUKEBOX:
{
AddBlockEntity(new cJukeboxEntity(WorldPos.x, WorldPos.y, WorldPos.z, m_World));
AddBlockEntity(cBlockEntity::CreateByBlockType(a_BlockType, a_BlockMeta, WorldPos.x, WorldPos.y, WorldPos.z, m_World));
break;
}
} // switch (a_BlockType)

24
source/Generating/ChunkDesc.cpp
View File

@ -8,6 +8,7 @@
#include "../BlockArea.h"
#include "../Cuboid.h"
#include "../Noise.h"
#include "../BlockEntities/BlockEntity.h"
@ -526,9 +527,28 @@ void cChunkDesc::RandomFillRelCuboid(
void cChunkDesc::AddBlockEntity(cBlockEntity * a_BlockEntity)
cBlockEntity * cChunkDesc::GetBlockEntity(int a_RelX, int a_RelY, int a_RelZ)
{
m_BlockEntities.push_back(a_BlockEntity);
int AbsX = a_RelX + m_ChunkX * cChunkDef::Width;
int AbsZ = a_RelZ + m_ChunkZ * cChunkDef::Width;
for (cBlockEntityList::iterator itr = m_BlockEntities.begin(), end = m_BlockEntities.end(); itr != end; ++itr)
{
if (((*itr)->GetPosX() == AbsX) && ((*itr)->GetPosY() == a_RelY) && ((*itr)->GetPosZ() == AbsZ))
{
// Already in the list, return it:
return *itr;
}
} // for itr - m_BlockEntities[]
// The block entity is not created yet, try to create it and add to list:
cBlockEntity * be = cBlockEntity::CreateByBlockType(GetBlockType(a_RelX, a_RelY, a_RelZ), GetBlockMeta(a_RelX, a_RelY, a_RelZ), AbsX, a_RelY, AbsZ);
if (be == NULL)
{
// No block entity for this block type
return NULL;
}
m_BlockEntities.push_back(be);
return be;
}

7
source/Generating/ChunkDesc.h
View File

@ -170,9 +170,12 @@ public:
);
}
// tolua_end
/// Returns the block entity at the specified coords.
/// If there is no block entity at those coords, tries to create one, based on the block type
/// If the blocktype doesn't support a block entity, returns NULL.
cBlockEntity * GetBlockEntity(int a_RelX, int a_RelY, int a_RelZ);
void AddBlockEntity(cBlockEntity * a_BlockEntity);
// tolua_end
// Accessors used by cChunkGenerator::Generator descendants:
inline cChunkDef::BiomeMap & GetBiomeMap (void) { return m_BiomeMap; }

4
source/Generating/MineShafts.cpp
View File

@ -794,12 +794,12 @@ void cMineShaftCorridor::PlaceChest(cChunkDesc & a_ChunkDesc)
)
{
a_ChunkDesc.SetBlockTypeMeta(x, m_BoundingBox.p1.y + 1, z, E_BLOCK_CHEST, Meta);
cChestEntity * ChestEntity = new cChestEntity(BlockX + x, m_BoundingBox.p1.y + 1, BlockZ + z);
cChestEntity * ChestEntity = (cChestEntity *)a_ChunkDesc.GetBlockEntity(x, m_BoundingBox.p1.y + 1, z);
ASSERT((ChestEntity != NULL) && (ChestEntity->GetBlockType() == E_BLOCK_CHEST));
cNoise Noise(a_ChunkDesc.GetChunkX() ^ a_ChunkDesc.GetChunkZ());
int NumSlots = 3 + ((Noise.IntNoise3DInt(x, m_BoundingBox.p1.y, z) / 11) % 4);
int Seed = Noise.IntNoise2DInt(x, z);
ChestEntity->GetContents().GenerateRandomLootWithBooks(LootProbab, ARRAYCOUNT(LootProbab), NumSlots, Seed);
a_ChunkDesc.AddBlockEntity(ChestEntity);
}
}