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

Enchantments: API and sending to client

Browse Source 
git-svn-id: http://mc-server.googlecode.com/svn/trunk@1539 0a769ca7-a7f5-676a-18bf-c427514a06d6
This commit is contained in:
madmaxoft@gmail.com 2013-06-02 10:40:20 +00:00
parent a1e58728e5
commit a19a070121
13 changed files with 1100 additions and 73 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
MCServer/Plugins/Debuggers/Debuggers.lua
View File

@ -595,6 +595,7 @@ function HandleTestWndCmd(a_Split, a_Player)
local Window = cLuaWindow(WindowType, WindowSizeX, WindowSizeY, "TestWnd");
Window:SetSlot(a_Player, 0, cItem(E_ITEM_DIAMOND, 64));
Window:SetSlot(a_Player, 1, cItem(E_ITEM_DIAMOND_SWORD, 1, 0, "1=1"));
Window:SetOnClosing(OnClosing);
Window:SetOnSlotChanged(OnSlotChanged);

8
VC2008/MCServer.vcproj
View File

@ -382,6 +382,14 @@
RelativePath="..\source\Defines.h"
>
</File>
<File
RelativePath="..\source\Enchantments.cpp"
>
</File>
<File
RelativePath="..\source\Enchantments.h"
>
</File>
<File
RelativePath="..\source\Endianness.h"
>

1
source/AllToLua.pkg
View File

@ -37,6 +37,7 @@ $cfile "Plugin_NewLua.h"
$cfile "Server.h"
$cfile "World.h"
$cfile "Inventory.h"
$cfile "Enchantments.h"
$cfile "Item.h"
$cfile "ItemGrid.h"
$cfile "BlockEntities/BlockEntity.h"

563
source/Bindings.cpp
View File

