CraftItem rework and Lua interface

This commit is contained in:
Kahrl 2011-11-29 17:15:18 +02:00 committed by Perttu Ahola
parent 1c19f959db
commit d6b30dd3a5
21 changed files with 2162 additions and 1250 deletions

@ -10,6 +10,7 @@
-- minetest.register_entity(name, prototype_table) -- minetest.register_entity(name, prototype_table)
-- minetest.register_tool(name, {lots of stuff}) -- minetest.register_tool(name, {lots of stuff})
-- minetest.register_node(name, {lots of stuff}) -- minetest.register_node(name, {lots of stuff})
-- minetest.register_craftitem(name, {lots of stuff})
-- minetest.register_craft({output=item, recipe={...}) -- minetest.register_craft({output=item, recipe={...})
-- minetest.register_globalstep(func) -- minetest.register_globalstep(func)
-- minetest.register_on_placenode(func(pos, newnode, placer)) -- minetest.register_on_placenode(func(pos, newnode, placer))
@ -30,7 +31,9 @@
-- --
-- Global tables: -- Global tables:
-- minetest.registered_nodes -- minetest.registered_nodes
-- ^ List of registed node definitions, indexed by name -- ^ List of registered node definitions, indexed by name
-- minetest.registered_craftitems
-- ^ List of registered craft item definitions, indexed by name
-- minetest.registered_entities -- minetest.registered_entities
-- ^ List of registered entity prototypes, indexed by name -- ^ List of registered entity prototypes, indexed by name
-- minetest.object_refs -- minetest.object_refs
@ -44,6 +47,9 @@
-- - remove_node(pos) -- - remove_node(pos)
-- - get_node(pos) -- - get_node(pos)
-- - add_luaentity(pos, name) -- - add_luaentity(pos, name)
-- - add_item(pos, itemstring)
-- - add_rat(pos)
-- - add_firefly(pos)
-- - get_meta(pos) -- Get a NodeMetaRef at that position -- - get_meta(pos) -- Get a NodeMetaRef at that position
-- --
-- NodeMetaRef -- NodeMetaRef
@ -73,6 +79,9 @@
-- - setpos(pos); pos={x=num, y=num, z=num} -- - setpos(pos); pos={x=num, y=num, z=num}
-- - moveto(pos, continuous=false): interpolated move -- - moveto(pos, continuous=false): interpolated move
-- - add_to_inventory(itemstring): add an item to object inventory -- - add_to_inventory(itemstring): add an item to object inventory
-- - add_to_inventory_later(itemstring): like above, but after callback returns (only allowed for craftitem callbacks)
-- - get_hp(): returns number of hitpoints (2 * number of hearts)
-- - set_hp(hp): set number of hitpoints (2 * number of hearts)
-- - settexturemod(mod) -- - settexturemod(mod)
-- - setsprite(p={x=0,y=0}, num_frames=1, framelength=0.2, -- - setsprite(p={x=0,y=0}, num_frames=1, framelength=0.2,
-- - select_horiz_by_yawpitch=false) -- - select_horiz_by_yawpitch=false)
@ -1159,6 +1168,118 @@ minetest.register_node("TNT", {
}, },
}) })
--
-- Crafting items
--
local craftitem_place_item = function(item, placer, pos)
--print("craftitem_place_item")
print("item: " .. dump(item))
print("placer: " .. dump(placer))
print("pos: " .. dump(pos))
minetest.env:add_item(pos, 'CraftItem "' .. item .. '" 1')
return true
end
local craftitem_eat = function(hp_change)
return function(item, user, pointed_thing) -- closure
--print("craftitem_eat(" .. hp_change .. ")")
--print("item: " .. dump(item))
--print("user: " .. dump(user))
--print("pointed_thing: " .. dump(pointed_thing))
user:set_hp(user:get_hp() + hp_change)
return true
end
end
minetest.register_craftitem("Stick", {
image = "stick.png",
--furnace_burntime = ...,
on_place_on_ground = craftitem_place_item,
})
minetest.register_craftitem("paper", {
image = "paper.png",
on_place_on_ground = craftitem_place_item,
})
minetest.register_craftitem("book", {
image = "book.png",
on_place_on_ground = craftitem_place_item,
})
minetest.register_craftitem("lump_of_coal", {
image = "lump_of_coal.png",
furnace_burntime = 40;
on_place_on_ground = craftitem_place_item,
})
minetest.register_craftitem("lump_of_iron", {
image = "lump_of_iron.png",
cookresult_item = 'CraftItem "steel_ingot" 1',
on_place_on_ground = craftitem_place_item,
})
minetest.register_craftitem("lump_of_clay", {
image = "lump_of_clay.png",
cookresult_item = 'CraftItem "clay_brick" 1',
on_place_on_ground = craftitem_place_item,
})
minetest.register_craftitem("steel_ingot", {
image = "steel_ingot.png",
on_place_on_ground = craftitem_place_item,
})
minetest.register_craftitem("clay_brick", {
image = "clay_brick.png",
on_place_on_ground = craftitem_place_item,
})
minetest.register_craftitem("rat", {
image = "rat.png",
cookresult_item = 'CraftItem "cooked_rat" 1',
on_drop = function(item, dropper, pos)
minetest.env:add_rat(pos)
return true
end,
})
minetest.register_craftitem("cooked_rat", {
image = "cooked_rat.png",
cookresult_item = 'CraftItem "scorched_stuff" 1',
on_place_on_ground = craftitem_place_item,
on_use = craftitem_eat(6),
})
minetest.register_craftitem("scorched_stuff", {
image = "scorched_stuff.png",
on_place_on_ground = craftitem_place_item,
})
minetest.register_craftitem("firefly", {
image = "firefly.png",
on_drop = function(item, dropper, pos)
minetest.env:add_firefly(pos)
return true
end,
})
minetest.register_craftitem("apple", {
image = "apple.png",
on_place_on_ground = craftitem_place_item,
on_use = craftitem_eat(4),
})
minetest.register_craftitem("apple_iron", {
image = "apple_iron.png",
on_place_on_ground = craftitem_place_item,
on_use = craftitem_eat(8),
})
print(dump(minetest.registered_craftitems))
-- --
-- Some common functions -- Some common functions
-- --
@ -1237,6 +1358,7 @@ function TNT:on_punch(hitter)
if self.health <= 0 then if self.health <= 0 then
self.object:remove() self.object:remove()
hitter:add_to_inventory("NodeItem TNT 1") hitter:add_to_inventory("NodeItem TNT 1")
hitter:set_hp(hitter:get_hp() - 1)
end end
end end
@ -1344,6 +1466,8 @@ function on_punchnode(p, node)
if node.name == "TNT" then if node.name == "TNT" then
minetest.env:remove_node(p) minetest.env:remove_node(p)
minetest.env:add_luaentity(p, "TNT") minetest.env:add_luaentity(p, "TNT")
--minetest.env:add_luaentity(p, "testentity")
--minetest.env:add_firefly(p)
nodeupdate(p) nodeupdate(p)
end end
end end
@ -1381,7 +1505,7 @@ minetest.register_on_chat_message(function(name, message)
end) end)
-- Grow papyrus on TNT every 10 seconds -- Grow papyrus on TNT every 10 seconds
--[[minetest.register_abm({ minetest.register_abm({
nodenames = {"TNT"}, nodenames = {"TNT"},
interval = 10.0, interval = 10.0,
chance = 1, chance = 1,
@ -1390,7 +1514,7 @@ end)
pos.y = pos.y + 1 pos.y = pos.y + 1
minetest.env:add_node(pos, {name="papyrus"}) minetest.env:add_node(pos, {name="papyrus"})
end, end,
})]] })
-- Replace texts of alls signs with "foo" every 10 seconds -- Replace texts of alls signs with "foo" every 10 seconds
--[[minetest.register_abm({ --[[minetest.register_abm({
@ -1404,6 +1528,79 @@ end)
end, end,
})]] })]]
--[[local ncpos = nil
local ncq = 1
local ncstuff = {
{2, 1, 0, 3}, {3, 0, 1, 2}, {4, -1, 0, 1}, {5, -1, 0, 1}, {6, 0, -1, 0},
{7, 0, -1, 0}, {8, 1, 0, 3}, {9, 1, 0, 3}, {10, 1, 0, 3}, {11, 0, 1, 2},
{12, 0, 1, 2}, {13, 0, 1, 2}, {14, -1, 0, 1}, {15, -1, 0, 1}, {16, -1, 0, 1},
{17, -1, 0, 1}, {18, 0, -1, 0}, {19, 0, -1, 0}, {20, 0, -1, 0}, {21, 0, -1, 0},
{22, 1, 0, 3}, {23, 1, 0, 3}, {24, 1, 0, 3}, {25, 1, 0, 3}, {10, 0, 1, 2}
}
local ncold = {}
local nctime = nil
minetest.register_abm({
nodenames = {"dirt_with_grass"},
interval = 100000.0,
chance = 1,
action = function(pos, node, active_object_count, active_object_count_wider)
if ncpos ~= nil then
return
end
if pos.x % 16 ~= 8 or pos.z % 16 ~= 8 then
return
end
pos.y = pos.y + 1
n = minetest.env:get_node(pos)
print(dump(n))
if n.name ~= "air" then
return
end
pos.y = pos.y + 2
ncpos = pos
nctime = os.clock()
minetest.env:add_node(ncpos, {name="nyancat"})
end
})
minetest.register_abm({
nodenames = {"nyancat"},
interval = 1.0,
chance = 1,
action = function(pos, node, active_object_count, active_object_count_wider)
if ncpos == nil then
return
end
if pos.x == ncpos.x and pos.y == ncpos.y and pos.z == ncpos.z then
clock = os.clock()
if clock - nctime < 0.1 then
return
end
nctime = clock
s0 = ncstuff[ncq]
ncq = s0[1]
s1 = ncstuff[ncq]
p0 = pos
p1 = {x = p0.x + s0[2], y = p0.y, z = p0.z + s0[3]}
p2 = {x = p1.x + s1[2], y = p1.y, z = p1.z + s1[3]}
table.insert(ncold, 1, p0)
while #ncold >= 10 do
minetest.env:add_node(ncold[#ncold], {name="air"})
table.remove(ncold, #ncold)
end
minetest.env:add_node(p0, {name="nyancat_rainbow"})
minetest.env:add_node(p1, {name="nyancat", param1=s0[4]})
minetest.env:add_node(p2, {name="air"})
ncpos = p1
end
end,
})--]]
-- LuaNodeMetadata should support something like this -- LuaNodeMetadata should support something like this
--meta.setvar("somevariable", {x=0, y=0, z=0}) --meta.setvar("somevariable", {x=0, y=0, z=0})
--meta.getvar("somevariable") -> {x=0, y=0, z=0} --meta.getvar("somevariable") -> {x=0, y=0, z=0}

@ -99,6 +99,7 @@ set(common_SRCS
nameidmapping.cpp nameidmapping.cpp
tooldef.cpp tooldef.cpp
nodedef.cpp nodedef.cpp
craftitemdef.cpp
luaentity_common.cpp luaentity_common.cpp
scriptapi.cpp scriptapi.cpp
script.cpp script.cpp

@ -34,6 +34,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "nodemetadata.h" #include "nodemetadata.h"
#include "nodedef.h" #include "nodedef.h"
#include "tooldef.h" #include "tooldef.h"
#include "craftitemdef.h"
#include <IFileSystem.h> #include <IFileSystem.h>
/* /*
@ -191,11 +192,13 @@ Client::Client(
MapDrawControl &control, MapDrawControl &control,
IWritableTextureSource *tsrc, IWritableTextureSource *tsrc,
IWritableToolDefManager *tooldef, IWritableToolDefManager *tooldef,
IWritableNodeDefManager *nodedef IWritableNodeDefManager *nodedef,
IWritableCraftItemDefManager *craftitemdef
): ):
m_tsrc(tsrc), m_tsrc(tsrc),
m_tooldef(tooldef), m_tooldef(tooldef),
m_nodedef(nodedef), m_nodedef(nodedef),
m_craftitemdef(craftitemdef),
m_mesh_update_thread(this), m_mesh_update_thread(this),
m_env( m_env(
new ClientMap(this, this, control, new ClientMap(this, this, control,
@ -207,6 +210,7 @@ Client::Client(
m_con(PROTOCOL_ID, 512, CONNECTION_TIMEOUT, this), m_con(PROTOCOL_ID, 512, CONNECTION_TIMEOUT, this),
m_device(device), m_device(device),
m_server_ser_ver(SER_FMT_VER_INVALID), m_server_ser_ver(SER_FMT_VER_INVALID),
m_playeritem(0),
m_inventory_updated(false), m_inventory_updated(false),
m_time_of_day(0), m_time_of_day(0),
m_map_seed(0), m_map_seed(0),
@ -215,7 +219,8 @@ Client::Client(
m_texture_receive_progress(0), m_texture_receive_progress(0),
m_textures_received(false), m_textures_received(false),
m_tooldef_received(false), m_tooldef_received(false),
m_nodedef_received(false) m_nodedef_received(false),
m_craftitemdef_received(false)
{ {
m_packetcounter_timer = 0.0; m_packetcounter_timer = 0.0;
//m_delete_unused_sectors_timer = 0.0; //m_delete_unused_sectors_timer = 0.0;
@ -1628,6 +1633,26 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id)
m_mesh_update_thread.setRun(true); m_mesh_update_thread.setRun(true);
m_mesh_update_thread.Start(); m_mesh_update_thread.Start();
} }
else if(command == TOCLIENT_CRAFTITEMDEF)
{
infostream<<"Client: Received CraftItem definitions: packet size: "
<<datasize<<std::endl;
std::string datastring((char*)&data[2], datasize-2);
std::istringstream is(datastring, std::ios_base::binary);
m_craftitemdef_received = true;
// Stop threads while updating content definitions
m_mesh_update_thread.stop();
std::istringstream tmp_is(deSerializeLongString(is), std::ios::binary);
m_craftitemdef->deSerialize(tmp_is);
// Resume threads
m_mesh_update_thread.setRun(true);
m_mesh_update_thread.Start();
}
else else
{ {
infostream<<"Client: Ignoring unknown command " infostream<<"Client: Ignoring unknown command "
@ -1641,93 +1666,41 @@ void Client::Send(u16 channelnum, SharedBuffer<u8> data, bool reliable)
m_con.Send(PEER_ID_SERVER, channelnum, data, reliable); m_con.Send(PEER_ID_SERVER, channelnum, data, reliable);
} }
void Client::groundAction(u8 action, v3s16 nodepos_undersurface, void Client::interact(u8 action, const PointedThing& pointed)
v3s16 nodepos_oversurface, u16 item)
{ {
if(connectedAndInitialized() == false){ if(connectedAndInitialized() == false){
infostream<<"Client::groundAction() " infostream<<"Client::interact() "
"cancelled (not connected)" "cancelled (not connected)"
<<std::endl; <<std::endl;
return; return;
} }
std::ostringstream os(std::ios_base::binary);
/* /*
length: 17
[0] u16 command [0] u16 command
[2] u8 action [2] u8 action
[3] v3s16 nodepos_undersurface [3] u16 item
[9] v3s16 nodepos_abovesurface [5] u32 length of the next item
[15] u16 item [9] serialized PointedThing
actions: actions:
0: start digging 0: start digging (from undersurface) or use
1: place block 1: stop digging (all parameters ignored)
2: stop digging (all parameters ignored) 2: digging completed
3: digging completed 3: place block or item (to abovesurface)
4: use item
*/ */
u8 datasize = 2 + 1 + 6 + 6 + 2; writeU16(os, TOSERVER_INTERACT);
SharedBuffer<u8> data(datasize); writeU8(os, action);
writeU16(&data[0], TOSERVER_GROUND_ACTION); writeU16(os, getPlayerItem());
writeU8(&data[2], action); std::ostringstream tmp_os(std::ios::binary);
writeV3S16(&data[3], nodepos_undersurface); pointed.serialize(tmp_os);
writeV3S16(&data[9], nodepos_oversurface); os<<serializeLongString(tmp_os.str());
writeU16(&data[15], item);
Send(0, data, true);
}
void Client::clickActiveObject(u8 button, u16 id, u16 item_i) std::string s = os.str();
{ SharedBuffer<u8> data((u8*)s.c_str(), s.size());
if(connectedAndInitialized() == false){
infostream<<"Client::clickActiveObject() "
"cancelled (not connected)"
<<std::endl;
return;
}
Player *player = m_env.getLocalPlayer(); // Send as reliable
if(player == NULL)
return;
ClientActiveObject *obj = m_env.getActiveObject(id);
if(obj){
if(button == 0){
ToolItem *titem = NULL;
std::string toolname = "";
InventoryList *mlist = player->inventory.getList("main");
if(mlist != NULL)
{
InventoryItem *item = mlist->getItem(item_i);
if(item && (std::string)item->getName() == "ToolItem")
{
titem = (ToolItem*)item;
toolname = titem->getToolName();
}
}
v3f playerpos = player->getPosition();
v3f objpos = obj->getPosition();
v3f dir = (objpos - playerpos).normalize();
bool disable_send = obj->directReportPunch(toolname, dir);
if(disable_send)
return;
}
}
/*
length: 7
[0] u16 command
[2] u8 button (0=left, 1=right)
[3] u16 id
[5] u16 item
*/
u8 datasize = 2 + 1 + 6 + 2 + 2;
SharedBuffer<u8> data(datasize);
writeU16(&data[0], TOSERVER_CLICK_ACTIVEOBJECT);
writeU8(&data[2], button);
writeU16(&data[3], id);
writeU16(&data[5], item_i);
Send(0, data, true); Send(0, data, true);
} }
@ -2036,9 +2009,12 @@ void Client::setPlayerControl(PlayerControl &control)
void Client::selectPlayerItem(u16 item) void Client::selectPlayerItem(u16 item)
{ {
//JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
m_playeritem = item;
m_inventory_updated = true;
LocalPlayer *player = m_env.getLocalPlayer(); LocalPlayer *player = m_env.getLocalPlayer();
assert(player != NULL); assert(player != NULL);
player->wieldItem(item); player->wieldItem(item);
sendPlayerItem(item); sendPlayerItem(item);
@ -2322,6 +2298,10 @@ ICraftDefManager* Client::getCraftDefManager()
return NULL; return NULL;
//return m_craftdef; //return m_craftdef;
} }
ICraftItemDefManager* Client::getCraftItemDefManager()
{
return m_craftitemdef;
}
ITextureSource* Client::getTextureSource() ITextureSource* Client::getTextureSource()
{ {
return m_tsrc; return m_tsrc;

@ -37,6 +37,7 @@ class IWritableTextureSource;
class IWritableToolDefManager; class IWritableToolDefManager;
class IWritableNodeDefManager; class IWritableNodeDefManager;
//class IWritableCraftDefManager; //class IWritableCraftDefManager;
class IWritableCraftItemDefManager;
class ClientNotReadyException : public BaseException class ClientNotReadyException : public BaseException
{ {
@ -165,7 +166,8 @@ public:
MapDrawControl &control, MapDrawControl &control,
IWritableTextureSource *tsrc, IWritableTextureSource *tsrc,
IWritableToolDefManager *tooldef, IWritableToolDefManager *tooldef,
IWritableNodeDefManager *nodedef IWritableNodeDefManager *nodedef,
IWritableCraftItemDefManager *craftitemdef
); );
~Client(); ~Client();
@ -203,9 +205,7 @@ public:
// Pops out a packet from the packet queue // Pops out a packet from the packet queue
//IncomingPacket getPacket(); //IncomingPacket getPacket();
void groundAction(u8 action, v3s16 nodepos_undersurface, void interact(u8 action, const PointedThing& pointed);
v3s16 nodepos_oversurface, u16 item);
void clickActiveObject(u8 button, u16 id, u16 item_i);
void sendSignNodeText(v3s16 p, std::string text); void sendSignNodeText(v3s16 p, std::string text);
void sendInventoryAction(InventoryAction *a); void sendInventoryAction(InventoryAction *a);
@ -234,6 +234,8 @@ public:
void setPlayerControl(PlayerControl &control); void setPlayerControl(PlayerControl &control);
void selectPlayerItem(u16 item); void selectPlayerItem(u16 item);
u16 getPlayerItem() const
{ return m_playeritem; }
// Returns true if the inventory of the local player has been // Returns true if the inventory of the local player has been
// updated from the server. If it is true, it is set to false. // updated from the server. If it is true, it is set to false.
@ -321,6 +323,8 @@ public:
{ return m_tooldef_received; } { return m_tooldef_received; }
bool nodedefReceived() bool nodedefReceived()
{ return m_nodedef_received; } { return m_nodedef_received; }
bool craftitemdefReceived()
{ return m_craftitemdef_received; }
float getRTT(void); float getRTT(void);
@ -328,6 +332,7 @@ public:
virtual IToolDefManager* getToolDefManager(); virtual IToolDefManager* getToolDefManager();
virtual INodeDefManager* getNodeDefManager(); virtual INodeDefManager* getNodeDefManager();
virtual ICraftDefManager* getCraftDefManager(); virtual ICraftDefManager* getCraftDefManager();
virtual ICraftItemDefManager* getCraftItemDefManager();
virtual ITextureSource* getTextureSource(); virtual ITextureSource* getTextureSource();
virtual u16 allocateUnknownNodeId(const std::string &name); virtual u16 allocateUnknownNodeId(const std::string &name);
@ -356,13 +361,14 @@ private:
IWritableTextureSource *m_tsrc; IWritableTextureSource *m_tsrc;
IWritableToolDefManager *m_tooldef; IWritableToolDefManager *m_tooldef;
IWritableNodeDefManager *m_nodedef; IWritableNodeDefManager *m_nodedef;
IWritableCraftItemDefManager *m_craftitemdef;
MeshUpdateThread m_mesh_update_thread; MeshUpdateThread m_mesh_update_thread;
ClientEnvironment m_env; ClientEnvironment m_env;
con::Connection m_con; con::Connection m_con;
IrrlichtDevice *m_device; IrrlichtDevice *m_device;
// Server serialization version // Server serialization version
u8 m_server_ser_ver; u8 m_server_ser_ver;
// This is behind m_env_mutex. u16 m_playeritem;
bool m_inventory_updated; bool m_inventory_updated;
core::map<v3s16, bool> m_active_blocks; core::map<v3s16, bool> m_active_blocks;
PacketCounter m_packetcounter; PacketCounter m_packetcounter;
@ -383,6 +389,7 @@ private:
bool m_textures_received; bool m_textures_received;
bool m_tooldef_received; bool m_tooldef_received;
bool m_nodedef_received; bool m_nodedef_received;
bool m_craftitemdef_received;
friend class FarMesh; friend class FarMesh;
}; };

@ -31,6 +31,10 @@ with this program; if not, write to the Free Software Foundation, Inc.,
Add TOCLIENT_TEXTURES Add TOCLIENT_TEXTURES
Add TOCLIENT_TOOLDEF Add TOCLIENT_TOOLDEF
Add TOCLIENT_NODEDEF Add TOCLIENT_NODEDEF
Add TOCLIENT_CRAFTITEMDEF
Add TOSERVER_INTERACT
Obsolete TOSERVER_CLICK_ACTIVEOBJECT
Obsolete TOSERVER_GROUND_ACTION
*/ */
#define PROTOCOL_VERSION 4 #define PROTOCOL_VERSION 4
@ -222,6 +226,13 @@ enum ToClientCommand
u32 length of the next item u32 length of the next item
serialized NodeDefManager serialized NodeDefManager
*/ */
TOCLIENT_CRAFTITEMDEF = 0x3b,
/*
u16 command
u32 length of the next item
serialized CraftiItemDefManager
*/
}; };
enum ToServerCommand enum ToServerCommand
@ -283,7 +294,7 @@ enum ToServerCommand
[8] u16 i [8] u16 i
*/ */
TOSERVER_CLICK_OBJECT = 0x27, TOSERVER_CLICK_OBJECT = 0x27, // Obsolete
/* /*
length: 13 length: 13
[0] u16 command [0] u16 command
@ -293,7 +304,7 @@ enum ToServerCommand
[11] u16 item [11] u16 item
*/ */
TOSERVER_GROUND_ACTION = 0x28, TOSERVER_GROUND_ACTION = 0x28, // Obsolete
/* /*
length: 17 length: 17
[0] u16 command [0] u16 command
@ -312,7 +323,7 @@ enum ToServerCommand
// (oops, there is some gap here) // (oops, there is some gap here)
TOSERVER_SIGNTEXT = 0x30, // Old signs TOSERVER_SIGNTEXT = 0x30, // Old signs, obsolete
/* /*
u16 command u16 command
v3s16 blockpos v3s16 blockpos
@ -341,7 +352,7 @@ enum ToServerCommand
textdata textdata
*/ */
TOSERVER_CLICK_ACTIVEOBJECT = 0x34, TOSERVER_CLICK_ACTIVEOBJECT = 0x34, // Obsolete
/* /*
length: 7 length: 7
[0] u16 command [0] u16 command
@ -377,6 +388,24 @@ enum ToServerCommand
/* /*
u16 TOSERVER_RESPAWN u16 TOSERVER_RESPAWN
*/ */
TOSERVER_INTERACT = 0x39,
/*
[0] u16 command
[2] u8 action
[3] u16 item
[5] u32 length of the next item
[9] serialized PointedThing
actions:
0: start digging (from undersurface) or use
1: stop digging (all parameters ignored)
2: digging completed
3: place block or item (to abovesurface)
4: use item
(Obsoletes TOSERVER_GROUND_ACTION and TOSERVER_CLICK_ACTIVEOBJECT.)
*/
}; };
inline SharedBuffer<u8> makePacket_TOCLIENT_TIME_OF_DAY(u16 time) inline SharedBuffer<u8> makePacket_TOCLIENT_TIME_OF_DAY(u16 time)

