#include "log.h"
#include "nodemetadata.h"
#include "nodedef.h"
-#include "tooldef.h"
+#include "itemdef.h"
#include <IFileSystem.h>
+#include "sha1.h"
+#include "base64.h"
+
+static std::string getTextureCacheDir()
+{
+ return porting::path_userdata + DIR_DELIM + "cache" + DIR_DELIM + "texture";
+}
+
+struct TextureRequest
+{
+ std::string name;
+
+ TextureRequest(const std::string &name_=""):
+ name(name_)
+ {}
+};
/*
QueuedMeshUpdate
std::string password,
MapDrawControl &control,
IWritableTextureSource *tsrc,
- IWritableToolDefManager *tooldef,
+ IWritableItemDefManager *itemdef,
IWritableNodeDefManager *nodedef
):
m_tsrc(tsrc),
- m_tooldef(tooldef),
+ m_itemdef(itemdef),
m_nodedef(nodedef),
m_mesh_update_thread(this),
m_env(
device->getSceneManager()->getRootSceneNode(),
device->getSceneManager(), 666),
device->getSceneManager(),
- tsrc, this
+ tsrc, this, device
),
m_con(PROTOCOL_ID, 512, CONNECTION_TIMEOUT, this),
m_device(device),
m_server_ser_ver(SER_FMT_VER_INVALID),
+ m_playeritem(0),
m_inventory_updated(false),
+ m_inventory_from_server(NULL),
+ m_inventory_from_server_age(0.0),
m_time_of_day(0),
m_map_seed(0),
m_password(password),
m_access_denied(false),
m_texture_receive_progress(0),
m_textures_received(false),
- m_tooldef_received(false),
+ m_itemdef_received(false),
m_nodedef_received(false)
{
m_packetcounter_timer = 0.0;
else
infostream<<"Not building texture atlas."<<std::endl;
- // Update node textures
- m_nodedef->updateTextures(m_tsrc);
-
- // Start threads after setting up content definitions
- m_mesh_update_thread.Start();
-
/*
Add local player
*/
player->updateName(playername);
m_env.addPlayer(player);
-
- // Initialize player in the inventory context
- m_inventory_context.current_player = player;
}
}
m_mesh_update_thread.setRun(false);
while(m_mesh_update_thread.IsRunning())
sleep_ms(100);
+
+ delete m_inventory_from_server;
}
void Client::connect(Address address)
if(m_ignore_damage_timer <= 0)
{
u8 damage = event.player_damage.amount;
- sendDamage(damage);
+
+ if(event.player_damage.send_to_server)
+ sendDamage(damage);
// Add to ClientEvent queue
ClientEvent event;
}
}
}
+
+ /*
+ If the server didn't update the inventory in a while, revert
+ the local inventory (so the player notices the lag problem
+ and knows something is wrong).
+ */
+ if(m_inventory_from_server)
+ {
+ float interval = 10.0;
+ float count_before = floor(m_inventory_from_server_age / interval);
+
+ m_inventory_from_server_age += dtime;
+
+ float count_after = floor(m_inventory_from_server_age / interval);
+
+ if(count_after != count_before)
+ {
+ // Do this every <interval> seconds after TOCLIENT_INVENTORY
+ // Reset the locally changed inventory to the authoritative inventory
+ Player *player = m_env.getLocalPlayer();
+ player->inventory = *m_inventory_from_server;
+ m_inventory_updated = true;
+ }
+ }
}
// Virtual methods from con::PeerHandler
Update an existing block
*/
//infostream<<"Updating"<<std::endl;
- block->deSerialize(istr, ser_version);
+ block->deSerialize(istr, ser_version, false);
}
else
{
*/
//infostream<<"Creating new"<<std::endl;
block = new MapBlock(&m_env.getMap(), p, this);
- block->deSerialize(istr, ser_version);
+ block->deSerialize(istr, ser_version, false);
sector->insertBlock(block);
-
- //DEBUG
- /*NodeMod mod;
- mod.type = NODEMOD_CHANGECONTENT;
- mod.param = CONTENT_MESE;
- block->setTempMod(v3s16(8,10,8), mod);
- block->setTempMod(v3s16(8,9,8), mod);
- block->setTempMod(v3s16(8,8,8), mod);
- block->setTempMod(v3s16(8,7,8), mod);
- block->setTempMod(v3s16(8,6,8), mod);*/
}
#if 0
//infostream<<"Adding mesh update task for received block"<<std::endl;
addUpdateMeshTaskWithEdge(p, true);
}
- else if(command == TOCLIENT_PLAYERPOS)
- {
- infostream<<"Received deprecated TOCLIENT_PLAYERPOS"
- <<std::endl;
- /*u16 our_peer_id;
- {
- //JMutexAutoLock lock(m_con_mutex); //bulk comment-out
- our_peer_id = m_con.GetPeerID();
- }
- // Cancel if we don't have a peer id
- if(our_peer_id == PEER_ID_INEXISTENT){
- infostream<<"TOCLIENT_PLAYERPOS cancelled: "
- "we have no peer id"
- <<std::endl;
- return;
- }*/
-
- { //envlock
- //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
-
- u32 player_size = 2+12+12+4+4;
-
- u32 player_count = (datasize-2) / player_size;
- u32 start = 2;
- for(u32 i=0; i<player_count; i++)
- {
- u16 peer_id = readU16(&data[start]);
-
- Player *player = m_env.getPlayer(peer_id);
-
- // Skip if player doesn't exist
- if(player == NULL)
- {
- start += player_size;
- continue;
- }
-
- // Skip if player is local player
- if(player->isLocal())
- {
- start += player_size;
- continue;
- }
-
- v3s32 ps = readV3S32(&data[start+2]);
- v3s32 ss = readV3S32(&data[start+2+12]);
- s32 pitch_i = readS32(&data[start+2+12+12]);
- s32 yaw_i = readS32(&data[start+2+12+12+4]);
- /*infostream<<"Client: got "
- <<"pitch_i="<<pitch_i
- <<" yaw_i="<<yaw_i<<std::endl;*/
- f32 pitch = (f32)pitch_i / 100.0;
- f32 yaw = (f32)yaw_i / 100.0;
- v3f position((f32)ps.X/100., (f32)ps.Y/100., (f32)ps.Z/100.);
- v3f speed((f32)ss.X/100., (f32)ss.Y/100., (f32)ss.Z/100.);
- player->setPosition(position);
- player->setSpeed(speed);
- player->setPitch(pitch);
- player->setYaw(yaw);
-
- /*infostream<<"Client: player "<<peer_id
- <<" pitch="<<pitch
- <<" yaw="<<yaw<<std::endl;*/
-
- start += player_size;
- }
- } //envlock
- }
- else if(command == TOCLIENT_PLAYERINFO)
- {
- u16 our_peer_id;
- {
- //JMutexAutoLock lock(m_con_mutex); //bulk comment-out
- our_peer_id = m_con.GetPeerID();
- }
- // Cancel if we don't have a peer id
- if(our_peer_id == PEER_ID_INEXISTENT){
- infostream<<"TOCLIENT_PLAYERINFO cancelled: "
- "we have no peer id"
- <<std::endl;
- return;
- }
-
- //infostream<<"Client: Server reports players:"<<std::endl;
-
- { //envlock
- //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
-
- u32 item_size = 2+PLAYERNAME_SIZE;
- u32 player_count = (datasize-2) / item_size;
- u32 start = 2;
- // peer_ids
- core::list<u16> players_alive;
- for(u32 i=0; i<player_count; i++)
- {
- // Make sure the name ends in '\0'
- data[start+2+20-1] = 0;
-
- u16 peer_id = readU16(&data[start]);
-
- players_alive.push_back(peer_id);
-
- /*infostream<<"peer_id="<<peer_id
- <<" name="<<((char*)&data[start+2])<<std::endl;*/
-
- // Don't update the info of the local player
- if(peer_id == our_peer_id)
- {
- start += item_size;
- continue;
- }
-
- Player *player = m_env.getPlayer(peer_id);
-
- // Create a player if it doesn't exist
- if(player == NULL)
- {
- player = new RemotePlayer(this,
- m_device->getSceneManager()->getRootSceneNode(),
- m_device,
- -1);
- player->peer_id = peer_id;
- m_env.addPlayer(player);
- infostream<<"Client: Adding new player "
- <<peer_id<<std::endl;
- }
-
- player->updateName((char*)&data[start+2]);
-
- start += item_size;
- }
-
- /*
- Remove those players from the environment that
- weren't listed by the server.
- */
- //infostream<<"Removing dead players"<<std::endl;
- core::list<Player*> players = m_env.getPlayers();
- core::list<Player*>::Iterator ip;
- for(ip=players.begin(); ip!=players.end(); ip++)
- {
- // Ingore local player
- if((*ip)->isLocal())
- continue;
-
- // Warn about a special case
- if((*ip)->peer_id == 0)
- {
- infostream<<"Client: Removing "
- "dead player with id=0"<<std::endl;
- }
-
- bool is_alive = false;
- core::list<u16>::Iterator i;
- for(i=players_alive.begin(); i!=players_alive.end(); i++)
- {
- if((*ip)->peer_id == *i)
- {
- is_alive = true;
- break;
- }
- }
- /*infostream<<"peer_id="<<((*ip)->peer_id)
- <<" is_alive="<<is_alive<<std::endl;*/
- if(is_alive)
- continue;
- infostream<<"Removing dead player "<<(*ip)->peer_id
- <<std::endl;
- m_env.removePlayer((*ip)->peer_id);
- }
- } //envlock
- }
- else if(command == TOCLIENT_SECTORMETA)
- {
- infostream<<"Client received DEPRECATED TOCLIENT_SECTORMETA"<<std::endl;
-#if 0
- /*
- [0] u16 command
- [2] u8 sector count
- [3...] v2s16 pos + sector metadata
- */
- if(datasize < 3)
- return;
-
- //infostream<<"Client received TOCLIENT_SECTORMETA"<<std::endl;
-
- { //envlock
- //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
-
- std::string datastring((char*)&data[2], datasize-2);
- std::istringstream is(datastring, std::ios_base::binary);
-
- u8 buf[4];
-
- is.read((char*)buf, 1);
- u16 sector_count = readU8(buf);
-
- //infostream<<"sector_count="<<sector_count<<std::endl;
-
- for(u16 i=0; i<sector_count; i++)
- {
- // Read position
- is.read((char*)buf, 4);
- v2s16 pos = readV2S16(buf);
- /*infostream<<"Client: deserializing sector at "
- <<"("<<pos.X<<","<<pos.Y<<")"<<std::endl;*/
- // Create sector
- assert(m_env.getMap().mapType() == MAPTYPE_CLIENT);
- ((ClientMap&)m_env.getMap()).deSerializeSector(pos, is);
- }
- } //envlock
-#endif
- }
else if(command == TOCLIENT_INVENTORY)
{
if(datasize < 3)
//t4.stop();
//TimeTaker t1("inventory.deSerialize()", m_device);
- player->inventory.deSerialize(is, this);
+ player->inventory.deSerialize(is);
//t1.stop();
m_inventory_updated = true;
+ delete m_inventory_from_server;
+ m_inventory_from_server = new Inventory(player->inventory);
+ m_inventory_from_server_age = 0.0;
+
//infostream<<"Client got player inventory:"<<std::endl;
//player->inventory.print(infostream);
}
}
- //DEBUG
- else if(command == TOCLIENT_OBJECTDATA)
- {
- // Strip command word and create a stringstream
- std::string datastring((char*)&data[2], datasize-2);
- std::istringstream is(datastring, std::ios_base::binary);
-
- u8 buf[12];
-
- /*
- Read players
- */
-
- is.read((char*)buf, 2);
- u16 playercount = readU16(buf);
-
- for(u16 i=0; i<playercount; i++)
- {
- is.read((char*)buf, 2);
- u16 peer_id = readU16(buf);
- is.read((char*)buf, 12);
- v3s32 p_i = readV3S32(buf);
- is.read((char*)buf, 12);
- v3s32 s_i = readV3S32(buf);
- is.read((char*)buf, 4);
- s32 pitch_i = readS32(buf);
- is.read((char*)buf, 4);
- s32 yaw_i = readS32(buf);
-
- Player *player = m_env.getPlayer(peer_id);
-
- // Skip if player doesn't exist
- if(player == NULL)
- {
- continue;
- }
-
- // Skip if player is local player
- if(player->isLocal())
- {
- continue;
- }
-
- f32 pitch = (f32)pitch_i / 100.0;
- f32 yaw = (f32)yaw_i / 100.0;
- v3f position((f32)p_i.X/100., (f32)p_i.Y/100., (f32)p_i.Z/100.);
- v3f speed((f32)s_i.X/100., (f32)s_i.Y/100., (f32)s_i.Z/100.);
-
- player->setPosition(position);
- player->setSpeed(speed);
- player->setPitch(pitch);
- player->setYaw(yaw);
- }
-
- /*
- Read block objects
- NOTE: Deprecated stuff
- */
-
- // Read active block count
- u16 blockcount = readU16(is);
- if(blockcount != 0){
- infostream<<"TOCLIENT_OBJECTDATA: blockcount != 0 "
- "not supported"<<std::endl;
- return;
- }
- }
else if(command == TOCLIENT_TIME_OF_DAY)
{
if(datasize < 4)
} else {
InventoryList *inv = player->inventory.getList("main");
std::string itemstring(deSerializeString(is));
- if (itemstring.empty()) {
- inv->deleteItem(0);
- infostream
- <<"Client: empty player item for peer "
- << peer_id << std::endl;
- } else {
- std::istringstream iss(itemstring);
- delete inv->changeItem(0,
- InventoryItem::deSerialize(iss, this));
- infostream<<"Client: player item for peer " << peer_id << ": ";
- player->getWieldItem()->serialize(infostream);
- infostream<<std::endl;
+ ItemStack item;
+ item.deSerialize(itemstring, m_itemdef);
+ inv->changeItem(0, item);
+ if(itemstring.empty())
+ {
+ infostream<<"Client: empty player item for peer "
+ <<peer_id<<std::endl;
+ }
+ else
+ {
+ infostream<<"Client: player item for peer "
+ <<peer_id<<": "<<itemstring<<std::endl;
}
}
}
event.deathscreen.camera_point_target_z = camera_point_target.Z;
m_client_event_queue.push_back(event);
}
+ else if(command == TOCLIENT_ANNOUNCE_TEXTURES)
+ {
+ io::IFileSystem *irrfs = m_device->getFileSystem();
+ video::IVideoDriver *vdrv = m_device->getVideoDriver();
+
+ std::string datastring((char*)&data[2], datasize-2);
+ std::istringstream is(datastring, std::ios_base::binary);
+
+ // Mesh update thread must be stopped while
+ // updating content definitions
+ assert(!m_mesh_update_thread.IsRunning());
+
+ int num_textures = readU16(is);
+
+ core::list<TextureRequest> texture_requests;
+
+ for(int i=0; i<num_textures; i++){
+
+ bool texture_found = false;
+
+ //read texture from cache
+ std::string name = deSerializeString(is);
+ std::string sha1_texture = deSerializeString(is);
+
+ // if name contains illegal characters, ignore the texture
+ if(!string_allowed(name, TEXTURENAME_ALLOWED_CHARS)){
+ errorstream<<"Client: ignoring illegal texture name "
+ <<"sent by server: \""<<name<<"\""<<std::endl;
+ continue;
+ }
+
+ std::string tpath = getTextureCacheDir() + DIR_DELIM + name;
+ // Read data
+ std::ifstream fis(tpath.c_str(), std::ios_base::binary);
+
+
+ if(fis.good() == false){
+ infostream<<"Client::Texture not found in cache: "
+ <<name << " expected it at: "<<tpath<<std::endl;
+ }
+ else
+ {
+ std::ostringstream tmp_os(std::ios_base::binary);
+ bool bad = false;
+ for(;;){
+ char buf[1024];
+ fis.read(buf, 1024);
+ std::streamsize len = fis.gcount();
+ tmp_os.write(buf, len);
+ if(fis.eof())
+ break;
+ if(!fis.good()){
+ bad = true;
+ break;
+ }
+ }
+ if(bad){
+ infostream<<"Client: Failed to read texture from cache\""
+ <<name<<"\""<<std::endl;
+ }
+ else {
+
+ SHA1 sha1;
+ sha1.addBytes(tmp_os.str().c_str(), tmp_os.str().length());
+
+ unsigned char *digest = sha1.getDigest();
+
+ std::string digest_string = base64_encode(digest, 20);
+
+ if (digest_string == sha1_texture) {
+ // Silly irrlicht's const-incorrectness
+ Buffer<char> data_rw(tmp_os.str().c_str(), tmp_os.str().size());
+
+ // Create an irrlicht memory file
+ io::IReadFile *rfile = irrfs->createMemoryReadFile(
+ *data_rw, tmp_os.str().size(), "_tempreadfile");
+ assert(rfile);
+ // Read image
+ video::IImage *img = vdrv->createImageFromFile(rfile);
+ if(!img){
+ infostream<<"Client: Cannot create image from data of "
+ <<"received texture \""<<name<<"\""<<std::endl;
+ rfile->drop();
+ }
+ else {
+ m_tsrc->insertSourceImage(name, img);
+ img->drop();
+ rfile->drop();
+
+ texture_found = true;
+ }
+ }
+ else {
+ infostream<<"Client::Texture cached sha1 hash not matching server hash: "
+ <<name << ": server ->"<<sha1_texture <<" client -> "<<digest_string<<std::endl;
+ }
+
+ free(digest);
+ }
+ }
+
+ //add texture request
+ if (!texture_found) {
+ infostream<<"Client: Adding texture to request list: \""
+ <<name<<"\""<<std::endl;
+ texture_requests.push_back(TextureRequest(name));
+ }
+
+ }
+
+ ClientEvent event;
+ event.type = CE_TEXTURES_UPDATED;
+ m_client_event_queue.push_back(event);
+
+
+ //send Texture request
+ /*
+ u16 command
+ u16 number of textures requested
+ for each texture {
+ u16 length of name
+ string name
+ }
+ */
+ std::ostringstream os(std::ios_base::binary);
+ u8 buf[12];
+
+
+ // Write command
+ writeU16(buf, TOSERVER_REQUEST_TEXTURES);
+ os.write((char*)buf, 2);
+
+ writeU16(buf,texture_requests.size());
+ os.write((char*)buf, 2);
+
+
+ for(core::list<TextureRequest>::Iterator i = texture_requests.begin();
+ i != texture_requests.end(); i++) {
+ os<<serializeString(i->name);
+ }
+
+ // Make data buffer
+ std::string s = os.str();
+ SharedBuffer<u8> data((u8*)s.c_str(), s.size());
+ // Send as reliable
+ Send(0, data, true);
+ infostream<<"Client: Sending request list to server " <<std::endl;
+ }
else if(command == TOCLIENT_TEXTURES)
{
io::IFileSystem *irrfs = m_device->getFileSystem();
std::string datastring((char*)&data[2], datasize-2);
std::istringstream is(datastring, std::ios_base::binary);
- // Stop threads while updating content definitions
- m_mesh_update_thread.stop();
-
+ // Mesh update thread must be stopped while
+ // updating content definitions
+ assert(!m_mesh_update_thread.IsRunning());
+
/*
u16 command
u16 total number of texture bunches
for(int i=0; i<num_textures; i++){
std::string name = deSerializeString(is);
std::string data = deSerializeLongString(is);
+
+ // if name contains illegal characters, ignore the texture
+ if(!string_allowed(name, TEXTURENAME_ALLOWED_CHARS)){
+ errorstream<<"Client: ignoring illegal texture name "
+ <<"sent by server: \""<<name<<"\""<<std::endl;
+ continue;
+ }
+
// Silly irrlicht's const-incorrectness
Buffer<char> data_rw(data.c_str(), data.size());
// Create an irrlicht memory file
rfile->drop();
continue;
}
+
+ fs::CreateAllDirs(getTextureCacheDir());
+
+ std::string filename = getTextureCacheDir() + DIR_DELIM + name;
+ std::ofstream outfile(filename.c_str(), std::ios_base::binary | std::ios_base::trunc);
+
+ if (outfile.good()) {
+ outfile.write(data.c_str(),data.length());
+ outfile.close();
+ }
+ else {
+ errorstream<<"Client: Unable to open cached texture file "<< filename <<std::endl;
+ }
+
m_tsrc->insertSourceImage(name, img);
img->drop();
rfile->drop();
}
-
- if(m_nodedef_received && m_textures_received){
- // Rebuild inherited images and recreate textures
- m_tsrc->rebuildImagesAndTextures();
-
- // Update texture atlas
- if(g_settings->getBool("enable_texture_atlas"))
- m_tsrc->buildMainAtlas(this);
-
- // Update node textures
- m_nodedef->updateTextures(m_tsrc);
- }
-
- // Resume threads
- m_mesh_update_thread.setRun(true);
- m_mesh_update_thread.Start();
ClientEvent event;
event.type = CE_TEXTURES_UPDATED;
}
else if(command == TOCLIENT_TOOLDEF)
{
- infostream<<"Client: Received tool definitions: packet size: "
- <<datasize<<std::endl;
-
- std::string datastring((char*)&data[2], datasize-2);
- std::istringstream is(datastring, std::ios_base::binary);
-
- m_tooldef_received = true;
-
- // Stop threads while updating content definitions
- m_mesh_update_thread.stop();
-
- std::istringstream tmp_is(deSerializeLongString(is), std::ios::binary);
- m_tooldef->deSerialize(tmp_is);
-
- // Resume threads
- m_mesh_update_thread.setRun(true);
- m_mesh_update_thread.Start();
+ infostream<<"Client: WARNING: Ignoring TOCLIENT_TOOLDEF"<<std::endl;
}
else if(command == TOCLIENT_NODEDEF)
{
infostream<<"Client: Received node definitions: packet size: "
<<datasize<<std::endl;
+ // Mesh update thread must be stopped while
+ // updating content definitions
+ assert(!m_mesh_update_thread.IsRunning());
+
+ // Decompress node definitions
std::string datastring((char*)&data[2], datasize-2);
std::istringstream is(datastring, std::ios_base::binary);
+ std::istringstream tmp_is(deSerializeLongString(is), std::ios::binary);
+ std::ostringstream tmp_os;
+ decompressZlib(tmp_is, tmp_os);
+ // Deserialize node definitions
+ std::istringstream tmp_is2(tmp_os.str());
+ m_nodedef->deSerialize(tmp_is2);
m_nodedef_received = true;
+ }
+ else if(command == TOCLIENT_CRAFTITEMDEF)
+ {
+ infostream<<"Client: WARNING: Ignoring TOCLIENT_CRAFTITEMDEF"<<std::endl;
+ }
+ else if(command == TOCLIENT_ITEMDEF)
+ {
+ infostream<<"Client: Received item definitions: packet size: "
+ <<datasize<<std::endl;
- // Stop threads while updating content definitions
- m_mesh_update_thread.stop();
+ // Mesh update thread must be stopped while
+ // updating content definitions
+ assert(!m_mesh_update_thread.IsRunning());
+ // Decompress item definitions
+ std::string datastring((char*)&data[2], datasize-2);
+ std::istringstream is(datastring, std::ios_base::binary);
std::istringstream tmp_is(deSerializeLongString(is), std::ios::binary);
- m_nodedef->deSerialize(tmp_is, this);
-
- if(m_textures_received){
- // Update texture atlas
- if(g_settings->getBool("enable_texture_atlas"))
- m_tsrc->buildMainAtlas(this);
-
- // Update node textures
- m_nodedef->updateTextures(m_tsrc);
- }
+ std::ostringstream tmp_os;
+ decompressZlib(tmp_is, tmp_os);
- // Resume threads
- m_mesh_update_thread.setRun(true);
- m_mesh_update_thread.Start();
+ // Deserialize node definitions
+ std::istringstream tmp_is2(tmp_os.str());
+ m_itemdef->deSerialize(tmp_is2);
+ m_itemdef_received = true;
}
else
{
m_con.Send(PEER_ID_SERVER, channelnum, data, reliable);
}
-void Client::groundAction(u8 action, v3s16 nodepos_undersurface,
- v3s16 nodepos_oversurface, u16 item)
+void Client::interact(u8 action, const PointedThing& pointed)
{
if(connectedAndInitialized() == false){
- infostream<<"Client::groundAction() "
+ infostream<<"Client::interact() "
"cancelled (not connected)"
<<std::endl;
return;
}
-
+
+ std::ostringstream os(std::ios_base::binary);
+
/*
- length: 17
[0] u16 command
[2] u8 action
- [3] v3s16 nodepos_undersurface
- [9] v3s16 nodepos_abovesurface
- [15] u16 item
+ [3] u16 item
+ [5] u32 length of the next item
+ [9] serialized PointedThing
actions:
- 0: start digging
- 1: place block
- 2: stop digging (all parameters ignored)
- 3: digging completed
+ 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
*/
- u8 datasize = 2 + 1 + 6 + 6 + 2;
- SharedBuffer<u8> data(datasize);
- writeU16(&data[0], TOSERVER_GROUND_ACTION);
- writeU8(&data[2], action);
- writeV3S16(&data[3], nodepos_undersurface);
- writeV3S16(&data[9], nodepos_oversurface);
- writeU16(&data[15], item);
- Send(0, data, true);
-}
-
-void Client::clickActiveObject(u8 button, u16 id, u16 item_i)
-{
- if(connectedAndInitialized() == false){
- infostream<<"Client::clickActiveObject() "
- "cancelled (not connected)"
- <<std::endl;
- return;
- }
+ writeU16(os, TOSERVER_INTERACT);
+ writeU8(os, action);
+ writeU16(os, getPlayerItem());
+ std::ostringstream tmp_os(std::ios::binary);
+ pointed.serialize(tmp_os);
+ os<<serializeLongString(tmp_os.str());
- Player *player = m_env.getLocalPlayer();
- 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();
- }
- }
+ std::string s = os.str();
+ SharedBuffer<u8> data((u8*)s.c_str(), s.size());
- 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 as reliable
Send(0, data, true);
}
try
{
//TimeTaker timer3("Client::addNode(): addNodeAndUpdate");
- std::string st = std::string("");
- m_env.getMap().addNodeAndUpdate(p, n, modified_blocks, st);
+ m_env.getMap().addNodeAndUpdate(p, n, modified_blocks);
}
catch(InvalidPositionException &e)
{}
void Client::selectPlayerItem(u16 item)
{
- LocalPlayer *player = m_env.getLocalPlayer();
- assert(player != NULL);
-
- player->wieldItem(item);
-
+ //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out
+ m_playeritem = item;
+ m_inventory_updated = true;
sendPlayerItem(item);
}
dst = player->inventory;
}
-InventoryContext *Client::getInventoryContext()
+Inventory* Client::getInventory(const InventoryLocation &loc)
{
- return &m_inventory_context;
-}
-
-Inventory* Client::getInventory(InventoryContext *c, std::string id)
-{
- if(id == "current_player")
+ switch(loc.type){
+ case InventoryLocation::UNDEFINED:
+ {}
+ break;
+ case InventoryLocation::CURRENT_PLAYER:
{
- assert(c->current_player);
- return &(c->current_player->inventory);
+ Player *player = m_env.getLocalPlayer();
+ assert(player != NULL);
+ return &player->inventory;
}
-
- Strfnd fn(id);
- std::string id0 = fn.next(":");
-
- if(id0 == "nodemeta")
+ break;
+ case InventoryLocation::PLAYER:
{
- v3s16 p;
- p.X = stoi(fn.next(","));
- p.Y = stoi(fn.next(","));
- p.Z = stoi(fn.next(","));
- NodeMetadata* meta = getNodeMetadata(p);
- if(meta)
- return meta->getInventory();
- infostream<<"nodemeta at ("<<p.X<<","<<p.Y<<","<<p.Z<<"): "
- <<"no metadata found"<<std::endl;
- return NULL;
+ Player *player = m_env.getPlayer(loc.name.c_str());
+ if(!player)
+ return NULL;
+ return &player->inventory;
+ }
+ break;
+ case InventoryLocation::NODEMETA:
+ {
+ NodeMetadata *meta = m_env.getMap().getNodeMetadata(loc.p);
+ if(!meta)
+ return NULL;
+ return meta->getInventory();
+ }
+ break;
+ default:
+ assert(0);
}
-
- infostream<<__FUNCTION_NAME<<": unknown id "<<id<<std::endl;
return NULL;
}
void Client::inventoryAction(InventoryAction *a)
{
+ /*
+ Send it to the server
+ */
sendInventoryAction(a);
+
+ /*
+ Predict some local inventory changes
+ */
+ a->clientApply(this, this);
}
ClientActiveObject * Client::getSelectedActiveObject(
return m_client_event_queue.pop_front();
}
+void Client::afterContentReceived()
+{
+ assert(m_itemdef_received);
+ assert(m_nodedef_received);
+ assert(m_textures_received);
+
+ // Rebuild inherited images and recreate textures
+ m_tsrc->rebuildImagesAndTextures();
+
+ // Update texture atlas
+ if(g_settings->getBool("enable_texture_atlas"))
+ m_tsrc->buildMainAtlas(this);
+
+ // Update node aliases
+ m_nodedef->updateAliases(m_itemdef);
+
+ // Update node textures
+ m_nodedef->updateTextures(m_tsrc);
+
+ // Update item textures and meshes
+ m_itemdef->updateTexturesAndMeshes(this);
+
+ // Start mesh update thread after setting up content definitions
+ m_mesh_update_thread.Start();
+}
+
float Client::getRTT(void)
{
try{
// IGameDef interface
// Under envlock
-IToolDefManager* Client::getToolDefManager()
+IItemDefManager* Client::getItemDefManager()
{
- return m_tooldef;
+ return m_itemdef;
}
INodeDefManager* Client::getNodeDefManager()
{
return m_nodedef;
}
+ICraftDefManager* Client::getCraftDefManager()
+{
+ return NULL;
+ //return m_craftdef;
+}
ITextureSource* Client::getTextureSource()
{
return m_tsrc;
projects / minetest.git / blobdiff