@ -1,6 +1,6 @@
/*
** Lua binding: AllToLua
** Generated automatically by tolua++-1.0.92 on 06/01/13 09:50:23.
** Generated automatically by tolua++-1.0.92 on 06/02/13 12:36:50.
*/
#ifndef __cplusplus
@ -36,6 +36,7 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S);
#include "Server.h"
#include "World.h"
#include "Inventory.h"
#include "Enchantments.h"
#include "Item.h"
#include "ItemGrid.h"
#include "BlockEntities/BlockEntity.h"
@ -64,20 +65,6 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S);
/* function to release collected object via destructor */
#ifdef __cplusplus
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_cCraftingGrid (lua_State* tolua_S)
{
cCraftingGrid* self = (cCraftingGrid*) tolua_tousertype(tolua_S,1,0);
Mtolua_delete(self);
return 0;
}
static int tolua_collect_cItem (lua_State* tolua_S)
{
cItem* self = (cItem*) tolua_tousertype(tolua_S,1,0);
@ -92,34 +79,6 @@ static int tolua_collect_Vector3f (lua_State* tolua_S)
return 0;
}
static int tolua_collect_cDropperEntity (lua_State* tolua_S)
{
cDropperEntity* self = (cDropperEntity*) 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_cItems (lua_State* tolua_S)
{
cItems* self = (cItems*) tolua_tousertype(tolua_S,1,0);
Mtolua_delete(self);
return 0;
}
static int tolua_collect_cBlockArea (lua_State* tolua_S)
{
cBlockArea* self = (cBlockArea*) tolua_tousertype(tolua_S,1,0);
Mtolua_delete(self);
return 0;
}
static int tolua_collect_cChestEntity (lua_State* tolua_S)
{
cChestEntity* self = (cChestEntity*) tolua_tousertype(tolua_S,1,0);
@ -148,16 +107,16 @@ static int tolua_collect_cBlockEntity (lua_State* tolua_S)
return 0;
}
static int tolua_collect_Vector3i (lua_State* tolua_S)
static int tolua_collect_cBlockArea (lua_State* tolua_S)
{
Vector3i* self = (Vector3i*) tolua_tousertype(tolua_S,1,0);
cBlockArea* self = (cBlockArea*) tolua_tousertype(tolua_S,1,0);
Mtolua_delete(self);
return 0;
}
static int tolua_collect_cTracer (lua_State* tolua_S)
static int tolua_collect_cEnchantments (lua_State* tolua_S)
{
cTracer* self = (cTracer*) tolua_tousertype(tolua_S,1,0);
cEnchantments* self = (cEnchantments*) tolua_tousertype(tolua_S,1,0);
Mtolua_delete(self);
return 0;
}
@ -169,6 +128,55 @@ static int tolua_collect_cLuaWindow (lua_State* tolua_S)
return 0;
}
static int tolua_collect_cDropperEntity (lua_State* tolua_S)
{
cDropperEntity* self = (cDropperEntity*) 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_cItems (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);
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_cIniFile (lua_State* tolua_S)
{
cIniFile* self = (cIniFile*) 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_Vector3d (lua_State* tolua_S)
{
Vector3d* self = (Vector3d*) tolua_tousertype(tolua_S,1,0);
@ -182,13 +190,14 @@ static int tolua_collect_Vector3d (lua_State* tolua_S)
static void tolua_reg_types (lua_State* tolua_S)
{
tolua_usertype(tolua_S,"TakeDamageInfo");
tolua_usertype(tolua_S,"cCraftingRecipe");
tolua_usertype(tolua_S,"cPlugin_NewLua");
tolua_usertype(tolua_S,"cCraftingGrid");
tolua_usertype(tolua_S,"cCraftingRecipe");
tolua_usertype(tolua_S,"cPlugin");
tolua_usertype(tolua_S,"cWindow");
tolua_usertype(tolua_S,"cStringMap");
tolua_usertype(tolua_S,"cItemGrid");
tolua_usertype(tolua_S,"cBlockArea");
tolua_usertype(tolua_S,"cWindow");
tolua_usertype(tolua_S,"cEnchantments");
tolua_usertype(tolua_S,"cLuaWindow");
tolua_usertype(tolua_S,"cInventory");
tolua_usertype(tolua_S,"cRoot");
@ -221,12 +230,12 @@ static void tolua_reg_types (lua_State* tolua_S)
tolua_usertype(tolua_S,"cBlockEntity");
tolua_usertype(tolua_S,"cItemGrid::cListener");
tolua_usertype(tolua_S,"cDropperEntity");
tolua_usertype(tolua_S,"cPlugin");
tolua_usertype(tolua_S,"cServer");
tolua_usertype(tolua_S,"cPluginManager");
tolua_usertype(tolua_S,"cBlockEntityWithItems");
tolua_usertype(tolua_S,"cLadder");
tolua_usertype(tolua_S,"cEntity");
tolua_usertype(tolua_S,"cCriticalSection");
tolua_usertype(tolua_S,"cEntity");
tolua_usertype(tolua_S,"cIniFile");
tolua_usertype(tolua_S,"cListeners");
tolua_usertype(tolua_S,"AStringVector");
@ -234,8 +243,8 @@ static void tolua_reg_types (lua_State* tolua_S)
tolua_usertype(tolua_S,"cPlayer");
tolua_usertype(tolua_S,"cTorch");
tolua_usertype(tolua_S,"cBlockEntityWindowOwner");
tolua_usertype(tolua_S,"cServer");
tolua_usertype(tolua_S,"cWorld");
tolua_usertype(tolua_S,"cPlugin_NewLua");
tolua_usertype(tolua_S,"cPawn");
tolua_usertype(tolua_S,"Lua__cEntity");
tolua_usertype(tolua_S,"Vector3d");
@ -13828,6 +13837,314 @@ static int tolua_AllToLua_cInventory_GetEquippedBoots00(lua_State* tolua_S)
}
#endif //#ifndef TOLUA_DISABLE
/* method: new of class cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments_new00
static int tolua_AllToLua_cEnchantments_new00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertable(tolua_S,1,"cEnchantments",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
{
cEnchantments* tolua_ret = (cEnchantments*) Mtolua_new((cEnchantments)());
tolua_pushusertype(tolua_S,(void*)tolua_ret,"cEnchantments");
}
}
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 cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments_new00_local
static int tolua_AllToLua_cEnchantments_new00_local(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertable(tolua_S,1,"cEnchantments",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
{
cEnchantments* tolua_ret = (cEnchantments*) Mtolua_new((cEnchantments)());
tolua_pushusertype(tolua_S,(void*)tolua_ret,"cEnchantments");
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 cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments_new01
static int tolua_AllToLua_cEnchantments_new01(lua_State* tolua_S)
{
tolua_Error tolua_err;
if (
!tolua_isusertable(tolua_S,1,"cEnchantments",0,&tolua_err) ||
!tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
else
{
const AString a_StringSpec = ((const AString) tolua_tocppstring(tolua_S,2,0));
{
cEnchantments* tolua_ret = (cEnchantments*) Mtolua_new((cEnchantments)(a_StringSpec));
tolua_pushusertype(tolua_S,(void*)tolua_ret,"cEnchantments");
tolua_pushcppstring(tolua_S,(const char*)a_StringSpec);
}
}
return 2;
tolua_lerror:
return tolua_AllToLua_cEnchantments_new00(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE
/* method: new_local of class cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments_new01_local
static int tolua_AllToLua_cEnchantments_new01_local(lua_State* tolua_S)
{
tolua_Error tolua_err;
if (
!tolua_isusertable(tolua_S,1,"cEnchantments",0,&tolua_err) ||
!tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
else
{
const AString a_StringSpec = ((const AString) tolua_tocppstring(tolua_S,2,0));
{
cEnchantments* tolua_ret = (cEnchantments*) Mtolua_new((cEnchantments)(a_StringSpec));
tolua_pushusertype(tolua_S,(void*)tolua_ret,"cEnchantments");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
tolua_pushcppstring(tolua_S,(const char*)a_StringSpec);
}
}
return 2;
tolua_lerror:
return tolua_AllToLua_cEnchantments_new00_local(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE
/* method: AddFromString of class cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments_AddFromString00
static int tolua_AllToLua_cEnchantments_AddFromString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"cEnchantments",0,&tolua_err) ||
!tolua_iscppstring(tolua_S,2,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
cEnchantments* self = (cEnchantments*) tolua_tousertype(tolua_S,1,0);
const AString a_StringSpec = ((const AString) tolua_tocppstring(tolua_S,2,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'AddFromString'", NULL);
#endif
{
self->AddFromString(a_StringSpec);
tolua_pushcppstring(tolua_S,(const char*)a_StringSpec);
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'AddFromString'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: ToString of class cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments_ToString00
static int tolua_AllToLua_cEnchantments_ToString00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"const cEnchantments",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
const cEnchantments* self = (const cEnchantments*) tolua_tousertype(tolua_S,1,0);
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'ToString'", NULL);
#endif
{
AString tolua_ret = (AString) self->ToString();
tolua_pushcppstring(tolua_S,(const char*)tolua_ret);
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'ToString'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: GetLevel of class cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments_GetLevel00
static int tolua_AllToLua_cEnchantments_GetLevel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"const cEnchantments",0,&tolua_err) ||
!tolua_isnumber(tolua_S,2,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,3,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
const cEnchantments* self = (const cEnchantments*) tolua_tousertype(tolua_S,1,0);
int a_EnchantmentID = ((int) tolua_tonumber(tolua_S,2,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'GetLevel'", NULL);
#endif
{
int tolua_ret = (int) self->GetLevel(a_EnchantmentID);
tolua_pushnumber(tolua_S,(lua_Number)tolua_ret);
}
}
return 1;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'GetLevel'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: SetLevel of class cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments_SetLevel00
static int tolua_AllToLua_cEnchantments_SetLevel00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"cEnchantments",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
{
cEnchantments* self = (cEnchantments*) tolua_tousertype(tolua_S,1,0);
int a_EnchantmentID = ((int) tolua_tonumber(tolua_S,2,0));
int a_Level = ((int) tolua_tonumber(tolua_S,3,0));
#ifndef TOLUA_RELEASE
if (!self) tolua_error(tolua_S,"invalid 'self' in function 'SetLevel'", NULL);
#endif
{
self->SetLevel(a_EnchantmentID,a_Level);
}
}
return 0;
#ifndef TOLUA_RELEASE
tolua_lerror:
tolua_error(tolua_S,"#ferror in function 'SetLevel'.",&tolua_err);
return 0;
#endif
}
#endif //#ifndef TOLUA_DISABLE
/* method: Clear of class cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments_Clear00
static int tolua_AllToLua_cEnchantments_Clear00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"cEnchantments",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
cEnchantments* self = (cEnchantments*) 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: IsEmpty of class cEnchantments */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cEnchantments_IsEmpty00
static int tolua_AllToLua_cEnchantments_IsEmpty00(lua_State* tolua_S)
{
#ifndef TOLUA_RELEASE
tolua_Error tolua_err;
if (
!tolua_isusertype(tolua_S,1,"const cEnchantments",0,&tolua_err) ||
!tolua_isnoobj(tolua_S,2,&tolua_err)
)
goto tolua_lerror;
else
#endif
{
const cEnchantments* self = (const cEnchantments*) 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: new of class cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_new00
static int tolua_AllToLua_cItem_new00(lua_State* tolua_S)
@ -13944,6 +14261,71 @@ tolua_lerror:
}
#endif //#ifndef TOLUA_DISABLE
/* method: new of class cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_new02
static int tolua_AllToLua_cItem_new02(lua_State* tolua_S)
{
tolua_Error tolua_err;
if (
!tolua_isusertable(tolua_S,1,"cItem",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_iscppstring(tolua_S,5,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,6,&tolua_err)
)
goto tolua_lerror;
else
{
short a_ItemType = ((short) tolua_tonumber(tolua_S,2,0));
char a_ItemCount = ((char) tolua_tonumber(tolua_S,3,0));
short a_ItemDamage = ((short) tolua_tonumber(tolua_S,4,0));
const AString a_Enchantments = ((const AString) tolua_tocppstring(tolua_S,5,0));
{
cItem* tolua_ret = (cItem*) Mtolua_new((cItem)(a_ItemType,a_ItemCount,a_ItemDamage,a_Enchantments));
tolua_pushusertype(tolua_S,(void*)tolua_ret,"cItem");
tolua_pushcppstring(tolua_S,(const char*)a_Enchantments);
}
}
return 2;
tolua_lerror:
return tolua_AllToLua_cItem_new01(tolua_S);
}
#endif //#ifndef TOLUA_DISABLE
/* method: new_local of class cItem */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItem_new02_local
static int tolua_AllToLua_cItem_new02_local(lua_State* tolua_S)
{
tolua_Error tolua_err;
if (
!tolua_isusertable(tolua_S,1,"cItem",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_iscppstring(tolua_S,5,0,&tolua_err) ||
!tolua_isnoobj(tolua_S,6,&tolua_err)
)
goto tolua_lerror;
else
{
short a_ItemType = ((short) tolua_tonumber(tolua_S,2,0));
char a_ItemCount = ((char) tolua_tonumber(tolua_S,3,0));
short a_ItemDamage = ((short) tolua_tonumber(tolua_S,4,0));
const AString a_Enchantments = ((const AString) tolua_tocppstring(tolua_S,5,0));
{
cItem* tolua_ret = (cItem*) Mtolua_new((cItem)(a_ItemType,a_ItemCount,a_ItemDamage,a_Enchantments));
tolua_pushusertype(tolua_S,(void*)tolua_ret,"cItem");
tolua_register_gc(tolua_S,lua_gettop(tolua_S));
tolua_pushcppstring(tolua_S,(const char*)a_Enchantments);
}
}
return 2;
tolua_lerror:
return tolua_AllToLua_cItem_new01_local(tolua_S);
}
#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)
@ -14400,6 +14782,36 @@ static int tolua_set_cItem_m_ItemDamage(lua_State* tolua_S)
}
#endif //#ifndef TOLUA_DISABLE
/* get function: m_Enchantments of class cItem */
#ifndef TOLUA_DISABLE_tolua_get_cItem_m_Enchantments
static int tolua_get_cItem_m_Enchantments(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_Enchantments'",NULL);
#endif
tolua_pushusertype(tolua_S,(void*)&self->m_Enchantments,"cEnchantments");
return 1;
}
#endif //#ifndef TOLUA_DISABLE
/* set function: m_Enchantments of class cItem */
#ifndef TOLUA_DISABLE_tolua_set_cItem_m_Enchantments
static int tolua_set_cItem_m_Enchantments(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_Enchantments'",NULL);
if ((tolua_isvaluenil(tolua_S,2,&tolua_err) || !tolua_isusertype(tolua_S,2,"cEnchantments",0,&tolua_err)))
tolua_error(tolua_S,"#vinvalid type in variable assignment.",&tolua_err);
#endif
self->m_Enchantments = *((cEnchantments*) tolua_tousertype(tolua_S,2,0))
;
return 0;
}
#endif //#ifndef TOLUA_DISABLE
/* method: new of class cItems */
#ifndef TOLUA_DISABLE_tolua_AllToLua_cItems_new00
static int tolua_AllToLua_cItems_new00(lua_State* tolua_S)
@ -27250,6 +27662,47 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S)
tolua_function(tolua_S,"GetEquippedBoots",tolua_AllToLua_cInventory_GetEquippedBoots00);
tolua_endmodule(tolua_S);
#ifdef __cplusplus
tolua_cclass(tolua_S,"cEnchantments","cEnchantments","",tolua_collect_cEnchantments);
#else
tolua_cclass(tolua_S,"cEnchantments","cEnchantments","",NULL);
#endif
tolua_beginmodule(tolua_S,"cEnchantments");
tolua_constant(tolua_S,"enchProtection",cEnchantments::enchProtection);
tolua_constant(tolua_S,"enchFireProtection",cEnchantments::enchFireProtection);
tolua_constant(tolua_S,"enchFeatherFalling",cEnchantments::enchFeatherFalling);
tolua_constant(tolua_S,"enchBlastProtection",cEnchantments::enchBlastProtection);
tolua_constant(tolua_S,"enchProjectileProtection",cEnchantments::enchProjectileProtection);
tolua_constant(tolua_S,"enchRespiration",cEnchantments::enchRespiration);
tolua_constant(tolua_S,"enchAquaAffinity",cEnchantments::enchAquaAffinity);
tolua_constant(tolua_S,"enchThorns",cEnchantments::enchThorns);
tolua_constant(tolua_S,"enchSharpness",cEnchantments::enchSharpness);
tolua_constant(tolua_S,"enchSmite",cEnchantments::enchSmite);
tolua_constant(tolua_S,"enchBaneOfArthropods",cEnchantments::enchBaneOfArthropods);
tolua_constant(tolua_S,"enchKnockback",cEnchantments::enchKnockback);
tolua_constant(tolua_S,"enchFireAspect",cEnchantments::enchFireAspect);
tolua_constant(tolua_S,"enchLooting",cEnchantments::enchLooting);
tolua_constant(tolua_S,"enchEfficiency",cEnchantments::enchEfficiency);
tolua_constant(tolua_S,"enchSilkTouch",cEnchantments::enchSilkTouch);
tolua_constant(tolua_S,"enchUnbreaking",cEnchantments::enchUnbreaking);
tolua_constant(tolua_S,"enchFortune",cEnchantments::enchFortune);
tolua_constant(tolua_S,"enchPower",cEnchantments::enchPower);
tolua_constant(tolua_S,"enchPunch",cEnchantments::enchPunch);
tolua_constant(tolua_S,"enchFlame",cEnchantments::enchFlame);
tolua_constant(tolua_S,"enchInfinity",cEnchantments::enchInfinity);
tolua_function(tolua_S,"new",tolua_AllToLua_cEnchantments_new00);
tolua_function(tolua_S,"new_local",tolua_AllToLua_cEnchantments_new00_local);
tolua_function(tolua_S,".call",tolua_AllToLua_cEnchantments_new00_local);
tolua_function(tolua_S,"new",tolua_AllToLua_cEnchantments_new01);
tolua_function(tolua_S,"new_local",tolua_AllToLua_cEnchantments_new01_local);
tolua_function(tolua_S,".call",tolua_AllToLua_cEnchantments_new01_local);
tolua_function(tolua_S,"AddFromString",tolua_AllToLua_cEnchantments_AddFromString00);
tolua_function(tolua_S,"ToString",tolua_AllToLua_cEnchantments_ToString00);
tolua_function(tolua_S,"GetLevel",tolua_AllToLua_cEnchantments_GetLevel00);
tolua_function(tolua_S,"SetLevel",tolua_AllToLua_cEnchantments_SetLevel00);
tolua_function(tolua_S,"Clear",tolua_AllToLua_cEnchantments_Clear00);
tolua_function(tolua_S,"IsEmpty",tolua_AllToLua_cEnchantments_IsEmpty00);
tolua_endmodule(tolua_S);
#ifdef __cplusplus
tolua_cclass(tolua_S,"cItem","cItem","",tolua_collect_cItem);
#else
tolua_cclass(tolua_S,"cItem","cItem","",NULL);
@ -27261,6 +27714,9 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S)
tolua_function(tolua_S,"new",tolua_AllToLua_cItem_new01);
tolua_function(tolua_S,"new_local",tolua_AllToLua_cItem_new01_local);
tolua_function(tolua_S,".call",tolua_AllToLua_cItem_new01_local);
tolua_function(tolua_S,"new",tolua_AllToLua_cItem_new02);
tolua_function(tolua_S,"new_local",tolua_AllToLua_cItem_new02_local);
tolua_function(tolua_S,".call",tolua_AllToLua_cItem_new02_local);
tolua_function(tolua_S,"Empty",tolua_AllToLua_cItem_Empty00);
tolua_function(tolua_S,"Clear",tolua_AllToLua_cItem_Clear00);
tolua_function(tolua_S,"IsEmpty",tolua_AllToLua_cItem_IsEmpty00);
@ -27275,6 +27731,7 @@ TOLUA_API int tolua_AllToLua_open (lua_State* tolua_S)
tolua_variable(tolua_S,"m_ItemType",tolua_get_cItem_m_ItemType,tolua_set_cItem_m_ItemType);
tolua_variable(tolua_S,"m_ItemCount",tolua_get_cItem_m_ItemCount,tolua_set_cItem_m_ItemCount);
tolua_variable(tolua_S,"m_ItemDamage",tolua_get_cItem_m_ItemDamage,tolua_set_cItem_m_ItemDamage);
tolua_variable(tolua_S,"m_Enchantments",tolua_get_cItem_m_Enchantments,tolua_set_cItem_m_Enchantments);
tolua_endmodule(tolua_S);
#ifdef __cplusplus
tolua_cclass(tolua_S,"cItems","cItems","",tolua_collect_cItems);

2
source/Bindings.h
View File

@ -1,6 +1,6 @@
/*
** Lua binding: AllToLua
** Generated automatically by tolua++-1.0.92 on 06/01/13 09:50:24.
** Generated automatically by tolua++-1.0.92 on 06/02/13 12:36:50.
*/
/* Exported function */

231
source/Enchantments.cpp Normal file
View File

@ -0,0 +1,231 @@
// Enchantments.cpp
// Implements the cEnchantments class representing a storage for item enchantments and stored-enchantments
#include "Globals.h"
#include "Enchantments.h"
#include "WorldStorage/FastNBT.h"
cEnchantments::cEnchantments(void)
{
// Nothing needed yet, but the constructor needs to be declared and impemented in order to be usable
}
cEnchantments::cEnchantments(const AString & a_StringSpec)
{
AddFromString(a_StringSpec);
}
void cEnchantments::AddFromString(const AString & a_StringSpec)
{
// Add enchantments in the stringspec; if a specified enchantment already exists, overwrites it
// Split the StringSpec into separate declarations, each in the form "id=lvl":
AStringVector Decls = StringSplit(a_StringSpec, ";");
for (AStringVector::const_iterator itr = Decls.begin(), end = Decls.end(); itr != end; ++itr)
{
// Split each declaration into the id and lvl part:
if (itr->empty())
{
// The decl is empty (may happen if there's an extra semicolon at the end), ignore silently
continue;
}
AStringVector Split = StringSplitAndTrim(*itr, "=");
if (Split.size() != 2)
{
// Malformed decl
LOG("%s: Malformed enchantment decl: \"%s\", skipping.", __FUNCTION__, itr->c_str());
continue;
}
int id = atoi(Split[0].c_str());
int lvl = atoi(Split[1].c_str());
if (
((id == 0) && (Split[0] != "0")) ||
((lvl == 0) && (Split[1] != "0"))
)
{
// Numbers failed to parse
LOG("%s: Failed to parse enchantment declaration for numbers: \"%s\" and \"%s\", skipping.",
__FUNCTION__, Split[0].c_str(), Split[1].c_str()
);
continue;
}
SetLevel(id, lvl);
} // for itr - Decls[]
}
AString cEnchantments::ToString(void) const
{
// Serialize all the enchantments into a string
AString res;
for (cEnchantments::cMap::const_iterator itr = m_Enchantments.begin(), end = m_Enchantments.end(); itr != end; ++itr)
{
AppendPrintf(res, "%d=%d;", itr->first, itr->second);
} // for itr - m_Enchantments[]
return res;
}
int cEnchantments::GetLevel(int a_EnchantmentID) const
{
// Return the level for the specified enchantment; 0 if not stored
cMap::const_iterator itr = m_Enchantments.find(a_EnchantmentID);
if (itr != m_Enchantments.end())
{
return itr->second;
}
// Not stored, return zero
return 0;
}
void cEnchantments::SetLevel(int a_EnchantmentID, int a_Level)
{
// Sets the level for the specified enchantment, adding it if not stored before or removing it if level <= 0
if (a_Level == 0)
{
// Delete enchantment, if present:
cMap::iterator itr = m_Enchantments.find(a_EnchantmentID);
if (itr != m_Enchantments.end())
{
m_Enchantments.erase(itr);
}
}
else
{
// Add / overwrite enchantment
m_Enchantments[a_EnchantmentID] = a_Level;
}
}
void cEnchantments::Clear(void)
{
m_Enchantments.clear();
}
bool cEnchantments::IsEmpty(void) const
{
return m_Enchantments.empty();
}
void cEnchantments::WriteToNBTCompound(cFastNBTWriter & a_Writer, const AString & a_ListTagName) const
{
// Write the enchantments into the specified NBT writer
// begin with the LIST tag of the specified name ("ench" or "StoredEnchantments")
a_Writer.BeginList(a_ListTagName, TAG_Compound);
for (cMap::const_iterator itr = m_Enchantments.begin(), end = m_Enchantments.end(); itr != end; ++itr)
{
a_Writer.BeginCompound("");
a_Writer.AddShort("id", itr->first);
a_Writer.AddShort("lvl", itr->second);
a_Writer.EndCompound();
} // for itr - m_Enchantments[]
a_Writer.EndList();
}
void cEnchantments::ParseFromNBT(cParsedNBT & a_NBT, int a_EnchListTagIdx)
{
// Read the enchantments from the specified NBT list tag (ench or StoredEnchantments)
// Verify that the tag is a list:
if (a_NBT.GetType(a_EnchListTagIdx) != TAG_List)
{
LOGWARNING("%s: Invalid EnchListTag type: exp %d, got %d. Enchantments not parsed",
__FUNCTION__, TAG_List, a_NBT.GetType(a_EnchListTagIdx)
);
ASSERT(!"Bad EnchListTag type");
return;
}
// Verify that the list is of Compounds:
if (a_NBT.GetChildrenType(a_EnchListTagIdx) != TAG_Compound)
{
LOGWARNING("%s: Invalid NBT list children type: exp %d, got %d. Enchantments not parsed",
__FUNCTION__, TAG_Compound, a_NBT.GetChildrenType(a_EnchListTagIdx)
);
ASSERT(!"Bad EnchListTag children type");
return;
}
Clear();
// Iterate over all the compound children, parse an enchantment from each:
for (int tag = a_NBT.GetFirstChild(a_EnchListTagIdx); tag >= 0; tag = a_NBT.GetNextSibling(tag))
{
// tag is the compound inside the "ench" list tag
ASSERT(a_NBT.GetType(tag) == TAG_Compound);
// Search for the id and lvl tags' values:
int id = -1, lvl = -1;
for (int ch = a_NBT.GetFirstChild(tag); ch >= 0; ch = a_NBT.GetNextSibling(ch))
{
if (a_NBT.GetType(ch) != TAG_Short)
{
continue;
}
if (a_NBT.GetName(ch) == "id")
{
id = a_NBT.GetShort(ch);
}
else if (a_NBT.GetName(ch) == "lvl")
{
lvl = a_NBT.GetShort(ch);
}
} // for ch - children of the compound tag
if ((id == -1) || (lvl <= 0))
{
// Failed to parse either the id or the lvl, skip this compound
continue;
}
// Store the enchantment:
m_Enchantments[id] = lvl;
} // for tag - children of the ench list tag
}

105
source/Enchantments.h Normal file
View File

@ -0,0 +1,105 @@
// Enchantments.h
// Declares the cEnchantments class representing a storage for item enchantments and stored-enchantments
#pragma once
// fwd: WorldStorage/FastNBT.h
class cFastNBTWriter;
class cParsedNBT;
// tolua_begin
/** Class that stores item enchantments or stored-enchantments
The enchantments may be serialized to a stringspec and read back from such stringspec.
The format for the stringspec is "id=lvl;id=lvl;id=lvl...", with an optional semicolon at the end,
mapping each enchantment's id onto its level.
Level value of 0 means no such enchantment, and it will not be stored in the m_Enchantments.
Serialization will never put zero-level enchantments into the stringspec.
*/
class cEnchantments
{
public:
/// Individual enchantment IDs, corresponding to their NBT IDs ( http://www.minecraftwiki.net/wiki/Data_Values#Enchantment_IDs )
enum
{
enchProtection = 0,
enchFireProtection = 1,
enchFeatherFalling = 2,
enchBlastProtection = 3,
enchProjectileProtection = 4,
enchRespiration = 5,
enchAquaAffinity = 6,
enchThorns = 7,
enchSharpness = 16,
enchSmite = 17,
enchBaneOfArthropods = 18,
enchKnockback = 19,
enchFireAspect = 20,
enchLooting = 21,
enchEfficiency = 32,
enchSilkTouch = 33,
enchUnbreaking = 34,
enchFortune = 35,
enchPower = 48,
enchPunch = 49,
enchFlame = 50,
enchInfinity = 51,
} ;
/// Creates an empty enchantments container
cEnchantments(void);
/// Creates an enchantments container filled with enchantments parsed from stringspec
cEnchantments(const AString & a_StringSpec);
/// Adds enchantments in the stringspec; if a specified enchantment already exists, overwrites it
void AddFromString(const AString & a_StringSpec);
/// Serializes all the enchantments into a string
AString ToString(void) const;
/// Returns the level for the specified enchantment; 0 if not stored
int GetLevel(int a_EnchantmentID) const;
/// Sets the level for the specified enchantment, adding it if not stored before or removing it if level <= 0
void SetLevel(int a_EnchantmentID, int a_Level);
/// Removes all enchantments
void Clear(void);
/// Returns true if there are no enchantments
bool IsEmpty(void) const;
// tolua_end
/// Writes the enchantments into the specified NBT writer; begins with the LIST tag of the specified name ("ench" or "StoredEnchantments")
void WriteToNBTCompound(cFastNBTWriter & a_Writer, const AString & a_ListTagName) const;
/// Reads the enchantments from the specified NBT list tag (ench or StoredEnchantments)
void ParseFromNBT(cParsedNBT & a_NBT, int a_EnchListTagIdx);
protected:
/// Maps enchantment ID -> enchantment level
typedef std::map<int, int> cMap;
/// Currently stored enchantments
cMap m_Enchantments;
} ; // tolua_export

35
source/Item.h
View File

@ -1,7 +1,20 @@
// Item.h
// Declares the cItem class representing an item (in the inventory sense)
#pragma once
#include "Defines.h"
#include "BlockID.h"
#include "Enchantments.h"
namespace Json
{
@ -25,15 +38,17 @@ public:
}
/// Creates an item of the specified type, by default 1 piece with no damage
/// Creates an item of the specified type, by default 1 piece with no damage and no enchantments
cItem(
short a_ItemType,
char a_ItemCount = 1,
short a_ItemDamage = 0
short a_ItemDamage = 0,
const AString & a_Enchantments = ""
) :
m_ItemType (a_ItemType),
m_ItemCount (a_ItemCount),
m_ItemDamage(a_ItemDamage)
m_ItemType (a_ItemType),
m_ItemCount (a_ItemCount),
m_ItemDamage (a_ItemDamage),
m_Enchantments(a_Enchantments)
{
if (!IsValidItem(m_ItemType))
{
@ -48,6 +63,7 @@ public:
m_ItemType = E_ITEM_EMPTY;
m_ItemCount = 0;
m_ItemDamage = 0;
m_Enchantments.Clear();
}
@ -98,9 +114,10 @@ public:
static bool IsEnchantable(short a_ItemType);
short m_ItemType;
char m_ItemCount;
short m_ItemDamage;
short m_ItemType;
char m_ItemCount;
short m_ItemDamage;
cEnchantments m_Enchantments;
};
// tolua_end

73
source/Protocol/Protocol132.cpp
View File

@ -15,6 +15,8 @@
#include "../Mobs/Monster.h"
#include "../UI/Window.h"
#include "../Pickup.h"
#include "../WorldStorage/FastNBT.h"
#include "../StringCompression.h"
@ -693,8 +695,21 @@ void cProtocol132::WriteItem(const cItem & a_Item)
WriteByte (a_Item.m_ItemCount);
WriteShort(a_Item.m_ItemDamage);
// TODO: Implement enchantments
WriteShort(-1);
if (a_Item.m_Enchantments.IsEmpty())
{
WriteShort(-1);
return;
}
// Send the enchantments:
cFastNBTWriter Writer;
const char * TagName = (a_Item.m_ItemType == E_ITEM_BOOK) ? "StoredEnchantments" : "ench";
a_Item.m_Enchantments.WriteToNBTCompound(Writer, TagName);
Writer.Finish();
AString Compressed;
CompressStringGZIP(Writer.GetResult().data(), Writer.GetResult().size(), Compressed);
WriteShort(Compressed.size());
SendData(Compressed.data(), Compressed.size());
}
@ -721,18 +736,64 @@ int cProtocol132::ParseItem(cItem & a_Item)
a_Item.Empty();
}
HANDLE_PACKET_READ(ReadBEShort, short, EnchantNumBytes);
if (EnchantNumBytes <= 0)
HANDLE_PACKET_READ(ReadBEShort, short, MetadataLength);
if (MetadataLength <= 0)
{
return PARSE_OK;
}
// TODO: Enchantment not implemented yet!
if (!m_ReceivedData.SkipRead(EnchantNumBytes))
// Read the metadata
AString Metadata;
Metadata.resize(MetadataLength);
if (!m_ReceivedData.ReadBuf((void *)Metadata.data(), MetadataLength))
{
return PARSE_INCOMPLETE;
}
return ParseItemMetadata(a_Item, Metadata);
}
int cProtocol132::ParseItemMetadata(cItem & a_Item, const AString & a_Metadata)
{
// Uncompress the GZIPped data:
AString Uncompressed;
if (UncompressStringGZIP(a_Metadata.data(), a_Metadata.size(), Uncompressed) != Z_OK)
{
AString HexDump;
CreateHexDump(HexDump, a_Metadata.data(), a_Metadata.size(), 16);
LOG("Cannot unGZIP item metadata:\n%s", HexDump.c_str());
return PARSE_ERROR;
}
// Parse into NBT:
cParsedNBT NBT(Uncompressed.data(), Uncompressed.size());
if (!NBT.IsValid())
{
AString HexDump;
CreateHexDump(HexDump, Uncompressed.data(), Uncompressed.size(), 16);
LOG("Cannot parse NBT item metadata:\n%s", HexDump.c_str());
return PARSE_ERROR;
}
// Load enchantments from the NBT:
for (int tag = NBT.GetFirstChild(NBT.GetRoot()); tag >= 0; tag = NBT.GetNextSibling(tag))
{
if (
(NBT.GetType(tag) == TAG_List) &&
(
(NBT.GetName(tag) == "ench") ||
(NBT.GetName(tag) == "StoredEnchantments")
)
)
{
a_Item.m_Enchantments.ParseFromNBT(NBT, tag);
}
}
return PARSE_OK;
}