@ -251,24 +251,6 @@ void ItemSAO::punch(ServerActiveObject *puncher)
delete item; delete item;
} }
void ItemSAO::rightClick(ServerActiveObject *clicker)
{
infostream<<__FUNCTION_NAME<<std::endl;
InventoryItem *item = createInventoryItem();
if(item == NULL)
return;
bool to_be_deleted = item->use(m_env, clicker);
if(to_be_deleted)
m_removed = true;
else
// Reflect changes to the item here
m_inventorystring = item->getItemString();
delete item; // Delete temporary item
}
/* /*
RatSAO RatSAO
*/ */

@ -51,7 +51,6 @@ public:
std::string getStaticData(); std::string getStaticData();
InventoryItem* createInventoryItem(); InventoryItem* createInventoryItem();
void punch(ServerActiveObject *puncher); void punch(ServerActiveObject *puncher);
void rightClick(ServerActiveObject *clicker);
float getMinimumSavedMovement(){ return 0.1*BS; } float getMinimumSavedMovement(){ return 0.1*BS; }
private: private:
std::string m_inventorystring; std::string m_inventorystring;

@ -40,6 +40,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "settings.h" #include "settings.h"
#include "profiler.h" #include "profiler.h"
#include "mainmenumanager.h" #include "mainmenumanager.h"
#include "craftitemdef.h"
#include "gettext.h" #include "gettext.h"
#include "log.h" #include "log.h"
#include "filesys.h" #include "filesys.h"
@ -87,8 +88,6 @@ Queue<InventoryAction*> inventory_action_queue;
// This is a copy of the inventory that the client's environment has // This is a copy of the inventory that the client's environment has
Inventory local_inventory; Inventory local_inventory;
u16 g_selected_item = 0;
/* /*
Text input system Text input system
*/ */
@ -159,7 +158,7 @@ private:
void draw_hotbar(video::IVideoDriver *driver, gui::IGUIFont *font, void draw_hotbar(video::IVideoDriver *driver, gui::IGUIFont *font,
ITextureSource *tsrc, ITextureSource *tsrc,
v2s32 centerlowerpos, s32 imgsize, s32 itemcount, v2s32 centerlowerpos, s32 imgsize, s32 itemcount,
Inventory *inventory, s32 halfheartcount) Inventory *inventory, s32 halfheartcount, u16 playeritem)
{ {
InventoryList *mainlist = inventory->getList("main"); InventoryList *mainlist = inventory->getList("main");
if(mainlist == NULL) if(mainlist == NULL)
@ -190,7 +189,7 @@ void draw_hotbar(video::IVideoDriver *driver, gui::IGUIFont *font,
core::rect<s32> rect = imgrect + pos core::rect<s32> rect = imgrect + pos
+ v2s32(padding+i*(imgsize+padding*2), padding); + v2s32(padding+i*(imgsize+padding*2), padding);
if(g_selected_item == i) if(playeritem == i)
{ {
video::SColor c_outside(255,255,0,0); video::SColor c_outside(255,255,0,0);
//video::SColor c_outside(255,0,0,0); //video::SColor c_outside(255,0,0,0);
@ -288,16 +287,65 @@ void draw_hotbar(video::IVideoDriver *driver, gui::IGUIFont *font,
} }
} }
/*
Check if a node is pointable
*/
inline bool isPointableNode(const MapNode& n,
Client *client, bool liquids_pointable)
{
const ContentFeatures &features = client->getNodeDefManager()->get(n);
return features.pointable ||
(liquids_pointable && features.isLiquid());
}
/* /*
Find what the player is pointing at Find what the player is pointing at
*/ */
void getPointedNode(Client *client, v3f player_position, PointedThing getPointedThing(Client *client, v3f player_position,
v3f camera_direction, v3f camera_position, v3f camera_direction, v3f camera_position,
bool &nodefound, core::line3d<f32> shootline, core::line3d<f32> shootline, f32 d,
v3s16 &nodepos, v3s16 &neighbourpos, bool liquids_pointable,
core::aabbox3d<f32> &nodehilightbox, bool look_for_object,
f32 d) core::aabbox3d<f32> &hilightbox,
bool &should_show_hilightbox,
ClientActiveObject *&selected_object)
{ {
PointedThing result;
hilightbox = core::aabbox3d<f32>(0,0,0,0,0,0);
should_show_hilightbox = false;
selected_object = NULL;
// First try to find a pointed at active object
if(look_for_object)
{
selected_object = client->getSelectedActiveObject(d*BS,
camera_position, shootline);
}
if(selected_object != NULL)
{
core::aabbox3d<f32> *selection_box
= selected_object->getSelectionBox();
// Box should exist because object was returned in the
// first place
assert(selection_box);
v3f pos = selected_object->getPosition();
hilightbox = core::aabbox3d<f32>(
selection_box->MinEdge + pos,
selection_box->MaxEdge + pos
);
should_show_hilightbox = selected_object->doShowSelectionBox();
result.type = POINTEDTHING_OBJECT;
result.object_id = selected_object->getId();
return result;
}
// That didn't work, try to find a pointed at node
f32 mindistance = BS * 1001; f32 mindistance = BS * 1001;
v3s16 pos_i = floatToInt(player_position, BS); v3s16 pos_i = floatToInt(player_position, BS);
@ -321,13 +369,13 @@ void getPointedNode(Client *client, v3f player_position,
try try
{ {
n = client->getNode(v3s16(x,y,z)); n = client->getNode(v3s16(x,y,z));
if(client->getNodeDefManager()->get(n).pointable == false)
continue;
} }
catch(InvalidPositionException &e) catch(InvalidPositionException &e)
{ {
continue; continue;
} }
if(!isPointableNode(n, client, liquids_pointable))
continue;
v3s16 np(x,y,z); v3s16 np(x,y,z);
v3f npf = intToFloat(np, BS); v3f npf = intToFloat(np, BS);
@ -402,11 +450,12 @@ void getPointedNode(Client *client, v3f player_position,
continue; continue;
if(!faceboxes[i].intersectsWithLine(shootline)) if(!faceboxes[i].intersectsWithLine(shootline))
continue; continue;
nodefound = true; result.type = POINTEDTHING_NODE;
nodepos = np; result.node_undersurface = np;
neighbourpos = np+facedirs[i]; result.node_abovesurface = np+facedirs[i];
mindistance = distance; mindistance = distance;
nodehilightbox = box; hilightbox = box;
should_show_hilightbox = true;
} }
} }
else if(f.selection_box.type == NODEBOX_WALLMOUNTED) else if(f.selection_box.type == NODEBOX_WALLMOUNTED)
@ -458,11 +507,12 @@ void getPointedNode(Client *client, v3f player_position,
{ {
if(box.intersectsWithLine(shootline)) if(box.intersectsWithLine(shootline))
{ {
nodefound = true; result.type = POINTEDTHING_NODE;
nodepos = np; result.node_undersurface = np;
neighbourpos = np; result.node_abovesurface = np;
mindistance = distance; mindistance = distance;
nodehilightbox = box; hilightbox = box;
should_show_hilightbox = true;
} }
} }
} }
@ -498,25 +548,28 @@ void getPointedNode(Client *client, v3f player_position,
if(facebox.intersectsWithLine(shootline)) if(facebox.intersectsWithLine(shootline))
{ {
nodefound = true; result.type = POINTEDTHING_NODE;
nodepos = np; result.node_undersurface = np;
neighbourpos = np + dirs[i]; result.node_abovesurface = np + dirs[i];
mindistance = distance; mindistance = distance;
//nodehilightbox = facebox; //hilightbox = facebox;
const float d = 0.502; const float d = 0.502;
core::aabbox3d<f32> nodebox core::aabbox3d<f32> nodebox
(-BS*d, -BS*d, -BS*d, BS*d, BS*d, BS*d); (-BS*d, -BS*d, -BS*d, BS*d, BS*d, BS*d);
v3f nodepos_f = intToFloat(nodepos, BS); v3f nodepos_f = intToFloat(np, BS);
nodebox.MinEdge += nodepos_f; nodebox.MinEdge += nodepos_f;
nodebox.MaxEdge += nodepos_f; nodebox.MaxEdge += nodepos_f;
nodehilightbox = nodebox; hilightbox = nodebox;
should_show_hilightbox = true;
} }
} // if distance < mindistance } // if distance < mindistance
} // for dirs } // for dirs
} // regular block } // regular block
} // for coords } // for coords
return result;
} }
void update_skybox(video::IVideoDriver* driver, ITextureSource *tsrc, void update_skybox(video::IVideoDriver* driver, ITextureSource *tsrc,
@ -642,6 +695,8 @@ void the_game(
IWritableToolDefManager *tooldef = createToolDefManager(); IWritableToolDefManager *tooldef = createToolDefManager();
// Create node definition manager // Create node definition manager
IWritableNodeDefManager *nodedef = createNodeDefManager(); IWritableNodeDefManager *nodedef = createNodeDefManager();
// Create CraftItem definition manager
IWritableCraftItemDefManager *craftitemdef = createCraftItemDefManager();
// Add chat log output for errors to be shown in chat // Add chat log output for errors to be shown in chat
LogOutputBuffer chat_log_error_buf(LMT_ERROR); LogOutputBuffer chat_log_error_buf(LMT_ERROR);
@ -670,7 +725,7 @@ void the_game(
MapDrawControl draw_control; MapDrawControl draw_control;
Client client(device, playername.c_str(), password, draw_control, Client client(device, playername.c_str(), password, draw_control,
tsrc, tooldef, nodedef); tsrc, tooldef, nodedef, craftitemdef);
// Client acts as our GameDef // Client acts as our GameDef
IGameDef *gamedef = &client; IGameDef *gamedef = &client;
@ -781,7 +836,8 @@ void the_game(
// End condition // End condition
if(client.texturesReceived() && if(client.texturesReceived() &&
client.tooldefReceived() && client.tooldefReceived() &&
client.nodedefReceived()){ client.nodedefReceived() &&
client.craftitemdefReceived()){
got_content = true; got_content = true;
break; break;
} }
@ -801,6 +857,8 @@ void the_game(
ss<<L" Tool definitions\n"; ss<<L" Tool definitions\n";
ss<<(client.nodedefReceived()?L"[X]":L"[ ]"); ss<<(client.nodedefReceived()?L"[X]":L"[ ]");
ss<<L" Node definitions\n"; ss<<L" Node definitions\n";
ss<<(client.craftitemdefReceived()?L"[X]":L"[ ]");
ss<<L" Item definitions\n";
//ss<<(client.texturesReceived()?L"[X]":L"[ ]"); //ss<<(client.texturesReceived()?L"[X]":L"[ ]");
ss<<L"["<<(int)(client.textureReceiveProgress()*100+0.5)<<L"%] "; ss<<L"["<<(int)(client.textureReceiveProgress()*100+0.5)<<L"%] ";
ss<<L" Textures\n"; ss<<L" Textures\n";
@ -937,10 +995,11 @@ void the_game(
core::list<float> frametime_log; core::list<float> frametime_log;
float nodig_delay_counter = 0.0; float nodig_delay_timer = 0.0;
float dig_time = 0.0; float dig_time = 0.0;
u16 dig_index = 0; u16 dig_index = 0;
v3s16 nodepos_old(-32768,-32768,-32768); PointedThing pointed_old;
bool digging = false;
bool ldown_for_dig = false; bool ldown_for_dig = false;
float damage_flash_timer = 0; float damage_flash_timer = 0;
@ -1083,7 +1142,10 @@ void the_game(
/* Run timers */ /* Run timers */
object_hit_delay_timer -= dtime; if(nodig_delay_timer >= 0)
nodig_delay_timer -= dtime;
if(object_hit_delay_timer >= 0)
object_hit_delay_timer -= dtime;
g_profiler->add("Elapsed time", dtime); g_profiler->add("Elapsed time", dtime);
g_profiler->avg("FPS", 1./dtime); g_profiler->avg("FPS", 1./dtime);
@ -1228,7 +1290,7 @@ void the_game(
a->count = 0; a->count = 0;
a->from_inv = "current_player"; a->from_inv = "current_player";
a->from_list = "main"; a->from_list = "main";
a->from_i = g_selected_item; a->from_i = client.getPlayerItem();
client.inventoryAction(a); client.inventoryAction(a);
} }
else if(input->wasKeyDown(getKeySetting("keymap_inventory"))) else if(input->wasKeyDown(getKeySetting("keymap_inventory")))
@ -1369,6 +1431,7 @@ void the_game(
} }
// Item selection with mouse wheel // Item selection with mouse wheel
u16 new_playeritem = client.getPlayerItem();
{ {
s32 wheel = input->getMouseWheel(); s32 wheel = input->getMouseWheel();
u16 max_item = MYMIN(PLAYER_INVENTORY_SIZE-1, u16 max_item = MYMIN(PLAYER_INVENTORY_SIZE-1,
@ -1376,17 +1439,17 @@ void the_game(
if(wheel < 0) if(wheel < 0)
{ {
if(g_selected_item < max_item) if(new_playeritem < max_item)
g_selected_item++; new_playeritem++;
else else
g_selected_item = 0; new_playeritem = 0;
} }
else if(wheel > 0) else if(wheel > 0)
{ {
if(g_selected_item > 0) if(new_playeritem > 0)
g_selected_item--; new_playeritem--;
else else
g_selected_item = max_item; new_playeritem = max_item;
} }
} }
@ -1398,10 +1461,10 @@ void the_game(
{ {
if(i < PLAYER_INVENTORY_SIZE && i < hotbar_itemcount) if(i < PLAYER_INVENTORY_SIZE && i < hotbar_itemcount)
{ {
g_selected_item = i; new_playeritem = i;
infostream<<"Selected item: " infostream<<"Selected item: "
<<g_selected_item<<std::endl; <<new_playeritem<<std::endl;
} }
} }
} }
@ -1623,116 +1686,124 @@ void the_game(
//timer2.stop(); //timer2.stop();
//TimeTaker //timer3("//timer3"); //TimeTaker //timer3("//timer3");
/*
For interaction purposes, get info about the held item
- Is it a tool, and what is the toolname?
- Is it a usable item?
- Can it point to liquids?
*/
std::string playeritem_toolname = "";
bool playeritem_usable = false;
bool playeritem_liquids_pointable = false;
{
InventoryList *mlist = local_inventory.getList("main");
if(mlist != NULL)
{
InventoryItem *item = mlist->getItem(client.getPlayerItem());
if(item)
{
if((std::string)item->getName() == "ToolItem")
{
ToolItem *titem = (ToolItem*)item;
playeritem_toolname = titem->getToolName();
}
playeritem_usable = item->isUsable();
playeritem_liquids_pointable =
item->areLiquidsPointable();
}
}
}
/* /*
Calculate what block is the crosshair pointing to Calculate what block is the crosshair pointing to
*/ */
//u32 t1 = device->getTimer()->getRealTime(); //u32 t1 = device->getTimer()->getRealTime();
//f32 d = 4; // max. distance
f32 d = 4; // max. distance f32 d = 4; // max. distance
core::line3d<f32> shootline(camera_position, core::line3d<f32> shootline(camera_position,
camera_position + camera_direction * BS * (d+1)); camera_position + camera_direction * BS * (d+1));
ClientActiveObject *selected_active_object core::aabbox3d<f32> hilightbox;
= client.getSelectedActiveObject bool should_show_hilightbox = false;
(d*BS, camera_position, shootline); ClientActiveObject *selected_object = NULL;
PointedThing pointed = getPointedThing(
// input
&client, player_position, camera_direction,
camera_position, shootline, d,
playeritem_liquids_pointable, !ldown_for_dig,
// output
hilightbox, should_show_hilightbox,
selected_object);
if(pointed != pointed_old)
{
infostream<<"Pointing at "<<pointed.dump()<<std::endl;
//dstream<<"Pointing at "<<pointed.dump()<<std::endl;
}
/*
Visualize selection
*/
if(should_show_hilightbox)
hilightboxes.push_back(hilightbox);
/*
Stop digging when
- releasing left mouse button
- pointing away from node
*/
if(digging)
{
if(input->getLeftReleased())
{
infostream<<"Left button released"
<<" (stopped digging)"<<std::endl;
digging = false;
}
else if(pointed != pointed_old)
{
if (pointed.type == POINTEDTHING_NODE
&& pointed_old.type == POINTEDTHING_NODE
&& pointed.node_undersurface == pointed_old.node_undersurface)
{
// Still pointing to the same node,
// but a different face. Don't reset.
}
else
{
infostream<<"Pointing away from node"
<<" (stopped digging)"<<std::endl;
digging = false;
}
}
if(!digging)
{
client.interact(1, pointed_old);
client.clearTempMod(pointed_old.node_undersurface);
dig_time = 0.0;
}
}
if(!digging && ldown_for_dig && !input->getLeftState())
{
ldown_for_dig = false;
}
bool left_punch = false; bool left_punch = false;
bool left_punch_muted = false; bool left_punch_muted = false;
if(selected_active_object != NULL && !ldown_for_dig) if(playeritem_usable && input->getLeftState())
{ {
/* Clear possible cracking animation */ if(input->getLeftClicked())
if(nodepos_old != v3s16(-32768,-32768,-32768)) client.interact(4, pointed);
{
client.clearTempMod(nodepos_old);
dig_time = 0.0;
nodepos_old = v3s16(-32768,-32768,-32768);
}
//infostream<<"Client returned selected_active_object != NULL"<<std::endl;
core::aabbox3d<f32> *selection_box
= selected_active_object->getSelectionBox();
// Box should exist because object was returned in the
// first place
assert(selection_box);
v3f pos = selected_active_object->getPosition();
core::aabbox3d<f32> box_on_map(
selection_box->MinEdge + pos,
selection_box->MaxEdge + pos
);
if(selected_active_object->doShowSelectionBox())
hilightboxes.push_back(box_on_map);
//infotext = narrow_to_wide("A ClientActiveObject");
infotext = narrow_to_wide(selected_active_object->infoText());
//if(input->getLeftClicked())
if(input->getLeftState())
{
bool do_punch = false;
bool do_punch_damage = false;
if(object_hit_delay_timer <= 0.0){
do_punch = true;
do_punch_damage = true;
object_hit_delay_timer = object_hit_delay;
}
if(input->getLeftClicked()){
do_punch = true;
}
if(do_punch){
infostream<<"Left-clicked object"<<std::endl;
left_punch = true;
}
if(do_punch_damage){
client.clickActiveObject(0,
selected_active_object->getId(), g_selected_item);
}
}
else if(input->getRightClicked())
{
infostream<<"Right-clicked object"<<std::endl;
client.clickActiveObject(1,
selected_active_object->getId(), g_selected_item);
}
} }
else // selected_object == NULL else if(pointed.type == POINTEDTHING_NODE)
{ {
v3s16 nodepos = pointed.node_undersurface;
/* v3s16 neighbourpos = pointed.node_abovesurface;
Find out which node we are pointing at
*/
bool nodefound = false;
v3s16 nodepos;
v3s16 neighbourpos;
core::aabbox3d<f32> nodehilightbox;
getPointedNode(&client, player_position,
camera_direction, camera_position,
nodefound, shootline,
nodepos, neighbourpos,
nodehilightbox, d);
if(!nodefound){
if(nodepos_old != v3s16(-32768,-32768,-32768))
{
client.clearTempMod(nodepos_old);
dig_time = 0.0;
nodepos_old = v3s16(-32768,-32768,-32768);
ldown_for_dig = false;
}
} else {
/*
Visualize selection
*/
hilightboxes.push_back(nodehilightbox);
/* /*
Check information text of node Check information text of node
@ -1744,139 +1815,94 @@ void the_game(
infotext = narrow_to_wide(meta->infoText()); infotext = narrow_to_wide(meta->infoText());
} }
//MapNode node = client.getNode(nodepos);
/* /*
Handle digging Handle digging
*/ */
if(input->getLeftReleased())
{
client.clearTempMod(nodepos);
dig_time = 0.0;
ldown_for_dig = false;
}
if(nodig_delay_counter > 0.0) if(nodig_delay_timer <= 0.0 && input->getLeftState())
{ {
nodig_delay_counter -= dtime; if(!digging)
}
else
{
if(nodepos != nodepos_old)
{
infostream<<"Pointing at ("<<nodepos.X<<","
<<nodepos.Y<<","<<nodepos.Z<<")"<<std::endl;
if(nodepos_old != v3s16(-32768,-32768,-32768))
{
client.clearTempMod(nodepos_old);
dig_time = 0.0;
nodepos_old = v3s16(-32768,-32768,-32768);
}
}
if(input->getLeftClicked() ||
(input->getLeftState() && nodepos != nodepos_old))
{ {
infostream<<"Started digging"<<std::endl; infostream<<"Started digging"<<std::endl;
client.groundAction(0, nodepos, neighbourpos, g_selected_item); client.interact(0, pointed);
} digging = true;
if(input->getLeftClicked())
{
client.setTempMod(nodepos, NodeMod(NODEMOD_CRACK, 0));
ldown_for_dig = true; ldown_for_dig = true;
} }
if(input->getLeftState()) MapNode n = client.getNode(nodepos);
// Get digging properties for material and tool
content_t material = n.getContent();
ToolDiggingProperties tp =
tooldef->getDiggingProperties(playeritem_toolname);
DiggingProperties prop =
getDiggingProperties(material, &tp, nodedef);
float dig_time_complete = 0.0;
if(prop.diggable == false)
{ {
MapNode n = client.getNode(nodepos); /*infostream<<"Material "<<(int)material
<<" not diggable with \""
// Get tool name. Default is "" = bare hands <<playeritem_toolname<<"\""<<std::endl;*/
std::string toolname = ""; // I guess nobody will wait for this long
InventoryList *mlist = local_inventory.getList("main"); dig_time_complete = 10000000.0;
if(mlist != NULL)
{
InventoryItem *item = mlist->getItem(g_selected_item);
if(item && (std::string)item->getName() == "ToolItem")
{
ToolItem *titem = (ToolItem*)item;
toolname = titem->getToolName();
}
}
// Get digging properties for material and tool
content_t material = n.getContent();
ToolDiggingProperties tp =
tooldef->getDiggingProperties(toolname);
DiggingProperties prop =
getDiggingProperties(material, &tp, nodedef);
float dig_time_complete = 0.0;
if(prop.diggable == false)
{
/*infostream<<"Material "<<(int)material
<<" not diggable with \""
<<toolname<<"\""<<std::endl;*/
// I guess nobody will wait for this long
dig_time_complete = 10000000.0;
}
else
{
dig_time_complete = prop.time;
}
if(dig_time_complete >= 0.001)
{
dig_index = (u16)((float)CRACK_ANIMATION_LENGTH
* dig_time/dig_time_complete);
}
// This is for torches
else
{
dig_index = CRACK_ANIMATION_LENGTH;
}
if(dig_index < CRACK_ANIMATION_LENGTH)
{
//TimeTaker timer("client.setTempMod");
//infostream<<"dig_index="<<dig_index<<std::endl;
client.setTempMod(nodepos, NodeMod(NODEMOD_CRACK, dig_index));
}
else
{
infostream<<"Digging completed"<<std::endl;
client.groundAction(3, nodepos, neighbourpos, g_selected_item);
client.clearTempMod(nodepos);
client.removeNode(nodepos);
dig_time = 0;
nodig_delay_counter = dig_time_complete
/ (float)CRACK_ANIMATION_LENGTH;
// We don't want a corresponding delay to
// very time consuming nodes
if(nodig_delay_counter > 0.5)
{
nodig_delay_counter = 0.5;
}
// We want a slight delay to very little
// time consuming nodes
float mindelay = 0.15;
if(nodig_delay_counter < mindelay)
{
nodig_delay_counter = mindelay;
}
}
dig_time += dtime;
camera.setDigging(0); // left click animation
} }
else
{
dig_time_complete = prop.time;
}
if(dig_time_complete >= 0.001)
{
dig_index = (u16)((float)CRACK_ANIMATION_LENGTH
* dig_time/dig_time_complete);
}
// This is for torches
else
{
dig_index = CRACK_ANIMATION_LENGTH;
}
if(dig_index < CRACK_ANIMATION_LENGTH)
{
//TimeTaker timer("client.setTempMod");
//infostream<<"dig_index="<<dig_index<<std::endl;
client.setTempMod(nodepos, NodeMod(NODEMOD_CRACK, dig_index));
}
else
{
infostream<<"Digging completed"<<std::endl;
client.interact(2, pointed);
client.clearTempMod(nodepos);
client.removeNode(nodepos);
dig_time = 0;
digging = false;
nodig_delay_timer = dig_time_complete
/ (float)CRACK_ANIMATION_LENGTH;
// We don't want a corresponding delay to
// very time consuming nodes
if(nodig_delay_timer > 0.5)
{
nodig_delay_timer = 0.5;
}
// We want a slight delay to very little
// time consuming nodes
float mindelay = 0.15;
if(nodig_delay_timer < mindelay)
{
nodig_delay_timer = mindelay;
}
}
dig_time += dtime;
camera.setDigging(0); // left click animation
} }
if(input->getRightClicked()) if(input->getRightClicked())
{ {
infostream<<"Ground right-clicked"<<std::endl; infostream<<"Ground right-clicked"<<std::endl;
@ -1933,15 +1959,50 @@ void the_game(
// Otherwise report right click to server // Otherwise report right click to server
else else
{ {
client.groundAction(1, nodepos, neighbourpos, g_selected_item); client.interact(3, pointed);
camera.setDigging(1); // right click animation camera.setDigging(1); // right click animation
} }
} }
}
nodepos_old = nodepos; else if(pointed.type == POINTEDTHING_OBJECT)
{
infotext = narrow_to_wide(selected_object->infoText());
//if(input->getLeftClicked())
if(input->getLeftState())
{
bool do_punch = false;
bool do_punch_damage = false;
if(object_hit_delay_timer <= 0.0){
do_punch = true;
do_punch_damage = true;
object_hit_delay_timer = object_hit_delay;
}
if(input->getLeftClicked()){
do_punch = true;
}
if(do_punch){
infostream<<"Left-clicked object"<<std::endl;
left_punch = true;
}
if(do_punch_damage){
// Report direct punch
v3f objpos = selected_object->getPosition();
v3f dir = (objpos - player_position).normalize();
bool disable_send = selected_object->directReportPunch(playeritem_toolname, dir);
if(!disable_send)
client.interact(0, pointed);
}
}
else if(input->getRightClicked())
{
infostream<<"Right-clicked object"<<std::endl;
client.interact(3, pointed); // place
}
} }
} // selected_object == NULL pointed_old = pointed;
if(left_punch || (input->getLeftClicked() && !left_punch_muted)) if(left_punch || (input->getLeftClicked() && !left_punch_muted))
{ {
@ -1950,20 +2011,7 @@ void the_game(
input->resetLeftClicked(); input->resetLeftClicked();
input->resetRightClicked(); input->resetRightClicked();
if(input->getLeftReleased())
{
infostream<<"Left button released (stopped digging)"
<<std::endl;
client.groundAction(2, v3s16(0,0,0), v3s16(0,0,0), 0);
ldown_for_dig = false;
}
if(input->getRightReleased())
{
//inostream<<DTIME<<"Right released"<<std::endl;
// Nothing here
}
input->resetLeftReleased(); input->resetLeftReleased();
input->resetRightReleased(); input->resetRightReleased();
@ -2210,12 +2258,12 @@ void the_game(
Inventory Inventory
*/ */
static u16 old_selected_item = 65535; if(client.getPlayerItem() != new_playeritem)
if(client.getLocalInventoryUpdated() {
|| g_selected_item != old_selected_item) client.selectPlayerItem(new_playeritem);
}
if(client.getLocalInventoryUpdated())
{ {
client.selectPlayerItem(g_selected_item);
old_selected_item = g_selected_item;
//infostream<<"Updating local inventory"<<std::endl; //infostream<<"Updating local inventory"<<std::endl;
client.getLocalInventory(local_inventory); client.getLocalInventory(local_inventory);
@ -2223,7 +2271,7 @@ void the_game(
InventoryList *mlist = local_inventory.getList("main"); InventoryList *mlist = local_inventory.getList("main");
InventoryItem *item = NULL; InventoryItem *item = NULL;
if(mlist != NULL) if(mlist != NULL)
item = mlist->getItem(g_selected_item); item = mlist->getItem(client.getPlayerItem());
camera.wield(item, gamedef); camera.wield(item, gamedef);
} }
@ -2350,7 +2398,7 @@ void the_game(
draw_hotbar(driver, font, tsrc, draw_hotbar(driver, font, tsrc,
v2s32(displaycenter.X, screensize.Y), v2s32(displaycenter.X, screensize.Y),
hotbar_imagesize, hotbar_itemcount, &local_inventory, hotbar_imagesize, hotbar_itemcount, &local_inventory,
client.getHP()); client.getHP(), client.getPlayerItem());
} }
/* /*

@ -25,7 +25,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
class IToolDefManager; class IToolDefManager;
class INodeDefManager; class INodeDefManager;
class ICraftDefManager; class ICraftDefManager;
//class IItemDefManager; //TODO class ICraftItemDefManager;
// Mineral too? // Mineral too?
class ITextureSource; class ITextureSource;
@ -42,7 +42,7 @@ public:
virtual IToolDefManager* getToolDefManager()=0; virtual IToolDefManager* getToolDefManager()=0;
virtual INodeDefManager* getNodeDefManager()=0; virtual INodeDefManager* getNodeDefManager()=0;
virtual ICraftDefManager* getCraftDefManager()=0; virtual ICraftDefManager* getCraftDefManager()=0;
//virtual IItemDefManager* getItemDefManager()=0; virtual ICraftItemDefManager* getCraftItemDefManager()=0;
// This is always thread-safe, but referencing the irrlicht texture // This is always thread-safe, but referencing the irrlicht texture
// pointers in other threads than main thread will make things explode. // pointers in other threads than main thread will make things explode.
@ -55,6 +55,7 @@ public:
IToolDefManager* tdef(){return getToolDefManager();} IToolDefManager* tdef(){return getToolDefManager();}
INodeDefManager* ndef(){return getNodeDefManager();} INodeDefManager* ndef(){return getNodeDefManager();}
ICraftDefManager* cdef(){return getCraftDefManager();} ICraftDefManager* cdef(){return getCraftDefManager();}
ICraftItemDefManager* cidef(){return getCraftItemDefManager();}
ITextureSource* tsrc(){return getTextureSource();} ITextureSource* tsrc(){return getTextureSource();}
}; };

@ -33,7 +33,9 @@ with this program; if not, write to the Free Software Foundation, Inc.,
#include "log.h" #include "log.h"
#include "nodedef.h" #include "nodedef.h"
#include "tooldef.h" #include "tooldef.h"
#include "craftitemdef.h"
#include "gamedef.h" #include "gamedef.h"
#include "scriptapi.h"
#include "strfnd.h" #include "strfnd.h"
/* /*
@ -182,18 +184,52 @@ std::string InventoryItem::getItemString() {
return os.str(); return os.str();
} }
ServerActiveObject* InventoryItem::createSAO(ServerEnvironment *env, v3f pos) bool InventoryItem::dropOrPlace(ServerEnvironment *env,
ServerActiveObject *dropper,
v3f pos, bool place, s16 count)
{ {
/* /*
Create an ItemSAO Ensure that the block is loaded so that the item
can properly be added to the static list too
*/ */
pos.Y -= BS*0.25; // let it drop a bit v3s16 blockpos = getNodeBlockPos(floatToInt(pos, BS));
// Randomize a bit MapBlock *block = env->getMap().emergeBlock(blockpos, false);
pos.X += BS*0.2*(float)myrand_range(-1000,1000)/1000.0; if(block==NULL)
pos.Z += BS*0.2*(float)myrand_range(-1000,1000)/1000.0; {
// Create object infostream<<"InventoryItem::dropOrPlace(): FAIL: block not found: "
ServerActiveObject *obj = new ItemSAO(env, pos, getItemString()); <<blockpos.X<<","<<blockpos.Y<<","<<blockpos.Z
return obj; <<std::endl;
return false;
}
/*
Take specified number of items,
but limit to getDropCount().
*/
s16 dropcount = getDropCount();
if(count < 0 || count > dropcount)
count = dropcount;
if(count < 0 || count > getCount());
count = getCount();
if(count > 0)
{
/*
Create an ItemSAO
*/
pos.Y -= BS*0.25; // let it drop a bit
// Randomize a bit
//pos.X += BS*0.2*(float)myrand_range(-1000,1000)/1000.0;
//pos.Z += BS*0.2*(float)myrand_range(-1000,1000)/1000.0;
// Create object
ServerActiveObject *obj = new ItemSAO(env, pos, getItemString());
// Add the object to the environment
env->addActiveObject(obj);
infostream<<"Dropped item"<<std::endl;
setCount(getCount() - count);
}
return getCount() < 1; // delete the item?
} }
/* /*
@ -307,75 +343,150 @@ video::ITexture * ToolItem::getImageRaw() const
#ifndef SERVER #ifndef SERVER
video::ITexture * CraftItem::getImage() const video::ITexture * CraftItem::getImage() const
{ {
ICraftItemDefManager *cidef = m_gamedef->cidef();
ITextureSource *tsrc = m_gamedef->tsrc(); ITextureSource *tsrc = m_gamedef->tsrc();
std::string imagename = cidef->getImagename(m_subname);
std::string name = item_craft_get_image_name(m_subname, m_gamedef); return tsrc->getTextureRaw(imagename);
// Get such a texture
return tsrc->getTextureRaw(name);
} }
#endif #endif
ServerActiveObject* CraftItem::createSAO(ServerEnvironment *env, v3f pos) u16 CraftItem::getStackMax() const
{ {
// Special cases ICraftItemDefManager *cidef = m_gamedef->cidef();
ServerActiveObject *obj = item_craft_create_object(m_subname, env, pos); const CraftItemDefinition *def = cidef->getCraftItemDefinition(m_subname);
if(obj) if(def == NULL)
return obj; return InventoryItem::getStackMax();
// Default return def->stack_max;
return InventoryItem::createSAO(env, pos);
} }
u16 CraftItem::getDropCount() const bool CraftItem::isUsable() const
{ {
// Special cases ICraftItemDefManager *cidef = m_gamedef->cidef();
s16 dc = item_craft_get_drop_count(m_subname, m_gamedef); const CraftItemDefinition *def = cidef->getCraftItemDefinition(m_subname);
if(dc != -1) return def != NULL && def->usable;
return dc;
// Default
return InventoryItem::getDropCount();
} }
bool CraftItem::isCookable() const bool CraftItem::isCookable() const
{ {
return item_craft_is_cookable(m_subname, m_gamedef); ICraftItemDefManager *cidef = m_gamedef->cidef();
const CraftItemDefinition *def = cidef->getCraftItemDefinition(m_subname);
return def != NULL && def->cookresult_item != "";
} }
InventoryItem *CraftItem::createCookResult() const InventoryItem *CraftItem::createCookResult() const
{ {
return item_craft_create_cook_result(m_subname, m_gamedef); ICraftItemDefManager *cidef = m_gamedef->cidef();
const CraftItemDefinition *def = cidef->getCraftItemDefinition(m_subname);
if(def == NULL)
return InventoryItem::createCookResult();
std::istringstream is(def->cookresult_item, std::ios::binary);
return InventoryItem::deSerialize(is, m_gamedef);
} }
float CraftItem::getCookTime() const float CraftItem::getCookTime() const
{ {
return 3.0; ICraftItemDefManager *cidef = m_gamedef->cidef();
const CraftItemDefinition *def = cidef->getCraftItemDefinition(m_subname);
if (def == NULL)
return InventoryItem::getCookTime();
return def->furnace_cooktime;
} }
float CraftItem::getBurnTime() const float CraftItem::getBurnTime() const
{ {
if(m_subname == "lump_of_coal") ICraftItemDefManager *cidef = m_gamedef->cidef();
return 40; const CraftItemDefinition *def = cidef->getCraftItemDefinition(m_subname);
return -1; if (def == NULL)
return InventoryItem::getBurnTime();
return def->furnace_burntime;
} }
bool CraftItem::use(ServerEnvironment *env, ServerActiveObject *user) s16 CraftItem::getDropCount() const
{ {
if(!item_craft_is_eatable(m_subname, m_gamedef)) // Special cases
ICraftItemDefManager *cidef = m_gamedef->cidef();
const CraftItemDefinition *def = cidef->getCraftItemDefinition(m_subname);
if(def != NULL && def->dropcount >= 0)
return def->dropcount;
// Default
return InventoryItem::getDropCount();
}
bool CraftItem::areLiquidsPointable() const
{
ICraftItemDefManager *cidef = m_gamedef->cidef();
const CraftItemDefinition *def = cidef->getCraftItemDefinition(m_subname);
return def != NULL && def->liquids_pointable;
}
bool CraftItem::dropOrPlace(ServerEnvironment *env,
ServerActiveObject *dropper,
v3f pos, bool place, s16 count)
{
if(count == 0)
return false; return false;
u16 result_count = getCount() - 1; // Eat one at a time bool callback_exists = false;
s16 hp_change = item_craft_eat_hp_change(m_subname, m_gamedef); bool result = false;
s16 hp = user->getHP();
hp += hp_change; if(place)
if(hp < 0) {
hp = 0; result = scriptapi_craftitem_on_place_on_ground(
user->setHP(hp); env->getLua(),
m_subname.c_str(), dropper, pos,
if(result_count < 1) callback_exists);
return true; }
setCount(result_count); // note: on_drop is fallback for on_place_on_ground
return false;
if(!callback_exists)
{
result = scriptapi_craftitem_on_drop(
env->getLua(),
m_subname.c_str(), dropper, pos,
callback_exists);
}
if(callback_exists)
{
// If the callback returned true, drop one item
if(result)
setCount(getCount() - 1);
return getCount() < 1;
}
else
{
// If neither on_place_on_ground (if place==true)
// nor on_drop exists, call the base implementation
return InventoryItem::dropOrPlace(env, dropper, pos, place, count);
}
}
bool CraftItem::use(ServerEnvironment *env,
ServerActiveObject *user,
const PointedThing& pointed)
{
bool callback_exists = false;
bool result = false;
result = scriptapi_craftitem_on_use(
env->getLua(),
m_subname.c_str(), user, pointed,
callback_exists);
if(callback_exists)
{
// If the callback returned true, drop one item
if(result)
setCount(getCount() - 1);
return getCount() < 1;
}
else
{
// If neither on_place_on_ground (if place==true)
// nor on_drop exists, call the base implementation
return InventoryItem::use(env, user, pointed);
}
} }
/* /*
@ -1067,6 +1178,19 @@ IDropAction::IDropAction(std::istream &is)
void IDropAction::apply(InventoryContext *c, InventoryManager *mgr, void IDropAction::apply(InventoryContext *c, InventoryManager *mgr,
ServerEnvironment *env) ServerEnvironment *env)
{ {
if(c->current_player == NULL){
infostream<<"IDropAction::apply(): FAIL: current_player is NULL"<<std::endl;
return;
}
// Do NOT cast directly to ServerActiveObject*, it breaks
// because of multiple inheritance.
ServerActiveObject *dropper =
static_cast<ServerActiveObject*>(
static_cast<ServerRemotePlayer*>(
c->current_player
));
Inventory *inv_from = mgr->getInventory(c, from_inv); Inventory *inv_from = mgr->getInventory(c, from_inv);
if(!inv_from){ if(!inv_from){
@ -1086,7 +1210,8 @@ void IDropAction::apply(InventoryContext *c, InventoryManager *mgr,
<<", from_list=\""<<from_list<<"\""<<std::endl; <<", from_list=\""<<from_list<<"\""<<std::endl;
return; return;
} }
if(list_from->getItem(from_i) == NULL) InventoryItem *item = list_from->getItem(from_i);
if(item == NULL)
{ {
infostream<<"IDropAction::apply(): FAIL: source item not found: " infostream<<"IDropAction::apply(): FAIL: source item not found: "
<<"context=["<<describeC(c)<<"], from_inv=\""<<from_inv<<"\"" <<"context=["<<describeC(c)<<"], from_inv=\""<<from_inv<<"\""
@ -1095,43 +1220,19 @@ void IDropAction::apply(InventoryContext *c, InventoryManager *mgr,
return; return;
} }
v3f pos = c->current_player->getPosition(); v3f pos = dropper->getBasePosition();
pos.Y += 0.5*BS; pos.Y += 0.5*BS;
v3s16 blockpos = getNodeBlockPos(floatToInt(pos, BS));
s16 count2 = count;
if(count2 == 0)
count2 = -1;
/* /*
Ensure that the block is loaded so that the item Drop the item
can properly be added to the static list too
*/ */
MapBlock *block = env->getMap().emergeBlock(blockpos, false); bool remove = item->dropOrPlace(env, dropper, pos, false, count2);
if(block==NULL) if(remove)
{ list_from->deleteItem(from_i);
infostream<<"IDropAction::apply(): FAIL: block not found: "
<<blockpos.X<<","<<blockpos.Y<<","<<blockpos.Z
<<std::endl;
return;
}
// Take item from source list
if(count == 0)
count = list_from->getItem(from_i)->getDropCount();
InventoryItem *item1 = list_from->takeItem(from_i, count);
// Create an active object
ServerActiveObject *obj = item1->createSAO(env, pos);
if(obj == NULL)
{
infostream<<"IDropAction::apply(): item resulted in NULL object, "
<<"not placing onto map"
<<std::endl;
}
else
{
// Add the object to the environment
env->addActiveObject(obj);
infostream<<"Dropped object"<<std::endl;
}
mgr->inventoryModified(c, from_inv); mgr->inventoryModified(c, from_inv);

@ -31,6 +31,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
class ServerActiveObject; class ServerActiveObject;
class ServerEnvironment; class ServerEnvironment;
class PointedThing;
class ITextureSource; class ITextureSource;
class IGameDef; class IGameDef;
@ -63,10 +64,6 @@ public:
virtual std::string getText() { return ""; } virtual std::string getText() { return ""; }
// Returns the string used for inventory // Returns the string used for inventory
virtual std::string getItemString(); virtual std::string getItemString();
// Creates an object from the item, to be placed in the world.
virtual ServerActiveObject* createSAO(ServerEnvironment *env, v3f pos);
// Gets amount of items that dropping one SAO will decrement
virtual u16 getDropCount() const { return getCount(); }
/* /*
Quantity methods Quantity methods
@ -88,13 +85,17 @@ public:
void setCount(u16 count) void setCount(u16 count)
{ m_count = count; } { m_count = count; }
// This should return something else for stackable items u16 freeSpace() const
virtual u16 freeSpace() const {
{ return 0; } u16 max = getStackMax();
if(m_count > max)
return 0;
return max - m_count;
}
void add(u16 count) void add(u16 count)
{ {
assert(m_count + count <= QUANTITY_ITEM_MAX_COUNT); assert(m_count + count <= getStackMax());
m_count += count; m_count += count;
} }
void remove(u16 count) void remove(u16 count)
@ -107,6 +108,10 @@ public:
Other properties Other properties
*/ */
// Maximum size of a stack
virtual u16 getStackMax() const {return 1;}
// Whether it can be used
virtual bool isUsable() const {return false;}
// Whether it can be cooked // Whether it can be cooked
virtual bool isCookable() const {return false;} virtual bool isCookable() const {return false;}
// Result of cooking (can randomize) // Result of cooking (can randomize)
@ -115,12 +120,24 @@ public:
virtual float getCookTime() const {return 3.0;} virtual float getCookTime() const {return 3.0;}
// Whether it can be burned (<0 = cannot be burned) // Whether it can be burned (<0 = cannot be burned)
virtual float getBurnTime() const {return -1;} virtual float getBurnTime() const {return -1;}
// Gets amount of items that dropping one ItemSAO will decrement
// -1 means as many as possible
virtual s16 getDropCount() const { return -1; }
// Whether this item can point to liquids
virtual bool areLiquidsPointable() const { return false; }
// Creates an object from the item and places it in the world.
// If return value is true, item should be removed.
virtual bool dropOrPlace(ServerEnvironment *env,
ServerActiveObject *dropper,
v3f pos, bool place, s16 count);
// Eat, press, activate, whatever. // Eat, press, activate, whatever.
// Called when item is right-clicked when lying on ground. // Called when item is left-clicked while in hand.
// If returns true, item shall be deleted. // If returns true, item shall be deleted.
virtual bool use(ServerEnvironment *env, virtual bool use(ServerEnvironment *env,
ServerActiveObject *user){return false;} ServerActiveObject *user,
const PointedThing& pointed){return false;}
protected: protected:
IGameDef *m_gamedef; IGameDef *m_gamedef;
@ -189,12 +206,11 @@ public:
return true; return true;
} }
u16 freeSpace() const u16 getStackMax() const
{ {
if(m_count > QUANTITY_ITEM_MAX_COUNT) return QUANTITY_ITEM_MAX_COUNT;
return 0;
return QUANTITY_ITEM_MAX_COUNT - m_count;
} }
/* /*
Other properties Other properties
*/ */
@ -254,9 +270,6 @@ public:
return os.str(); return os.str();
} }
ServerActiveObject* createSAO(ServerEnvironment *env, v3f pos);
u16 getDropCount() const;
virtual bool addableTo(const InventoryItem *other) const virtual bool addableTo(const InventoryItem *other) const
{ {
if(std::string(other->getName()) != "CraftItem") if(std::string(other->getName()) != "CraftItem")
@ -284,24 +297,26 @@ public:
return true; return true;
} }
u16 freeSpace() const
{
if(m_count > QUANTITY_ITEM_MAX_COUNT)
return 0;
return QUANTITY_ITEM_MAX_COUNT - m_count;
}
/* /*
Other properties Other properties
*/ */
u16 getStackMax() const;
bool isUsable() const;
bool isCookable() const; bool isCookable() const;
InventoryItem *createCookResult() const; InventoryItem *createCookResult() const;
float getCookTime() const; float getCookTime() const;
float getBurnTime() const; float getBurnTime() const;
s16 getDropCount() const;
bool areLiquidsPointable() const;
bool dropOrPlace(ServerEnvironment *env,
ServerActiveObject *dropper,
v3f pos, bool place, s16 count);
bool use(ServerEnvironment *env,
ServerActiveObject *user,
const PointedThing& pointed);
bool use(ServerEnvironment *env, ServerActiveObject *user);
/* /*
Special methods Special methods
*/ */

@ -183,7 +183,8 @@ ServerRemotePlayer::ServerRemotePlayer(ServerEnvironment *env):
Player(env->getGameDef()), Player(env->getGameDef()),
ServerActiveObject(env, v3f(0,0,0)), ServerActiveObject(env, v3f(0,0,0)),
m_last_good_position(0,0,0), m_last_good_position(0,0,0),
m_last_good_position_age(0) m_last_good_position_age(0),
m_additional_items()
{ {
} }
ServerRemotePlayer::ServerRemotePlayer(ServerEnvironment *env, v3f pos_, u16 peer_id_, ServerRemotePlayer::ServerRemotePlayer(ServerEnvironment *env, v3f pos_, u16 peer_id_,
@ -195,6 +196,10 @@ ServerRemotePlayer::ServerRemotePlayer(ServerEnvironment *env, v3f pos_, u16 pee
peer_id = peer_id_; peer_id = peer_id_;
updateName(name_); updateName(name_);
} }
ServerRemotePlayer::~ServerRemotePlayer()
{
clearAddToInventoryLater();
}
/* ServerActiveObject interface */ /* ServerActiveObject interface */
@ -247,9 +252,59 @@ bool ServerRemotePlayer::addToInventory(InventoryItem *item)
return true; return true;
} }
void ServerRemotePlayer::addToInventoryLater(InventoryItem *item)
{
infostream<<"Adding (later) "<<item->getName()<<" into "<<getName()
<<"'s inventory"<<std::endl;
m_additional_items.push_back(item);
}
void ServerRemotePlayer::clearAddToInventoryLater()
{
for (std::vector<InventoryItem*>::iterator
i = m_additional_items.begin();
i != m_additional_items.end(); i++)
{
delete *i;
}
m_additional_items.clear();
}
void ServerRemotePlayer::completeAddToInventoryLater(u16 preferred_index)
{
InventoryList *ilist = inventory.getList("main");
if(ilist == NULL)
{
clearAddToInventoryLater();
return;
}
// In creative mode, just delete the items
if(g_settings->getBool("creative_mode"))
{
clearAddToInventoryLater();
return;
}
for (std::vector<InventoryItem*>::iterator
i = m_additional_items.begin();
i != m_additional_items.end(); i++)
{
InventoryItem *item = *i;
InventoryItem *leftover = item;
leftover = ilist->addItem(preferred_index, leftover);
leftover = ilist->addItem(leftover);
delete leftover;
}
m_additional_items.clear();
}
void ServerRemotePlayer::setHP(s16 hp_) void ServerRemotePlayer::setHP(s16 hp_)
{ {
hp = hp_; hp = hp_;
// FIXME: don't hardcode maximum HP, make configurable per object
if(hp < 0)
hp = 0;
else if(hp > 20)
hp = 20;
} }
s16 ServerRemotePlayer::getHP() s16 ServerRemotePlayer::getHP()
{ {

@ -188,8 +188,7 @@ public:
ServerRemotePlayer(ServerEnvironment *env, v3f pos_, u16 peer_id_, ServerRemotePlayer(ServerEnvironment *env, v3f pos_, u16 peer_id_,
const char *name_); const char *name_);
virtual ~ServerRemotePlayer() virtual ~ServerRemotePlayer();
{}
virtual bool isLocal() const virtual bool isLocal() const
{ return false; } { return false; }
@ -230,11 +229,15 @@ public:
virtual void damageWieldedItem(u16 amount); virtual void damageWieldedItem(u16 amount);
// If all fits, eats item and returns true. Otherwise returns false. // If all fits, eats item and returns true. Otherwise returns false.
virtual bool addToInventory(InventoryItem *item); virtual bool addToInventory(InventoryItem *item);
virtual void addToInventoryLater(InventoryItem *item);
void clearAddToInventoryLater();
void completeAddToInventoryLater(u16 preferred_index);
virtual void setHP(s16 hp_); virtual void setHP(s16 hp_);
virtual s16 getHP(); virtual s16 getHP();
v3f m_last_good_position; v3f m_last_good_position;
float m_last_good_position_age; float m_last_good_position_age;
std::vector<InventoryItem*> m_additional_items;
private: private:
}; };

@ -39,11 +39,13 @@ extern "C" {
#include "tooldef.h" #include "tooldef.h"
#include "nodedef.h" #include "nodedef.h"
#include "craftdef.h" #include "craftdef.h"
#include "craftitemdef.h"
#include "main.h" // For g_settings #include "main.h" // For g_settings
#include "settings.h" // For accessing g_settings #include "settings.h" // For accessing g_settings
#include "nodemetadata.h" #include "nodemetadata.h"
#include "mapblock.h" // For getNodeBlockPos #include "mapblock.h" // For getNodeBlockPos
#include "content_nodemeta.h" #include "content_nodemeta.h"
#include "utility.h"
static void stackDump(lua_State *L, std::ostream &o) static void stackDump(lua_State *L, std::ostream &o)
{ {
@ -615,6 +617,55 @@ static int l_register_tool(lua_State *L)
return 0; /* number of results */ return 0; /* number of results */
} }
// register_craftitem(name, {lots of stuff})
static int l_register_craftitem(lua_State *L)
{
const char *name = luaL_checkstring(L, 1);
infostream<<"register_craftitem: "<<name<<std::endl;
luaL_checktype(L, 2, LUA_TTABLE);
int table = 2;
// Get server from registry
lua_getfield(L, LUA_REGISTRYINDEX, "minetest_server");
Server *server = (Server*)lua_touserdata(L, -1);
// And get the writable CraftItem definition manager from the server
IWritableCraftItemDefManager *craftitemdef =
server->getWritableCraftItemDefManager();
// Check if on_drop is defined
lua_getfield(L, table, "on_drop");
bool got_on_drop = !lua_isnil(L, -1);
lua_pop(L, 1);
// Check if on_use is defined
lua_getfield(L, table, "on_use");
bool got_on_use = !lua_isnil(L, -1);
lua_pop(L, 1);
CraftItemDefinition def;
getstringfield(L, table, "image", def.imagename);
getstringfield(L, table, "cookresult_item", def.cookresult_item);
getfloatfield(L, table, "furnace_cooktime", def.furnace_cooktime);
getfloatfield(L, table, "furnace_burntime", def.furnace_burntime);
def.usable = getboolfield_default(L, table, "usable", got_on_use);
getboolfield(L, table, "liquids_pointable", def.liquids_pointable);
def.dropcount = getintfield_default(L, table, "dropcount", def.dropcount);
def.stack_max = getintfield_default(L, table, "stack_max", def.stack_max);
// If an on_drop callback is defined, force dropcount to 1
if (got_on_drop)
def.dropcount = 1;
// Register it
craftitemdef->registerCraftItem(name, def);
lua_pushvalue(L, table);
scriptapi_add_craftitem(L, name);
return 0; /* number of results */
}
// register_node(name, {lots of stuff}) // register_node(name, {lots of stuff})
static int l_register_node(lua_State *L) static int l_register_node(lua_State *L)
{ {
@ -976,6 +1027,7 @@ static const struct luaL_Reg minetest_f [] = {
{"register_nodedef_defaults", l_register_nodedef_defaults}, {"register_nodedef_defaults", l_register_nodedef_defaults},
{"register_entity", l_register_entity}, {"register_entity", l_register_entity},
{"register_tool", l_register_tool}, {"register_tool", l_register_tool},
{"register_craftitem", l_register_craftitem},
{"register_node", l_register_node}, {"register_node", l_register_node},
{"register_craft", l_register_craft}, {"register_craft", l_register_craft},
{"register_abm", l_register_abm}, {"register_abm", l_register_abm},
@ -1541,6 +1593,56 @@ private:
return 0; return 0;
} }
// EnvRef:add_item(pos, inventorystring)
// pos = {x=num, y=num, z=num}
static int l_add_item(lua_State *L)
{
infostream<<"EnvRef::l_add_item()"<<std::endl;
EnvRef *o = checkobject(L, 1);
ServerEnvironment *env = o->m_env;
if(env == NULL) return 0;
// pos
v3f pos = readFloatPos(L, 2);
// inventorystring
const char *inventorystring = lua_tostring(L, 3);
// Do it
ServerActiveObject *obj = new ItemSAO(env, pos, inventorystring);
env->addActiveObject(obj);
return 0;
}
// EnvRef:add_rat(pos)
// pos = {x=num, y=num, z=num}
static int l_add_rat(lua_State *L)
{
infostream<<"EnvRef::l_add_rat()"<<std::endl;
EnvRef *o = checkobject(L, 1);
ServerEnvironment *env = o->m_env;
if(env == NULL) return 0;
// pos
v3f pos = readFloatPos(L, 2);
// Do it
ServerActiveObject *obj = new RatSAO(env, pos);
env->addActiveObject(obj);
return 0;
}
// EnvRef:add_firefly(pos)
// pos = {x=num, y=num, z=num}
static int l_add_firefly(lua_State *L)
{
infostream<<"EnvRef::l_add_firefly()"<<std::endl;
EnvRef *o = checkobject(L, 1);
ServerEnvironment *env = o->m_env;
if(env == NULL) return 0;
// pos
v3f pos = readFloatPos(L, 2);
// Do it
ServerActiveObject *obj = new FireflySAO(env, pos);
env->addActiveObject(obj);
return 0;
}
// EnvRef:get_meta(pos) // EnvRef:get_meta(pos)
static int l_get_meta(lua_State *L) static int l_get_meta(lua_State *L)
{ {
@ -1623,6 +1725,9 @@ const luaL_reg EnvRef::methods[] = {
method(EnvRef, remove_node), method(EnvRef, remove_node),
method(EnvRef, get_node), method(EnvRef, get_node),
method(EnvRef, add_luaentity), method(EnvRef, add_luaentity),
method(EnvRef, add_item),
method(EnvRef, add_rat),
method(EnvRef, add_firefly),
method(EnvRef, get_meta), method(EnvRef, get_meta),
{0,0} {0,0}
}; };
@ -1663,6 +1768,16 @@ private:
return (LuaEntitySAO*)obj; return (LuaEntitySAO*)obj;
} }
static ServerRemotePlayer* getplayer(ObjectRef *ref)
{
ServerActiveObject *obj = getobject(ref);
if(obj == NULL)
return NULL;
if(obj->getType() != ACTIVEOBJECT_TYPE_PLAYER)
return NULL;
return static_cast<ServerRemotePlayer*>(obj);
}
// Exported functions // Exported functions
// garbage collector // garbage collector
@ -1795,6 +1910,64 @@ private:
return 1; return 1;
} }
// add_to_inventory_later(self, itemstring)
// returns: nil
static int l_add_to_inventory_later(lua_State *L)
{
ObjectRef *ref = checkobject(L, 1);
luaL_checkstring(L, 2);
ServerActiveObject *co = getobject(ref);
if(co == NULL) return 0;
// itemstring
const char *itemstring = lua_tostring(L, 2);
infostream<<"ObjectRef::l_add_to_inventory_later(): id="<<co->getId()
<<" itemstring=\""<<itemstring<<"\""<<std::endl;
// Do it
std::istringstream is(itemstring, std::ios::binary);
ServerEnvironment *env = co->getEnv();
assert(env);
IGameDef *gamedef = env->getGameDef();
InventoryItem *item = InventoryItem::deSerialize(is, gamedef);
infostream<<"item="<<env<<std::endl;
co->addToInventoryLater(item);
// Return
return 0;
}
// get_hp(self)
// returns: number of hitpoints (2 * number of hearts)
// 0 if not applicable to this type of object
static int l_get_hp(lua_State *L)
{
ObjectRef *ref = checkobject(L, 1);
ServerActiveObject *co = getobject(ref);
if(co == NULL) return 0;
int hp = co->getHP();
infostream<<"ObjectRef::l_get_hp(): id="<<co->getId()
<<" hp="<<hp<<std::endl;
// Return
lua_pushnumber(L, hp);
return 1;
}
// set_hp(self, hp)
// hp = number of hitpoints (2 * number of hearts)
// returns: nil
static int l_set_hp(lua_State *L)
{
ObjectRef *ref = checkobject(L, 1);
luaL_checknumber(L, 2);
ServerActiveObject *co = getobject(ref);
if(co == NULL) return 0;
int hp = lua_tonumber(L, 2);
infostream<<"ObjectRef::l_set_hp(): id="<<co->getId()
<<" hp="<<hp<<std::endl;
// Do it
co->setHP(hp);
// Return
return 0;
}
// settexturemod(self, mod) // settexturemod(self, mod)
static int l_settexturemod(lua_State *L) static int l_settexturemod(lua_State *L)
{ {
@ -1901,6 +2074,9 @@ const luaL_reg ObjectRef::methods[] = {
method(ObjectRef, setvelocity), method(ObjectRef, setvelocity),
method(ObjectRef, setacceleration), method(ObjectRef, setacceleration),
method(ObjectRef, add_to_inventory), method(ObjectRef, add_to_inventory),
method(ObjectRef, add_to_inventory_later),
method(ObjectRef, get_hp),
method(ObjectRef, set_hp),
method(ObjectRef, settexturemod), method(ObjectRef, settexturemod),
method(ObjectRef, setsprite), method(ObjectRef, setsprite),
{0,0} {0,0}
@ -1951,6 +2127,8 @@ void scriptapi_export(lua_State *L, Server *server)
lua_newtable(L); lua_newtable(L);
lua_setfield(L, -2, "registered_entities"); lua_setfield(L, -2, "registered_entities");
lua_newtable(L); lua_newtable(L);
lua_setfield(L, -2, "registered_craftitems");
lua_newtable(L);
lua_setfield(L, -2, "registered_abms"); lua_setfield(L, -2, "registered_abms");
lua_newtable(L); lua_newtable(L);
@ -2199,6 +2377,163 @@ bool scriptapi_on_respawnplayer(lua_State *L, ServerActiveObject *player)
return positioning_handled_by_some; return positioning_handled_by_some;
} }
/*
craftitem
*/
static void pushPointedThing(lua_State *L, const PointedThing& pointed)
{
lua_newtable(L);
if(pointed.type == POINTEDTHING_NODE)
{
lua_pushstring(L, "node");
lua_setfield(L, -2, "type");
pushpos(L, pointed.node_undersurface);
lua_setfield(L, -2, "under");
pushpos(L, pointed.node_abovesurface);
lua_setfield(L, -2, "above");
}
else if(pointed.type == POINTEDTHING_OBJECT)
{
lua_pushstring(L, "object");
lua_setfield(L, -2, "type");
objectref_get(L, pointed.object_id);
lua_setfield(L, -2, "ref");
}
else
{
lua_pushstring(L, "nothing");
lua_setfield(L, -2, "type");
}
}
void scriptapi_add_craftitem(lua_State *L, const char *name)
{
StackUnroller stack_unroller(L);
assert(lua_gettop(L) > 0);
// Set minetest.registered_craftitems[name] = table on top of stack
lua_getglobal(L, "minetest");
lua_getfield(L, -1, "registered_craftitems");
luaL_checktype(L, -1, LUA_TTABLE);
lua_pushvalue(L, -3); // push another reference to the table to be registered
lua_setfield(L, -2, name); // set minetest.registered_craftitems[name]
}
static bool get_craftitem_callback(lua_State *L, const char *name,
const char *callbackname)
{
// Get minetest.registered_craftitems[name][callbackname]
// If that is nil or on error, return false and stack is unchanged
// If that is a function, returns true and pushes the
// function onto the stack
lua_getglobal(L, "minetest");
lua_getfield(L, -1, "registered_craftitems");
lua_remove(L, -2);
luaL_checktype(L, -1, LUA_TTABLE);
lua_getfield(L, -1, name);
lua_remove(L, -2);
// Should be a table
if(lua_type(L, -1) != LUA_TTABLE)
{
errorstream<<"CraftItem name \""<<name<<"\" not defined"<<std::endl;
lua_pop(L, 1);
return false;
}
lua_getfield(L, -1, callbackname);
lua_remove(L, -2);
// Should be a function or nil
if(lua_type(L, -1) == LUA_TFUNCTION)
{
return true;
}
else if(lua_isnil(L, -1))
{
lua_pop(L, 1);
return false;
}
else
{
errorstream<<"CraftItem name \""<<name<<"\" callback \""
<<callbackname<<" is not a function"<<std::endl;
lua_pop(L, 1);
return false;
}
}
bool scriptapi_craftitem_on_drop(lua_State *L, const char *name,
ServerActiveObject *dropper, v3f pos,
bool &callback_exists)
{
realitycheck(L);
assert(lua_checkstack(L, 20));
//infostream<<"scriptapi_craftitem_on_drop"<<std::endl;
StackUnroller stack_unroller(L);
bool result = false;
callback_exists = get_craftitem_callback(L, name, "on_drop");
if(callback_exists)
{
// Call function
lua_pushstring(L, name);
objectref_get_or_create(L, dropper);
pushFloatPos(L, pos);
if(lua_pcall(L, 3, 1, 0))
script_error(L, "error: %s\n", lua_tostring(L, -1));
result = lua_toboolean(L, -1);
}
return result;
}
bool scriptapi_craftitem_on_place_on_ground(lua_State *L, const char *name,
ServerActiveObject *placer, v3f pos,
bool &callback_exists)
{
realitycheck(L);
assert(lua_checkstack(L, 20));
//infostream<<"scriptapi_craftitem_on_place_on_ground"<<std::endl;
StackUnroller stack_unroller(L);
bool result = false;
callback_exists = get_craftitem_callback(L, name, "on_place_on_ground");
if(callback_exists)
{
// Call function
lua_pushstring(L, name);
objectref_get_or_create(L, placer);
pushFloatPos(L, pos);
if(lua_pcall(L, 3, 1, 0))
script_error(L, "error: %s\n", lua_tostring(L, -1));
result = lua_toboolean(L, -1);
}
return result;
}
bool scriptapi_craftitem_on_use(lua_State *L, const char *name,
ServerActiveObject *user, const PointedThing& pointed,
bool &callback_exists)
{
realitycheck(L);
assert(lua_checkstack(L, 20));
//infostream<<"scriptapi_craftitem_on_use"<<std::endl;
StackUnroller stack_unroller(L);
bool result = false;
callback_exists = get_craftitem_callback(L, name, "on_use");
if(callback_exists)
{
// Call function
lua_pushstring(L, name);
objectref_get_or_create(L, user);
pushPointedThing(L, pointed);
if(lua_pcall(L, 3, 1, 0))
script_error(L, "error: %s\n", lua_tostring(L, -1));
result = lua_toboolean(L, -1);
}
return result;
}
/* /*
environment environment
*/ */

@ -29,6 +29,7 @@ class ServerEnvironment;
class ServerActiveObject; class ServerActiveObject;
typedef struct lua_State lua_State; typedef struct lua_State lua_State;
struct LuaEntityProperties; struct LuaEntityProperties;
struct PointedThing;
//class IGameDef; //class IGameDef;
void scriptapi_export(lua_State *L, Server *server); void scriptapi_export(lua_State *L, Server *server);
@ -60,6 +61,18 @@ void scriptapi_environment_on_generated(lua_State *L, v3s16 minp, v3s16 maxp);
void scriptapi_on_newplayer(lua_State *L, ServerActiveObject *player); void scriptapi_on_newplayer(lua_State *L, ServerActiveObject *player);
bool scriptapi_on_respawnplayer(lua_State *L, ServerActiveObject *player); bool scriptapi_on_respawnplayer(lua_State *L, ServerActiveObject *player);
/* craftitem */
void scriptapi_add_craftitem(lua_State *L, const char *name);
bool scriptapi_craftitem_on_drop(lua_State *L, const char *name,
ServerActiveObject *dropper, v3f pos,
bool &callback_exists);
bool scriptapi_craftitem_on_place_on_ground(lua_State *L, const char *name,
ServerActiveObject *placer, v3f pos,
bool &callback_exists);
bool scriptapi_craftitem_on_use(lua_State *L, const char *name,
ServerActiveObject *user, const PointedThing& pointed,
bool &callback_exists);
/* luaentity */ /* luaentity */
// Returns true if succesfully added into Lua; false otherwise. // Returns true if succesfully added into Lua; false otherwise.
bool scriptapi_luaentity_add(lua_State *L, u16 id, const char *name, bool scriptapi_luaentity_add(lua_State *L, u16 id, const char *name,

File diff suppressed because it is too large Load Diff

@ -36,6 +36,7 @@ typedef struct lua_State lua_State;
class IWritableToolDefManager; class IWritableToolDefManager;
class IWritableNodeDefManager; class IWritableNodeDefManager;
class IWritableCraftDefManager; class IWritableCraftDefManager;
class IWritableCraftItemDefManager;
/* /*
Some random functions Some random functions
@ -495,12 +496,14 @@ public:
virtual IToolDefManager* getToolDefManager(); virtual IToolDefManager* getToolDefManager();
virtual INodeDefManager* getNodeDefManager(); virtual INodeDefManager* getNodeDefManager();
virtual ICraftDefManager* getCraftDefManager(); virtual ICraftDefManager* getCraftDefManager();
virtual ICraftItemDefManager* getCraftItemDefManager();
virtual ITextureSource* getTextureSource(); virtual ITextureSource* getTextureSource();
virtual u16 allocateUnknownNodeId(const std::string &name); virtual u16 allocateUnknownNodeId(const std::string &name);
IWritableToolDefManager* getWritableToolDefManager(); IWritableToolDefManager* getWritableToolDefManager();
IWritableNodeDefManager* getWritableNodeDefManager(); IWritableNodeDefManager* getWritableNodeDefManager();
IWritableCraftDefManager* getWritableCraftDefManager(); IWritableCraftDefManager* getWritableCraftDefManager();
IWritableCraftItemDefManager* getWritableCraftItemDefManager();
private: private:
@ -523,6 +526,8 @@ private:
IToolDefManager *tooldef); IToolDefManager *tooldef);
static void SendNodeDef(con::Connection &con, u16 peer_id, static void SendNodeDef(con::Connection &con, u16 peer_id,
INodeDefManager *nodedef); INodeDefManager *nodedef);
static void SendCraftItemDef(con::Connection &con, u16 peer_id,
ICraftItemDefManager *nodedef);
/* /*
Non-static send methods. Non-static send methods.
@ -644,6 +649,9 @@ private:
// Craft definition manager // Craft definition manager
IWritableCraftDefManager *m_craftdef; IWritableCraftDefManager *m_craftdef;
// CraftItem definition manager
IWritableCraftItemDefManager *m_craftitemdef;
/* /*
Threads Threads
*/ */

@ -225,7 +225,7 @@ void cmd_teleport(std::wostringstream &os,
//ctx->player->setPosition(dest); //ctx->player->setPosition(dest);
// Use the ServerActiveObject interface of ServerRemotePlayer // Use the ServerActiveObject interface of ServerRemotePlayer
ServerRemotePlayer *srp = (ServerRemotePlayer*)ctx->player; ServerRemotePlayer *srp = static_cast<ServerRemotePlayer*>(ctx->player);
srp->setPos(dest); srp->setPos(dest);
ctx->server->SendMovePlayer(ctx->player); ctx->server->SendMovePlayer(ctx->player);

@ -123,6 +123,8 @@ public:
// If all fits, eats item and returns true. Otherwise returns false. // If all fits, eats item and returns true. Otherwise returns false.
virtual bool addToInventory(InventoryItem *item) virtual bool addToInventory(InventoryItem *item)
{return false;} {return false;}
virtual void addToInventoryLater(InventoryItem *item)
{}
virtual void setHP(s16 hp) virtual void setHP(s16 hp)
{} {}
virtual s16 getHP() virtual s16 getHP()

@ -276,3 +276,103 @@ std::string translatePassword(std::string playername, std::wstring password)
PointedThing::PointedThing():
type(POINTEDTHING_NOTHING),
node_undersurface(0,0,0),
node_abovesurface(0,0,0),
object_id(-1)
{}
std::string PointedThing::dump() const
{
std::ostringstream os(std::ios::binary);
if(type == POINTEDTHING_NOTHING)
{
os<<"[nothing]";
}
else if(type == POINTEDTHING_NODE)
{
const v3s16 &u = node_undersurface;
const v3s16 &a = node_abovesurface;
os<<"[node under="<<u.X<<","<<u.Y<<","<<u.Z
<< " above="<<a.X<<","<<a.Y<<","<<a.Z<<"]";
}
else if(type == POINTEDTHING_OBJECT)
{
os<<"[object "<<object_id<<"]";
}
else
{
os<<"[unknown PointedThing]";
}
return os.str();
}
void PointedThing::serialize(std::ostream &os) const
{
writeU8(os, 0); // version
writeU8(os, (u8)type);
if(type == POINTEDTHING_NOTHING)
{
// nothing
}
else if(type == POINTEDTHING_NODE)
{
writeV3S16(os, node_undersurface);
writeV3S16(os, node_abovesurface);
}
else if(type == POINTEDTHING_OBJECT)
{
writeS16(os, object_id);
}
}
void PointedThing::deSerialize(std::istream &is)
{
int version = readU8(is);
if(version != 0) throw SerializationError(
"unsupported PointedThing version");
type = (PointedThingType) readU8(is);
if(type == POINTEDTHING_NOTHING)
{
// nothing
}
else if(type == POINTEDTHING_NODE)
{
node_undersurface = readV3S16(is);
node_abovesurface = readV3S16(is);
}
else if(type == POINTEDTHING_OBJECT)
{
object_id = readS16(is);
}
else
{
throw SerializationError(
"unsupported PointedThingType");
}
}
bool PointedThing::operator==(const PointedThing &pt2) const
{
if(type != pt2.type)
return false;
if(type == POINTEDTHING_NODE)
{
if(node_undersurface != pt2.node_undersurface)
return false;
if(node_abovesurface != pt2.node_abovesurface)
return false;
}
else if(type == POINTEDTHING_OBJECT)
{
if(object_id != pt2.object_id)
return false;
}
return true;
}
bool PointedThing::operator!=(const PointedThing &pt2) const
{
return !(*this == pt2);
}

@ -104,13 +104,6 @@ inline s32 readS32(u8 *data){
return (s32)readU32(data); return (s32)readU32(data);
} }
inline void writeF1000(u8 *data, f32 i){
writeS32(data, i*1000);
}
inline f32 readF1000(u8 *data){
return (f32)readS32(data)/1000.;
}
inline void writeS16(u8 *data, s16 i){ inline void writeS16(u8 *data, s16 i){
writeU16(data, (u16)i); writeU16(data, (u16)i);
} }
@ -118,6 +111,20 @@ inline s16 readS16(u8 *data){
return (s16)readU16(data); return (s16)readU16(data);
} }
inline void writeS8(u8 *data, s8 i){
writeU8(data, (u8)i);
}
inline s8 readS8(u8 *data){
return (s8)readU8(data);
}
inline void writeF1000(u8 *data, f32 i){
writeS32(data, i*1000);
}
inline f32 readF1000(u8 *data){
return (f32)readS32(data)/1000.;
}
inline void writeV3S32(u8 *data, v3s32 p) inline void writeV3S32(u8 *data, v3s32 p)
{ {
writeS32(&data[0], p.X); writeS32(&data[0], p.X);
@ -248,19 +255,45 @@ inline u32 readU32(std::istream &is)
return readU32((u8*)buf); return readU32((u8*)buf);
} }
inline void writeS32(std::ostream &os, u32 p) inline void writeS32(std::ostream &os, s32 p)
{ {
char buf[4]; char buf[4];
writeS32((u8*)buf, p); writeS32((u8*)buf, p);
os.write(buf, 4); os.write(buf, 4);
} }
inline u32 readS32(std::istream &is) inline s32 readS32(std::istream &is)
{ {
char buf[4]; char buf[4];
is.read(buf, 4); is.read(buf, 4);
return readS32((u8*)buf); return readS32((u8*)buf);
} }
inline void writeS16(std::ostream &os, s16 p)
{
char buf[2];
writeS16((u8*)buf, p);
os.write(buf, 2);
}
inline s16 readS16(std::istream &is)
{
char buf[2];
is.read(buf, 2);
return readS16((u8*)buf);
}
inline void writeS8(std::ostream &os, s8 p)
{
char buf[1];
writeS8((u8*)buf, p);
os.write(buf, 1);
}
inline s8 readS8(std::istream &is)
{
char buf[1];
is.read(buf, 1);
return readS8((u8*)buf);
}
inline void writeF1000(std::ostream &os, f32 p) inline void writeF1000(std::ostream &os, f32 p)
{ {
char buf[4]; char buf[4];
@ -1725,5 +1758,27 @@ protected:
std::string translatePassword(std::string playername, std::wstring password); std::string translatePassword(std::string playername, std::wstring password);
enum PointedThingType
{
POINTEDTHING_NOTHING,
POINTEDTHING_NODE,
POINTEDTHING_OBJECT
};
struct PointedThing
{
PointedThingType type;
v3s16 node_undersurface;
v3s16 node_abovesurface;
s16 object_id;
PointedThing();
std::string dump() const;
void serialize(std::ostream &os) const;
void deSerialize(std::istream &is);
bool operator==(const PointedThing &pt2) const;
bool operator!=(const PointedThing &pt2) const;
};
#endif #endif