X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fclient.cpp;h=f27f95d98c2d939d7c8e010e28344f78ec67e90f;hb=e1ff5b13619666e5b987ecf4faaf294400ffd979;hp=2e3984bae543f638fee950cf8844df1e4cd1a7df;hpb=582e450bad08006dff141216351b81d3eb9270b7;p=dragonfireclient.git diff --git a/src/client.cpp b/src/client.cpp index 2e3984bae..f27f95d98 100644 --- a/src/client.cpp +++ b/src/client.cpp @@ -1,24 +1,23 @@ /* -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 "clientserver.h" #include "jmutexautolock.h" @@ -28,6 +27,33 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "mapsector.h" #include "mapblock_mesh.h" #include "mapblock.h" +#include "settings.h" +#include "profiler.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" +#include "filecache.h" +#include "sound.h" +#include "util/string.h" +#include "hex.h" +#include "IMeshCache.h" +#include "util/serialize.h" +#include "config.h" + +#if USE_CURL +#include +#endif + +static std::string getMediaCacheDir() +{ + return porting::path_user + DIR_DELIM + "cache" + DIR_DELIM + "media"; +} /* QueuedMeshUpdate @@ -59,8 +85,9 @@ MeshUpdateQueue::~MeshUpdateQueue() { JMutexAutoLock lock(m_mutex); - core::list::Iterator i; - for(i=m_queue.begin(); i!=m_queue.end(); i++) + for(std::vector::iterator + i = m_queue.begin(); + i != m_queue.end(); i++) { QueuedMeshUpdate *q = *i; delete q; @@ -70,7 +97,7 @@ MeshUpdateQueue::~MeshUpdateQueue() /* peer_id=0 adds with nobody to send to */ -void MeshUpdateQueue::addBlock(v3s16 p, MeshMakeData *data, bool ack_block_to_server) +void MeshUpdateQueue::addBlock(v3s16 p, MeshMakeData *data, bool ack_block_to_server, bool urgent) { DSTACK(__FUNCTION_NAME); @@ -78,12 +105,16 @@ void MeshUpdateQueue::addBlock(v3s16 p, MeshMakeData *data, bool ack_block_to_se JMutexAutoLock lock(m_mutex); + if(urgent) + m_urgents.insert(p); + /* Find if block is already in queue. If it is, update the data and quit. */ - core::list::Iterator i; - for(i=m_queue.begin(); i!=m_queue.end(); i++) + for(std::vector::iterator + i = m_queue.begin(); + i != m_queue.end(); i++) { QueuedMeshUpdate *q = *i; if(q->p == p) @@ -113,12 +144,19 @@ QueuedMeshUpdate * MeshUpdateQueue::pop() { JMutexAutoLock lock(m_mutex); - core::list::Iterator i = m_queue.begin(); - if(i == m_queue.end()) - return NULL; - QueuedMeshUpdate *q = *i; - m_queue.erase(i); - return q; + bool must_be_urgent = !m_urgents.empty(); + for(std::vector::iterator + i = m_queue.begin(); + i != m_queue.end(); i++) + { + QueuedMeshUpdate *q = *i; + if(must_be_urgent && m_urgents.count(q->p) == 0) + continue; + m_queue.erase(i); + m_urgents.erase(q->p); + return q; + } + return NULL; } /* @@ -129,6 +167,8 @@ void * MeshUpdateThread::Thread() { ThreadStarted(); + log_register_thread("MeshUpdateThread"); + DSTACK(__FUNCTION_NAME); BEGIN_DEBUG_EXCEPTION_HANDLER @@ -151,17 +191,21 @@ void * MeshUpdateThread::Thread() continue; } - ScopeProfiler sp(&g_profiler, "mesh make"); + ScopeProfiler sp(g_profiler, "Client: Mesh making"); - scene::SMesh *mesh_new = NULL; - mesh_new = makeMapBlockMesh(q->data); + MapBlockMesh *mesh_new = new MapBlockMesh(q->data); + if(mesh_new->getMesh()->getMeshBufferCount() == 0) + { + delete mesh_new; + mesh_new = NULL; + } MeshUpdateResult r; r.p = q->p; r.mesh = mesh_new; r.ack_block_to_server = q->ack_block_to_server; - /*dstream<<"MeshUpdateThread: Processed " + /*infostream<<"MeshUpdateThread: Processed " <<"("<p.X<<","<p.Y<<","<p.Z<<")" <::iterator i = m_file_requests.begin(); + i != m_file_requests.end(); ++i) { + curl = curl_easy_init(); + assert(curl); + curl_easy_setopt(curl, CURLOPT_NOSIGNAL, 1); + curl_easy_setopt(curl, CURLOPT_URL, (m_remote_url + i->name).c_str()); + curl_easy_setopt(curl, CURLOPT_FAILONERROR, true); + std::ostringstream stream; + curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, curl_write_data); + curl_easy_setopt(curl, CURLOPT_WRITEDATA, &stream); + res = curl_easy_perform(curl); + if (res == CURLE_OK) { + std::string data = stream.str(); + m_file_data.push_back(make_pair(i->name, data)); + } else { + m_failed.push_back(*i); + infostream << "cURL request failed for " << i->name << std::endl; + } + curl_easy_cleanup(curl); + } + #endif + + END_DEBUG_EXCEPTION_HANDLER(errorstream) return NULL; } @@ -179,24 +263,52 @@ Client::Client( IrrlichtDevice *device, const char *playername, std::string password, - MapDrawControl &control): - m_mesh_update_thread(), + MapDrawControl &control, + IWritableTextureSource *tsrc, + IWritableShaderSource *shsrc, + IWritableItemDefManager *itemdef, + IWritableNodeDefManager *nodedef, + ISoundManager *sound, + MtEventManager *event +): + 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, control, + new ClientMap(this, this, control, device->getSceneManager()->getRootSceneNode(), device->getSceneManager(), 666), - device->getSceneManager() + device->getSceneManager(), + tsrc, this, device ), m_con(PROTOCOL_ID, 512, CONNECTION_TIMEOUT, this), m_device(device), - camera_position(0,0,0), - camera_direction(0,0,1), m_server_ser_ver(SER_FMT_VER_INVALID), + m_playeritem(0), m_inventory_updated(false), - m_time_of_day(0), + m_inventory_from_server(NULL), + m_inventory_from_server_age(0.0), + m_animation_time(0), + m_crack_level(-1), + m_crack_pos(0,0,0), m_map_seed(0), m_password(password), - m_access_denied(false) + m_access_denied(false), + m_media_cache(getMediaCacheDir()), + m_media_receive_started(false), + m_media_count(0), + m_media_received_count(0), + m_itemdef_received(false), + m_nodedef_received(false), + m_time_of_day_set(false), + m_last_time_of_day_f(-1), + 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; @@ -205,26 +317,25 @@ Client::Client( m_playerpos_send_timer = 0.0; m_ignore_damage_timer = 0.0; - //m_env_mutex.Init(); - //m_con_mutex.Init(); - - m_mesh_update_thread.Start(); - + // 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."<updateName(playername); m_env.addPlayer(player); - - // Initialize player in the inventory context - m_inventory_context.current_player = player; } + + for (size_t i = 0; i < g_settings->getU16("media_fetch_threads"); ++i) + m_media_fetch_threads.push_back(new MediaFetchThread(this)); } Client::~Client() @@ -237,13 +348,28 @@ Client::~Client() m_mesh_update_thread.setRun(false); while(m_mesh_update_thread.IsRunning()) sleep_ms(100); + + delete m_inventory_from_server; + + // Delete detached inventories + { + for(std::map::iterator + i = m_detached_inventories.begin(); + i != m_detached_inventories.end(); i++){ + delete i->second; + } + } + + for (std::list::iterator i = m_media_fetch_threads.begin(); + i != m_media_fetch_threads.end(); ++i) + delete *i; } void Client::connect(Address address) { DSTACK(__FUNCTION_NAME); //JMutexAutoLock lock(m_con_mutex); //bulk comment-out - m_con.setTimeoutMs(0); + m_con.SetTimeoutMs(0); m_con.Connect(address); } @@ -273,7 +399,13 @@ void Client::step(float dtime) else m_ignore_damage_timer = 0.0; - //dstream<<"Client steps "< 60.0) + m_animation_time -= 60.0; + + m_time_of_day_update_timer += dtime; + + //infostream<<"Client steps "< deleted_blocks; float delete_unused_sectors_timeout = - g_settings.getFloat("client_delete_unused_sectors_timeout"); + g_settings->getFloat("client_delete_unused_sectors_timeout"); // Delete sector blocks /*u32 num = m_env.getMap().unloadUnusedData @@ -343,9 +475,9 @@ void Client::step(float dtime) if(deleted_blocks.size() > 0) { - /*dstream< 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); memset((char*)&data[3], 0, PLAYERNAME_SIZE); snprintf((char*)&data[3], PLAYERNAME_SIZE, "%s", myplayer->getName()); - /*dstream<<"Client: sending initial password hash: \""< deleted_blocks; + ScopeProfiler sp(g_profiler, "Client: map timer and unload"); + std::list deleted_blocks; m_env.getMap().timerUpdate(map_timer_and_unload_dtime, - g_settings.getFloat("client_unload_unused_data_timeout"), + g_settings->getFloat("client_unload_unused_data_timeout"), &deleted_blocks); /*if(deleted_blocks.size() > 0) - dstream<<"Client: Unloaded "<::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()) @@ -486,9 +619,9 @@ 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++; @@ -502,7 +635,7 @@ void Client::step(float dtime) } sendlist.push_back(*i); - i++; + ++i; } } @@ -522,24 +655,6 @@ void Client::step(float dtime) // Step environment m_env.step(dtime); - /* - Handle active blocks - NOTE: These old objects are DEPRECATED. TODO: Remove - */ - for(core::map::Iterator - i = m_active_blocks.getIterator(); - i.atEnd() == false; i++) - { - v3s16 p = i.getNode()->getKey(); - - MapBlock *block = m_env.getMap().getBlockNoCreateNoEx(p); - if(block == NULL) - continue; - - // Step MapBlockObjects - block->stepObjects(dtime, false, m_env.getDayNightRatio()); - } - /* Get events */ @@ -555,7 +670,9 @@ void Client::step(float dtime) 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; @@ -578,8 +695,8 @@ void Client::step(float dtime) counter = 0.0; //JMutexAutoLock lock(m_con_mutex); //bulk comment-out // connectedAndInitialized() is true, peer exists. - con::Peer *peer = m_con.GetPeer(PEER_ID_SERVER); - dstream< 0) + + int num_processed_meshes = 0; + while(!m_mesh_update_thread.m_queue_out.empty()) { + num_processed_meshes++; MeshUpdateResult r = m_mesh_update_thread.m_queue_out.pop_front(); MapBlock *block = m_env.getMap().getBlockNoCreateNoEx(r.p); if(block) { - block->replaceMesh(r.mesh); + //JMutexAutoLock lock(block->mesh_mutex); + + // Delete the old mesh + if(block->mesh != NULL) + { + // TODO: Remove hardware buffers of meshbuffers of block->mesh + delete block->mesh; + block->mesh = NULL; + } + + // Replace with the new mesh + block->mesh = r.mesh; } if(r.ack_block_to_server) { - /*dstream<<"Client: ACK block ("< 0) + g_profiler->graphAdd("num_processed_meshes", num_processed_meshes); + } + + /* + Load fetched media + */ + if (m_media_receive_started) { + bool all_stopped = true; + for (std::list::iterator thread = m_media_fetch_threads.begin(); + thread != m_media_fetch_threads.end(); ++thread) { + all_stopped &= !(*thread)->IsRunning(); + while (!(*thread)->m_file_data.empty()) { + std::pair out = (*thread)->m_file_data.pop_front(); + ++m_media_received_count; + + bool success = loadMedia(out.second, out.first); + if(success){ + verbosestream<<"Client: Loaded received media: " + <<"\""<::iterator n; + n = m_media_name_sha1_map.find(out.first); + if(n == m_media_name_sha1_map.end()) + errorstream<<"The server sent a file that has not " + <<"been announced."< fetch_failed; + for (std::list::iterator thread = m_media_fetch_threads.begin(); + thread != m_media_fetch_threads.end(); ++thread) { + for (std::list::iterator request = (*thread)->m_failed.begin(); + request != (*thread)->m_failed.end(); ++request) + fetch_failed.push_back(*request); + (*thread)->m_failed.clear(); + } + if (fetch_failed.size() > 0) { + infostream << "Failed to remote-fetch " << fetch_failed.size() << " files. " + << "Requesting them the usual way." << std::endl; + request_media(fetch_failed); + } + } + } + + /* + 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 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; + } + } + + /* + 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(0, 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 Irrlicht: " + <<"\""<getFileSystem(); + io::IReadFile *rfile = irrfs->createMemoryReadFile( + *data_rw, data_rw.getSize(), filename.c_str()); + assert(rfile); + + scene::ISceneManager *smgr = m_device->getSceneManager(); + scene::IAnimatedMesh *mesh = smgr->getMesh(rfile); + smgr->getMeshCache()->addMesh(filename.c_str(), mesh); + + return true; } + + errorstream<<"Client: Don't know how to load file \"" + <id=" + infostream<<"Client::peerAdded(): peer->id=" <id< &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<name); + } + + // 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 media request list to server (" + < start_ms + 100) + break; + try{ Receive(); + g_profiler->graphAdd("client_received_packets", 1); } catch(con::NoIncomingDataException &e) { @@ -670,7 +1056,7 @@ void Client::ReceiveAll() } catch(con::InvalidIncomingDataException &e) { - dout_client<= 2+1+6+8+4) + { + // Get map seed + m_recommended_send_interval = readF1000(&data[2+1+6+8]); + infostream<<"Client: received recommended send interval " + <deSerialize(istr, ser_version); + //infostream<<"Updating"<deSerialize(istr, ser_version, false); } else { /* Create a new block */ - //dstream<<"Creating new"<deSerialize(istr, ser_version); + //infostream<<"Creating new"<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 @@ -929,232 +1301,12 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id) m_con.Send(PEER_ID_SERVER, 1, reply, true); #endif - /* - Update Mesh of this block and blocks at x-, y- and z-. - Environment should not be locked as it interlocks with the - main thread, from which is will want to retrieve textures. - */ - - //m_env.getClientMap().updateMeshes(block->getPos(), getDayNightRatio()); /* Add it to mesh update queue and set it to be acknowledged after update. */ - //std::cerr<<"Adding mesh update task for received block"<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]); - /*dstream<<"Client: got " - <<"pitch_i="< players_alive; - for(u32 i=0; iupdateName((char*)&data[start+2]); - - start += item_size; - } - - /* - Remove those players from the environment that - weren't listed by the server. - */ - //dstream< players = m_env.getPlayers(); - core::list::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) - { - dstream<::Iterator i; - for(i=players_alive.begin(); i!=players_alive.end(); i++) - { - if((*ip)->peer_id == *i) - { - is_alive = true; - break; - } - } - /*dstream<peer_id) - <<" is_alive="<peer_id - <peer_id); - } - } //envlock - } - else if(command == TOCLIENT_SECTORMETA) - { - dstream<<"Client received DEPRECATED TOCLIENT_SECTORMETA"<inventory.print(dstream); + 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:"<inventory.print(infostream); } } - //DEBUG - else if(command == TOCLIENT_OBJECTDATA) - //else if(0) + else if(command == TOCLIENT_TIME_OF_DAY) { - // Strip command word and create a stringstream - std::string datastring((char*)&data[2], datasize-2); - std::istringstream is(datastring, std::ios_base::binary); + if(datasize < 4) + return; - { //envlock + u16 time_of_day = readU16(&data[2]); + time_of_day = time_of_day % 24000; + //infostream<<"Client: time_of_day="<= 2 + 2 + 4){ + time_speed = readF1000(&data[4]); + } else { + // Old message; try to approximate speed of time by ourselves + float time_of_day_f = (float)time_of_day / 24000.0; + float tod_diff_f = 0; + if(time_of_day_f < 0.2 && m_last_time_of_day_f > 0.8) + tod_diff_f = time_of_day_f - m_last_time_of_day_f + 1.0; + else + tod_diff_f = time_of_day_f - m_last_time_of_day_f; + m_last_time_of_day_f = time_of_day_f; + float time_diff = m_time_of_day_update_timer; + m_time_of_day_update_timer = 0; + if(m_time_of_day_set){ + time_speed = 3600.0*24.0 * tod_diff_f / time_diff; + infostream<<"Client: Measured time_of_day speed (old format): " + <updateObjects(is, m_server_ser_ver, - m_device->getSceneManager(), m_env.getDayNightRatio()); - } - - /*dstream<<"Final delete queue size: "<::Iterator - i = abs_to_delete.getIterator(); - i.atEnd() == false; i++) - { - v3s16 p = i.getNode()->getKey(); - try - { - MapBlock *block = m_env.getMap().getBlockNoCreate(p); - - // Clear objects - block->clearObjects(); - // Remove from active blocks list - m_active_blocks.remove(p); - } - catch(InvalidPositionException &e) - { - dstream<<"WARNAING: Client: " - <<"Couldn't clear objects of active->inactive" - <<" block " - <<"("<getBool("enable_experimental")) { /* u16 command @@ -1464,7 +1473,7 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id) } else if(command == TOCLIENT_ACTIVE_OBJECT_MESSAGES) { - //if(g_settings.getBool("enable_experimental")) + //if(g_settings->getBool("enable_experimental")) { /* u16 command @@ -1505,14 +1514,44 @@ 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); std::istringstream is(datastring, std::ios_base::binary); Player *player = m_env.getLocalPlayer(); assert(player != NULL); + u8 oldhp = player->hp; u8 hp = readU8(is); player->hp = hp; + + if(hp < oldhp) + { + // Add to ClientEvent queue + ClientEvent event; + event.type = CE_PLAYER_DAMAGE; + event.player_damage.amount = oldhp - hp; + m_client_event_queue.push_back(event); + } } else if(command == TOCLIENT_MOVE_PLAYER) { @@ -1527,7 +1566,7 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id) /*player->setPitch(pitch); player->setYaw(yaw);*/ - dstream<<"Client got TOCLIENT_MOVE_PLAYER" + infostream<<"Client got TOCLIENT_MOVE_PLAYER" <<" pos=("< file_requests; + + for(int i=0; i::iterator cur = m_media_fetch_threads.begin(); + for(std::list::iterator i = file_requests.begin(); + i != file_requests.end(); ++i) { + (*cur)->m_file_requests.push_back(*i); + cur++; + if (cur == m_media_fetch_threads.end()) + cur = m_media_fetch_threads.begin(); + } + for (std::list::iterator i = m_media_fetch_threads.begin(); + i != m_media_fetch_threads.end(); ++i) { + (*i)->m_remote_url = remote_media; + (*i)->Start(); + } + #endif + + // notify server we received everything + std::ostringstream os(std::ios_base::binary); + writeU16(os, TOSERVER_RECEIVED_MEDIA); + std::string s = os.str(); + SharedBuffer data((u8*)s.c_str(), s.size()); + // Send as reliable + Send(0, data, true); + } + ClientEvent event; + event.type = CE_TEXTURES_UPDATED; + m_client_event_queue.push_back(event); + } + else if(command == TOCLIENT_MEDIA) + { + if (m_media_count == 0) + return; + 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 file bunches + u16 index of this bunch + u32 number of files in this bunch + for each file { + u16 length of name + string name + u32 length of data + data + } + */ + int num_bunches = readU16(is); + int bunch_i = readU16(is); + int num_files = readU32(is); + infostream<<"Client: Received files: bunch "<isLocal()) { - dout_client<inventory.getList("main"); - std::string itemstring(deSerializeString(is)); - if (itemstring.empty()) { - inv->deleteItem(0); - dout_client<changeItem(0, InventoryItem::deSerialize(iss)); - dout_client<getWieldItem()->serialize(dout_client); - dout_client<::iterator n; + n = m_media_name_sha1_map.find(name); + if(n == m_media_name_sha1_map.end()) + errorstream<<"The server sent a file that has not " + <<"been announced."<deSerialize(tmp_is2); + m_nodedef_received = true; + } + else if(command == TOCLIENT_CRAFTITEMDEF) + { + infostream<<"Client: WARNING: Ignoring TOCLIENT_CRAFTITEMDEF"<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); + + 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.add_particlespawner.collisiondetection = + collisiondetection; + 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); + + 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.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 { - dout_client< data, bool reliable) 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){ - dout_client< 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); -} + writeU16(os, TOSERVER_INTERACT); + writeU8(os, action); + writeU16(os, getPlayerItem()); + std::ostringstream tmp_os(std::ios::binary); + pointed.serialize(tmp_os); + os< data(datasize); - writeU16(&data[0], TOSERVER_CLICK_OBJECT); - writeU8(&data[2], button); - writeV3S16(&data[3], blockpos); - writeS16(&data[9], id); - writeU16(&data[11], item); - Send(0, data, true); -} + std::string s = os.str(); + SharedBuffer data((u8*)s.c_str(), s.size()); -void Client::clickActiveObject(u8 button, u16 id, u16 item) -{ - if(connectedAndInitialized() == false){ - dout_client< data(datasize); - writeU16(&data[0], TOSERVER_CLICK_ACTIVEOBJECT); - writeU8(&data[2], button); - writeU16(&data[3], id); - writeU16(&data[5], item); + // Send as reliable Send(0, data, true); } -void Client::sendSignText(v3s16 blockpos, s16 id, std::string text) +void Client::sendNodemetaFields(v3s16 p, const std::string &formname, + const std::map &fields) { - /* - u16 command - v3s16 blockpos - s16 id - u16 textlen - textdata - */ std::ostringstream os(std::ios_base::binary); - u8 buf[12]; - - // Write command - writeU16(buf, TOSERVER_SIGNTEXT); - os.write((char*)buf, 2); - - // Write blockpos - writeV3S16(buf, blockpos); - os.write((char*)buf, 6); - - // Write id - writeS16(buf, id); - os.write((char*)buf, 2); - 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()); @@ -1726,40 +2094,29 @@ void Client::sendSignText(v3s16 blockpos, s16 id, std::string text) Send(0, data, true); } -void Client::sendSignNodeText(v3s16 p, std::string text) +void Client::sendInventoryFields(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_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); @@ -1858,14 +2215,42 @@ void Client::sendDamage(u8 damage) Send(0, data, true); } +void Client::sendRespawn() +{ + DSTACK(__FUNCTION_NAME); + std::ostringstream os(std::ios_base::binary); + + writeU16(os, TOSERVER_RESPAWN); + + // 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::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 @@ -1884,7 +2269,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 @@ -1892,15 +2277,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); - + writeS32(&data[2+12+12+4], yaw); + writeU32(&data[2+12+12+4+4], keyPressed); // Send as unreliable Send(0, data, false); } @@ -1929,9 +2314,7 @@ void Client::sendPlayerItem(u16 item) void Client::removeNode(v3s16 p) { - //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out - - core::map modified_blocks; + std::map modified_blocks; try { @@ -1942,73 +2325,39 @@ void Client::removeNode(v3s16 p) { } - for(core::map::Iterator - i = modified_blocks.getIterator(); - i.atEnd() == false; i++) + // add urgent task to update the modified node + addUpdateMeshTaskForNode(p, false, true); + + for(std::map::iterator + i = modified_blocks.begin(); + i != modified_blocks.end(); ++i) { - v3s16 p = i.getNode()->getKey(); - //m_env.getClientMap().updateMeshes(p, m_env.getDayNightRatio()); - addUpdateMeshTaskWithEdge(p); + addUpdateMeshTaskWithEdge(i->first); } } void Client::addNode(v3s16 p, MapNode n) { - //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out - TimeTaker timer1("Client::addNode()"); - core::map modified_blocks; + std::map modified_blocks; 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) {} - //TimeTaker timer2("Client::addNode(): updateMeshes"); - - 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(); - //m_env.getClientMap().updateMeshes(p, m_env.getDayNightRatio()); - addUpdateMeshTaskWithEdge(p); + addUpdateMeshTaskWithEdge(i->first); } } -void Client::updateCamera(v3f pos, v3f dir) -{ - m_env.getClientMap().updateCamera(pos, dir); - camera_position = pos; - camera_direction = dir; -} - -MapNode Client::getNode(v3s16 p) -{ - //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out - return m_env.getMap().getNode(p); -} - -NodeMetadata* Client::getNodeMetadata(v3s16 p) -{ - return m_env.getMap().getNodeMetadata(p); -} - -v3f Client::getPlayerPosition(v3f *eye_position) -{ - //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out - LocalPlayer *player = m_env.getLocalPlayer(); - assert(player != NULL); - if (eye_position) - *eye_position = player->getEyePosition(); - return player->getPosition(); -} - void Client::setPlayerControl(PlayerControl &control) { //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out @@ -2019,11 +2368,9 @@ void Client::setPlayerControl(PlayerControl &control) 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); } @@ -2047,107 +2394,58 @@ void Client::getLocalInventory(Inventory &dst) dst = player->inventory; } -InventoryContext *Client::getInventoryContext() -{ - return &m_inventory_context; -} - -Inventory* Client::getInventory(InventoryContext *c, std::string id) +Inventory* Client::getInventory(const InventoryLocation &loc) { - 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(); - dstream<<"nodemeta at ("<inventory; + } + break; + case InventoryLocation::NODEMETA: + { + NodeMetadata *meta = m_env.getMap().getNodeMetadata(loc.p); + if(!meta) + return NULL; + 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); + } return NULL; } void Client::inventoryAction(InventoryAction *a) { + /* + Send it to the server + */ sendInventoryAction(a); -} - -MapBlockObject * Client::getSelectedObject( - f32 max_d, - v3f from_pos_f_on_map, - core::line3d shootline_on_map - ) -{ - //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out - - core::array objects; - - for(core::map::Iterator - i = m_active_blocks.getIterator(); - i.atEnd() == false; i++) - { - v3s16 p = i.getNode()->getKey(); - - MapBlock *block = NULL; - try - { - block = m_env.getMap().getBlockNoCreate(p); - } - catch(InvalidPositionException &e) - { - continue; - } - - // Calculate from_pos relative to block - v3s16 block_pos_i_on_map = block->getPosRelative(); - v3f block_pos_f_on_map = intToFloat(block_pos_i_on_map, BS); - v3f from_pos_f_on_block = from_pos_f_on_map - block_pos_f_on_map; - - block->getObjects(from_pos_f_on_block, max_d, objects); - //block->getPseudoObjects(from_pos_f_on_block, max_d, objects); - } - - //dstream<<"Collected "<getBlock(); - // Calculate shootline relative to block - v3s16 block_pos_i_on_map = block->getPosRelative(); - v3f block_pos_f_on_map = intToFloat(block_pos_i_on_map, BS); - core::line3d shootline_on_block( - shootline_on_map.start - block_pos_f_on_map, - shootline_on_map.end - block_pos_f_on_map - ); - - if(obj->isSelected(shootline_on_block)) - { - //dstream<<"Returning selected object"<clientApply(this, this); } ClientActiveObject * Client::getSelectedActiveObject( @@ -2156,15 +2454,15 @@ 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); - //dstream<<"Collected "< affected_blocks; - ((ClientMap&)m_env.getMap()).clearTempMod(p, - &affected_blocks); + // Send to others + sendChatMessage(message); - for(core::map::Iterator - i = affected_blocks.getIterator(); - i.atEnd() == false; i++) + // Show locally + if (message[0] == L'/') + { + m_chat_queue.push_back( + (std::wstring)L"issued command: "+message); + } + else { - i.getNode()->getValue()->updateMesh(m_env.getDayNightRatio()); + LocalPlayer *player = m_env.getLocalPlayer(); + assert(player != NULL); + std::wstring name = narrow_to_wide(player->getName()); + m_chat_queue.push_back( + (std::wstring)L"<"+name+L"> "+message); } } -void Client::addUpdateMeshTask(v3s16 p, bool ack_to_server) +void Client::addUpdateMeshTask(v3s16 p, bool ack_to_server, bool urgent) { - /*dstream<<"Client::addUpdateMeshTask(): " + /*infostream<<"Client::addUpdateMeshTask(): " <<"("<fill(getDayNightRatio(), b); + data->fill(b); + data->setCrack(m_crack_level, m_crack_pos); + data->setSmoothLighting(g_settings->getBool("smooth_lighting")); } // Debug wait //while(m_mesh_update_thread.m_queue_in.size() > 0) sleep_ms(10); // Add task to queue - m_mesh_update_thread.m_queue_in.addBlock(p, data, ack_to_server); + m_mesh_update_thread.m_queue_in.addBlock(p, data, ack_to_server, urgent); - /*dstream<<"Mesh update input queue size is " + /*infostream<<"Mesh update input queue size is " <replaceMesh(mesh_new); - delete data; - } -#endif - - /* - Mark mesh as non-expired at this point so that it can already - be marked as expired again if the data changes - */ - b->setMeshExpired(false); } -void Client::addUpdateMeshTaskWithEdge(v3s16 blockpos, bool ack_to_server) +void Client::addUpdateMeshTaskWithEdge(v3s16 blockpos, bool ack_to_server, bool urgent) { /*{ v3s16 p = blockpos; - dstream<<"Client::addUpdateMeshTaskWithEdge(): " + infostream<<"Client::addUpdateMeshTaskWithEdge(): " <<"("<rebuildImagesAndTextures(); + + // Update texture atlas + infostream<<"- Updating texture atlas"<getBool("enable_texture_atlas")) + m_tsrc->buildMainAtlas(this); + + // Rebuild shaders + m_shsrc->rebuildShaders(); + + // Update node aliases + infostream<<"- Updating node aliases"<updateAliases(m_itemdef); + + // Update node textures + infostream<<"- Updating node textures"<updateTextures(m_tsrc); + + // 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(); + 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); + } + } + + // Start mesh update thread after setting up content definitions + infostream<<"- Starting mesh update thread"<