3
source/Protocol/Protocol132.h
View File

@ -82,6 +82,9 @@ protected:
virtual void WriteItem(const cItem & a_Item) override;
virtual int ParseItem(cItem & a_Item) override;
/// Parses the metadata that may come with the item.
int ParseItemMetadata(cItem & a_Item, const AString & a_Metadata);
virtual void SendCompass(const cWorld & a_World);
virtual void SendEncryptionKeyRequest(void);

129
source/StringCompression.cpp
View File

@ -5,13 +5,12 @@
#include "Globals.h"
#include "StringCompression.h"
#include "zlib.h"
/// Compresses a_Data into a_Compressed; return Z_XXX error constants same as zlib's compress2()
/// Compresses a_Data into a_Compressed; returns Z_XXX error constants same as zlib's compress2()
int CompressString(const char * a_Data, int a_Length, AString & a_Compressed)
{
uLongf CompressedSize = compressBound(a_Length);
@ -53,3 +52,129 @@ int UncompressString(const char * a_Data, int a_Length, AString & a_Uncompressed
int CompressStringGZIP(const char * a_Data, int a_Length, AString & a_Compressed)
{
// Compress a_Data into a_Compressed using GZIP; return Z_XXX error constants same as zlib's compress2()
a_Compressed.reserve(a_Length);
char Buffer[64 KiB];
z_stream strm;
memset(&strm, 0, sizeof(strm));
strm.next_in = (Bytef *)a_Data;
strm.avail_in = a_Length;
strm.next_out = (Bytef *)Buffer;
strm.avail_out = sizeof(Buffer);
int res = deflateInit2(&strm, 9, Z_DEFLATED, 31, 9, Z_DEFAULT_STRATEGY);
if (res != Z_OK)
{
LOG("%s: compression initialization failed: %d (\"%s\").", __FUNCTION__, res, strm.msg);
return res;
}
while (true)
{
res = deflate(&strm, Z_FINISH);
switch (res)
{
case Z_OK:
{
// Some data has been compressed. Consume the buffer and continue compressing
a_Compressed.append(Buffer, sizeof(Buffer) - strm.avail_out);
strm.avail_out = sizeof(Buffer);
if (strm.avail_in == 0)
{
// All data has been compressed
deflateEnd(&strm);
return Z_OK;
}
break;
}
case Z_STREAM_END:
{
// Finished compressing. Consume the rest of the buffer and return
a_Compressed.append(Buffer, sizeof(Buffer) - strm.avail_out);
deflateEnd(&strm);
return Z_OK;
}
default:
{
// An error has occurred, log it and return the error value
LOG("%s: compression failed: %d (\"%s\").", __FUNCTION__, res, strm.msg);
deflateEnd(&strm);
return res;
}
} // switch (res)
} // while (true)
}
extern int UncompressStringGZIP(const char * a_Data, int a_Length, AString & a_Uncompressed)
{
// Uncompresses a_Data into a_Uncompressed using GZIP; returns Z_OK for success or Z_XXX error constants same as zlib
a_Uncompressed.reserve(a_Length);
char Buffer[64 KiB];
z_stream strm;
memset(&strm, 0, sizeof(strm));
strm.next_in = (Bytef *)a_Data;
strm.avail_in = a_Length;
strm.next_out = (Bytef *)Buffer;
strm.avail_out = sizeof(Buffer);
int res = inflateInit2(&strm, 31); // Force GZIP decoding
if (res != Z_OK)
{
LOG("%s: uncompression initialization failed: %d (\"%s\").", __FUNCTION__, res, strm.msg);
return res;
}
while (true)
{
res = inflate(&strm, Z_FINISH);
switch (res)
{
case Z_OK:
{
// Some data has been uncompressed. Consume the buffer and continue uncompressing
a_Uncompressed.append(Buffer, sizeof(Buffer) - strm.avail_out);
strm.avail_out = sizeof(Buffer);
if (strm.avail_in == 0)
{
// All data has been uncompressed
inflateEnd(&strm);
return Z_OK;
}
break;
}
case Z_STREAM_END:
{
// Finished uncompressing. Consume the rest of the buffer and return
a_Uncompressed.append(Buffer, sizeof(Buffer) - strm.avail_out);
inflateEnd(&strm);
return Z_OK;
}
default:
{
// An error has occurred, log it and return the error value
LOG("%s: uncompression failed: %d (\"%s\").", __FUNCTION__, res, strm.msg);
inflateEnd(&strm);
return res;
}
} // switch (res)
} // while (true)
}

12
source/StringCompression.h
View File

@ -3,15 +3,23 @@
// Interfaces to the wrapping functions for compression and decompression using AString as their data
#include "zlib.h" // Needed for the Z_XXX return values
/// Compresses a_Data into a_Compressed; return Z_XXX error constants same as zlib's compress2()
/// Compresses a_Data into a_Compressed using ZLIB; returns Z_XXX error constants same as zlib's compress2()
extern int CompressString(const char * a_Data, int a_Length, AString & a_Compressed);
/// Uncompresses a_Data into a_Decompressed; returns Z_XXX error constants same as zlib's decompress()
/// Uncompresses a_Data into a_Uncompressed; returns Z_XXX error constants same as zlib's decompress()
extern int UncompressString(const char * a_Data, int a_Length, AString & a_Uncompressed, int a_UncompressedSize);
/// Compresses a_Data into a_Compressed using GZIP; returns Z_OK for success or Z_XXX error constants same as zlib
extern int CompressStringGZIP(const char * a_Data, int a_Length, AString & a_Compressed);
/// Uncompresses a_Data into a_Uncompressed using GZIP; returns Z_OK for success or Z_XXX error constants same as zlib
extern int UncompressStringGZIP(const char * a_Data, int a_Length, AString & a_Uncompressed);

10
source/WorldStorage/NBTChunkSerializer.cpp
View File

@ -68,6 +68,16 @@ void cNBTChunkSerializer::AddItem(const cItem & a_Item, int a_Slot, const AStrin
{
m_Writer.AddByte ("Slot", (unsigned char)a_Slot);
}
// Write the enchantments:
if (!a_Item.m_Enchantments.IsEmpty())
{
const char * TagName = (a_Item.m_ItemType == E_ITEM_BOOK) ? "StoredEnchantments" : "ench";
m_Writer.BeginCompound("tag");
a_Item.m_Enchantments.WriteToNBTCompound(m_Writer, TagName);
m_Writer.EndCompound();
}
m_Writer.EndCompound();
}