X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fclient.cpp;h=ca6c80c4d2696376d4a879e0a1fe524f21058796;hb=5a34f40d80ea1a339b599bc11db549a6bd86912f;hp=2148bfe59b438749d52dcac8ed668c3f6e5d080f;hpb=2e90ed07acd295387c0da6c0689d14665b6c125d;p=minetest.git diff --git a/src/client.cpp b/src/client.cpp index 2148bfe59..ca6c80c4d 100644 --- a/src/client.cpp +++ b/src/client.cpp @@ -1,57 +1,55 @@ /* -Minetest-c55 -Copyright (C) 2010 celeron55, Perttu Ahola +Minetest +Copyright (C) 2013 celeron55, Perttu Ahola This program is free software; you can redistribute it and/or modify -it under the terms of the GNU General Public License as published by -the Free Software Foundation; either version 2 of the License, or +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. +GNU Lesser General Public License for more details. -You should have received a copy of the GNU General Public License along +You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ #include "client.h" -#include "utility.h" #include +#include #include "clientserver.h" -#include "jmutexautolock.h" +#include "jthread/jmutexautolock.h" #include "main.h" #include +#include "filesys.h" #include "porting.h" #include "mapsector.h" #include "mapblock_mesh.h" #include "mapblock.h" #include "settings.h" #include "profiler.h" +#include "gettext.h" #include "log.h" #include "nodemetadata.h" #include "nodedef.h" #include "itemdef.h" +#include "shader.h" #include -#include "sha1.h" #include "base64.h" #include "clientmap.h" - -static std::string getTextureCacheDir() -{ - return porting::path_user + DIR_DELIM + "cache" + DIR_DELIM + "textures"; -} - -struct TextureRequest -{ - std::string name; - - TextureRequest(const std::string &name_=""): - name(name_) - {} -}; +#include "clientmedia.h" +#include "sound.h" +#include "util/string.h" +#include "IMeshCache.h" +#include "serialization.h" +#include "util/serialize.h" +#include "config.h" +#include "util/directiontables.h" +#include "util/pointedthing.h" +#include "version.h" /* QueuedMeshUpdate @@ -76,7 +74,6 @@ QueuedMeshUpdate::~QueuedMeshUpdate() MeshUpdateQueue::MeshUpdateQueue() { - m_mutex.Init(); } MeshUpdateQueue::~MeshUpdateQueue() @@ -171,7 +168,7 @@ void * MeshUpdateThread::Thread() BEGIN_DEBUG_EXCEPTION_HANDLER - while(getRun()) + while(!StopRequested()) { /*// Wait for output queue to flush. // Allow 2 in queue, this makes less frametime jitter. @@ -217,18 +214,29 @@ void * MeshUpdateThread::Thread() return NULL; } +/* + Client +*/ + Client::Client( IrrlichtDevice *device, const char *playername, std::string password, MapDrawControl &control, IWritableTextureSource *tsrc, + IWritableShaderSource *shsrc, IWritableItemDefManager *itemdef, - IWritableNodeDefManager *nodedef + IWritableNodeDefManager *nodedef, + ISoundManager *sound, + MtEventManager *event, + bool ipv6 ): m_tsrc(tsrc), + m_shsrc(shsrc), m_itemdef(itemdef), m_nodedef(nodedef), + m_sound(sound), + m_event(event), m_mesh_update_thread(this), m_env( new ClientMap(this, this, control, @@ -237,7 +245,7 @@ Client::Client( device->getSceneManager(), tsrc, this, device ), - m_con(PROTOCOL_ID, 512, CONNECTION_TIMEOUT, this), + m_con(PROTOCOL_ID, 512, CONNECTION_TIMEOUT, ipv6, this), m_device(device), m_server_ser_ver(SER_FMT_VER_INVALID), m_playeritem(0), @@ -250,13 +258,14 @@ Client::Client( m_map_seed(0), m_password(password), m_access_denied(false), - m_texture_receive_progress(0), - m_textures_received(false), m_itemdef_received(false), m_nodedef_received(false), + m_media_downloader(new ClientMediaDownloader()), m_time_of_day_set(false), m_last_time_of_day_f(-1), - m_time_of_day_update_timer(0) + m_time_of_day_update_timer(0), + m_recommended_send_interval(0.1), + m_removed_sounds_check_timer(0) { m_packetcounter_timer = 0.0; //m_delete_unused_sectors_timer = 0.0; @@ -265,12 +274,6 @@ Client::Client( m_playerpos_send_timer = 0.0; m_ignore_damage_timer = 0.0; - // Build main texture atlas, now that the GameDef exists (that is, us) - if(g_settings->getBool("enable_texture_atlas")) - m_tsrc->buildMainAtlas(this); - else - infostream<<"Not building texture atlas."<::iterator + i = m_detached_inventories.begin(); + i != m_detached_inventories.end(); i++){ + delete i->second; + } + } + + // cleanup 3d model meshes on client shutdown + while (m_device->getSceneManager()->getMeshCache()->getMeshCount() != 0) { + scene::IAnimatedMesh * mesh = + m_device->getSceneManager()->getMeshCache()->getMeshByIndex(0); + + if (mesh != NULL) + m_device->getSceneManager()->getMeshCache()->removeMesh(mesh); + } } void Client::connect(Address address) @@ -344,13 +383,6 @@ void Client::step(float dtime) // 0ms ReceiveAll(); } - - { - //TimeTaker timer("m_con_mutex + m_con.RunTimeouts()", m_device); - // 0ms - //JMutexAutoLock lock(m_con_mutex); //bulk comment-out - m_con.RunTimeouts(dtime); - } /* Packet counter @@ -392,7 +424,7 @@ void Client::step(float dtime) core::list deleted_blocks; - float delete_unused_sectors_timeout = + float delete_unused_sectors_timeout = g_settings->getFloat("client_delete_unused_sectors_timeout"); // Delete sector blocks @@ -477,13 +509,14 @@ void Client::step(float dtime) // Send TOSERVER_INIT // [0] u16 TOSERVER_INIT - // [2] u8 SER_FMT_VER_HIGHEST + // [2] u8 SER_FMT_VER_HIGHEST_READ // [3] u8[20] player_name // [23] u8[28] password (new in some version) - // [51] u16 client network protocol version (new in some version) - SharedBuffer data(2+1+PLAYERNAME_SIZE+PASSWORD_SIZE+2); + // [51] u16 minimum supported network protocol version (added sometime) + // [53] u16 maximum supported network protocol version (added later than the previous one) + SharedBuffer data(2+1+PLAYERNAME_SIZE+PASSWORD_SIZE+2+2); writeU16(&data[0], TOSERVER_INIT); - writeU8(&data[2], SER_FMT_VER_HIGHEST); + writeU8(&data[2], SER_FMT_VER_HIGHEST_READ); memset((char*)&data[3], 0, PLAYERNAME_SIZE); snprintf((char*)&data[3], PLAYERNAME_SIZE, "%s", myplayer->getName()); @@ -494,11 +527,11 @@ void Client::step(float dtime) memset((char*)&data[23], 0, PASSWORD_SIZE); snprintf((char*)&data[23], PASSWORD_SIZE, "%s", m_password.c_str()); - // This should be incremented in each version - writeU16(&data[51], PROTOCOL_VERSION); + writeU16(&data[51], CLIENT_PROTOCOL_VERSION_MIN); + writeU16(&data[53], CLIENT_PROTOCOL_VERSION_MAX); // Send as unreliable - Send(0, data, false); + Send(1, data, false); } // Not connected, return @@ -516,7 +549,7 @@ void Client::step(float dtime) if(m_map_timer_and_unload_interval.step(dtime, map_timer_and_unload_dtime)) { ScopeProfiler sp(g_profiler, "Client: map timer and unload"); - core::list deleted_blocks; + std::list deleted_blocks; m_env.getMap().timerUpdate(map_timer_and_unload_dtime, g_settings->getFloat("client_unload_unused_data_timeout"), &deleted_blocks); @@ -530,8 +563,8 @@ void Client::step(float dtime) NOTE: This loop is intentionally iterated the way it is. */ - core::list::Iterator i = deleted_blocks.begin(); - core::list sendlist; + std::list::iterator i = deleted_blocks.begin(); + std::list sendlist; for(;;) { if(sendlist.size() == 255 || i == deleted_blocks.end()) @@ -550,14 +583,14 @@ void Client::step(float dtime) writeU16(&reply[0], TOSERVER_DELETEDBLOCKS); reply[2] = sendlist.size(); u32 k = 0; - for(core::list::Iterator + for(std::list::iterator j = sendlist.begin(); - j != sendlist.end(); j++) + j != sendlist.end(); ++j) { writeV3S16(&reply[2+1+6*k], *j); k++; } - m_con.Send(PEER_ID_SERVER, 1, reply, true); + m_con.Send(PEER_ID_SERVER, 2, reply, true); if(i == deleted_blocks.end()) break; @@ -566,7 +599,7 @@ void Client::step(float dtime) } sendlist.push_back(*i); - i++; + ++i; } } @@ -612,9 +645,14 @@ void Client::step(float dtime) m_client_event_queue.push_back(event); } } + else if(event.type == CEE_PLAYER_BREATH) + { + u16 breath = event.player_breath.amount; + sendBreath(breath); + } } } - + /* Print some info */ @@ -637,7 +675,7 @@ void Client::step(float dtime) { float &counter = m_playerpos_send_timer; counter += dtime; - if(counter >= 0.2) + if(counter >= m_recommended_send_interval) { counter = 0.0; sendPlayerPos(); @@ -656,10 +694,12 @@ void Client::step(float dtime) /*infostream<<"Mesh update result queue size is " < 0) + + int num_processed_meshes = 0; + while(!m_mesh_update_thread.m_queue_out.empty()) { - MeshUpdateResult r = m_mesh_update_thread.m_queue_out.pop_front(); + num_processed_meshes++; + MeshUpdateResult r = m_mesh_update_thread.m_queue_out.pop_frontNoEx(); MapBlock *block = m_env.getMap().getBlockNoCreateNoEx(r.p); if(block) { @@ -675,6 +715,8 @@ void Client::step(float dtime) // Replace with the new mesh block->mesh = r.mesh; + } else { + delete r.mesh; } if(r.ack_block_to_server) { @@ -696,9 +738,23 @@ void Client::step(float dtime) reply[2] = 1; writeV3S16(&reply[3], r.p); // Send as reliable - m_con.Send(PEER_ID_SERVER, 1, reply, true); + m_con.Send(PEER_ID_SERVER, 2, reply, true); } } + if(num_processed_meshes > 0) + g_profiler->graphAdd("num_processed_meshes", num_processed_meshes); + } + + /* + Load fetched media + */ + if (m_media_downloader && m_media_downloader->isStarted()) { + m_media_downloader->step(this); + if (m_media_downloader->isDone()) { + received_media(); + delete m_media_downloader; + m_media_downloader = NULL; + } } /* @@ -724,6 +780,139 @@ void Client::step(float dtime) m_inventory_updated = true; } } + + /* + Update positions of sounds attached to objects + */ + { + for(std::map::iterator + i = m_sounds_to_objects.begin(); + i != m_sounds_to_objects.end(); i++) + { + int client_id = i->first; + u16 object_id = i->second; + ClientActiveObject *cao = m_env.getActiveObject(object_id); + if(!cao) + continue; + v3f pos = cao->getPosition(); + m_sound->updateSoundPosition(client_id, pos); + } + } + + /* + Handle removed remotely initiated sounds + */ + m_removed_sounds_check_timer += dtime; + if(m_removed_sounds_check_timer >= 2.32) + { + m_removed_sounds_check_timer = 0; + // Find removed sounds and clear references to them + std::set removed_server_ids; + for(std::map::iterator + i = m_sounds_server_to_client.begin(); + i != m_sounds_server_to_client.end();) + { + s32 server_id = i->first; + int client_id = i->second; + i++; + if(!m_sound->soundExists(client_id)){ + m_sounds_server_to_client.erase(server_id); + m_sounds_client_to_server.erase(client_id); + m_sounds_to_objects.erase(client_id); + removed_server_ids.insert(server_id); + } + } + // Sync to server + if(removed_server_ids.size() != 0) + { + std::ostringstream os(std::ios_base::binary); + writeU16(os, TOSERVER_REMOVED_SOUNDS); + writeU16(os, removed_server_ids.size()); + for(std::set::iterator i = removed_server_ids.begin(); + i != removed_server_ids.end(); i++) + writeS32(os, *i); + std::string s = os.str(); + SharedBuffer data((u8*)s.c_str(), s.size()); + // Send as reliable + Send(1, data, true); + } + } +} + +bool Client::loadMedia(const std::string &data, const std::string &filename) +{ + // Silly irrlicht's const-incorrectness + Buffer data_rw(data.c_str(), data.size()); + + std::string name; + + const char *image_ext[] = { + ".png", ".jpg", ".bmp", ".tga", + ".pcx", ".ppm", ".psd", ".wal", ".rgb", + NULL + }; + name = removeStringEnd(filename, image_ext); + if(name != "") + { + verbosestream<<"Client: Attempting to load image " + <<"file \""<getFileSystem(); + video::IVideoDriver *vdrv = m_device->getVideoDriver(); + + // Create an irrlicht memory file + io::IReadFile *rfile = irrfs->createMemoryReadFile( + *data_rw, data_rw.getSize(), "_tempreadfile"); + assert(rfile); + // Read image + video::IImage *img = vdrv->createImageFromFile(rfile); + if(!img){ + errorstream<<"Client: Cannot create image from data of " + <<"file \""<drop(); + return false; + } + else { + m_tsrc->insertSourceImage(filename, img); + img->drop(); + rfile->drop(); + return true; + } + } + + const char *sound_ext[] = { + ".0.ogg", ".1.ogg", ".2.ogg", ".3.ogg", ".4.ogg", + ".5.ogg", ".6.ogg", ".7.ogg", ".8.ogg", ".9.ogg", + ".ogg", NULL + }; + name = removeStringEnd(filename, sound_ext); + if(name != "") + { + verbosestream<<"Client: Attempting to load sound " + <<"file \""<loadSoundData(name, data); + return true; + } + + const char *model_ext[] = { + ".x", ".b3d", ".md2", ".obj", + NULL + }; + name = removeStringEnd(filename, model_ext); + if(name != "") + { + verbosestream<<"Client: Storing model into memory: " + <<"\""< &file_requests) +{ + std::ostringstream os(std::ios_base::binary); + writeU16(os, TOSERVER_REQUEST_MEDIA); + writeU16(os, file_requests.size()); + + for(std::list::const_iterator i = file_requests.begin(); + i != file_requests.end(); ++i) { + os< data((u8*)s.c_str(), s.size()); + // Send as reliable + Send(1, data, true); + infostream<<"Client: Sending media request list to server (" + < data((u8*)s.c_str(), s.size()); + // Send as reliable + Send(1, data, true); + infostream<<"Client: Notifying server that we received all media" + <graphAdd("client_received_packets", 1); } catch(con::NoIncomingDataException &e) { @@ -826,8 +1057,7 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id) infostream<<"Client: TOCLIENT_INIT received with " "deployed="<<((int)deployed&0xff)< SER_FMT_VER_HIGHEST) + if(!ser_ver_supported(deployed)) { infostream<<"Client: TOCLIENT_INIT: Server sent " <<"unsupported ser_fmt_ver"<= 2+1+6+8+4) + { + // Get map seed + m_recommended_send_interval = readF1000(&data[2+1+6+8]); + infostream<<"Client: received recommended send interval " + <= index+1) && data[index]){ + remove_metadata = false; + } + + addNode(p, n, remove_metadata); } else if(command == TOCLIENT_BLOCKDATA) { @@ -964,6 +1208,7 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id) */ //infostream<<"Updating"<deSerialize(istr, ser_version, false); + block->deSerializeNetworkSpecific(istr); } else { @@ -973,6 +1218,7 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id) //infostream<<"Creating new"<deSerialize(istr, ser_version, false); + block->deSerializeNetworkSpecific(istr); sector->insertBlock(block); } @@ -1019,8 +1265,6 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id) std::istringstream is(datastring, std::ios_base::binary); //t3.stop(); - //m_env.printPlayers(infostream); - //TimeTaker t4("player get", m_device); Player *player = m_env.getLocalPlayer(); assert(player != NULL); @@ -1209,6 +1453,26 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id) } } } + else if(command == TOCLIENT_MOVEMENT) + { + std::string datastring((char*)&data[2], datasize-2); + std::istringstream is(datastring, std::ios_base::binary); + Player *player = m_env.getLocalPlayer(); + assert(player != NULL); + + player->movement_acceleration_default = readF1000(is) * BS; + player->movement_acceleration_air = readF1000(is) * BS; + player->movement_acceleration_fast = readF1000(is) * BS; + player->movement_speed_walk = readF1000(is) * BS; + player->movement_speed_crouch = readF1000(is) * BS; + player->movement_speed_fast = readF1000(is) * BS; + player->movement_speed_climb = readF1000(is) * BS; + player->movement_speed_jump = readF1000(is) * BS; + player->movement_liquid_fluidity = readF1000(is) * BS; + player->movement_liquid_fluidity_smooth = readF1000(is) * BS; + player->movement_liquid_sink = readF1000(is) * BS; + player->movement_gravity = readF1000(is) * BS; + } else if(command == TOCLIENT_HP) { std::string datastring((char*)&data[2], datasize-2); @@ -1228,6 +1492,15 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id) m_client_event_queue.push_back(event); } } + else if(command == TOCLIENT_BREATH) + { + std::string datastring((char*)&data[2], datasize-2); + std::istringstream is(datastring, std::ios_base::binary); + Player *player = m_env.getLocalPlayer(); + assert(player != NULL); + u16 breath = readU16(is); + player->setBreath(breath) ; + } else if(command == TOCLIENT_MOVE_PLAYER) { std::string datastring((char*)&data[2], datasize-2); @@ -1265,45 +1538,7 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id) } else if(command == TOCLIENT_PLAYERITEM) { - std::string datastring((char*)&data[2], datasize-2); - std::istringstream is(datastring, std::ios_base::binary); - - u16 count = readU16(is); - - for (u16 i = 0; i < count; ++i) { - u16 peer_id = readU16(is); - Player *player = m_env.getPlayer(peer_id); - - if (player == NULL) - { - infostream<<"Client: ignoring player item " - << deSerializeString(is) - << " for non-existing peer id " << peer_id - << std::endl; - continue; - } else if (player->isLocal()) { - infostream<<"Client: ignoring player item " - << deSerializeString(is) - << " for local player" << std::endl; - continue; - } else { - InventoryList *inv = player->inventory.getList("main"); - std::string itemstring(deSerializeString(is)); - ItemStack item; - item.deSerialize(itemstring, m_itemdef); - inv->changeItem(0, item); - if(itemstring.empty()) - { - infostream<<"Client: empty player item for peer " - <getFileSystem(); - video::IVideoDriver *vdrv = m_device->getVideoDriver(); - std::string datastring((char*)&data[2], datasize-2); std::istringstream is(datastring, std::ios_base::binary); + int num_files = readU16(is); + + infostream<<"Client: Received media announcement: packet size: " + <isStarted()) { + const char *problem = m_media_downloader ? + "we already saw another announcement" : + "all media has been received already"; + errorstream<<"Client: Received media announcement but " + < 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 \""<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: " - <"< "<addFile(name, sha1_raw); + } - //add texture request - if (!texture_found) { - infostream<<"Client: Adding texture to request list: \"" - < remote_media; + try { + Strfnd sf(deSerializeString(is)); + while(!sf.atend()) { + std::string baseurl = trim(sf.next(",")); + if(baseurl != "") + m_media_downloader->addRemoteServer(baseurl); } - } - - 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::Iterator i = texture_requests.begin(); - i != texture_requests.end(); i++) { - os<name); + catch(SerializationError) { + // not supported by server or turned off } - // Make data buffer - std::string s = os.str(); - SharedBuffer data((u8*)s.c_str(), s.size()); - // Send as reliable - Send(0, data, true); - infostream<<"Client: Sending request list to server " <step(this); } - else if(command == TOCLIENT_TEXTURES) + else if(command == TOCLIENT_MEDIA) { - 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()); - /* u16 command - u16 total number of texture bunches + u16 total number of file bunches u16 index of this bunch - u32 number of textures in this bunch - for each texture { + u32 number of files in this bunch + for each file { u16 length of name string name u32 length of data @@ -1495,60 +1624,37 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id) */ int num_bunches = readU16(is); int bunch_i = readU16(is); - m_texture_receive_progress = (float)bunch_i / (float)(num_bunches - 1); - if(bunch_i == num_bunches - 1) - m_textures_received = true; - int num_textures = readU32(is); - infostream<<"Client: Received textures: bunch "< data_rw(data.c_str(), data.size()); - // Create an irrlicht memory file - io::IReadFile *rfile = irrfs->createMemoryReadFile( - *data_rw, data.size(), "_tempreadfile"); - assert(rfile); - // Read image - video::IImage *img = vdrv->createImageFromFile(rfile); - if(!img){ - errorstream<<"Client: Cannot create image from data of " - <<"received texture \""<drop(); - continue; - } - - fs::CreateAllDirs(getTextureCacheDir()); + if (num_files == 0) + return; - std::string filename = getTextureCacheDir() + DIR_DELIM + name; - std::ofstream outfile(filename.c_str(), std::ios_base::binary | std::ios_base::trunc); + if (m_media_downloader == NULL || + !m_media_downloader->isStarted()) { + const char *problem = m_media_downloader ? + "media has not been requested" : + "all media has been received already"; + errorstream<<"Client: Received media but " + <insertSourceImage(name, img); - img->drop(); - rfile->drop(); + for(u32 i=0; iconventionalTransferDone( + name, data, this); } - - ClientEvent event; - event.type = CE_TEXTURES_UPDATED; - m_client_event_queue.push_back(event); } else if(command == TOCLIENT_TOOLDEF) { @@ -1600,6 +1706,359 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id) m_itemdef->deSerialize(tmp_is2); m_itemdef_received = true; } + else if(command == TOCLIENT_PLAY_SOUND) + { + std::string datastring((char*)&data[2], datasize-2); + std::istringstream is(datastring, std::ios_base::binary); + + s32 server_id = readS32(is); + std::string name = deSerializeString(is); + float gain = readF1000(is); + int type = readU8(is); // 0=local, 1=positional, 2=object + v3f pos = readV3F1000(is); + u16 object_id = readU16(is); + bool loop = readU8(is); + // Start playing + int client_id = -1; + switch(type){ + case 0: // local + client_id = m_sound->playSound(name, loop, gain); + break; + case 1: // positional + client_id = m_sound->playSoundAt(name, loop, gain, pos); + break; + case 2: { // object + ClientActiveObject *cao = m_env.getActiveObject(object_id); + if(cao) + pos = cao->getPosition(); + client_id = m_sound->playSoundAt(name, loop, gain, pos); + // TODO: Set up sound to move with object + break; } + default: + break; + } + if(client_id != -1){ + m_sounds_server_to_client[server_id] = client_id; + m_sounds_client_to_server[client_id] = server_id; + if(object_id != 0) + m_sounds_to_objects[client_id] = object_id; + } + } + else if(command == TOCLIENT_STOP_SOUND) + { + std::string datastring((char*)&data[2], datasize-2); + std::istringstream is(datastring, std::ios_base::binary); + + s32 server_id = readS32(is); + std::map::iterator i = + m_sounds_server_to_client.find(server_id); + if(i != m_sounds_server_to_client.end()){ + int client_id = i->second; + m_sound->stopSound(client_id); + } + } + else if(command == TOCLIENT_PRIVILEGES) + { + std::string datastring((char*)&data[2], datasize-2); + std::istringstream is(datastring, std::ios_base::binary); + + m_privileges.clear(); + infostream<<"Client: Privileges updated: "; + u16 num_privileges = readU16(is); + for(u16 i=0; iinventory_formspec = deSerializeLongString(is); + } + else if(command == TOCLIENT_DETACHED_INVENTORY) + { + std::string datastring((char*)&data[2], datasize-2); + std::istringstream is(datastring, std::ios_base::binary); + + std::string name = deSerializeString(is); + + infostream<<"Client: Detached inventory update: \""< 0) + inv = m_detached_inventories[name]; + else{ + inv = new Inventory(m_itemdef); + m_detached_inventories[name] = inv; + } + inv->deSerialize(is); + } + else if(command == TOCLIENT_SHOW_FORMSPEC) + { + std::string datastring((char*)&data[2], datasize-2); + std::istringstream is(datastring, std::ios_base::binary); + + std::string formspec = deSerializeLongString(is); + std::string formname = deSerializeString(is); + + ClientEvent event; + event.type = CE_SHOW_FORMSPEC; + // pointer is required as event is a struct only! + // adding a std:string to a struct isn't possible + event.show_formspec.formspec = new std::string(formspec); + event.show_formspec.formname = new std::string(formname); + m_client_event_queue.push_back(event); + } + else if(command == TOCLIENT_SPAWN_PARTICLE) + { + std::string datastring((char*)&data[2], datasize-2); + std::istringstream is(datastring, std::ios_base::binary); + + v3f pos = readV3F1000(is); + v3f vel = readV3F1000(is); + v3f acc = readV3F1000(is); + float expirationtime = readF1000(is); + float size = readF1000(is); + bool collisiondetection = readU8(is); + std::string texture = deSerializeLongString(is); + bool vertical = false; + try { + vertical = readU8(is); + } catch (...) {} + + ClientEvent event; + event.type = CE_SPAWN_PARTICLE; + event.spawn_particle.pos = new v3f (pos); + event.spawn_particle.vel = new v3f (vel); + event.spawn_particle.acc = new v3f (acc); + + event.spawn_particle.expirationtime = expirationtime; + event.spawn_particle.size = size; + event.spawn_particle.collisiondetection = + collisiondetection; + event.spawn_particle.vertical = vertical; + event.spawn_particle.texture = new std::string(texture); + + m_client_event_queue.push_back(event); + } + else if(command == TOCLIENT_ADD_PARTICLESPAWNER) + { + std::string datastring((char*)&data[2], datasize-2); + std::istringstream is(datastring, std::ios_base::binary); + + u16 amount = readU16(is); + float spawntime = readF1000(is); + v3f minpos = readV3F1000(is); + v3f maxpos = readV3F1000(is); + v3f minvel = readV3F1000(is); + v3f maxvel = readV3F1000(is); + v3f minacc = readV3F1000(is); + v3f maxacc = readV3F1000(is); + float minexptime = readF1000(is); + float maxexptime = readF1000(is); + float minsize = readF1000(is); + float maxsize = readF1000(is); + bool collisiondetection = readU8(is); + std::string texture = deSerializeLongString(is); + u32 id = readU32(is); + bool vertical = false; + try { + vertical = readU8(is); + } catch (...) {} + + ClientEvent event; + event.type = CE_ADD_PARTICLESPAWNER; + event.add_particlespawner.amount = amount; + event.add_particlespawner.spawntime = spawntime; + + event.add_particlespawner.minpos = new v3f (minpos); + event.add_particlespawner.maxpos = new v3f (maxpos); + event.add_particlespawner.minvel = new v3f (minvel); + event.add_particlespawner.maxvel = new v3f (maxvel); + event.add_particlespawner.minacc = new v3f (minacc); + event.add_particlespawner.maxacc = new v3f (maxacc); + + event.add_particlespawner.minexptime = minexptime; + event.add_particlespawner.maxexptime = maxexptime; + event.add_particlespawner.minsize = minsize; + event.add_particlespawner.maxsize = maxsize; + event.add_particlespawner.collisiondetection = collisiondetection; + event.add_particlespawner.vertical = vertical; + event.add_particlespawner.texture = new std::string(texture); + event.add_particlespawner.id = id; + + m_client_event_queue.push_back(event); + } + else if(command == TOCLIENT_DELETE_PARTICLESPAWNER) + { + std::string datastring((char*)&data[2], datasize-2); + std::istringstream is(datastring, std::ios_base::binary); + + u32 id = readU16(is); + + ClientEvent event; + event.type = CE_DELETE_PARTICLESPAWNER; + event.delete_particlespawner.id = id; + + m_client_event_queue.push_back(event); + } + else if(command == TOCLIENT_HUDADD) + { + std::string datastring((char *)&data[2], datasize - 2); + std::istringstream is(datastring, std::ios_base::binary); + + u32 id = readU32(is); + u8 type = readU8(is); + v2f pos = readV2F1000(is); + std::string name = deSerializeString(is); + v2f scale = readV2F1000(is); + std::string text = deSerializeString(is); + u32 number = readU32(is); + u32 item = readU32(is); + u32 dir = readU32(is); + v2f align = readV2F1000(is); + v2f offset = readV2F1000(is); + v3f world_pos; + try{ + world_pos = readV3F1000(is); + }catch(SerializationError &e) {}; + + ClientEvent event; + event.type = CE_HUDADD; + event.hudadd.id = id; + event.hudadd.type = type; + event.hudadd.pos = new v2f(pos); + event.hudadd.name = new std::string(name); + event.hudadd.scale = new v2f(scale); + event.hudadd.text = new std::string(text); + event.hudadd.number = number; + event.hudadd.item = item; + event.hudadd.dir = dir; + event.hudadd.align = new v2f(align); + event.hudadd.offset = new v2f(offset); + event.hudadd.world_pos = new v3f(world_pos); + m_client_event_queue.push_back(event); + } + else if(command == TOCLIENT_HUDRM) + { + std::string datastring((char *)&data[2], datasize - 2); + std::istringstream is(datastring, std::ios_base::binary); + + u32 id = readU32(is); + + ClientEvent event; + event.type = CE_HUDRM; + event.hudrm.id = id; + m_client_event_queue.push_back(event); + } + else if(command == TOCLIENT_HUDCHANGE) + { + std::string sdata; + v2f v2fdata; + v3f v3fdata; + u32 intdata = 0; + + std::string datastring((char *)&data[2], datasize - 2); + std::istringstream is(datastring, std::ios_base::binary); + + u32 id = readU32(is); + u8 stat = (HudElementStat)readU8(is); + + if (stat == HUD_STAT_POS || stat == HUD_STAT_SCALE || + stat == HUD_STAT_ALIGN || stat == HUD_STAT_OFFSET) + v2fdata = readV2F1000(is); + else if (stat == HUD_STAT_NAME || stat == HUD_STAT_TEXT) + sdata = deSerializeString(is); + else if (stat == HUD_STAT_WORLD_POS) + v3fdata = readV3F1000(is); + else + intdata = readU32(is); + + ClientEvent event; + event.type = CE_HUDCHANGE; + event.hudchange.id = id; + event.hudchange.stat = (HudElementStat)stat; + event.hudchange.v2fdata = new v2f(v2fdata); + event.hudchange.v3fdata = new v3f(v3fdata); + event.hudchange.sdata = new std::string(sdata); + event.hudchange.data = intdata; + m_client_event_queue.push_back(event); + } + else if(command == TOCLIENT_HUD_SET_FLAGS) + { + std::string datastring((char *)&data[2], datasize - 2); + std::istringstream is(datastring, std::ios_base::binary); + + Player *player = m_env.getLocalPlayer(); + assert(player != NULL); + + u32 flags = readU32(is); + u32 mask = readU32(is); + + player->hud_flags &= ~mask; + player->hud_flags |= flags; + } + else if(command == TOCLIENT_HUD_SET_PARAM) + { + std::string datastring((char *)&data[2], datasize - 2); + std::istringstream is(datastring, std::ios_base::binary); + + Player *player = m_env.getLocalPlayer(); + assert(player != NULL); + + u16 param = readU16(is); + std::string value = deSerializeString(is); + + if(param == HUD_PARAM_HOTBAR_ITEMCOUNT && value.size() == 4){ + s32 hotbar_itemcount = readS32((u8*) value.c_str()); + if(hotbar_itemcount > 0 && hotbar_itemcount <= HUD_HOTBAR_ITEMCOUNT_MAX) + player->hud_hotbar_itemcount = hotbar_itemcount; + } else if (param == HUD_PARAM_HOTBAR_IMAGE) { + ((LocalPlayer *) player)->hotbar_image = value; + } else if (param == HUD_PARAM_HOTBAR_SELECTED_IMAGE) { + ((LocalPlayer *) player)->hotbar_selected_image = value; + } + } + else if(command == TOCLIENT_SET_SKY) + { + std::string datastring((char *)&data[2], datasize - 2); + std::istringstream is(datastring, std::ios_base::binary); + + video::SColor *bgcolor = new video::SColor(readARGB8(is)); + std::string *type = new std::string(deSerializeString(is)); + u16 count = readU16(is); + std::vector *params = new std::vector; + for(size_t i=0; ipush_back(deSerializeString(is)); + + ClientEvent event; + event.type = CE_SET_SKY; + event.set_sky.bgcolor = bgcolor; + event.set_sky.type = type; + event.set_sky.params = params; + m_client_event_queue.push_back(event); + } + else if(command == TOCLIENT_OVERRIDE_DAY_NIGHT_RATIO) + { + std::string datastring((char *)&data[2], datasize - 2); + std::istringstream is(datastring, std::ios_base::binary); + + bool do_override = readU8(is); + float day_night_ratio_f = (float)readU16(is) / 65536; + + ClientEvent event; + event.type = CE_OVERRIDE_DAY_NIGHT_RATIO; + event.override_day_night_ratio.do_override = do_override; + event.override_day_night_ratio.ratio_f = day_night_ratio_f; + m_client_event_queue.push_back(event); + } else { infostream<<"Client: Ignoring unknown command " @@ -1651,33 +2110,23 @@ void Client::interact(u8 action, const PointedThing& pointed) Send(0, data, true); } -void Client::sendSignNodeText(v3s16 p, std::string text) +void Client::sendNodemetaFields(v3s16 p, const std::string &formname, + const std::map &fields) { - /* - u16 command - v3s16 p - u16 textlen - textdata - */ std::ostringstream os(std::ios_base::binary); - u8 buf[12]; - - // Write command - writeU16(buf, TOSERVER_SIGNNODETEXT); - os.write((char*)buf, 2); - - // Write p - writeV3S16(buf, p); - os.write((char*)buf, 6); - u16 textlen = text.size(); - // Write text length - writeS16(buf, textlen); - os.write((char*)buf, 2); + writeU16(os, TOSERVER_NODEMETA_FIELDS); + writeV3S16(os, p); + os<::const_iterator + i = fields.begin(); i != fields.end(); i++){ + const std::string &name = i->first; + const std::string &value = i->second; + os< data((u8*)s.c_str(), s.size()); @@ -1685,6 +2134,29 @@ void Client::sendSignNodeText(v3s16 p, std::string text) Send(0, data, true); } +void Client::sendInventoryFields(const std::string &formname, + const std::map &fields) +{ + std::ostringstream os(std::ios_base::binary); + + writeU16(os, TOSERVER_INVENTORY_FIELDS); + os<::const_iterator + i = fields.begin(); i != fields.end(); i++){ + const std::string &name = i->first; + const std::string &value = i->second; + os< data((u8*)s.c_str(), s.size()); + // Send as reliable + Send(0, data, true); +} + void Client::sendInventoryAction(InventoryAction *a) { std::ostringstream os(std::ios_base::binary); @@ -1783,6 +2255,20 @@ void Client::sendDamage(u8 damage) Send(0, data, true); } +void Client::sendBreath(u16 breath) +{ + DSTACK(__FUNCTION_NAME); + std::ostringstream os(std::ios_base::binary); + + writeU16(os, TOSERVER_BREATH); + writeU16(os, breath); + // Make data buffer + std::string s = os.str(); + SharedBuffer data((u8*)s.c_str(), s.size()); + // Send as reliable + Send(0, data, true); +} + void Client::sendRespawn() { DSTACK(__FUNCTION_NAME); @@ -1801,10 +2287,24 @@ void Client::sendPlayerPos() { //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out - Player *myplayer = m_env.getLocalPlayer(); + LocalPlayer *myplayer = m_env.getLocalPlayer(); if(myplayer == NULL) return; - + + // Save bandwidth by only updating position when something changed + if(myplayer->last_position == myplayer->getPosition() && + myplayer->last_speed == myplayer->getSpeed() && + myplayer->last_pitch == myplayer->getPitch() && + myplayer->last_yaw == myplayer->getYaw() && + myplayer->last_keyPressed == myplayer->keyPressed) + return; + + myplayer->last_position = myplayer->getPosition(); + myplayer->last_speed = myplayer->getSpeed(); + myplayer->last_pitch = myplayer->getPitch(); + myplayer->last_yaw = myplayer->getYaw(); + myplayer->last_keyPressed = myplayer->keyPressed; + u16 our_peer_id; { //JMutexAutoLock lock(m_con_mutex); //bulk comment-out @@ -1823,7 +2323,7 @@ void Client::sendPlayerPos() v3s32 speed(sf.X*100, sf.Y*100, sf.Z*100); s32 pitch = myplayer->getPitch() * 100; s32 yaw = myplayer->getYaw() * 100; - + u32 keyPressed=myplayer->keyPressed; /* Format: [0] u16 command @@ -1831,15 +2331,15 @@ void Client::sendPlayerPos() [2+12] v3s32 speed*100 [2+12+12] s32 pitch*100 [2+12+12+4] s32 yaw*100 + [2+12+12+4+4] u32 keyPressed */ - - SharedBuffer data(2+12+12+4+4); + SharedBuffer data(2+12+12+4+4+4); writeU16(&data[0], TOSERVER_PLAYERPOS); writeV3S32(&data[2], position); writeV3S32(&data[2+12], speed); writeS32(&data[2+12+12], pitch); writeS32(&data[2+12+12+4], yaw); - + writeU32(&data[2+12+12+4+4], keyPressed); // Send as unreliable Send(0, data, false); } @@ -1868,7 +2368,7 @@ void Client::sendPlayerItem(u16 item) void Client::removeNode(v3s16 p) { - core::map modified_blocks; + std::map modified_blocks; try { @@ -1882,35 +2382,33 @@ void Client::removeNode(v3s16 p) // add urgent task to update the modified node addUpdateMeshTaskForNode(p, false, true); - for(core::map::Iterator - i = modified_blocks.getIterator(); - i.atEnd() == false; i++) + for(std::map::iterator + i = modified_blocks.begin(); + i != modified_blocks.end(); ++i) { - v3s16 p = i.getNode()->getKey(); - addUpdateMeshTaskWithEdge(p); + addUpdateMeshTaskWithEdge(i->first); } } -void Client::addNode(v3s16 p, MapNode n) +void Client::addNode(v3s16 p, MapNode n, bool remove_metadata) { TimeTaker timer1("Client::addNode()"); - core::map modified_blocks; + std::map modified_blocks; try { //TimeTaker timer3("Client::addNode(): addNodeAndUpdate"); - m_env.getMap().addNodeAndUpdate(p, n, modified_blocks); + m_env.getMap().addNodeAndUpdate(p, n, modified_blocks, remove_metadata); } catch(InvalidPositionException &e) {} - for(core::map::Iterator - i = modified_blocks.getIterator(); - i.atEnd() == false; i++) + for(std::map::iterator + i = modified_blocks.begin(); + i != modified_blocks.end(); ++i) { - v3s16 p = i.getNode()->getKey(); - addUpdateMeshTaskWithEdge(p); + addUpdateMeshTaskWithEdge(i->first); } } @@ -1979,6 +2477,13 @@ Inventory* Client::getInventory(const InventoryLocation &loc) return meta->getInventory(); } break; + case InventoryLocation::DETACHED: + { + if(m_detached_inventories.count(loc.name) == 0) + return NULL; + return m_detached_inventories[loc.name]; + } + break; default: assert(0); } @@ -1995,6 +2500,9 @@ void Client::inventoryAction(InventoryAction *a) Predict some local inventory changes */ a->clientApply(this, this); + + // Remove it + delete a; } ClientActiveObject * Client::getSelectedActiveObject( @@ -2003,7 +2511,7 @@ ClientActiveObject * Client::getSelectedActiveObject( core::line3d shootline_on_map ) { - core::array objects; + std::vector objects; m_env.getActiveObjects(from_pos_f_on_map, max_d, objects); @@ -2011,7 +2519,7 @@ ClientActiveObject * Client::getSelectedActiveObject( // Sort them. // After this, the closest object is the first in the array. - objects.sort(); + std::sort(objects.begin(), objects.end()); for(u32 i=0; i Client::getConnectedPlayerNames() +std::list Client::getConnectedPlayerNames() { - core::list players = m_env.getPlayers(true); - core::list playerNames; - for(core::list::Iterator - i = players.begin(); - i != players.end(); i++) - { - Player *player = *i; - playerNames.push_back(narrow_to_wide(player->getName())); - } - return playerNames; + return m_env.getPlayerNames(); } float Client::getAnimationTime() @@ -2101,6 +2600,13 @@ u16 Client::getHP() return player->hp; } +u16 Client::getBreath() +{ + Player *player = m_env.getLocalPlayer(); + assert(player != NULL); + return player->getBreath(); +} + bool Client::getChatMessage(std::wstring &message) { if(m_chat_queue.size() == 0) @@ -2188,21 +2694,14 @@ void Client::addUpdateMeshTaskWithEdge(v3s16 blockpos, bool ack_to_server, bool } catch(InvalidPositionException &e){} // Leading edge - try{ - v3s16 p = blockpos + v3s16(-1,0,0); - addUpdateMeshTask(p, false, urgent); - } - catch(InvalidPositionException &e){} - try{ - v3s16 p = blockpos + v3s16(0,-1,0); - addUpdateMeshTask(p, false, urgent); - } - catch(InvalidPositionException &e){} - try{ - v3s16 p = blockpos + v3s16(0,0,-1); - addUpdateMeshTask(p, false, urgent); + for (int i=0;i<6;i++) + { + try{ + v3s16 p = blockpos + g_6dirs[i]; + addUpdateMeshTask(p, false, urgent); + } + catch(InvalidPositionException &e){} } - catch(InvalidPositionException &e){} } void Client::addUpdateMeshTaskForNode(v3s16 nodepos, bool ack_to_server, bool urgent) @@ -2257,30 +2756,68 @@ ClientEvent Client::getClientEvent() return m_client_event_queue.pop_front(); } -void Client::afterContentReceived() +float Client::mediaReceiveProgress() { + if (m_media_downloader) + return m_media_downloader->getProgress(); + else + return 1.0; // downloader only exists when not yet done +} + +void draw_load_screen(const std::wstring &text, + IrrlichtDevice* device, gui::IGUIFont* font, + float dtime=0 ,int percent=0, bool clouds=true); +void Client::afterContentReceived(IrrlichtDevice *device, gui::IGUIFont* font) +{ + infostream<<"Client::afterContentReceived() started"<rebuildImagesAndTextures(); - // Update texture atlas - if(g_settings->getBool("enable_texture_atlas")) - m_tsrc->buildMainAtlas(this); + // Rebuild shaders + infostream<<"- Rebuilding shaders"<rebuildShaders(); // Update node aliases + infostream<<"- Updating node aliases"<updateAliases(m_itemdef); // Update node textures + infostream<<"- Updating node textures"<updateTextures(m_tsrc); - // Update item textures and meshes - m_itemdef->updateTexturesAndMeshes(this); + // Preload item textures and meshes if configured to + if(g_settings->getBool("preload_item_visuals")) + { + verbosestream<<"Updating item textures and meshes"< names = m_itemdef->getAll(); + size_t size = names.size(); + size_t count = 0; + int percent = 0; + for(std::set::const_iterator + i = names.begin(); i != names.end(); ++i){ + // Asking for these caches the result + m_itemdef->getInventoryTexture(*i, this); + m_itemdef->getWieldMesh(*i, this); + count++; + percent = count*100/size; + if (count%50 == 0) // only update every 50 item + draw_load_screen(text,device,font,0,percent); + } + delete[] text; + } // Start mesh update thread after setting up content definitions + infostream<<"- Starting mesh update thread"<::const_iterator i = + m_mesh_data.find(filename); + if(i == m_mesh_data.end()){ + errorstream<<"Client::getMesh(): Mesh not found: \""<second; + scene::ISceneManager *smgr = m_device->getSceneManager(); + + // Create the mesh, remove it from cache and return it + // This allows unique vertex colors and other properties for each instance + Buffer data_rw(data.c_str(), data.size()); // Const-incorrect Irrlicht + io::IFileSystem *irrfs = m_device->getFileSystem(); + io::IReadFile *rfile = irrfs->createMemoryReadFile( + *data_rw, data_rw.getSize(), filename.c_str()); + assert(rfile); + scene::IAnimatedMesh *mesh = smgr->getMesh(rfile); + rfile->drop(); + // NOTE: By playing with Irrlicht refcounts, maybe we could cache a bunch + // of uniquely named instances and re-use them + mesh->grab(); + smgr->getMeshCache()->removeMesh(mesh); + return mesh; +}