/*
-Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU Lesser General Public License as published by
#include "client.h"
#include <iostream>
#include "clientserver.h"
-#include "jmutexautolock.h"
+#include "jthread/jmutexautolock.h"
#include "main.h"
#include <sstream>
+#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 <IFileSystem.h>
#include "sha1.h"
#include "base64.h"
#include "hex.h"
#include "IMeshCache.h"
#include "util/serialize.h"
+#include "config.h"
+#include "util/directiontables.h"
+
+#if USE_CURL
+#include <curl/curl.h>
+#endif
static std::string getMediaCacheDir()
{
return porting::path_user + DIR_DELIM + "cache" + DIR_DELIM + "media";
}
-struct MediaRequest
-{
- std::string name;
-
- MediaRequest(const std::string &name_=""):
- name(name_)
- {}
-};
-
/*
QueuedMeshUpdate
*/
return NULL;
}
+void * MediaFetchThread::Thread()
+{
+ ThreadStarted();
+
+ log_register_thread("MediaFetchThread");
+
+ DSTACK(__FUNCTION_NAME);
+
+ BEGIN_DEBUG_EXCEPTION_HANDLER
+
+ #if USE_CURL
+ CURL *curl;
+ CURLcode res;
+ for (std::list<MediaRequest>::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 << " (" << curl_easy_strerror(res) << ")"<< std::endl;
+ }
+ curl_easy_cleanup(curl);
+ }
+ #endif
+
+ END_DEBUG_EXCEPTION_HANDLER(errorstream)
+
+ return NULL;
+}
+
Client::Client(
IrrlichtDevice *device,
const char *playername,
std::string password,
MapDrawControl &control,
IWritableTextureSource *tsrc,
+ IWritableShaderSource *shsrc,
IWritableItemDefManager *itemdef,
IWritableNodeDefManager *nodedef,
ISoundManager *sound,
- MtEventManager *event
+ MtEventManager *event,
+ bool ipv6
):
m_tsrc(tsrc),
+ m_shsrc(shsrc),
m_itemdef(itemdef),
m_nodedef(nodedef),
m_sound(sound),
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),
m_password(password),
m_access_denied(false),
m_media_cache(getMediaCacheDir()),
- m_media_receive_progress(0),
- m_media_received(false),
+ 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_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."<<std::endl;
-
/*
Add local player
*/
m_env.addPlayer(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()
m_mesh_update_thread.setRun(false);
while(m_mesh_update_thread.IsRunning())
sleep_ms(100);
+ while(!m_mesh_update_thread.m_queue_out.empty()) {
+ MeshUpdateResult r = m_mesh_update_thread.m_queue_out.pop_front();
+ delete r.mesh;
+ }
+
delete m_inventory_from_server;
delete i->second;
}
}
+
+ for (std::list<MediaFetchThread*>::iterator i = m_media_fetch_threads.begin();
+ i != m_media_fetch_threads.end(); ++i)
+ delete *i;
+
+ // 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)
// 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 minimum supported network protocol version (added sometime)
// [53] u16 maximum supported network protocol version (added later than the previous one)
SharedBuffer<u8> 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());
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<v3s16> deleted_blocks;
+ std::list<v3s16> deleted_blocks;
m_env.getMap().timerUpdate(map_timer_and_unload_dtime,
g_settings->getFloat("client_unload_unused_data_timeout"),
&deleted_blocks);
NOTE: This loop is intentionally iterated the way it is.
*/
- core::list<v3s16>::Iterator i = deleted_blocks.begin();
- core::list<v3s16> sendlist;
+ std::list<v3s16>::iterator i = deleted_blocks.begin();
+ std::list<v3s16> sendlist;
for(;;)
{
if(sendlist.size() == 255 || i == deleted_blocks.end())
writeU16(&reply[0], TOSERVER_DELETEDBLOCKS);
reply[2] = sendlist.size();
u32 k = 0;
- for(core::list<v3s16>::Iterator
+ for(std::list<v3s16>::iterator
j = sendlist.begin();
- j != sendlist.end(); j++)
+ j != sendlist.end(); ++j)
{
writeV3S16(&reply[2+1+6*k], *j);
k++;
}
sendlist.push_back(*i);
- i++;
+ ++i;
}
}
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
*/
{
float &counter = m_playerpos_send_timer;
counter += dtime;
- if(counter >= 0.2)
+ if(counter >= m_recommended_send_interval)
{
counter = 0.0;
sendPlayerPos();
<<std::endl;*/
int num_processed_meshes = 0;
- while(m_mesh_update_thread.m_queue_out.size() > 0)
+ while(!m_mesh_update_thread.m_queue_out.empty())
{
num_processed_meshes++;
MeshUpdateResult r = m_mesh_update_thread.m_queue_out.pop_front();
// Replace with the new mesh
block->mesh = r.mesh;
+ } else {
+ delete r.mesh;
}
if(r.ack_block_to_server)
{
g_profiler->graphAdd("num_processed_meshes", num_processed_meshes);
}
+ /*
+ Load fetched media
+ */
+ if (m_media_receive_started) {
+ bool all_stopped = true;
+ for (std::list<MediaFetchThread*>::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 <std::string, std::string> out = (*thread)->m_file_data.pop_front();
+ if(m_media_received_count < m_media_count)
+ m_media_received_count++;
+
+ bool success = loadMedia(out.second, out.first);
+ if(success){
+ verbosestream<<"Client: Loaded received media: "
+ <<"\""<<out.first<<"\". Caching."<<std::endl;
+ } else{
+ infostream<<"Client: Failed to load received media: "
+ <<"\""<<out.first<<"\". Not caching."<<std::endl;
+ continue;
+ }
+
+ bool did = fs::CreateAllDirs(getMediaCacheDir());
+ if(!did){
+ errorstream<<"Could not create media cache directory"
+ <<std::endl;
+ }
+
+ {
+ std::map<std::string, std::string>::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."<<std::endl;
+ else
+ m_media_cache.update_sha1(out.second);
+ }
+ }
+ }
+ if (all_stopped) {
+ std::list<MediaRequest> fetch_failed;
+ for (std::list<MediaFetchThread*>::iterator thread = m_media_fetch_threads.begin();
+ thread != m_media_fetch_threads.end(); ++thread) {
+ for (std::list<MediaRequest>::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
{
verbosestream<<"Client: Storing model into Irrlicht: "
<<"\""<<filename<<"\""<<std::endl;
+ scene::ISceneManager *smgr = m_device->getSceneManager();
+
+ //check if mesh was already cached
+ scene::IAnimatedMesh *mesh =
+ smgr->getMeshCache()->getMeshByName(filename.c_str());
+
+ if (mesh != NULL) {
+ errorstream << "Multiple models with name: " << filename.c_str() <<
+ " found replacing previous model!" << std::endl;
+
+ smgr->getMeshCache()->removeMesh(mesh);
+ mesh = 0;
+ }
io::IFileSystem *irrfs = m_device->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);
+ mesh = smgr->getMesh(rfile);
smgr->getMeshCache()->addMesh(filename.c_str(), mesh);
-
+ rfile->drop();
return true;
}
<<"(timeout="<<timeout<<")"<<std::endl;
}
+/*
+ u16 command
+ u16 number of files requested
+ for each file {
+ u16 length of name
+ string name
+ }
+*/
+void Client::request_media(const std::list<MediaRequest> &file_requests)
+{
+ std::ostringstream os(std::ios_base::binary);
+ writeU16(os, TOSERVER_REQUEST_MEDIA);
+ writeU16(os, file_requests.size());
+
+ for(std::list<MediaRequest>::const_iterator i = file_requests.begin();
+ i != file_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 media request list to server ("
+ <<file_requests.size()<<" files)"<<std::endl;
+}
+
void Client::ReceiveAll()
{
DSTACK(__FUNCTION_NAME);
infostream<<"Client: TOCLIENT_INIT received with "
"deployed="<<((int)deployed&0xff)<<std::endl;
- if(deployed < SER_FMT_VER_LOWEST
- || deployed > SER_FMT_VER_HIGHEST)
+ if(!ser_ver_supported(deployed))
{
infostream<<"Client: TOCLIENT_INIT: Server sent "
<<"unsupported ser_fmt_ver"<<std::endl;
m_map_seed = readU64(&data[2+1+6]);
infostream<<"Client: received map seed: "<<m_map_seed<<std::endl;
}
+
+ if(datasize >= 2+1+6+8+4)
+ {
+ // Get map seed
+ m_recommended_send_interval = readF1000(&data[2+1+6+8]);
+ infostream<<"Client: received recommended send interval "
+ <<m_recommended_send_interval<<std::endl;
+ }
// Reply to server
u32 replysize = 2;
*/
//infostream<<"Updating"<<std::endl;
block->deSerialize(istr, ser_version, false);
+ block->deSerializeNetworkSpecific(istr);
}
else
{
//infostream<<"Creating new"<<std::endl;
block = new MapBlock(&m_env.getMap(), p, this);
block->deSerialize(istr, ser_version, false);
+ block->deSerializeNetworkSpecific(istr);
sector->insertBlock(block);
}
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);
}
}
}
+ 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);
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);
int num_files = readU16(is);
- verbosestream<<"Client received TOCLIENT_ANNOUNCE_MEDIA ("
- <<num_files<<" files)"<<std::endl;
+ infostream<<"Client: Received media announcement: packet size: "
+ <<datasize<<std::endl;
- core::list<MediaRequest> file_requests;
+ std::list<MediaRequest> file_requests;
for(int i=0; i<num_files; i++)
{
std::string sha1_hex = hex_encode(sha1_raw);
std::ostringstream tmp_os(std::ios_base::binary);
bool found_in_cache = m_media_cache.load_sha1(sha1_raw, tmp_os);
- m_media_name_sha1_map.set(name, sha1_raw);
+ m_media_name_sha1_map[name] = sha1_raw;
// If found in cache, try to load it from there
if(found_in_cache)
file_requests.push_back(MediaRequest(name));
}
- ClientEvent event;
- event.type = CE_TEXTURES_UPDATED;
- m_client_event_queue.push_back(event);
+ std::string remote_media = "";
+ try {
+ remote_media = deSerializeString(is);
+ }
+ catch(SerializationError) {
+ // not supported by server or turned off
+ }
- /*
- u16 command
- u16 number of files requested
- for each file {
- u16 length of name
- string name
+ m_media_count = file_requests.size();
+ m_media_receive_started = true;
+
+ if (remote_media == "" || !USE_CURL) {
+ request_media(file_requests);
+ } else {
+ #if USE_CURL
+ std::list<MediaFetchThread*>::iterator cur = m_media_fetch_threads.begin();
+ for(std::list<MediaRequest>::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();
}
- */
- std::ostringstream os(std::ios_base::binary);
- writeU16(os, TOSERVER_REQUEST_MEDIA);
- writeU16(os, file_requests.size());
+ for (std::list<MediaFetchThread*>::iterator i = m_media_fetch_threads.begin();
+ i != m_media_fetch_threads.end(); ++i) {
+ (*i)->m_remote_url = remote_media;
+ (*i)->Start();
+ }
+ #endif
- for(core::list<MediaRequest>::Iterator i = file_requests.begin();
- i != file_requests.end(); i++) {
- os<<serializeString(i->name);
+ // notify server we received everything
+ std::ostringstream os(std::ios_base::binary);
+ writeU16(os, TOSERVER_RECEIVED_MEDIA);
+ std::string s = os.str();
+ SharedBuffer<u8> data((u8*)s.c_str(), s.size());
+ // Send as reliable
+ Send(0, data, true);
}
-
- // 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 media request list to server ("
- <<file_requests.size()<<" files)"<<std::endl;
+ ClientEvent event;
+ event.type = CE_TEXTURES_UPDATED;
+ m_client_event_queue.push_back(event);
}
else if(command == TOCLIENT_MEDIA)
{
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
*/
int num_bunches = readU16(is);
int bunch_i = readU16(is);
- if(num_bunches >= 2)
- m_media_receive_progress = (float)bunch_i / (float)(num_bunches - 1);
- else
- m_media_receive_progress = 1.0;
- if(bunch_i == num_bunches - 1)
- m_media_received = true;
- int num_files = readU32(is);
+ u32 num_files = readU32(is);
infostream<<"Client: Received files: bunch "<<bunch_i<<"/"
<<num_bunches<<" files="<<num_files
<<" size="<<datasize<<std::endl;
- for(int i=0; i<num_files; i++){
+
+ // Check total and received media count
+ assert(m_media_received_count <= m_media_count);
+ if (num_files > m_media_count - m_media_received_count) {
+ errorstream<<"Client: Received more files than requested:"
+ <<" total count="<<m_media_count
+ <<" total received="<<m_media_received_count
+ <<" bunch "<<bunch_i<<"/"<<num_bunches
+ <<" files="<<num_files
+ <<" size="<<datasize<<std::endl;
+ num_files = m_media_count - m_media_received_count;
+ }
+ if (num_files == 0)
+ return;
+
+ // Mesh update thread must be stopped while
+ // updating content definitions
+ assert(!m_mesh_update_thread.IsRunning());
+
+ for(u32 i=0; i<num_files; i++){
+ assert(m_media_received_count < m_media_count);
+ m_media_received_count++;
std::string name = deSerializeString(is);
std::string data = deSerializeLongString(is);
}
{
- core::map<std::string, std::string>::Node *n;
+ std::map<std::string, std::string>::iterator n;
n = m_media_name_sha1_map.find(name);
- if(n == NULL)
+ if(n == m_media_name_sha1_map.end())
errorstream<<"The server sent a file that has not "
<<"been announced."<<std::endl;
else
}
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.spawn_particle.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 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);
+
+ 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);
+ 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;
+ 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
+ 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.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
{
infostream<<"Client: Ignoring unknown command "
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<u8> data((u8*)s.c_str(), s.size());
+ // Send as reliable
+ Send(0, data, true);
+}
+
void Client::sendRespawn()
{
DSTACK(__FUNCTION_NAME);
{
//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
void Client::removeNode(v3s16 p)
{
- core::map<v3s16, MapBlock*> modified_blocks;
+ std::map<v3s16, MapBlock*> modified_blocks;
try
{
// add urgent task to update the modified node
addUpdateMeshTaskForNode(p, false, true);
- for(core::map<v3s16, MapBlock * >::Iterator
- i = modified_blocks.getIterator();
- i.atEnd() == false; i++)
+ for(std::map<v3s16, MapBlock * >::iterator
+ i = modified_blocks.begin();
+ i != modified_blocks.end(); ++i)
{
- v3s16 p = i.getNode()->getKey();
- addUpdateMeshTaskWithEdge(p);
+ addUpdateMeshTaskWithEdge(i->first);
}
}
{
TimeTaker timer1("Client::addNode()");
- core::map<v3s16, MapBlock*> modified_blocks;
+ std::map<v3s16, MapBlock*> modified_blocks;
try
{
catch(InvalidPositionException &e)
{}
- for(core::map<v3s16, MapBlock * >::Iterator
- i = modified_blocks.getIterator();
- i.atEnd() == false; i++)
+ for(std::map<v3s16, MapBlock * >::iterator
+ i = modified_blocks.begin();
+ i != modified_blocks.end(); ++i)
{
- v3s16 p = i.getNode()->getKey();
- addUpdateMeshTaskWithEdge(p);
+ addUpdateMeshTaskWithEdge(i->first);
}
}
Predict some local inventory changes
*/
a->clientApply(this, this);
+
+ // Remove it
+ delete a;
}
ClientActiveObject * Client::getSelectedActiveObject(
core::line3d<f32> shootline_on_map
)
{
- core::array<DistanceSortedActiveObject> objects;
+ std::vector<DistanceSortedActiveObject> objects;
m_env.getActiveObjects(from_pos_f_on_map, max_d, objects);
// 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<objects.size(); i++)
{
<<std::endl;*/
}
-core::list<std::wstring> Client::getConnectedPlayerNames()
+std::list<std::string> Client::getConnectedPlayerNames()
{
- core::list<Player*> players = m_env.getPlayers(true);
- core::list<std::wstring> playerNames;
- for(core::list<Player*>::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()
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)
}
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)
return m_client_event_queue.pop_front();
}
-void Client::afterContentReceived()
+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)
{
- verbosestream<<"Client::afterContentReceived() started"<<std::endl;
+ infostream<<"Client::afterContentReceived() started"<<std::endl;
assert(m_itemdef_received);
assert(m_nodedef_received);
- assert(m_media_received);
+ assert(texturesReceived());
// remove the information about which checksum each texture
// ought to have
m_media_name_sha1_map.clear();
// Rebuild inherited images and recreate textures
- verbosestream<<"Rebuilding images and textures"<<std::endl;
+ infostream<<"- Rebuilding images and textures"<<std::endl;
m_tsrc->rebuildImagesAndTextures();
- // Update texture atlas
- verbosestream<<"Updating texture atlas"<<std::endl;
- if(g_settings->getBool("enable_texture_atlas"))
- m_tsrc->buildMainAtlas(this);
+ // Rebuild shaders
+ infostream<<"- Rebuilding shaders"<<std::endl;
+ m_shsrc->rebuildShaders();
// Update node aliases
- verbosestream<<"Updating node aliases"<<std::endl;
+ infostream<<"- Updating node aliases"<<std::endl;
m_nodedef->updateAliases(m_itemdef);
// Update node textures
- verbosestream<<"Updating node textures"<<std::endl;
+ infostream<<"- Updating node textures"<<std::endl;
m_nodedef->updateTextures(m_tsrc);
- // Update item textures and meshes
- verbosestream<<"Updating item textures and meshes"<<std::endl;
- 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"<<std::endl;
+ wchar_t* text = wgettext("Item textures...");
+ draw_load_screen(text,device,font,0,0);
+ std::set<std::string> names = m_itemdef->getAll();
+ size_t size = names.size();
+ size_t count = 0;
+ int percent = 0;
+ for(std::set<std::string>::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
- verbosestream<<"Starting mesh update thread"<<std::endl;
+ infostream<<"- Starting mesh update thread"<<std::endl;
m_mesh_update_thread.Start();
- verbosestream<<"Client::afterContentReceived() done"<<std::endl;
+ infostream<<"Client::afterContentReceived() done"<<std::endl;
}
float Client::getRTT(void)
{
return m_tsrc;
}
+IShaderSource* Client::getShaderSource()
+{
+ return m_shsrc;
+}
u16 Client::allocateUnknownNodeId(const std::string &name)
{
errorstream<<"Client::allocateUnknownNodeId(): "