X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fserver.cpp;h=b3ce9c13aeeef720b876219bf11227d0516b75dd;hb=01c2b003e1efb839ad246eb939af7fa8336b9ad5;hp=99683615ab454b5a04402a6e5596f44016ef4063;hpb=c51fef56a89d91f1c014aeb14cc0b3f9d22d81f8;p=dragonfireclient.git diff --git a/src/server.cpp b/src/server.cpp index 99683615a..b3ce9c13a 100644 --- a/src/server.cpp +++ b/src/server.cpp @@ -1,5 +1,20 @@ /* -(c) 2010 Perttu Ahola +Minetest-c55 +Copyright (C) 2010 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 +(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. + +You should have received a copy of the GNU 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 "server.h" @@ -10,6 +25,11 @@ #include "jmutexautolock.h" #include "main.h" #include "constants.h" +#include "voxel.h" +#include "materials.h" +#include "mineral.h" + +#define BLOCK_EMERGE_FLAG_FROMDISK (1<<0) void * ServerThread::Thread() { @@ -17,10 +37,17 @@ void * ServerThread::Thread() DSTACK(__FUNCTION_NAME); + BEGIN_DEBUG_EXCEPTION_HANDLER + while(getRun()) { try{ - m_server->AsyncRunStep(); + //TimeTaker timer("AsyncRunStep() + Receive()"); + + { + //TimeTaker timer("AsyncRunStep()"); + m_server->AsyncRunStep(); + } //dout_server<<"Running m_server->Receive()"<Receive(); @@ -28,19 +55,13 @@ void * ServerThread::Thread() catch(con::NoIncomingDataException &e) { } -#if CATCH_UNHANDLED_EXCEPTIONS - /* - This is what has to be done in threads to get suitable debug info - */ - catch(std::exception &e) + catch(con::PeerNotFoundException &e) { - dstream<pos; //derr_server<<"EmergeThread::Thread(): running"<getValue(); - if((flags & TOSERVER_GETBLOCK_FLAG_OPTIONAL) == false) + if((flags & BLOCK_EMERGE_FLAG_FROMDISK) == false) optional = false; } @@ -120,27 +141,67 @@ void * EmergeThread::Thread() {//envlock + //TimeTaker envlockwaittimer("block emerge envlock wait time"); + + // 0-50ms JMutexAutoLock envlock(m_server->m_env_mutex); - //TimeTaker timer("block emerge envlock", g_device); + //envlockwaittimer.stop(); + + //TimeTaker timer("block emerge (while env locked)"); try{ bool only_from_disk = false; if(optional) only_from_disk = true; - - block = map.emergeBlock( - p, - only_from_disk, - changed_blocks, - lighting_invalidated_blocks); + // First check if the block already exists + //block = map.getBlockNoCreate(p); + + if(block == NULL) + { + //dstream<<"Calling emergeBlock"<isDummy()) { //dstream<<"EmergeThread: Got a dummy block"< 0) + { + /*dstream<<"lighting "<::Iterator i = changed_blocks.getIterator(); i.atEnd() == false; i++) { MapBlock *block = i.getNode()->getValue(); modified_blocks.insert(block->getPos(), block); } - - /*dstream<<"lighting "<SetBlocksNotSent(modified_blocks); } - - /*if(q->peer_ids.find(client->peer_id) != NULL) - { - // Decrement emerge queue count of client - client->BlockEmerged(); - }*/ } } -#if CATCH_UNHANDLED_EXCEPTIONS - }//try - /* - This is what has to be done in threads to get suitable debug info - */ - catch(std::exception &e) - { - dstream<= g_settings.getU16 + ("max_simultaneous_block_sends_per_client")) { - JMutexAutoLock lock(m_blocks_sending_mutex); - - if(m_blocks_sending.size() >= g_settings.getU16 - ("max_simultaneous_block_sends_per_client")) - { - //dstream<<"Not sending any blocks, Queue full."<m_env.getPlayer(peer_id); + assert(player != NULL); + v3f playerpos = player->getPosition(); v3f playerspeed = player->getSpeed(); - v3s16 center_nodepos = floatToInt(playerpos); + v3s16 center_nodepos = floatToInt(playerpos, BS); v3s16 center = getNodeBlockPos(center_nodepos); + + // Camera position and direction + v3f camera_pos = + playerpos + v3f(0, BS+BS/2, 0); + v3f camera_dir = v3f(0,0,1); + camera_dir.rotateYZBy(player->getPitch()); + camera_dir.rotateXZBy(player->getYaw()); /* Get the starting value of the block finder radius. */ s16 last_nearest_unsent_d; s16 d_start; - { - JMutexAutoLock lock(m_blocks_sent_mutex); - if(m_last_center != center) - { - m_nearest_unsent_d = 0; - m_last_center = center; - } - - static float reset_counter = 0; - reset_counter += dtime; - if(reset_counter > 5.0) - { - reset_counter = 0; - m_nearest_unsent_d = 0; - } + if(m_last_center != center) + { + m_nearest_unsent_d = 0; + m_last_center = center; + } - last_nearest_unsent_d = m_nearest_unsent_d; - - d_start = m_nearest_unsent_d; + /*dstream<<"m_nearest_unsent_reset_timer=" + < 5.0) + { + m_nearest_unsent_reset_timer = 0; + m_nearest_unsent_d = 0; + //dstream<<"Resetting m_nearest_unsent_d"< lock(m_time_from_building.getLock()); - m_time_from_building.m_value += dtime; - if(m_time_from_building.m_value - < FULL_BLOCK_SEND_ENABLE_MIN_TIME_FROM_BUILDING) - { - maximum_simultaneous_block_sends - = LIMITED_MAX_SIMULTANEOUS_BLOCK_SENDS; - } + maximum_simultaneous_block_sends + = LIMITED_MAX_SIMULTANEOUS_BLOCK_SENDS; } - - // Serialization version used - //u8 ser_version = serialization_version; - - //bool has_incomplete_blocks = false; + + u32 num_blocks_selected = m_blocks_sending.size(); /* - TODO: Get this from somewhere + next time d will be continued from the d from which the nearest + unsent block was found this time. + + This is because not necessarily any of the blocks found this + time are actually sent. */ - //s16 d_max = 7; - s16 d_max = 8; + s32 new_nearest_unsent_d = -1; - //TODO: Get this from somewhere (probably a bigger value) - s16 d_max_gen = 5; + s16 d_max = g_settings.getS16("max_block_send_distance"); + s16 d_max_gen = g_settings.getS16("max_block_generate_distance"); //dstream<<"Starting from "<= maximum_simultaneous_block_sends_now) + { + /*dstream<<"Not sending more blocks. Queue full. " + < MAP_GENERATION_LIMIT / MAP_BLOCKSIZE) continue; - - bool generate = d <= d_max_gen; - // Limit the generating area vertically to half - if(abs(p.Y - center.Y) > d_max_gen / 2) - generate = false; + // If this is true, inexistent block will be made from scratch + bool generate = d <= d_max_gen; + { + /*// Limit the generating area vertically to 2/3 + if(abs(p.Y - center.Y) > d_max_gen - d_max_gen / 3) + generate = false;*/ + + // Limit the send area vertically to 2/3 + if(abs(p.Y - center.Y) > d_max_gen - d_max_gen / 3) + continue; + } + +#if 0 /* - Don't send already sent blocks + If block is far away, don't generate it unless it is + near ground level + + NOTE: We can't know the ground level this way with the + new generator. */ + if(d > 4) { - JMutexAutoLock lock(m_blocks_sent_mutex); - - if(m_blocks_sent.find(p) != NULL) - continue; + v2s16 p2d(p.X, p.Z); + MapSector *sector = NULL; + try + { + sector = server->m_env.getMap().getSectorNoGenerate(p2d); + } + catch(InvalidPositionException &e) + { + } + + if(sector != NULL) + { + // Get center ground height in nodes + f32 gh = sector->getGroundHeight( + v2s16(MAP_BLOCKSIZE/2, MAP_BLOCKSIZE/2)); + // Block center y in nodes + f32 y = (f32)(p.Y * MAP_BLOCKSIZE + MAP_BLOCKSIZE/2); + // If differs a lot, don't generate + if(fabs(gh - y) > MAP_BLOCKSIZE*2) + generate = false; + } } - +#endif + /* - Check if map has this block + Don't generate or send if not in sight */ - MapBlock *block = NULL; - try + + if(isBlockInSight(p, camera_pos, camera_dir, 10000*BS) == false) { - block = server->m_env.getMap().getBlockNoCreate(p); + continue; } - catch(InvalidPositionException &e) + + /* + Don't send already sent blocks + */ { + if(m_blocks_sent.find(p) != NULL) + continue; } + + /* + Check if map has this block + */ + MapBlock *block = server->m_env.getMap().getBlockNoCreateNoEx(p); bool surely_not_found_on_disk = false; + bool block_is_invalid = false; if(block != NULL) { - /*if(block->isIncomplete()) - { - has_incomplete_blocks = true; - continue; - }*/ - if(block->isDummy()) { surely_not_found_on_disk = true; } + + if(block->isValid() == false) + { + block_is_invalid = true; + } + + /*if(block->isFullyGenerated() == false) + { + block_is_invalid = true; + }*/ + + v2s16 p2d(p.X, p.Z); + ServerMap *map = (ServerMap*)(&server->m_env.getMap()); + v2s16 chunkpos = map->sector_to_chunk(p2d); + if(map->chunkNonVolatile(chunkpos) == false) + block_is_invalid = true; } /* @@ -471,23 +566,32 @@ void RemoteClient::GetNextBlocks(Server *server, float dtime, continue; } + /* + Record the lowest d from which a a block has been + found being not sent and possibly to exist + */ + if(new_nearest_unsent_d == -1 || d < new_nearest_unsent_d) + { + new_nearest_unsent_d = d; + } + /* Add inexistent block to emerge queue. */ - if(block == NULL || surely_not_found_on_disk) + if(block == NULL || surely_not_found_on_disk || block_is_invalid) { - /*SharedPtr lock - (m_num_blocks_in_emerge_queue.getLock());*/ - //TODO: Get value from somewhere // Allow only one block in emerge queue - if(server->m_emerge_queue.peerItemCount(peer_id) < 1) + //if(server->m_emerge_queue.peerItemCount(peer_id) < 1) + if(server->m_emerge_queue.peerItemCount(peer_id) < 2) { + //dstream<<"Adding block to emerge queue"<m_emerge_queue.addBlock(peer_id, p, flags); server->m_emergethread.trigger(); @@ -498,16 +602,22 @@ void RemoteClient::GetNextBlocks(Server *server, float dtime, } /* - Add block to queue + Add block to send queue */ PrioritySortedBlockTransfer q((float)d, p, peer_id); dest.push_back(q); + + num_blocks_selected += 1; } } +queue_full: - // Don't add anything here. The loop breaks by returning. + if(new_nearest_unsent_d != -1) + { + m_nearest_unsent_d = new_nearest_unsent_d; + } } void RemoteClient::SendObjectData( @@ -552,8 +662,9 @@ void RemoteClient::SendObjectData( /* Get and write player data */ - - core::list players = server->m_env.getPlayers(); + + // Get connected players + core::list players = server->m_env.getPlayers(true); // Write player count u16 playercount = players.size(); @@ -600,25 +711,23 @@ void RemoteClient::SendObjectData( - Add blocks to emerge queue if they are not found SUGGESTION: These could be ignored from the backside of the player - - TODO: Keep track of total size of packet and stop when it is too big */ Player *player = server->m_env.getPlayer(peer_id); + assert(player); + v3f playerpos = player->getPosition(); v3f playerspeed = player->getSpeed(); - v3s16 center_nodepos = floatToInt(playerpos); + v3s16 center_nodepos = floatToInt(playerpos, BS); v3s16 center = getNodeBlockPos(center_nodepos); - //s16 d_max = ACTIVE_OBJECT_D_BLOCKS; s16 d_max = g_settings.getS16("active_object_range"); // Number of blocks whose objects were written to bos u16 blockcount = 0; - //core::map blocks; std::ostringstream bos(std::ios_base::binary); for(s16 d = 0; d <= d_max; d++) @@ -635,7 +744,6 @@ void RemoteClient::SendObjectData( Ignore blocks that haven't been sent to the client */ { - JMutexAutoLock sentlock(m_blocks_sent_mutex); if(m_blocks_sent.find(p) == NULL) continue; } @@ -647,18 +755,20 @@ void RemoteClient::SendObjectData( // Get block MapBlock *block = server->m_env.getMap().getBlockNoCreate(p); - // Skip block if there are no objects - if(block->getObjectCount() == 0) - continue; - - // Step block if not in stepped_blocks and add to stepped_blocks + /* + Step block if not in stepped_blocks and add to stepped_blocks. + */ if(stepped_blocks.find(p) == NULL) { - block->stepObjects(dtime, true); + block->stepObjects(dtime, true, server->getDayNightRatio()); stepped_blocks.insert(p, true); block->setChangedFlag(); } + // Skip block if there are no objects + if(block->getObjectCount() == 0) + continue; + /* Write objects */ @@ -696,7 +806,7 @@ void RemoteClient::SendObjectData( m_num_blocks_in_emerge_queue.m_value++;*/ // Add to queue as an anonymous fetch from disk - u8 flags = TOSERVER_GETBLOCK_FLAG_OPTIONAL; + u8 flags = BLOCK_EMERGE_FLAG_FROMDISK; server->m_emerge_queue.addBlock(0, p, flags); server->m_emergethread.trigger(); } @@ -727,25 +837,19 @@ void RemoteClient::SendObjectData( void RemoteClient::GotBlock(v3s16 p) { - JMutexAutoLock lock(m_blocks_sending_mutex); - JMutexAutoLock lock2(m_blocks_sent_mutex); if(m_blocks_sending.find(p) != NULL) m_blocks_sending.remove(p); else - dstream<<"RemoteClient::GotBlock(): Didn't find in" - " m_blocks_sending"< 15) - { - dstream<<"RemoteClient::SentBlock(): " - <<"m_blocks_sending.size()=" - < &blocks) { - JMutexAutoLock sendinglock(m_blocks_sending_mutex); - JMutexAutoLock sentlock(m_blocks_sent_mutex); - m_nearest_unsent_d = 0; for(core::map::Iterator @@ -786,40 +884,6 @@ void RemoteClient::SetBlocksNotSent(core::map &blocks) } } -/*void RemoteClient::BlockEmerged() -{ - SharedPtr lock(m_num_blocks_in_emerge_queue.getLock()); - assert(m_num_blocks_in_emerge_queue.m_value > 0); - m_num_blocks_in_emerge_queue.m_value--; -}*/ - -/*void RemoteClient::RunSendingTimeouts(float dtime, float timeout) -{ - JMutexAutoLock sendinglock(m_blocks_sending_mutex); - - core::list remove_queue; - for(core::map::Iterator - i = m_blocks_sending.getIterator(); - i.atEnd()==false; i++) - { - v3s16 p = i.getNode()->getKey(); - float t = i.getNode()->getValue(); - t += dtime; - i.getNode()->setValue(t); - - if(t > timeout) - { - remove_queue.push_back(p); - } - } - for(core::list::Iterator - i = remove_queue.begin(); - i != remove_queue.end(); i++) - { - m_blocks_sending.remove(*i); - } -}*/ - /* PlayerInfo */ @@ -831,9 +895,10 @@ PlayerInfo::PlayerInfo() void PlayerInfo::PrintLine(std::ostream *s) { - (*s)<::Iterator + i = m_clients.getIterator(); + i.atEnd() == false; i++) + { + // Get client and check that it is valid + RemoteClient *client = i.getNode()->getValue(); + assert(client->peer_id == i.getNode()->getKey()); + if(client->serialization_version == SER_FMT_VER_INVALID) + continue; - JMutexAutoLock clientslock(m_con_mutex); + SendChatMessage(client->peer_id, line); + } + } - for(core::map::Iterator - i = m_clients.getIterator(); - i.atEnd() == false; i++) + /* + Save players + */ + m_env.serializePlayers(m_mapsavedir); + + /* + Stop threads + */ + stop(); + + /* + Delete clients + */ { - u16 peer_id = i.getNode()->getKey(); + JMutexAutoLock clientslock(m_con_mutex); - // Delete player + for(core::map::Iterator + i = m_clients.getIterator(); + i.atEnd() == false; i++) { - JMutexAutoLock envlock(m_env_mutex); - m_env.removePlayer(peer_id); + /*// Delete player + // NOTE: These are removed by env destructor + { + u16 peer_id = i.getNode()->getKey(); + JMutexAutoLock envlock(m_env_mutex); + m_env.removePlayer(peer_id); + }*/ + + // Delete client + delete i.getNode()->getValue(); } - - // Delete client - delete i.getNode()->getValue(); } } @@ -911,19 +1030,25 @@ void Server::start(unsigned short port) m_thread.setRun(true); m_thread.Start(); - dout_server<<"Server started on port "<::Iterator + i = m_clients.getIterator(); + i.atEnd() == false; i++) + { + RemoteClient *client = i.getNode()->getValue(); + //Player *player = m_env.getPlayer(client->peer_id); + + SharedBuffer data = makePacket_TOCLIENT_TIME_OF_DAY( + m_time_of_day.get()); + // Send as reliable + m_con.Send(client->peer_id, 0, data, true); + } + } + } + + { + // Process connection's timeouts + JMutexAutoLock lock2(m_con_mutex); + m_con.RunTimeouts(dtime); + } + + { + // This has to be called so that the client list gets synced + // with the peer list of the connection + handlePeerChanges(); + } + + { // Step environment // This also runs Map's timers JMutexAutoLock lock(m_env_mutex); @@ -972,9 +1156,58 @@ void Server::AsyncRunStep() Do background stuff */ + /* + Transform liquids + */ + m_liquid_transform_timer += dtime; + if(m_liquid_transform_timer >= 1.00) + { + m_liquid_transform_timer -= 1.00; + + JMutexAutoLock lock(m_env_mutex); + + core::map modified_blocks; + m_env.getMap().transformLiquids(modified_blocks); +#if 0 + /* + Update lighting + */ + core::map lighting_modified_blocks; + ServerMap &map = ((ServerMap&)m_env.getMap()); + map.updateLighting(modified_blocks, lighting_modified_blocks); + + // Add blocks modified by lighting to modified_blocks + for(core::map::Iterator + i = lighting_modified_blocks.getIterator(); + i.atEnd() == false; i++) + { + MapBlock *block = i.getNode()->getValue(); + modified_blocks.insert(block->getPos(), block); + } +#endif + /* + Set the modified blocks unsent for all the clients + */ + + JMutexAutoLock lock2(m_con_mutex); + + for(core::map::Iterator + i = m_clients.getIterator(); + i.atEnd() == false; i++) + { + RemoteClient *client = i.getNode()->getValue(); + + if(modified_blocks.size() > 0) + { + // Remove block from sent history + client->SetBlocksNotSent(modified_blocks); + } + } + } + // Periodically print some info { - static float counter = 0.0; + float &counter = m_print_info_timer; counter += dtime; if(counter >= 30.0) { @@ -993,29 +1226,270 @@ void Server::AsyncRunStep() } } - // Run time- and client- related stuff - // NOTE: If you intend to add something here, check that it - // doesn't fit in RemoteClient::GetNextBlocks for example. - /*{ - // Clients are behind connection lock - JMutexAutoLock lock(m_con_mutex); + if(g_settings.getBool("enable_experimental")) + { + + /* + Check added and deleted active objects + */ + { + JMutexAutoLock envlock(m_env_mutex); + JMutexAutoLock conlock(m_con_mutex); + + // Radius inside which objects are active + s16 radius = 32; for(core::map::Iterator i = m_clients.getIterator(); i.atEnd() == false; i++) { RemoteClient *client = i.getNode()->getValue(); - //con::Peer *peer = m_con.GetPeer(client->peer_id); - //client->RunSendingTimeouts(dtime, peer->resend_timeout); + Player *player = m_env.getPlayer(client->peer_id); + if(player==NULL) + continue; + v3s16 pos = floatToInt(player->getPosition(), BS); + + core::map removed_objects; + core::map added_objects; + m_env.getRemovedActiveObjects(pos, radius, + client->m_known_objects, removed_objects); + m_env.getAddedActiveObjects(pos, radius, + client->m_known_objects, added_objects); + + // Ignore if nothing happened + if(removed_objects.size() == 0 && added_objects.size() == 0) + continue; + + std::string data_buffer; + + char buf[4]; + + // Handle removed objects + writeU16((u8*)buf, removed_objects.size()); + data_buffer.append(buf, 2); + for(core::map::Iterator + i = removed_objects.getIterator(); + i.atEnd()==false; i++) + { + // Get object + u16 id = i.getNode()->getKey(); + ServerActiveObject* obj = m_env.getActiveObject(id); + + // Add to data buffer for sending + writeU16((u8*)buf, i.getNode()->getKey()); + data_buffer.append(buf, 2); + + // Remove from known objects + client->m_known_objects.remove(i.getNode()->getKey()); + + if(obj && obj->m_known_by_count > 0) + obj->m_known_by_count--; + } + + // Handle added objects + writeU16((u8*)buf, added_objects.size()); + data_buffer.append(buf, 2); + for(core::map::Iterator + i = added_objects.getIterator(); + i.atEnd()==false; i++) + { + // Get object + u16 id = i.getNode()->getKey(); + ServerActiveObject* obj = m_env.getActiveObject(id); + + // Get object type + u8 type = ACTIVEOBJECT_TYPE_INVALID; + if(obj == NULL) + dstream<<"WARNING: "<<__FUNCTION_NAME + <<": NULL object"<getType(); + + // Add to data buffer for sending + writeU16((u8*)buf, id); + data_buffer.append(buf, 2); + writeU8((u8*)buf, type); + data_buffer.append(buf, 1); + + data_buffer.append(serializeLongString( + obj->getClientInitializationData())); + + // Add to known objects + client->m_known_objects.insert(i.getNode()->getKey(), false); + + if(obj) + obj->m_known_by_count++; + } + + // Send packet + SharedBuffer reply(2 + data_buffer.size()); + writeU16(&reply[0], TOCLIENT_ACTIVE_OBJECT_REMOVE_ADD); + memcpy((char*)&reply[2], data_buffer.c_str(), + data_buffer.size()); + // Send as reliable + m_con.Send(client->peer_id, 0, reply, true); + + dstream<<"INFO: Server: Sent object remove/add: " + <* > buffered_messages; + + // Get active object messages from environment + for(;;) + { + ActiveObjectMessage aom = m_env.getActiveObjectMessage(); + if(aom.id == 0) + break; + + core::list* message_list = NULL; + core::map* >::Node *n; + n = buffered_messages.find(aom.id); + if(n == NULL) + { + message_list = new core::list; + buffered_messages.insert(aom.id, message_list); + } + else + { + message_list = n->getValue(); + } + message_list->push_back(aom); + } + + // Route data to every client + for(core::map::Iterator + i = m_clients.getIterator(); + i.atEnd()==false; i++) + { + RemoteClient *client = i.getNode()->getValue(); + std::string reliable_data; + std::string unreliable_data; + // Go through all objects in message buffer + for(core::map* >::Iterator + j = buffered_messages.getIterator(); + j.atEnd()==false; j++) + { + // If object is not known by client, skip it + u16 id = j.getNode()->getKey(); + if(client->m_known_objects.find(id) == NULL) + continue; + // Get message list of object + core::list* list = j.getNode()->getValue(); + // Go through every message + for(core::list::Iterator + k = list->begin(); k != list->end(); k++) + { + // Compose the full new data with header + ActiveObjectMessage aom = *k; + std::string new_data; + // Add object id + char buf[2]; + writeU16((u8*)&buf[0], aom.id); + new_data.append(buf, 2); + // Add data + new_data += serializeString(aom.datastring); + // Add data to buffer + if(aom.reliable) + reliable_data += new_data; + else + unreliable_data += new_data; + } + } + /* + reliable_data and unreliable_data are now ready. + Send them. + */ + if(reliable_data.size() > 0) + { + SharedBuffer reply(2 + reliable_data.size()); + writeU16(&reply[0], TOCLIENT_ACTIVE_OBJECT_MESSAGES); + memcpy((char*)&reply[2], reliable_data.c_str(), + reliable_data.size()); + // Send as reliable + m_con.Send(client->peer_id, 0, reply, true); + } + if(unreliable_data.size() > 0) + { + SharedBuffer reply(2 + unreliable_data.size()); + writeU16(&reply[0], TOCLIENT_ACTIVE_OBJECT_MESSAGES); + memcpy((char*)&reply[2], unreliable_data.c_str(), + unreliable_data.size()); + // Send as unreliable + m_con.Send(client->peer_id, 0, reply, false); + } + + /*if(reliable_data.size() > 0 || unreliable_data.size() > 0) + { + dstream<<"INFO: Server: Size of object message data: " + <<"reliable: "<* >::Iterator + i = buffered_messages.getIterator(); + i.atEnd()==false; i++) + { + delete i.getNode()->getValue(); + } + } + + } // enable_experimental + + /* + Send queued-for-sending map edit events. + */ + { + while(m_unsent_map_edit_queue.size() != 0) + { + MapEditEvent* event = m_unsent_map_edit_queue.pop_front(); + + if(event->type == MEET_ADDNODE) + { + dstream<<"Server: MEET_ADDNODE"<p, event->n, event->already_known_by_peer); + } + else if(event->type == MEET_REMOVENODE) + { + dstream<<"Server: MEET_REMOVENODE"<p, event->already_known_by_peer); + } + else if(event->type == MEET_OTHER) + { + dstream<<"WARNING: Server: MEET_OTHER not implemented" + <type)<= g_settings.getFloat("objectdata_interval")) { @@ -1027,10 +1501,12 @@ void Server::AsyncRunStep() } } - // Trigger emergethread (it gets somehow gets to a - // non-triggered but bysy state sometimes) + /* + Trigger emergethread (it somehow gets to a non-triggered but + bysy state sometimes) + */ { - static float counter = 0.0; + float &counter = m_emergethread_trigger_timer; counter += dtime; if(counter >= 2.0) { @@ -1042,15 +1518,31 @@ void Server::AsyncRunStep() // Save map { - static float counter = 0.0; + float &counter = m_savemap_timer; counter += dtime; - if(counter >= SERVER_MAP_SAVE_INTERVAL) + if(counter >= g_settings.getFloat("server_map_save_interval")) { counter = 0.0; JMutexAutoLock lock(m_env_mutex); - // Save only changed parts - m_env.getMap().save(true); + + if(((ServerMap*)(&m_env.getMap()))->isSavingEnabled() == true) + { + // Save only changed parts + m_env.getMap().save(true); + + // Delete unused sectors + u32 deleted_count = m_env.getMap().deleteUnusedSectors( + g_settings.getFloat("server_unload_unused_sectors_timeout")); + if(deleted_count > 0) + { + dout_server<<"Server: Unloaded "<serialization_version; u8 peer_ser_ver = getClient(peer->id)->serialization_version; try @@ -1157,27 +1653,72 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) /* Set up player */ + + // Get player name + const u32 playername_size = 20; + char playername[playername_size]; + for(u32 i=0; iserialize(test_os); + dstream<<"Player serialization test: \""<deSerialize(test_is); + }*/ + + // If failed, cancel + if(player == NULL) + { + derr_server<peer_id != 0) + { + derr_server<peer_id = peer_id; + */ // Check if player doesn't exist if(player == NULL) throw con::InvalidIncomingDataException ("Server::ProcessData(): INIT: Player doesn't exist"); - // update name if it was supplied + /*// update name if it was supplied if(datasize >= 20+3) { data[20+3-1] = 0; player->updateName((const char*)&data[3]); - } + }*/ // Now answer with a TOCLIENT_INIT - SharedBuffer reply(2+1+6); + SharedBuffer reply(2+1+6+8); writeU16(&reply[0], TOCLIENT_INIT); writeU8(&reply[2], deployed); - writeV3S16(&reply[3], floatToInt(player->getPosition()+v3f(0,BS/2,0))); + writeV3S16(&reply[2+1], floatToInt(player->getPosition()+v3f(0,BS/2,0), BS)); + //writeU64(&reply[2+1+6], m_env.getServerMap().getSeed()); + // Send as reliable m_con.Send(peer_id, 0, reply, true); @@ -1201,6 +1742,30 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) // Send inventory to player SendInventory(peer->id); + + // Send time of day + { + SharedBuffer data = makePacket_TOCLIENT_TIME_OF_DAY( + m_time_of_day.get()); + m_con.Send(peer->id, 0, data, true); + } + + // Send information about server to player in chat + SendChatMessage(peer_id, getStatusString()); + + // Send information about joining in chat + { + std::wstring name = L"unknown"; + Player *player = m_env.getPlayer(peer_id); + if(player != NULL) + name = narrow_to_wide(player->getName()); + + std::wstring message; + message += L"*** "; + message += name; + message += L" joined game"; + BroadcastChatMessage(message); + } return; } @@ -1323,7 +1888,7 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) } catch(InvalidPositionException &e) { - derr_server<<"PICK_OBJECT block not found"<inventory.getList("main"); + if(g_settings.getBool("creative_mode") == false && ilist != NULL) { // Skip if inventory has no free space - if(player->inventory.getUsedSlots() == player->inventory.getSize()) + if(ilist->getUsedSlots() == ilist->getSize()) { dout_server<<"Player inventory has no free space"<getTypeId() == MAPBLOCKOBJECT_TYPE_ITEM) + { + item = ((ItemObject*)obj)->createInventoryItem(); + } + // Else create an item of the object + else + { + item = new MapBlockObjectItem + (obj->getInventoryString()); + } + // Add to inventory and send inventory - InventoryItem *item = new MapBlockObjectItem - (obj->getInventoryString()); - player->inventory.addItem(item); + ilist->addItem(item); SendInventory(player->peer_id); } @@ -1361,19 +1941,24 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) block->removeObject(id); } } - else if(command == TOSERVER_CLICK_GROUND) + else if(command == TOSERVER_GROUND_ACTION) { if(datasize < 17) return; /* length: 17 [0] u16 command - [2] u8 button (0=left, 1=right) + [2] u8 action [3] v3s16 nodepos_undersurface [9] v3s16 nodepos_abovesurface [15] u16 item + actions: + 0: start digging + 1: place block + 2: stop digging (all parameters ignored) + 3: digging completed */ - u8 button = readU8(&data[2]); + u8 action = readU8(&data[2]); v3s16 p_under; p_under.X = readS16(&data[3]); p_under.Y = readS16(&data[5]); @@ -1387,68 +1972,169 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) //TODO: Check that target is reasonably close /* - Left button digs ground + 0: start digging */ - if(button == 0) + if(action == 0) + { + /* + NOTE: This can be used in the future to check if + somebody is cheating, by checking the timing. + */ + } // action == 0 + + /* + 2: stop digging + */ + else if(action == 2) { +#if 0 + RemoteClient *client = getClient(peer->id); + JMutexAutoLock digmutex(client->m_dig_mutex); + client->m_dig_tool_item = -1; +#endif + } + /* + 3: Digging completed + */ + else if(action == 3) + { + // Mandatory parameter; actually used for nothing core::map modified_blocks; u8 material; + u8 mineral = MINERAL_NONE; try { + MapNode n = m_env.getMap().getNode(p_under); // Get material at position - material = m_env.getMap().getNode(p_under).d; - // If it's air, do nothing - if(material == MATERIAL_AIR) + material = n.d; + // If it's not diggable, do nothing + if(content_diggable(material) == false) { + derr_server<<"Server: Not finishing digging: Node not diggable" + <SetBlockNotSent(blockpos); + return; } + // Get mineral + mineral = n.getMineral(); } catch(InvalidPositionException &e) { - derr_server<<"Server: Ignoring REMOVENODE: Node not found" + derr_server<<"Server: Not finishing digging: Node not found." + <<" Adding block to emerge queue." <id)->m_time_from_building.set(0.0); - - // Create packet - u32 replysize = 8; - SharedBuffer reply(replysize); - writeU16(&reply[0], TOCLIENT_REMOVENODE); - writeS16(&reply[2], p_under.X); - writeS16(&reply[4], p_under.Y); - writeS16(&reply[6], p_under.Z); - // Send as reliable - m_con.SendToAll(0, reply, true); + /* + Send the removal to all other clients + */ + sendRemoveNode(p_under, peer_id); + /* + Update and send inventory + */ + if(g_settings.getBool("creative_mode") == false) { - // Add to inventory and send inventory - InventoryItem *item = new MaterialItem(material, 1); - player->inventory.addItem(item); - SendInventory(player->peer_id); - } + /* + Wear out tool + */ + InventoryList *mlist = player->inventory.getList("main"); + if(mlist != NULL) + { + InventoryItem *item = mlist->getItem(item_i); + if(item && (std::string)item->getName() == "ToolItem") + { + ToolItem *titem = (ToolItem*)item; + std::string toolname = titem->getToolName(); + + // Get digging properties for material and tool + DiggingProperties prop = + getDiggingProperties(material, toolname); + + if(prop.diggable == false) + { + derr_server<<"Server: WARNING: Player digged" + <<" with impossible material + tool" + <<" combination"<addWear(prop.wear); + + if(weared_out) + { + mlist->deleteItem(item_i); + } + } + } - /* - Remove the node - (this takes some time so it is done after the quick stuff) - */ - m_env.getMap().removeNodeAndUpdate(p_under, modified_blocks); + /* + Add dug item to inventory + */ - } // button == 0 - /* - Right button places blocks and stuff - */ - else if(button == 1) - { + InventoryItem *item = NULL; - // Get item - InventoryItem *item = player->inventory.getItem(item_i); + if(mineral != MINERAL_NONE) + item = getDiggedMineralItem(mineral); + + // If not mineral + if(item == NULL) + { + std::string &dug_s = content_features(material).dug_item; + if(dug_s != "") + { + std::istringstream is(dug_s, std::ios::binary); + item = InventoryItem::deSerialize(is); + } + } + + if(item != NULL) + { + // Add a item to inventory + player->inventory.addItem("main", item); + + // Send inventory + SendInventory(player->peer_id); + } + } + + /* + Remove the node + (this takes some time so it is done after the quick stuff) + */ + m_ignore_map_edit_events = true; + m_env.getMap().removeNodeAndUpdate(p_under, modified_blocks); + m_ignore_map_edit_events = false; + } + + /* + 1: place block + */ + else if(action == 1) + { + + InventoryList *ilist = player->inventory.getList("main"); + if(ilist == NULL) + return; + + // Get item + InventoryItem *item = ilist->getItem(item_i); // If there is no item, it is not possible to add it anywhere if(item == NULL) @@ -1459,69 +2145,93 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) */ if(std::string("MaterialItem") == item->getName()) { - MaterialItem *mitem = (MaterialItem*)item; - - MapNode n; - n.d = mitem->getMaterial(); - try{ - // Don't add a node if there isn't air + // Don't add a node if this is not a free space MapNode n2 = m_env.getMap().getNode(p_over); - if(n2.d != MATERIAL_AIR) + if(content_buildable_to(n2.d) == false) + { + // Client probably has wrong data. + // Set block not sent, so that client will get + // a valid one. + dstream<<"Client "<SetBlockNotSent(blockpos); return; + } } catch(InvalidPositionException &e) { derr_server<<"Server: Ignoring ADDNODE: Node not found" + <<" Adding block to emerge queue." <id)->m_time_from_building.set(0.0); + getClient(peer->id)->m_time_from_building = 0.0; + + // Create node data + MaterialItem *mitem = (MaterialItem*)item; + MapNode n; + n.d = mitem->getMaterial(); + if(content_features(n.d).wall_mounted) + n.dir = packDir(p_under - p_over); + + /* + Send to all players + */ + sendAddNode(p_over, n, 0); - if(g_settings.getBool("creative_mode") == false) + /* + Handle inventory + */ + InventoryList *ilist = player->inventory.getList("main"); + if(g_settings.getBool("creative_mode") == false && ilist) { // Remove from inventory and send inventory if(mitem->getCount() == 1) - player->inventory.deleteItem(item_i); + ilist->deleteItem(item_i); else mitem->remove(1); // Send inventory SendInventory(peer_id); } - // Create packet - u32 replysize = 8 + MapNode::serializedLength(peer_ser_ver); - SharedBuffer reply(replysize); - writeU16(&reply[0], TOCLIENT_ADDNODE); - writeS16(&reply[2], p_over.X); - writeS16(&reply[4], p_over.Y); - writeS16(&reply[6], p_over.Z); - n.serialize(&reply[8], peer_ser_ver); - // Send as reliable - m_con.SendToAll(0, reply, true); - /* Add node. This takes some time so it is done after the quick stuff */ core::map modified_blocks; + m_ignore_map_edit_events = true; m_env.getMap().addNodeAndUpdate(p_over, n, modified_blocks); + m_ignore_map_edit_events = false; + + /* + Calculate special events + */ + + /*if(n.d == CONTENT_MESE) + { + u32 count = 0; + for(s16 z=-1; z<=1; z++) + for(s16 y=-1; y<=1; y++) + for(s16 x=-1; x<=1; x++) + { + + } + }*/ } /* - Handle block object items + Handle other items */ - else if(std::string("MBOItem") == item->getName()) + else { - MapBlockObjectItem *oitem = (MapBlockObjectItem*)item; - - /*dout_server<<"Trying to place a MapBlockObjectItem: " - "inventorystring=\"" - <getInventoryString() - <<"\""<getPosRelative(); - v3f block_pos_f_on_map = intToFloat(block_pos_i_on_map); + v3f block_pos_f_on_map = intToFloat(block_pos_i_on_map, BS); - v3f pos = intToFloat(p_over); + v3f pos = intToFloat(p_over, BS); pos -= block_pos_f_on_map; /*dout_server<<"pos=" <<"("<createObject - (pos, player->getYaw(), player->getPitch()); + /* + Handle block object items + */ + if(std::string("MBOItem") == item->getName()) + { + MapBlockObjectItem *oitem = (MapBlockObjectItem*)item; + + /*dout_server<<"Trying to place a MapBlockObjectItem: " + "inventorystring=\"" + <getInventoryString() + <<"\""<createObject + (pos, player->getYaw(), player->getPitch()); + } + /* + Handle other items + */ + else + { + dout_server<<"Placing a miscellaneous item on map" + <serialize(os); + dout_server<<"Item string is \""<setItemString(os.str()); + obj = iobj; + } if(obj == NULL) - derr_server<<"WARNING: oitem created NULL object" + { + derr_server<<"WARNING: item resulted in NULL object, " + <<"not placing onto map" <addObject(obj); - - //dout_server<<"Placed object"<inventory.deleteItem(item_i); - // Send inventory - SendInventory(peer_id); + block->addObject(obj); + + dout_server<<"Placed object"<inventory.getList("main"); + if(g_settings.getBool("creative_mode") == false && ilist) + { + // Remove from inventory and send inventory + ilist->deleteItem(item_i); + // Send inventory + SendInventory(peer_id); + } } } - } // button == 1 + } // action == 1 + /* - Catch invalid buttons + Catch invalid actions */ else { - derr_server<<"WARNING: Server: Invalid button " - <getBlock()->setChangedFlag(); } + else if(command == TOSERVER_INVENTORY_ACTION) + { + /*// Ignore inventory changes if in creative mode + if(g_settings.getBool("creative_mode") == true) + { + dstream<<"TOSERVER_INVENTORY_ACTION: ignoring in creative mode" + <to_name == "craftresult") + { + // Do nothing + disable_action = true; + } + // When something is removed from craftresult + if(ma->from_name == "craftresult") + { + disable_action = true; + // Remove stuff from craft + InventoryList *clist = player->inventory.getList("craft"); + if(clist) + { + u16 count = ma->count; + if(count == 0) + count = 1; + clist->decrementMaterials(count); + } + // Do action + // Feed action to player inventory + a->apply(&player->inventory); + // Eat it + delete a; + // If something appeared in craftresult, throw it + // in the main list + InventoryList *rlist = player->inventory.getList("craftresult"); + InventoryList *mlist = player->inventory.getList("main"); + if(rlist && mlist && rlist->getUsedSlots() == 1) + { + InventoryItem *item1 = rlist->changeItem(0, NULL); + mlist->addItem(item1); + } + } + } + if(disable_action == false) + { + // Feed action to player inventory + a->apply(&player->inventory); + // Eat it + delete a; + } + // Send inventory + SendInventory(player->peer_id); + } + else + { + dstream<<"TOSERVER_INVENTORY_ACTION: " + <<"InventoryAction::deSerialize() returned NULL" + <getName()); + + // Line to send to players + std::wstring line; + // Whether to send to the player that sent the line + bool send_to_sender = false; + // Whether to send to other players + bool send_to_others = false; + + // Parse commands + std::wstring commandprefix = L"/#"; + if(message.substr(0, commandprefix.size()) == commandprefix) + { + line += L"Server: "; + + message = message.substr(commandprefix.size()); + // Get player name as narrow string + std::string name_s = player->getName(); + // Convert message to narrow string + std::string message_s = wide_to_narrow(message); + // Operator is the single name defined in config. + std::string operator_name = g_settings.get("name"); + bool is_operator = (operator_name != "" && + wide_to_narrow(name) == operator_name); + bool valid_command = false; + if(message_s == "help") + { + line += L"-!- Available commands: "; + line += L"status "; + if(is_operator) + { + line += L"shutdown setting "; + } + else + { + } + send_to_sender = true; + valid_command = true; + } + else if(message_s == "status") + { + line = getStatusString(); + send_to_sender = true; + valid_command = true; + } + else if(is_operator) + { + if(message_s == "shutdown") + { + dstream< "; + line += message; + send_to_others = true; + } + + if(line != L"") + { + dstream<<"CHAT: "<::Iterator + i = m_clients.getIterator(); + i.atEnd() == false; i++) + { + // Get client and check that it is valid + RemoteClient *client = i.getNode()->getValue(); + assert(client->peer_id == i.getNode()->getKey()); + if(client->serialization_version == SER_FMT_VER_INVALID) + continue; + + // Filter recipient + bool sender_selected = (peer_id == client->peer_id); + if(sender_selected == true && send_to_sender == false) + continue; + if(sender_selected == false && send_to_others == false) + continue; + + SendChatMessage(client->peer_id, line); + } + } + } else { derr_server<<"WARNING: Server::ProcessData(): Ignoring " @@ -1660,140 +2622,14 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) } } -/*void Server::Send(u16 peer_id, u16 channelnum, - SharedBuffer data, bool reliable) -{ - JMutexAutoLock lock(m_con_mutex); - m_con.Send(peer_id, channelnum, data, reliable); -}*/ - -void Server::SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver) -{ - DSTACK(__FUNCTION_NAME); - /* - Create a packet with the block in the right format - */ - - std::ostringstream os(std::ios_base::binary); - block->serialize(os, ver); - std::string s = os.str(); - SharedBuffer blockdata((u8*)s.c_str(), s.size()); - - u32 replysize = 8 + blockdata.getSize(); - SharedBuffer reply(replysize); - v3s16 p = block->getPos(); - writeU16(&reply[0], TOCLIENT_BLOCKDATA); - writeS16(&reply[2], p.X); - writeS16(&reply[4], p.Y); - writeS16(&reply[6], p.Z); - memcpy(&reply[8], *blockdata, blockdata.getSize()); - - /* - Send packet - */ - m_con.Send(peer_id, 1, reply, true); -} - -/*void Server::SendBlock(u16 peer_id, MapBlock *block, u8 ver) -{ - JMutexAutoLock conlock(m_con_mutex); - - SendBlockNoLock(peer_id, block, ver); -}*/ - -#if 0 -void Server::SendSectorMeta(u16 peer_id, core::list ps, u8 ver) +void Server::onMapEditEvent(MapEditEvent *event) { - DSTACK(__FUNCTION_NAME); - dstream<<"Server sending sector meta of " - <::Iterator i = ps.begin(); - core::list sendlist; - for(;;) - { - if(sendlist.size() == 255 || i == ps.end()) - { - if(sendlist.size() == 0) - break; - /* - [0] u16 command - [2] u8 sector count - [3...] v2s16 pos + sector metadata - */ - std::ostringstream os(std::ios_base::binary); - u8 buf[4]; - - writeU16(buf, TOCLIENT_SECTORMETA); - os.write((char*)buf, 2); - - writeU8(buf, sendlist.size()); - os.write((char*)buf, 1); - - for(core::list::Iterator - j = sendlist.begin(); - j != sendlist.end(); j++) - { - // Write position - writeV2S16(buf, *j); - os.write((char*)buf, 4); - - /* - Write ClientMapSector metadata - */ - - /* - [0] u8 serialization version - [1] s16 corners[0] - [3] s16 corners[1] - [5] s16 corners[2] - [7] s16 corners[3] - size = 9 - - In which corners are in these positions - v2s16(0,0), - v2s16(1,0), - v2s16(1,1), - v2s16(0,1), - */ - - // Write version - writeU8(buf, ver); - os.write((char*)buf, 1); - - // Write corners - // TODO: Get real values - s16 corners[4]; - ((ServerMap&)m_env.getMap()).getSectorCorners(*j, corners); - - writeS16(buf, corners[0]); - os.write((char*)buf, 2); - writeS16(buf, corners[1]); - os.write((char*)buf, 2); - writeS16(buf, corners[2]); - os.write((char*)buf, 2); - writeS16(buf, corners[3]); - os.write((char*)buf, 2); - } - - SharedBuffer data((u8*)os.str().c_str(), os.str().size()); - - /*dstream<<"Server::SendSectorMeta(): sending packet" - " with "<clone(); + m_unsent_map_edit_queue.push_back(e); } -#endif core::list Server::getPlayerInfo() { @@ -1812,15 +2648,17 @@ core::list Server::getPlayerInfo() PlayerInfo info; Player *player = *i; + try{ con::Peer *peer = m_con.GetPeer(player->peer_id); + // Copy info from peer to info struct info.id = peer->id; info.address = peer->address; info.avg_rtt = peer->avg_rtt; } catch(con::PeerNotFoundException &e) { - // Outdated peer info + // Set dummy peer info info.id = 0; info.address = Address(0,0,0,0,0); info.avg_rtt = 0.0; @@ -1835,226 +2673,532 @@ core::list Server::getPlayerInfo() return list; } + void Server::peerAdded(con::Peer *peer) { DSTACK(__FUNCTION_NAME); dout_server<<"Server::peerAdded(): peer->id=" <id<id; + c.timeout = false; + m_peer_change_queue.push_back(c); +} + +void Server::deletingPeer(con::Peer *peer, bool timeout) +{ + DSTACK(__FUNCTION_NAME); + dout_server<<"Server::deletingPeer(): peer->id=" + <id<<", timeout="<::Node *n; - n = m_clients.find(peer->id); - // The client shouldn't already exist - assert(n == NULL); + PeerChange c; + c.type = PEER_REMOVED; + c.peer_id = peer->id; + c.timeout = timeout; + m_peer_change_queue.push_back(c); +} - // Create client - RemoteClient *client = new RemoteClient(); - client->peer_id = peer->id; - m_clients.insert(client->peer_id, client); +void Server::SendObjectData(float dtime) +{ + DSTACK(__FUNCTION_NAME); - // Create player + core::map stepped_blocks; + + for(core::map::Iterator + i = m_clients.getIterator(); + i.atEnd() == false; i++) { - // Already locked when called - //JMutexAutoLock envlock(m_env_mutex); + u16 peer_id = i.getNode()->getKey(); + RemoteClient *client = i.getNode()->getValue(); + assert(client->peer_id == peer_id); - Player *player = m_env.getPlayer(peer->id); + if(client->serialization_version == SER_FMT_VER_INVALID) + continue; - // The player shouldn't already exist - assert(player == NULL); + client->SendObjectData(this, dtime, stepped_blocks); + } +} - player = new RemotePlayer(); - player->peer_id = peer->id; +void Server::SendPlayerInfos() +{ + DSTACK(__FUNCTION_NAME); - /* - Set player position - */ + //JMutexAutoLock envlock(m_env_mutex); + + // Get connected players + core::list players = m_env.getPlayers(true); + + u32 player_count = players.getSize(); + u32 datasize = 2+(2+PLAYERNAME_SIZE)*player_count; - // Get zero sector (it could have been unloaded to disk) - m_env.getMap().emergeSector(v2s16(0,0)); - // Get ground height at origin - f32 groundheight = m_env.getMap().getGroundHeight(v2s16(0,0), true); - // The zero sector should have been generated - assert(groundheight > GROUNDHEIGHT_VALID_MINVALUE); - // Don't go underwater - if(groundheight < WATER_LEVEL) - groundheight = WATER_LEVEL; + SharedBuffer data(datasize); + writeU16(&data[0], TOCLIENT_PLAYERINFO); + + u32 start = 2; + core::list::Iterator i; + for(i = players.begin(); + i != players.end(); i++) + { + Player *player = *i; - player->setPosition(intToFloat(v3s16( - 0, - groundheight + 1, - 0 - ))); + /*dstream<<"Server sending player info for player with " + "peer_id="<peer_id<peer_id); + memset((char*)&data[start+2], 0, PLAYERNAME_SIZE); + snprintf((char*)&data[start+2], PLAYERNAME_SIZE, "%s", player->getName()); + start += 2+PLAYERNAME_SIZE; + } - /* - Add player to environment - */ + //JMutexAutoLock conlock(m_con_mutex); - m_env.addPlayer(player); + // Send as reliable + m_con.SendToAll(0, data, true); +} - /* - Add stuff to inventory - */ +/* + Craft checking system +*/ + +enum ItemSpecType +{ + ITEM_NONE, + ITEM_MATERIAL, + ITEM_CRAFT, + ITEM_TOOL, + ITEM_MBO +}; + +struct ItemSpec +{ + ItemSpec(): + type(ITEM_NONE) + { + } + ItemSpec(enum ItemSpecType a_type, std::string a_name): + type(a_type), + name(a_name), + num(65535) + { + } + ItemSpec(enum ItemSpecType a_type, u16 a_num): + type(a_type), + name(""), + num(a_num) + { + } + enum ItemSpecType type; + // Only other one of these is used + std::string name; + u16 num; +}; + +/* + items: a pointer to an array of 9 pointers to items + specs: a pointer to an array of 9 ItemSpecs +*/ +bool checkItemCombination(InventoryItem **items, ItemSpec *specs) +{ + u16 items_min_x = 100; + u16 items_max_x = 100; + u16 items_min_y = 100; + u16 items_max_y = 100; + for(u16 y=0; y<3; y++) + for(u16 x=0; x<3; x++) + { + if(items[y*3 + x] == NULL) + continue; + if(items_min_x == 100 || x < items_min_x) + items_min_x = x; + if(items_min_y == 100 || y < items_min_y) + items_min_y = y; + if(items_max_x == 100 || x > items_max_x) + items_max_x = x; + if(items_max_y == 100 || y > items_max_y) + items_max_y = y; + } + // No items at all, just return false + if(items_min_x == 100) + return false; + + u16 items_w = items_max_x - items_min_x + 1; + u16 items_h = items_max_y - items_min_y + 1; + + u16 specs_min_x = 100; + u16 specs_max_x = 100; + u16 specs_min_y = 100; + u16 specs_max_y = 100; + for(u16 y=0; y<3; y++) + for(u16 x=0; x<3; x++) + { + if(specs[y*3 + x].type == ITEM_NONE) + continue; + if(specs_min_x == 100 || x < specs_min_x) + specs_min_x = x; + if(specs_min_y == 100 || y < specs_min_y) + specs_min_y = y; + if(specs_max_x == 100 || x > specs_max_x) + specs_max_x = x; + if(specs_max_y == 100 || y > specs_max_y) + specs_max_y = y; + } + // No specs at all, just return false + if(specs_min_x == 100) + return false; + + u16 specs_w = specs_max_x - specs_min_x + 1; + u16 specs_h = specs_max_y - specs_min_y + 1; + + // Different sizes + if(items_w != specs_w || items_h != specs_h) + return false; + + for(u16 y=0; ygetName(); + + if(spec.type == ITEM_MATERIAL) { - // Give all materials - assert(USEFUL_MATERIAL_COUNT <= PLAYER_INVENTORY_SIZE); - for(u16 i=0; igetMaterial() != spec.num) + return false; + } + else if(spec.type == ITEM_CRAFT) + { + if(itemname != "CraftItem") + return false; + CraftItem *mitem = (CraftItem*)item; + if(mitem->getSubName() != spec.name) + return false; + } + else if(spec.type == ITEM_TOOL) + { + // Not supported yet + assert(0); + } + else if(spec.type == ITEM_MBO) + { + // Not supported yet + assert(0); + } + else + { + // Not supported yet + assert(0); + } + } + + return true; +} + +void Server::SendInventory(u16 peer_id) +{ + DSTACK(__FUNCTION_NAME); + + Player* player = m_env.getPlayer(peer_id); + + /* + Calculate crafting stuff + */ + if(g_settings.getBool("creative_mode") == false) + { + InventoryList *clist = player->inventory.getList("craft"); + InventoryList *rlist = player->inventory.getList("craftresult"); + if(rlist) + { + rlist->clearItems(); + } + if(clist && rlist) + { + InventoryItem *items[9]; + for(u16 i=0; i<9; i++) { - InventoryItem *item = new MaterialItem(i, 1); - player->inventory.addItem(item); + items[i] = clist->getItem(i); } + + bool found = false; + + // Wood + if(!found) + { + ItemSpec specs[9]; + specs[0] = ItemSpec(ITEM_MATERIAL, CONTENT_TREE); + if(checkItemCombination(items, specs)) + { + rlist->addItem(new MaterialItem(CONTENT_WOOD, 4)); + found = true; + } + } + + // Stick + if(!found) + { + ItemSpec specs[9]; + specs[0] = ItemSpec(ITEM_MATERIAL, CONTENT_WOOD); + if(checkItemCombination(items, specs)) + { + rlist->addItem(new CraftItem("Stick", 4)); + found = true; + } + } + // Sign + if(!found) { - InventoryItem *item = new MapBlockObjectItem("Sign Example text"); - bool r = player->inventory.addItem(item); - assert(r == true); + ItemSpec specs[9]; + specs[0] = ItemSpec(ITEM_MATERIAL, CONTENT_WOOD); + specs[1] = ItemSpec(ITEM_MATERIAL, CONTENT_WOOD); + specs[2] = ItemSpec(ITEM_MATERIAL, CONTENT_WOOD); + specs[3] = ItemSpec(ITEM_MATERIAL, CONTENT_WOOD); + specs[4] = ItemSpec(ITEM_MATERIAL, CONTENT_WOOD); + specs[5] = ItemSpec(ITEM_MATERIAL, CONTENT_WOOD); + specs[7] = ItemSpec(ITEM_CRAFT, "Stick"); + if(checkItemCombination(items, specs)) + { + rlist->addItem(new MapBlockObjectItem("Sign")); + found = true; + } } - /*// Rat + + // Torch + if(!found) { - InventoryItem *item = new MapBlockObjectItem("Rat"); - bool r = player->inventory.addItem(item); - assert(r == true); - }*/ - } - else - { - // Give some lights + ItemSpec specs[9]; + specs[0] = ItemSpec(ITEM_CRAFT, "lump_of_coal"); + specs[3] = ItemSpec(ITEM_CRAFT, "Stick"); + if(checkItemCombination(items, specs)) + { + rlist->addItem(new MaterialItem(CONTENT_TORCH, 4)); + found = true; + } + } + + // Wooden pick + if(!found) { - InventoryItem *item = new MaterialItem(3, 999); - bool r = player->inventory.addItem(item); - assert(r == true); + ItemSpec specs[9]; + specs[0] = ItemSpec(ITEM_MATERIAL, CONTENT_WOOD); + specs[1] = ItemSpec(ITEM_MATERIAL, CONTENT_WOOD); + specs[2] = ItemSpec(ITEM_MATERIAL, CONTENT_WOOD); + specs[4] = ItemSpec(ITEM_CRAFT, "Stick"); + specs[7] = ItemSpec(ITEM_CRAFT, "Stick"); + if(checkItemCombination(items, specs)) + { + rlist->addItem(new ToolItem("WPick", 0)); + found = true; + } } - // and some signs - for(u16 i=0; i<4; i++) + + // Stone pick + if(!found) { - InventoryItem *item = new MapBlockObjectItem("Sign Example text"); - bool r = player->inventory.addItem(item); - assert(r == true); + ItemSpec specs[9]; + specs[0] = ItemSpec(ITEM_MATERIAL, CONTENT_STONE); + specs[1] = ItemSpec(ITEM_MATERIAL, CONTENT_STONE); + specs[2] = ItemSpec(ITEM_MATERIAL, CONTENT_STONE); + specs[4] = ItemSpec(ITEM_CRAFT, "Stick"); + specs[7] = ItemSpec(ITEM_CRAFT, "Stick"); + if(checkItemCombination(items, specs)) + { + rlist->addItem(new ToolItem("STPick", 0)); + found = true; + } } - /*// and some rats - for(u16 i=0; i<4; i++) + + // Mese pick + if(!found) { - InventoryItem *item = new MapBlockObjectItem("Rat"); - bool r = player->inventory.addItem(item); - assert(r == true); - }*/ + ItemSpec specs[9]; + specs[0] = ItemSpec(ITEM_MATERIAL, CONTENT_MESE); + specs[1] = ItemSpec(ITEM_MATERIAL, CONTENT_MESE); + specs[2] = ItemSpec(ITEM_MATERIAL, CONTENT_MESE); + specs[4] = ItemSpec(ITEM_CRAFT, "Stick"); + specs[7] = ItemSpec(ITEM_CRAFT, "Stick"); + if(checkItemCombination(items, specs)) + { + rlist->addItem(new ToolItem("MesePick", 0)); + found = true; + } + } } - } + } // if creative_mode == false + + /* + Serialize it + */ + + std::ostringstream os; + //os.imbue(std::locale("C")); + + player->inventory.serialize(os); + + std::string s = os.str(); + + SharedBuffer data(s.size()+2); + writeU16(&data[0], TOCLIENT_INVENTORY); + memcpy(&data[2], s.c_str(), s.size()); + + // Send as reliable + m_con.Send(peer_id, 0, data, true); } -void Server::deletingPeer(con::Peer *peer, bool timeout) +void Server::SendChatMessage(u16 peer_id, const std::wstring &message) { DSTACK(__FUNCTION_NAME); - dout_server<<"Server::deletingPeer(): peer->id=" - <id<<", timeout="<::Node *n; - n = m_clients.find(peer->id); - // The client should exist - assert(n != NULL); + std::ostringstream os(std::ios_base::binary); + u8 buf[12]; + + // Write command + writeU16(buf, TOCLIENT_CHAT_MESSAGE); + os.write((char*)buf, 2); + + // Write length + writeU16(buf, message.size()); + os.write((char*)buf, 2); - // Delete player + // Write string + for(u32 i=0; iid); + u16 w = message[i]; + writeU16(buf, w); + os.write((char*)buf, 2); } - // Delete client - delete m_clients[peer->id]; - m_clients.remove(peer->id); - - // Send player info to all clients - SendPlayerInfos(); + // Make data buffer + std::string s = os.str(); + SharedBuffer data((u8*)s.c_str(), s.size()); + // Send as reliable + m_con.Send(peer_id, 0, data, true); } -void Server::SendObjectData(float dtime) +void Server::BroadcastChatMessage(const std::wstring &message) { - DSTACK(__FUNCTION_NAME); - - core::map stepped_blocks; - for(core::map::Iterator i = m_clients.getIterator(); i.atEnd() == false; i++) { - u16 peer_id = i.getNode()->getKey(); + // Get client and check that it is valid RemoteClient *client = i.getNode()->getValue(); - assert(client->peer_id == peer_id); - + assert(client->peer_id == i.getNode()->getKey()); if(client->serialization_version == SER_FMT_VER_INVALID) continue; - - client->SendObjectData(this, dtime, stepped_blocks); + + SendChatMessage(client->peer_id, message); } } -void Server::SendPlayerInfos() +void Server::sendRemoveNode(v3s16 p, u16 ignore_id) { - DSTACK(__FUNCTION_NAME); - - //JMutexAutoLock envlock(m_env_mutex); - - core::list players = m_env.getPlayers(); - - u32 player_count = players.getSize(); - u32 datasize = 2+(2+PLAYERNAME_SIZE)*player_count; + // Create packet + u32 replysize = 8; + SharedBuffer reply(replysize); + writeU16(&reply[0], TOCLIENT_REMOVENODE); + writeS16(&reply[2], p.X); + writeS16(&reply[4], p.Y); + writeS16(&reply[6], p.Z); - SharedBuffer data(datasize); - writeU16(&data[0], TOCLIENT_PLAYERINFO); - - u32 start = 2; - core::list::Iterator i; - for(i = players.begin(); - i != players.end(); i++) + for(core::map::Iterator + i = m_clients.getIterator(); + i.atEnd() == false; i++) { - Player *player = *i; + // Get client and check that it is valid + RemoteClient *client = i.getNode()->getValue(); + assert(client->peer_id == i.getNode()->getKey()); + if(client->serialization_version == SER_FMT_VER_INVALID) + continue; - /*dstream<<"Server sending player info for player with " - "peer_id="<peer_id<peer_id); - snprintf((char*)&data[start+2], PLAYERNAME_SIZE, "%s", player->getName()); - start += 2+PLAYERNAME_SIZE; + // Don't send if it's the same one + if(client->peer_id == ignore_id) + continue; + + // Send as reliable + m_con.Send(client->peer_id, 0, reply, true); } +} - //JMutexAutoLock conlock(m_con_mutex); +void Server::sendAddNode(v3s16 p, MapNode n, u16 ignore_id) +{ + for(core::map::Iterator + i = m_clients.getIterator(); + i.atEnd() == false; i++) + { + // Get client and check that it is valid + RemoteClient *client = i.getNode()->getValue(); + assert(client->peer_id == i.getNode()->getKey()); + if(client->serialization_version == SER_FMT_VER_INVALID) + continue; - // Send as reliable - m_con.SendToAll(0, data, true); + // Don't send if it's the same one + if(client->peer_id == ignore_id) + continue; + + // Create packet + u32 replysize = 8 + MapNode::serializedLength(client->serialization_version); + SharedBuffer reply(replysize); + writeU16(&reply[0], TOCLIENT_ADDNODE); + writeS16(&reply[2], p.X); + writeS16(&reply[4], p.Y); + writeS16(&reply[6], p.Z); + n.serialize(&reply[8], client->serialization_version); + + // Send as reliable + m_con.Send(client->peer_id, 0, reply, true); + } } -void Server::SendInventory(u16 peer_id) +void Server::SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver) { DSTACK(__FUNCTION_NAME); + /* + Create a packet with the block in the right format + */ - //JMutexAutoLock envlock(m_env_mutex); - - Player* player = m_env.getPlayer(peer_id); - - std::ostringstream os; - //os.imbue(std::locale("C")); + std::ostringstream os(std::ios_base::binary); + block->serialize(os, ver); + std::string s = os.str(); + SharedBuffer blockdata((u8*)s.c_str(), s.size()); - player->inventory.serialize(os); + u32 replysize = 8 + blockdata.getSize(); + SharedBuffer reply(replysize); + v3s16 p = block->getPos(); + writeU16(&reply[0], TOCLIENT_BLOCKDATA); + writeS16(&reply[2], p.X); + writeS16(&reply[4], p.Y); + writeS16(&reply[6], p.Z); + memcpy(&reply[8], *blockdata, blockdata.getSize()); - std::string s = os.str(); - - SharedBuffer data(s.size()+2); - writeU16(&data[0], TOCLIENT_INVENTORY); - memcpy(&data[2], s.c_str(), s.size()); + /*dstream<<"Sending block ("< queue; @@ -2087,8 +3234,6 @@ void Server::SendBlocks(float dtime) // Lowest is most important. queue.sort(); - JMutexAutoLock conlock(m_con_mutex); - for(u32 i=0; igetValue(); } +std::wstring Server::getStatusString() +{ + std::wostringstream os(std::ios_base::binary); + os<::Iterator + i = m_clients.getIterator(); + i.atEnd() == false; i++) + { + // Get client and check that it is valid + RemoteClient *client = i.getNode()->getValue(); + assert(client->peer_id == i.getNode()->getKey()); + if(client->serialization_version == SER_FMT_VER_INVALID) + continue; + // Get player + Player *player = m_env.getPlayer(client->peer_id); + // Get name of player + std::wstring name = L"unknown"; + if(player != NULL) + name = narrow_to_wide(player->getName()); + // Add name to information string + os<isSavingEnabled() == false) + os<<" WARNING: Map saving is disabled."<resetInventory(); + + // Give some good picks + { + InventoryItem *item = new ToolItem("STPick", 0); + void* r = player->inventory.addItem("main", item); + assert(r == NULL); + } + { + InventoryItem *item = new ToolItem("MesePick", 0); + void* r = player->inventory.addItem("main", item); + assert(r == NULL); + } + + /* + Give materials + */ + + // CONTENT_IGNORE-terminated list + u8 material_items[] = { + CONTENT_TORCH, + CONTENT_MUD, + CONTENT_STONE, + CONTENT_SAND, + CONTENT_TREE, + CONTENT_LEAVES, + CONTENT_MESE, + CONTENT_WATERSOURCE, + CONTENT_CLOUD, + CONTENT_FURNACE, + CONTENT_SIGN_WALL, + CONTENT_IGNORE + }; + + u8 *mip = material_items; + for(u16 i=0; iinventory.addItem("main", item); + + mip++; + } + +#if 0 + assert(USEFUL_CONTENT_COUNT <= PLAYER_INVENTORY_SIZE); + + // add torch first + InventoryItem *item = new MaterialItem(CONTENT_TORCH, 1); + player->inventory.addItem("main", item); + + // Then others + for(u16 i=0; iinventory.addItem("main", item); + } +#endif + + // Sign + { + InventoryItem *item = new MapBlockObjectItem("Sign Example text"); + void* r = player->inventory.addItem("main", item); + assert(r == NULL); + } +} + +Player *Server::emergePlayer(const char *name, const char *password, + u16 peer_id) +{ + /* + Try to get an existing player + */ + Player *player = m_env.getPlayer(name); + if(player != NULL) + { + // If player is already connected, cancel + if(player->peer_id != 0) + { + dstream<<"emergePlayer(): Player already connected"<peer_id = peer_id; + + // Reset inventory to creative if in creative mode + if(g_settings.getBool("creative_mode")) + { + setCreativeInventory(player); + } + + return player; + } + + /* + If player with the wanted peer_id already exists, cancel. + */ + if(m_env.getPlayer(peer_id) != NULL) + { + dstream<<"emergePlayer(): Player with wrong name but same" + " peer_id already exists"<peer_id = c.peer_id; + //player->peer_id = PEER_ID_INEXISTENT; + player->peer_id = peer_id; + player->updateName(name); + + /* + Set player position + */ + + dstream<<"Server: Finding spawn place for player \"" + <getName()<<"\""<setPosition(intToFloat(v3s16( + 0, + 45, //64, + 0 + ), BS)); +#endif +#if 1 + s16 groundheight = 0; +#if 1 + // Try to find a good place a few times + for(s32 i=0; i<1000; i++) + { + s32 range = 1 + i; + // We're going to try to throw the player to this position + nodepos = v2s16(-range + (myrand()%(range*2)), + -range + (myrand()%(range*2))); + v2s16 sectorpos = getNodeSectorPos(nodepos); + // Get sector (NOTE: Don't get because it's slow) + //m_env.getMap().emergeSector(sectorpos); + // Get ground height at point (fallbacks to heightmap function) + groundheight = m_env.getServerMap().findGroundLevel(nodepos); + // Don't go underwater + if(groundheight < WATER_LEVEL) + { + //dstream<<"-> Underwater"< WATER_LEVEL + 4) + { + //dstream<<"-> Underwater"<emergeBlock(blockpos); + // Don't go inside ground + try{ + /*v3s16 footpos(nodepos.X, groundheight+1, nodepos.Y); + v3s16 headpos(nodepos.X, groundheight+2, nodepos.Y);*/ + v3s16 footpos = nodepos3d + v3s16(0,0,0); + v3s16 headpos = nodepos3d + v3s16(0,1,0); + if(m_env.getMap().getNode(footpos).d != CONTENT_AIR + || m_env.getMap().getNode(headpos).d != CONTENT_AIR) + { + dstream<<"-> Inside ground"< Invalid position"<setPosition(intToFloat(v3s16( + nodepos.X, + groundheight + 5, // Accomodate mud + nodepos.Y + ), BS)); +#endif + + /* + Add player to environment + */ + + m_env.addPlayer(player); + + /* + Add stuff to inventory + */ + + if(g_settings.getBool("creative_mode")) + { + setCreativeInventory(player); + } + else + { + /*{ + InventoryItem *item = new ToolItem("WPick", 32000); + void* r = player->inventory.addItem("main", item); + assert(r == NULL); + }*/ + /*{ + InventoryItem *item = new MaterialItem(CONTENT_MESE, 6); + void* r = player->inventory.addItem("main", item); + assert(r == NULL); + } + { + InventoryItem *item = new MaterialItem(CONTENT_COALSTONE, 6); + void* r = player->inventory.addItem("main", item); + assert(r == NULL); + } + { + InventoryItem *item = new MaterialItem(CONTENT_WOOD, 6); + void* r = player->inventory.addItem("main", item); + assert(r == NULL); + } + { + InventoryItem *item = new CraftItem("Stick", 4); + void* r = player->inventory.addItem("main", item); + assert(r == NULL); + } + { + InventoryItem *item = new ToolItem("WPick", 32000); + void* r = player->inventory.addItem("main", item); + assert(r == NULL); + } + { + InventoryItem *item = new ToolItem("STPick", 32000); + void* r = player->inventory.addItem("main", item); + assert(r == NULL); + }*/ + /*// Give some lights + { + InventoryItem *item = new MaterialItem(CONTENT_TORCH, 999); + bool r = player->inventory.addItem("main", item); + assert(r == true); + } + // and some signs + for(u16 i=0; i<4; i++) + { + InventoryItem *item = new MapBlockObjectItem("Sign Example text"); + bool r = player->inventory.addItem("main", item); + assert(r == true); + }*/ + /*// Give some other stuff + { + InventoryItem *item = new MaterialItem(CONTENT_TREE, 999); + bool r = player->inventory.addItem("main", item); + assert(r == true); + }*/ + } + + return player; + + } // create new player +} + +#if 0 +void Server::UpdateBlockWaterPressure(MapBlock *block, + core::map &modified_blocks) +{ + MapVoxelManipulator v(&m_env.getMap()); + v.m_disable_water_climb = + g_settings.getBool("disable_water_climb"); + + VoxelArea area(block->getPosRelative(), + block->getPosRelative() + v3s16(1,1,1)*(MAP_BLOCKSIZE-1)); + + try + { + v.updateAreaWaterPressure(area, m_flow_active_nodes); + } + catch(ProcessingLimitException &e) + { + dstream<<"Processing limit reached (1)"<::Node *n; + n = m_clients.find(c.peer_id); + // The client shouldn't already exist + assert(n == NULL); + + // Create client + RemoteClient *client = new RemoteClient(); + client->peer_id = c.peer_id; + m_clients.insert(client->peer_id, client); + + } // PEER_ADDED + else if(c.type == PEER_REMOVED) + { + /* + Delete + */ + + // Error check + core::map::Node *n; + n = m_clients.find(c.peer_id); + // The client should exist + assert(n != NULL); + + // Collect information about leaving in chat + std::wstring message; + { + std::wstring name = L"unknown"; + Player *player = m_env.getPlayer(c.peer_id); + if(player != NULL) + name = narrow_to_wide(player->getName()); + + message += L"*** "; + message += name; + message += L" left game"; + if(c.timeout) + message += L" (timed out)"; + } + + /*// Delete player + { + m_env.removePlayer(c.peer_id); + }*/ + + // Set player client disconnected + { + Player *player = m_env.getPlayer(c.peer_id); + if(player != NULL) + player->peer_id = 0; + } + + // Delete client + delete m_clients[c.peer_id]; + m_clients.remove(c.peer_id); + + // Send player info to all remaining clients + SendPlayerInfos(); + + // Send leave chat message to all remaining clients + BroadcastChatMessage(message); + + } // PEER_REMOVED + else + { + assert(0); + } +} + +void Server::handlePeerChanges() +{ + while(m_peer_change_queue.size() > 0) + { + PeerChange c = m_peer_change_queue.pop_front(); + + dout_server<<"Server: Handling peer change: " + <<"id="< list = server.getPlayerInfo(); + core::list::Iterator i; + static u32 sum_old = 0; + u32 sum = PIChecksum(list); + if(sum != sum_old) + { + std::cout<PrintLine(&std::cout); + } + } + sum_old = sum; + } + } +} +