X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;ds=sidebyside;f=src%2Fclient.cpp;h=c40c9e5136db6eff9f450fca75c84cfbfca2d296;hb=3f58028d3198e77ce26d09680f0a637188610871;hp=513be6d4b20ece9b9d974e1e7cbd31608debdb7e;hpb=2990f5d90bd556684c07d60872a707e649bd71ee;p=dragonfireclient.git diff --git a/src/client.cpp b/src/client.cpp index 513be6d4b..c40c9e513 100644 --- a/src/client.cpp +++ b/src/client.cpp @@ -25,25 +25,151 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "main.h" #include #include "porting.h" +#include "mapsector.h" +#include "mapblock_mesh.h" +#include "mapblock.h" +#include "settings.h" +#include "profiler.h" -void * ClientUpdateThread::Thread() +/* + QueuedMeshUpdate +*/ + +QueuedMeshUpdate::QueuedMeshUpdate(): + p(-1337,-1337,-1337), + data(NULL), + ack_block_to_server(false) +{ +} + +QueuedMeshUpdate::~QueuedMeshUpdate() +{ + if(data) + delete data; +} + +/* + MeshUpdateQueue +*/ + +MeshUpdateQueue::MeshUpdateQueue() +{ + m_mutex.Init(); +} + +MeshUpdateQueue::~MeshUpdateQueue() +{ + JMutexAutoLock lock(m_mutex); + + core::list::Iterator i; + for(i=m_queue.begin(); i!=m_queue.end(); i++) + { + QueuedMeshUpdate *q = *i; + delete q; + } +} + +/* + peer_id=0 adds with nobody to send to +*/ +void MeshUpdateQueue::addBlock(v3s16 p, MeshMakeData *data, bool ack_block_to_server) +{ + DSTACK(__FUNCTION_NAME); + + assert(data); + + JMutexAutoLock lock(m_mutex); + + /* + 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++) + { + QueuedMeshUpdate *q = *i; + if(q->p == p) + { + if(q->data) + delete q->data; + q->data = data; + if(ack_block_to_server) + q->ack_block_to_server = true; + return; + } + } + + /* + Add the block + */ + QueuedMeshUpdate *q = new QueuedMeshUpdate; + q->p = p; + q->data = data; + q->ack_block_to_server = ack_block_to_server; + m_queue.push_back(q); +} + +// Returned pointer must be deleted +// Returns NULL if queue is empty +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; +} + +/* + MeshUpdateThread +*/ + +void * MeshUpdateThread::Thread() { ThreadStarted(); DSTACK(__FUNCTION_NAME); BEGIN_DEBUG_EXCEPTION_HANDLER - + while(getRun()) { - m_client->asyncStep(); + /*// Wait for output queue to flush. + // Allow 2 in queue, this makes less frametime jitter. + // Umm actually, there is no much difference + if(m_queue_out.size() >= 2) + { + sleep_ms(3); + continue; + }*/ + + QueuedMeshUpdate *q = m_queue_in.pop(); + if(q == NULL) + { + sleep_ms(3); + continue; + } + + ScopeProfiler sp(g_profiler, "mesh make"); - //m_client->updateSomeExpiredMeshes(); + scene::SMesh *mesh_new = NULL; + mesh_new = makeMapBlockMesh(q->data); - bool was = m_client->AsyncProcessData(); + MeshUpdateResult r; + r.p = q->p; + r.mesh = mesh_new; + r.ack_block_to_server = q->ack_block_to_server; - if(was == false) - sleep_ms(10); + /*dstream<<"MeshUpdateThread: Processed " + <<"("<p.X<<","<p.Y<<","<p.Z<<")" + <getSceneManager()->getRootSceneNode(), @@ -64,70 +191,65 @@ Client::Client( ), 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_step_dtime(0.0), m_inventory_updated(false), - m_time_of_day(0) + m_time_of_day(0), + m_map_seed(0), + m_password(password), + m_access_denied(false) { m_packetcounter_timer = 0.0; - m_delete_unused_sectors_timer = 0.0; + //m_delete_unused_sectors_timer = 0.0; m_connection_reinit_timer = 0.0; m_avg_rtt_timer = 0.0; m_playerpos_send_timer = 0.0; + m_ignore_damage_timer = 0.0; - //m_fetchblock_mutex.Init(); - m_incoming_queue_mutex.Init(); - m_env_mutex.Init(); - m_con_mutex.Init(); - m_step_dtime_mutex.Init(); + //m_env_mutex.Init(); + //m_con_mutex.Init(); - m_thread.Start(); + m_mesh_update_thread.Start(); /* Add local player */ { - JMutexAutoLock envlock(m_env_mutex); + //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out Player *player = new LocalPlayer(); player->updateName(playername); m_env.addPlayer(player); + + // Initialize player in the inventory context + m_inventory_context.current_player = player; } - - // Add some active objects for testing - /*{ - ClientActiveObject *obj = new TestCAO(0, v3f(0, 10*BS, 0)); - m_env.addActiveObject(obj); - }*/ } Client::~Client() { { - JMutexAutoLock conlock(m_con_mutex); + //JMutexAutoLock conlock(m_con_mutex); //bulk comment-out m_con.Disconnect(); } - m_thread.setRun(false); - while(m_thread.IsRunning()) + m_mesh_update_thread.setRun(false); + while(m_mesh_update_thread.IsRunning()) sleep_ms(100); } void Client::connect(Address address) { DSTACK(__FUNCTION_NAME); - JMutexAutoLock lock(m_con_mutex); + //JMutexAutoLock lock(m_con_mutex); //bulk comment-out m_con.setTimeoutMs(0); m_con.Connect(address); } bool Client::connectedAndInitialized() { - JMutexAutoLock lock(m_con_mutex); + //JMutexAutoLock lock(m_con_mutex); //bulk comment-out if(m_con.Connected() == false) return false; @@ -146,6 +268,10 @@ void Client::step(float dtime) if(dtime > 2.0) dtime = 2.0; + if(m_ignore_damage_timer > dtime) + m_ignore_damage_timer -= dtime; + else + m_ignore_damage_timer = 0.0; //dstream<<"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().deleteUnusedSectors + /*u32 num = m_env.getMap().unloadUnusedData (delete_unused_sectors_timeout, true, &deleted_blocks);*/ // Delete whole sectors - u32 num = m_env.getMap().deleteUnusedSectors + m_env.getMap().unloadUnusedData (delete_unused_sectors_timeout, - false, &deleted_blocks); + &deleted_blocks); - if(num > 0) + if(deleted_blocks.size() > 0) { /*dstream<::Iterator i = deleted_blocks.begin(); core::list sendlist; @@ -266,8 +396,7 @@ void Client::step(float dtime) } } } - - bool connected = connectedAndInitialized(); +#endif if(connected == false) { @@ -277,7 +406,7 @@ void Client::step(float dtime) { counter = 2.0; - JMutexAutoLock envlock(m_env_mutex); + //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out Player *myplayer = m_env.getLocalPlayer(); assert(myplayer != NULL); @@ -286,11 +415,24 @@ void Client::step(float dtime) // [0] u16 TOSERVER_INIT // [2] u8 SER_FMT_VER_HIGHEST // [3] u8[20] player_name - SharedBuffer data(2+1+PLAYERNAME_SIZE); + // [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); 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; + m_env.getMap().timerUpdate(map_timer_and_unload_dtime, + 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; + for(;;) + { + if(sendlist.size() == 255 || i == deleted_blocks.end()) + { + if(sendlist.size() == 0) + break; + /* + [0] u16 command + [2] u8 count + [3] v3s16 pos_0 + [3+6] v3s16 pos_1 + ... + */ + u32 replysize = 2+1+6*sendlist.size(); + SharedBuffer reply(replysize); + writeU16(&reply[0], TOSERVER_DELETEDBLOCKS); + reply[2] = sendlist.size(); + u32 k = 0; + for(core::list::Iterator + j = sendlist.begin(); + j != sendlist.end(); j++) + { + writeV3S16(&reply[2+1+6*k], *j); + k++; + } + m_con.Send(PEER_ID_SERVER, 1, reply, true); + + if(i == deleted_blocks.end()) + break; + + sendlist.clear(); + } + + sendlist.push_back(*i); + i++; + } + } + + /* + Handle environment + */ { // 0ms - JMutexAutoLock lock(m_env_mutex); + //JMutexAutoLock lock(m_env_mutex); //bulk comment-out // Control local player (0ms) LocalPlayer *player = m_env.getLocalPlayer(); @@ -315,38 +521,53 @@ void Client::step(float dtime) //TimeTaker envtimer("env step", m_device); // Step environment m_env.step(dtime); - - // Step active blocks - for(core::map::Iterator - i = m_active_blocks.getIterator(); - i.atEnd() == false; i++) + + /* + Get events + */ + for(;;) { - v3s16 p = i.getNode()->getKey(); - - MapBlock *block = NULL; - try + ClientEnvEvent event = m_env.getClientEvent(); + if(event.type == CEE_NONE) { - block = m_env.getMap().getBlockNoCreate(p); - block->stepObjects(dtime, false, m_env.getDayNightRatio()); + break; } - catch(InvalidPositionException &e) + else if(event.type == CEE_PLAYER_DAMAGE) { + if(m_ignore_damage_timer <= 0) + { + u8 damage = event.player_damage.amount; + sendDamage(damage); + + // Add to ClientEvent queue + ClientEvent event; + event.type = CE_PLAYER_DAMAGE; + event.player_damage.amount = damage; + m_client_event_queue.push_back(event); + } } } } - + + /* + Print some info + */ { float &counter = m_avg_rtt_timer; counter += dtime; if(counter >= 10) { counter = 0.0; - JMutexAutoLock lock(m_con_mutex); + //JMutexAutoLock lock(m_con_mutex); //bulk comment-out // connectedAndInitialized() is true, peer exists. con::Peer *peer = m_con.GetPeer(PEER_ID_SERVER); dstream< 0) + { + 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); + } + if(r.ack_block_to_server) + { + /*dstream<<"Client: ACK block ("< reply(replysize); + writeU16(&reply[0], TOSERVER_GOTBLOCKS); + reply[2] = 1; + writeV3S16(&reply[3], r.p); + // Send as reliable + m_con.Send(PEER_ID_SERVER, 1, reply, true); + } + } + } } // Virtual methods from con::PeerHandler @@ -418,13 +662,13 @@ void Client::ReceiveAll() void Client::Receive() { DSTACK(__FUNCTION_NAME); - u32 data_maxsize = 10000; + u32 data_maxsize = 200000; Buffer data(data_maxsize); u16 sender_peer_id; u32 datasize; { //TimeTaker t1("con mutex and receive", m_device); - JMutexAutoLock lock(m_con_mutex); + //JMutexAutoLock lock(m_con_mutex); //bulk comment-out datasize = m_con.Receive(sender_peer_id, *data, data_maxsize); } //TimeTaker t1("ProcessData", m_device); @@ -464,7 +708,7 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id) con::Peer *peer; { - JMutexAutoLock lock(m_con_mutex); + //JMutexAutoLock lock(m_con_mutex); //bulk comment-out // All data is coming from the server // PeerNotFoundException is handled by caller. peer = m_con.GetPeer(PEER_ID_SERVER); @@ -474,8 +718,6 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id) //dstream<<"Client received command="<<(int)command<= 4) + { + std::string datastring((char*)&data[2], datasize-2); + std::istringstream is(datastring, std::ios_base::binary); + m_access_denied_reason = deSerializeWideString(is); + } + return; + } + if(ser_version == SER_FMT_VER_INVALID) { dout_client<getPos() == p2d); + + //TimeTaker timer("MapBlock deSerialize"); + // 0ms + + block = sector->getBlockNoCreateNoEx(p.Y); + if(block) + { + /* + Update an existing block + */ + //dstream<<"Updating"<deSerialize(istr, ser_version); + } + else + { + /* + Create a new block + */ + //dstream<<"Creating new"<deSerialize(istr, ser_version); + 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 + /* + Acknowledge block + */ + /* + [0] u16 command + [2] u8 count + [3] v3s16 pos_0 + [3+6] v3s16 pos_1 + ... + */ + u32 replysize = 2+1+6; + SharedBuffer reply(replysize); + writeU16(&reply[0], TOSERVER_GOTBLOCKS); + reply[2] = 1; + writeV3S16(&reply[3], p); + // Send as reliable + 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"< abs_to_delete; - for(core::map::Iterator - i = m_active_blocks.getIterator(); - i.atEnd() == false; i++) - { - v3s16 p = i.getNode()->getKey(); - /*dstream<<"adding " - <<"("<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 @@ -1052,7 +1304,7 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id) for all added objects { u16 id u8 type - u16 initialization data length + u32 initialization data length string initialization data } */ @@ -1074,7 +1326,7 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id) u16 id = readU16((u8*)buf); // Remove it { - JMutexAutoLock envlock(m_env_mutex); + //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out m_env.removeActiveObject(id); } } @@ -1091,7 +1343,7 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id) std::string data = deSerializeLongString(is); // Add it { - JMutexAutoLock envlock(m_env_mutex); + //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out m_env.addActiveObject(id, type, data); } } @@ -1099,7 +1351,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 @@ -1134,228 +1386,126 @@ void Client::ProcessData(u8 *data, u32 datasize, u16 sender_peer_id) } // Pass on to the environment { - JMutexAutoLock envlock(m_env_mutex); + //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out m_env.processActiveObjectMessage(id, message); } } } } - // Default to queueing it (for slow commands) - else + else if(command == TOCLIENT_HP) { - JMutexAutoLock lock(m_incoming_queue_mutex); - - IncomingPacket packet(data, datasize); - m_incoming_queue.push_back(packet); + 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 hp = readU8(is); + player->hp = hp; } -} - -/* - Returns true if there was something in queue -*/ -bool Client::AsyncProcessPacket() -{ - DSTACK(__FUNCTION_NAME); - - try //for catching con::PeerNotFoundException - { - - con::Peer *peer; + else if(command == TOCLIENT_MOVE_PLAYER) { - JMutexAutoLock lock(m_con_mutex); - // All data is coming from the server - peer = m_con.GetPeer(PEER_ID_SERVER); - } - - u8 ser_version = m_server_ser_ver; + std::string datastring((char*)&data[2], datasize-2); + std::istringstream is(datastring, std::ios_base::binary); + Player *player = m_env.getLocalPlayer(); + assert(player != NULL); + v3f pos = readV3F1000(is); + f32 pitch = readF1000(is); + f32 yaw = readF1000(is); + player->setPosition(pos); + /*player->setPitch(pitch); + player->setYaw(yaw);*/ + + dstream<<"Client got TOCLIENT_MOVE_PLAYER" + <<" pos=("<getPos(); - if(sp != p2d) - { - dstream<<"ERROR: Got sector with getPos()=" - <<"("<getPos() == p2d); - - try{ - block = sector->getBlockNoCreate(p.Y); - /* - Update an existing block - */ - //dstream<<"Updating"<deSerialize(istr, ser_version); - //block->setChangedFlag(); - } - catch(InvalidPositionException &e) + for (u16 i = 0; i < count; ++i) { + u16 peer_id = readU16(is); + Player *player = m_env.getPlayer(peer_id); + + if (player == NULL) { - /* - Create a new block - */ - //dstream<<"Creating new"<deSerialize(istr, ser_version); - sector->insertBlock(block); - //block->setChangedFlag(); - - //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);*/ - - /* - Add some coulds - Well, this is a dumb way to do it, they should just - be drawn as separate objects. - */ - /*if(p.Y == 3) - { - NodeMod mod; - mod.type = NODEMOD_CHANGECONTENT; - mod.param = CONTENT_CLOUD; - v3s16 p2; - p2.Y = 8; - for(p2.X=3; p2.X<=13; p2.X++) - for(p2.Z=3; p2.Z<=13; p2.Z++) - { - block->setTempMod(p2, mod); - } - }*/ + dout_client<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< reply(replysize); - writeU16(&reply[0], TOSERVER_GOTBLOCKS); - reply[2] = 1; - writeV3S16(&reply[3], p); - // Send as reliable - m_con.Send(PEER_ID_SERVER, 1, reply, true); - - /* - 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()); + bool set_camera_point_target = readU8(is); + v3f camera_point_target = readV3F1000(is); + + ClientEvent event; + event.type = CE_DEATHSCREEN; + event.deathscreen.set_camera_point_target = set_camera_point_target; + event.deathscreen.camera_point_target_x = camera_point_target.X; + event.deathscreen.camera_point_target_y = camera_point_target.Y; + event.deathscreen.camera_point_target_z = camera_point_target.Z; + m_client_event_queue.push_back(event); } else { dout_client< data, bool reliable) { - JMutexAutoLock lock(m_con_mutex); + //JMutexAutoLock lock(m_con_mutex); //bulk comment-out m_con.Send(PEER_ID_SERVER, channelnum, data, reliable); } -IncomingPacket Client::getPacket() -{ - JMutexAutoLock lock(m_incoming_queue_mutex); - - core::list::Iterator i; - // Refer to first one - i = m_incoming_queue.begin(); - - // If queue is empty, return empty packet - if(i == m_incoming_queue.end()){ - IncomingPacket packet; - return packet; - } - - // Pop out first packet and return it - IncomingPacket packet = *i; - m_incoming_queue.erase(i); - return packet; -} - void Client::groundAction(u8 action, v3s16 nodepos_undersurface, v3s16 nodepos_oversurface, u16 item) { @@ -1389,38 +1539,68 @@ void Client::groundAction(u8 action, v3s16 nodepos_undersurface, Send(0, data, true); } -void Client::clickObject(u8 button, v3s16 blockpos, s16 id, u16 item) +void Client::clickActiveObject(u8 button, u16 id, u16 item_i) { if(connectedAndInitialized() == false){ - dout_client<inventory.getList("main"); + if(mlist != NULL) + { + InventoryItem *item = mlist->getItem(item_i); + if(item && (std::string)item->getName() == "ToolItem") + { + titem = (ToolItem*)item; + toolname = titem->getToolName(); + } + } + + v3f playerpos = player->getPosition(); + v3f objpos = obj->getPosition(); + v3f dir = (objpos - playerpos).normalize(); + + bool disable_send = obj->directReportPunch(toolname, dir); + + if(disable_send) + return; + } + } /* - [0] u16 command=TOSERVER_CLICK_OBJECT + length: 7 + [0] u16 command [2] u8 button (0=left, 1=right) - [3] v3s16 block - [9] s16 id - [11] u16 item + [3] u16 id + [5] u16 item */ u8 datasize = 2 + 1 + 6 + 2 + 2; SharedBuffer data(datasize); - writeU16(&data[0], TOSERVER_CLICK_OBJECT); + writeU16(&data[0], TOSERVER_CLICK_ACTIVEOBJECT); writeU8(&data[2], button); - writeV3S16(&data[3], blockpos); - writeS16(&data[9], id); - writeU16(&data[11], item); + writeU16(&data[3], id); + writeU16(&data[5], item_i); Send(0, data, true); } -void Client::sendSignText(v3s16 blockpos, s16 id, std::string text) +void Client::sendSignNodeText(v3s16 p, std::string text) { /* u16 command - v3s16 blockpos - s16 id + v3s16 p u16 textlen textdata */ @@ -1428,17 +1608,13 @@ void Client::sendSignText(v3s16 blockpos, s16 id, std::string text) u8 buf[12]; // Write command - writeU16(buf, TOSERVER_SIGNTEXT); + writeU16(buf, TOSERVER_SIGNNODETEXT); os.write((char*)buf, 2); - // Write blockpos - writeV3S16(buf, blockpos); + // Write p + writeV3S16(buf, p); 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); @@ -1500,9 +1676,75 @@ void Client::sendChatMessage(const std::wstring &message) Send(0, data, true); } +void Client::sendChangePassword(const std::wstring oldpassword, + const std::wstring newpassword) +{ + Player *player = m_env.getLocalPlayer(); + if(player == NULL) + return; + + std::string playername = player->getName(); + std::string oldpwd = translatePassword(playername, oldpassword); + std::string newpwd = translatePassword(playername, newpassword); + + std::ostringstream os(std::ios_base::binary); + u8 buf[2+PASSWORD_SIZE*2]; + /* + [0] u16 TOSERVER_PASSWORD + [2] u8[28] old password + [30] u8[28] new password + */ + + writeU16(buf, TOSERVER_PASSWORD); + for(u32 i=0;i data((u8*)s.c_str(), s.size()); + // Send as reliable + Send(0, data, true); +} + + +void Client::sendDamage(u8 damage) +{ + DSTACK(__FUNCTION_NAME); + std::ostringstream os(std::ios_base::binary); + + writeU16(os, TOSERVER_DAMAGE); + writeU8(os, damage); + + // 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); + 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); + //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out Player *myplayer = m_env.getLocalPlayer(); if(myplayer == NULL) @@ -1510,7 +1752,7 @@ void Client::sendPlayerPos() u16 our_peer_id; { - JMutexAutoLock lock(m_con_mutex); + //JMutexAutoLock lock(m_con_mutex); //bulk comment-out our_peer_id = m_con.GetPeerID(); } @@ -1547,9 +1789,31 @@ void Client::sendPlayerPos() Send(0, data, false); } +void Client::sendPlayerItem(u16 item) +{ + Player *myplayer = m_env.getLocalPlayer(); + if(myplayer == NULL) + return; + + u16 our_peer_id = m_con.GetPeerID(); + + // Set peer id if not set already + if(myplayer->peer_id == PEER_ID_INEXISTENT) + myplayer->peer_id = our_peer_id; + // Check that an existing peer_id is the same as the connection's + assert(myplayer->peer_id == our_peer_id); + + SharedBuffer data(2+2); + writeU16(&data[0], TOSERVER_PLAYERITEM); + writeU16(&data[2], item); + + // Send as reliable + Send(0, data, true); +} + void Client::removeNode(v3s16 p) { - JMutexAutoLock envlock(m_env_mutex); + //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out core::map modified_blocks; @@ -1567,13 +1831,14 @@ void Client::removeNode(v3s16 p) i.atEnd() == false; i++) { v3s16 p = i.getNode()->getKey(); - m_env.getClientMap().updateMeshes(p, m_env.getDayNightRatio()); + //m_env.getClientMap().updateMeshes(p, m_env.getDayNightRatio()); + addUpdateMeshTaskWithEdge(p); } } void Client::addNode(v3s16 p, MapNode n) { - JMutexAutoLock envlock(m_env_mutex); + //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out TimeTaker timer1("Client::addNode()"); @@ -1581,58 +1846,75 @@ void Client::addNode(v3s16 p, MapNode n) try { - TimeTaker timer3("Client::addNode(): addNodeAndUpdate"); - m_env.getMap().addNodeAndUpdate(p, n, modified_blocks); + //TimeTaker timer3("Client::addNode(): addNodeAndUpdate"); + std::string st = std::string(""); + m_env.getMap().addNodeAndUpdate(p, n, modified_blocks, st); } catch(InvalidPositionException &e) {} - TimeTaker timer2("Client::addNode(): updateMeshes"); + //TimeTaker timer2("Client::addNode(): updateMeshes"); for(core::map::Iterator i = modified_blocks.getIterator(); i.atEnd() == false; i++) { v3s16 p = i.getNode()->getKey(); - m_env.getClientMap().updateMeshes(p, m_env.getDayNightRatio()); + //m_env.getClientMap().updateMeshes(p, m_env.getDayNightRatio()); + addUpdateMeshTaskWithEdge(p); } } -void Client::updateCamera(v3f pos, v3f dir) +void Client::updateCamera(v3f pos, v3f dir, f32 fov) { - m_env.getClientMap().updateCamera(pos, dir); - camera_position = pos; - camera_direction = dir; + m_env.getClientMap().updateCamera(pos, dir, fov); +} + +void Client::renderPostFx() +{ + m_env.getClientMap().renderPostFx(); } MapNode Client::getNode(v3s16 p) { - JMutexAutoLock envlock(m_env_mutex); + //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out return m_env.getMap().getNode(p); } -v3f Client::getPlayerPosition() +NodeMetadata* Client::getNodeMetadata(v3s16 p) { - JMutexAutoLock envlock(m_env_mutex); - LocalPlayer *player = m_env.getLocalPlayer(); - assert(player != NULL); - return player->getPosition(); + return m_env.getMap().getNodeMetadata(p); +} + +LocalPlayer* Client::getLocalPlayer() +{ + return m_env.getLocalPlayer(); } void Client::setPlayerControl(PlayerControl &control) { - JMutexAutoLock envlock(m_env_mutex); + //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out LocalPlayer *player = m_env.getLocalPlayer(); assert(player != NULL); player->control = control; } +void Client::selectPlayerItem(u16 item) +{ + LocalPlayer *player = m_env.getLocalPlayer(); + assert(player != NULL); + + player->wieldItem(item); + + sendPlayerItem(item); +} + // Returns true if the inventory of the local player has been // updated from the server. If it is true, it is set to false. bool Client::getLocalInventoryUpdated() { // m_inventory_updated is behind envlock - JMutexAutoLock envlock(m_env_mutex); + //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out bool updated = m_inventory_updated; m_inventory_updated = false; return updated; @@ -1641,46 +1923,59 @@ bool Client::getLocalInventoryUpdated() // Copies the inventory of the local player to parameter void Client::getLocalInventory(Inventory &dst) { - JMutexAutoLock envlock(m_env_mutex); + //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out Player *player = m_env.getLocalPlayer(); assert(player != NULL); dst = player->inventory; } -MapBlockObject * Client::getSelectedObject( - f32 max_d, - v3f from_pos_f_on_map, - core::line3d shootline_on_map - ) +InventoryContext *Client::getInventoryContext() { - JMutexAutoLock envlock(m_env_mutex); + return &m_inventory_context; +} - core::array objects; +Inventory* Client::getInventory(InventoryContext *c, std::string id) +{ + if(id == "current_player") + { + assert(c->current_player); + return &(c->current_player->inventory); + } + + Strfnd fn(id); + std::string id0 = fn.next(":"); - for(core::map::Iterator - i = m_active_blocks.getIterator(); - i.atEnd() == false; i++) + if(id0 == "nodemeta") { - v3s16 p = i.getNode()->getKey(); + 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 ("<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; +ClientActiveObject * Client::getSelectedActiveObject( + f32 max_d, + v3f from_pos_f_on_map, + core::line3d shootline_on_map + ) +{ + core::array objects; - block->getObjects(from_pos_f_on_block, max_d, objects); - //block->getPseudoObjects(from_pos_f_on_block, max_d, objects); - } + m_env.getActiveObjects(from_pos_f_on_map, 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 + ClientActiveObject *obj = objects[i].obj; + + core::aabbox3d *selection_box = obj->getSelectionBox(); + if(selection_box == NULL) + continue; + + v3f pos = obj->getPosition(); + + core::aabbox3d offsetted_box( + selection_box->MinEdge + pos, + selection_box->MaxEdge + pos ); - if(obj->isSelected(shootline_on_block)) + if(offsetted_box.intersectsWithLine(shootline_on_map)) { //dstream<<"Returning selected object"<hp; +} + +void Client::setTempMod(v3s16 p, NodeMod mod) +{ + //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out + assert(m_env.getMap().mapType() == MAPTYPE_CLIENT); + + core::map affected_blocks; + ((ClientMap&)m_env.getMap()).setTempMod(p, mod, + &affected_blocks); + + for(core::map::Iterator + i = affected_blocks.getIterator(); + i.atEnd() == false; i++) { - JMutexAutoLock envlock(m_env_mutex); - player = m_env.getLocalPlayer(); + i.getNode()->getValue()->updateMesh(m_env.getDayNightRatio()); } +} + +void Client::clearTempMod(v3s16 p) +{ + //JMutexAutoLock envlock(m_env_mutex); //bulk comment-out + assert(m_env.getMap().mapType() == MAPTYPE_CLIENT); - u32 daynight_ratio = getDayNightRatio(); + core::map affected_blocks; + ((ClientMap&)m_env.getMap()).clearTempMod(p, + &affected_blocks); + + for(core::map::Iterator + i = affected_blocks.getIterator(); + i.atEnd() == false; i++) + { + i.getNode()->getValue()->updateMesh(m_env.getDayNightRatio()); + } +} - v3f playerpos = player->getPosition(); - v3f playerspeed = player->getSpeed(); +void Client::addUpdateMeshTask(v3s16 p, bool ack_to_server) +{ + /*dstream<<"Client::addUpdateMeshTask(): " + <<"("<fill(getDayNightRatio(), b); + } - u32 counter = 0; + // 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); - s16 d_max = 5; + /*dstream<<"Mesh update input queue size is " + < list; - getFacePositions(list, d); - - core::list::Iterator li; - for(li=list.begin(); li!=list.end(); li++) - { - v3s16 p = *li + center; - MapBlock *block = NULL; - try - { - //JMutexAutoLock envlock(m_env_mutex); - block = m_env.getMap().getBlockNoCreate(p); - } - catch(InvalidPositionException &e) - { - } + //TimeTaker timer("make mesh"); + // 10ms + scene::SMesh *mesh_new = NULL; + mesh_new = makeMapBlockMesh(data); + b->replaceMesh(mesh_new); + delete data; + } +#endif - if(block == NULL) - continue; + /* + 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); +} - if(block->getMeshExpired() == false) - continue; +void Client::addUpdateMeshTaskWithEdge(v3s16 blockpos, bool ack_to_server) +{ + /*{ + v3s16 p = blockpos; + dstream<<"Client::addUpdateMeshTaskWithEdge(): " + <<"("<updateMesh(daynight_ratio); + try{ + v3s16 p = blockpos + v3s16(0,0,0); + //MapBlock *b = m_env.getMap().getBlockNoCreate(p); + addUpdateMeshTask(p, ack_to_server); + } + catch(InvalidPositionException &e){} + // Leading edge + try{ + v3s16 p = blockpos + v3s16(-1,0,0); + addUpdateMeshTask(p); + } + catch(InvalidPositionException &e){} + try{ + v3s16 p = blockpos + v3s16(0,-1,0); + addUpdateMeshTask(p); + } + catch(InvalidPositionException &e){} + try{ + v3s16 p = blockpos + v3s16(0,0,-1); + addUpdateMeshTask(p); + } + catch(InvalidPositionException &e){} +} - counter++; - if(counter >= 5) - return; - } +ClientEvent Client::getClientEvent() +{ + if(m_client_event_queue.size() == 0) + { + ClientEvent event; + event.type = CE_NONE; + return event; } -}*/ + return m_client_event_queue.pop_front(); +} +