X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fserver.cpp;h=b3ce9c13aeeef720b876219bf11227d0516b75dd;hb=01c2b003e1efb839ad246eb939af7fa8336b9ad5;hp=2f285b6e959eb0953f694bd38c65cf8e205e3428;hpb=3fb0d2fb65c968f91c333a1d31d2d7a1a02ab7d1;p=dragonfireclient.git diff --git a/src/server.cpp b/src/server.cpp index 2f285b6e9..b3ce9c13a 100644 --- a/src/server.cpp +++ b/src/server.cpp @@ -17,10 +17,6 @@ with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -/* -(c) 2010 Perttu Ahola -*/ - #include "server.h" #include "utility.h" #include @@ -31,6 +27,7 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "constants.h" #include "voxel.h" #include "materials.h" +#include "mineral.h" #define BLOCK_EMERGE_FLAG_FROMDISK (1<<0) @@ -45,7 +42,12 @@ void * ServerThread::Thread() while(getRun()) { try{ - m_server->AsyncRunStep(); + //TimeTaker timer("AsyncRunStep() + Receive()"); + + { + //TimeTaker timer("AsyncRunStep()"); + m_server->AsyncRunStep(); + } //dout_server<<"Running m_server->Receive()"<Receive(); @@ -53,6 +55,10 @@ void * ServerThread::Thread() catch(con::NoIncomingDataException &e) { } + catch(con::PeerNotFoundException &e) + { + dout_server<<"Server: PeerNotFoundException"<isDummy()) { //dstream<<"EmergeThread: Got a dummy block"<UpdateBlockWaterPressure(block, modified_blocks); - - for(core::map::Iterator i = changed_blocks.getIterator(); - i.atEnd() == false; i++) - { - MapBlock *block = i.getNode()->getValue(); - m_server->UpdateBlockWaterPressure(block, modified_blocks); - //v3s16 p = i.getNode()->getKey(); - //m_server->UpdateBlockWaterPressure(p, modified_blocks); - } - /* Collect a list of blocks that have been modified in addition to the fetched one. */ - - // Add all the "changed blocks" to modified_blocks + + if(lighting_invalidated_blocks.size() > 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 "<= 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); @@ -299,38 +322,42 @@ void RemoteClient::GetNextBlocks(Server *server, float dtime, 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; - } - - /*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)*/ - if(m_time_from_building.m_value < g_settings.getFloat( - "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; } - u32 num_blocks_selected; - { - JMutexAutoLock lock(m_blocks_sending_mutex); - num_blocks_selected = m_blocks_sending.size(); - } + u32 num_blocks_selected = m_blocks_sending.size(); /* next time d will be continued from the d from which the nearest @@ -369,11 +387,6 @@ void RemoteClient::GetNextBlocks(Server *server, float dtime, */ s32 new_nearest_unsent_d = -1; - // Serialization version used - //u8 ser_version = serialization_version; - - //bool has_incomplete_blocks = false; - s16 d_max = g_settings.getS16("max_block_send_distance"); s16 d_max_gen = g_settings.getS16("max_block_generate_distance"); @@ -383,20 +396,16 @@ void RemoteClient::GetNextBlocks(Server *server, float dtime, { //dstream<<"RemoteClient::SendBlocks(): d="<= maximum_simultaneous_block_sends_now) { - JMutexAutoLock lock(m_blocks_sending_mutex); - - // Limit is dynamically lowered when building - if(num_blocks_selected - >= 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 2/3 - if(abs(p.Y - center.Y) > d_max_gen - d_max_gen / 3) - 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; } /* @@ -521,15 +578,15 @@ void RemoteClient::GetNextBlocks(Server *server, float dtime, /* 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"<getPosition(); v3f playerspeed = player->getSpeed(); - v3s16 center_nodepos = floatToInt(playerpos); + v3s16 center_nodepos = floatToInt(playerpos, BS); v3s16 center = getNodeBlockPos(center_nodepos); s16 d_max = g_settings.getS16("active_object_range"); @@ -688,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; } @@ -782,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 @@ -854,8 +897,8 @@ 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 + */ { - /*// Delete player - // NOTE: These are removed by env destructor + JMutexAutoLock clientslock(m_con_mutex); + + for(core::map::Iterator + i = m_clients.getIterator(); + i.atEnd() == false; i++) { - u16 peer_id = i.getNode()->getKey(); - JMutexAutoLock envlock(m_env_mutex); - m_env.removePlayer(peer_id); - }*/ - - // Delete client - delete i.getNode()->getValue(); + /*// 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(); + } } } @@ -943,19 +1030,25 @@ void Server::start(unsigned short port) m_thread.setRun(true); m_thread.Start(); - dout_server<<"Server started on port "<= 1.00) { - float interval; + m_liquid_transform_timer -= 1.00; - if(g_settings.getBool("endless_water") == false) - interval = 1.0; - else - interval = 0.25; - - float &counter = m_flowwater_timer; - counter += dtime; - if(counter >= 0.25 && m_flow_active_nodes.size() > 0) - { + JMutexAutoLock lock(m_env_mutex); - counter = 0.0; - 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++) { - - JMutexAutoLock envlock(m_env_mutex); - - MapVoxelManipulator v(&m_env.getMap()); - v.m_disable_water_climb = - g_settings.getBool("disable_water_climb"); - - if(g_settings.getBool("endless_water") == false) - v.flowWater(m_flow_active_nodes, 0, false, 250); - else - v.flowWater(m_flow_active_nodes, 0, false, 50); - - v.blitBack(modified_blocks); - - ServerMap &map = ((ServerMap&)m_env.getMap()); - - // Update lighting - core::map lighting_modified_blocks; - 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); - } - } // envlock - + MapBlock *block = i.getNode()->getValue(); + modified_blocks.insert(block->getPos(), block); + } +#endif /* Set the modified blocks unsent for all the clients */ @@ -1132,10 +1203,8 @@ void Server::AsyncRunStep() client->SetBlocksNotSent(modified_blocks); } } - - } // interval counter } - + // Periodically print some info { float &counter = m_print_info_timer; @@ -1157,15 +1226,18 @@ void Server::AsyncRunStep() } } - /* - Update digging + if(g_settings.getBool("enable_experimental")) + { - NOTE: Some of this could be moved to RemoteClient + /* + Check added and deleted active objects */ -#if 0 { 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(); @@ -1173,100 +1245,249 @@ void Server::AsyncRunStep() { RemoteClient *client = i.getNode()->getValue(); Player *player = m_env.getPlayer(client->peer_id); - - JMutexAutoLock digmutex(client->m_dig_mutex); - - if(client->m_dig_tool_item == -1) + if(player==NULL) continue; - - client->m_dig_time_remaining -= dtime; - - if(client->m_dig_time_remaining > 0) - { - client->m_time_from_building.set(0.0); + 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; - v3s16 p_under = client->m_dig_position; + char buf[4]; - // Mandatory parameter; actually used for nothing - core::map modified_blocks; + // 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()); - u8 material; + if(obj && obj->m_known_by_count > 0) + obj->m_known_by_count--; + } - try + // 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 material at position - material = m_env.getMap().getNode(p_under).d; - // If it's not diggable, do nothing - if(content_diggable(material) == false) - { - derr_server<<"Server: Not finishing digging: Node not diggable" - <m_dig_tool_item = -1; - break; - } - } - catch(InvalidPositionException &e) - { - derr_server<<"Server: Not finishing digging: Node not found" - <m_dig_tool_item = -1; - break; + // 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++; } - - // 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 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.SendToAll(0, reply, true); + 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; - if(g_settings.getBool("creative_mode") == false) + core::list* message_list = NULL; + core::map* >::Node *n; + n = buffered_messages.find(aom.id); + if(n == NULL) { - // Add to inventory and send inventory - InventoryItem *item = new MaterialItem(material, 1); - player->inventory.addItem("main", item); - SendInventory(player->peer_id); + 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; + } } - - /* - Remove the node - (this takes some time so it is done after the quick stuff) - */ - m_env.getMap().removeNodeAndUpdate(p_under, modified_blocks); - /* - Update water + reliable_data and unreliable_data are now ready. + Send them. */ - - // Update water pressure around modification - // This also adds it to m_flow_active_nodes if appropriate + 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); + } - MapVoxelManipulator v(&m_env.getMap()); - v.m_disable_water_climb = - g_settings.getBool("disable_water_climb"); - - VoxelArea area(p_under-v3s16(1,1,1), p_under+v3s16(1,1,1)); + /*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) { - v.updateAreaWaterPressure(area, m_flow_active_nodes); + dstream<<"Server: MEET_ADDNODE"<p, event->n, event->already_known_by_peer); } - catch(ProcessingLimitException &e) + else if(event->type == MEET_REMOVENODE) { - dstream<<"Processing limit reached (1)"<p, event->already_known_by_peer); } - - v.blitBack(modified_blocks); + else if(event->type == MEET_OTHER) + { + dstream<<"WARNING: Server: MEET_OTHER not implemented" + <type)< 0) + if(((ServerMap*)(&m_env.getMap()))->isSavingEnabled() == true) { - dout_server<<"Server: Unloaded "< 0) + { + dout_server<<"Server: Unloaded "<serialization_version; u8 peer_ser_ver = getClient(peer->id)->serialization_version; try @@ -1436,9 +1664,28 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) playername[playername_size-1] = 0; // Get player - Player *player = emergePlayer(playername, ""); + Player *player = emergePlayer(playername, "", peer_id); //Player *player = m_env.getPlayer(peer_id); + /*{ + // DEBUG: Test serialization + std::ostringstream test_os; + player->serialize(test_os); + dstream<<"Player serialization test: \""<deSerialize(test_is); + }*/ + + // If failed, cancel + if(player == NULL) + { + derr_server<peer_id != 0) { @@ -1448,9 +1695,9 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) <peer_id<<")"<peer_id = peer_id; + */ // Check if player doesn't exist if(player == NULL) @@ -1466,10 +1713,12 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) // 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); @@ -1500,37 +1749,9 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) m_time_of_day.get()); m_con.Send(peer->id, 0, data, true); } - + // Send information about server to player in chat - { - 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< 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; + 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: Not finishing digging: Node not found" + derr_server<<"Server: Not finishing digging: Node not found." + <<" Adding block to emerge queue." < 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); - - 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; - - // Don't send if it's the same one - if(peer_id == client->peer_id) - continue; - - // Send as reliable - m_con.Send(client->peer_id, 0, reply, true); - } + sendRemoveNode(p_under, peer_id); /* Update and send inventory @@ -1872,46 +2085,42 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) } /* - Add digged item to inventory + Add dug item to inventory */ - InventoryItem *item = new MaterialItem(material, 1); - player->inventory.addItem("main", item); - /* - Send inventory - */ - SendInventory(player->peer_id); + InventoryItem *item = NULL; + + 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); - - /* - Update water - */ - - // Update water pressure around modification - // This also adds it to m_flow_active_nodes if appropriate - - MapVoxelManipulator v(&m_env.getMap()); - v.m_disable_water_climb = - g_settings.getBool("disable_water_climb"); - - VoxelArea area(p_under-v3s16(1,1,1), p_under+v3s16(1,1,1)); - - try - { - v.updateAreaWaterPressure(area, m_flow_active_nodes); - } - catch(ProcessingLimitException &e) - { - dstream<<"Processing limit reached (1)"<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_directional(n.d)) + if(content_features(n.d).wall_mounted) n.dir = packDir(p_under - p_over); - -#if 1 - // 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); /* - Handle inventory + Send to all players */ - InventoryList *ilist = player->inventory.getList("main"); - if(g_settings.getBool("creative_mode") == false && ilist) - { - // Remove from inventory and send inventory - if(mitem->getCount() == 1) - ilist->deleteItem(item_i); - else - mitem->remove(1); - // Send inventory - SendInventory(peer_id); - } + sendAddNode(p_over, n, 0); - /* - Add node. - - This takes some time so it is done after the quick stuff - */ - core::map modified_blocks; - m_env.getMap().addNodeAndUpdate(p_over, n, modified_blocks); -#endif -#if 0 /* Handle inventory */ @@ -2009,58 +2201,31 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) // Send inventory SendInventory(peer_id); } - + /* 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; + /* - Set the modified blocks unsent for all the clients + Calculate special events */ - //JMutexAutoLock lock2(m_con_mutex); - - for(core::map::Iterator - i = m_clients.getIterator(); - i.atEnd() == false; i++) + /*if(n.d == CONTENT_MESE) { - RemoteClient *client = i.getNode()->getValue(); - - if(modified_blocks.size() > 0) + u32 count = 0; + for(s16 z=-1; z<=1; z++) + for(s16 y=-1; y<=1; y++) + for(s16 x=-1; x<=1; x++) { - // Remove block from sent history - client->SetBlocksNotSent(modified_blocks); + } - } -#endif - - /* - Update water - */ - - // Update water pressure around modification - // This also adds it to m_flow_active_nodes if appropriate - - MapVoxelManipulator v(&m_env.getMap()); - v.m_disable_water_climb = - g_settings.getBool("disable_water_climb"); - - VoxelArea area(p_over-v3s16(1,1,1), p_over+v3s16(1,1,1)); - - try - { - v.updateAreaWaterPressure(area, m_flow_active_nodes); - } - catch(ProcessingLimitException &e) - { - dstream<<"Processing limit reached (1)"<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=" @@ -2331,31 +2496,117 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) // Get player name of this client std::wstring name = narrow_to_wide(player->getName()); - - std::wstring line = std::wstring(L"<")+name+L"> "+message; - dstream<<"CHAT: "<::Iterator - i = m_clients.getIterator(); - i.atEnd() == false; i++) + // 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<getValue(); - assert(client->peer_id == i.getNode()->getKey()); - if(client->serialization_version == SER_FMT_VER_INVALID) - continue; - - // Don't send if it's the same one - if(peer_id == client->peer_id) - continue; - - SendChatMessage(client->peer_id, line); + line += L"<"; + /*if(is_operator) + line += L"@";*/ + line += name; + line += L"> "; + 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 " @@ -2371,41 +2622,13 @@ void Server::ProcessData(u8 *data, u32 datasize, u16 peer_id) } } -/*void Server::Send(u16 peer_id, u16 channelnum, - SharedBuffer data, bool reliable) +void Server::onMapEditEvent(MapEditEvent *event) { - 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()); - - /*dstream<<"Sending block ("<clone(); + m_unsent_map_edit_queue.push_back(e); } core::list Server::getPlayerInfo() @@ -2450,6 +2673,7 @@ core::list Server::getPlayerInfo() return list; } + void Server::peerAdded(con::Peer *peer) { DSTACK(__FUNCTION_NAME); @@ -2523,6 +2747,7 @@ void Server::SendPlayerInfos() "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; } @@ -2533,6 +2758,10 @@ void Server::SendPlayerInfos() m_con.SendToAll(0, data, true); } +/* + Craft checking system +*/ + enum ItemSpecType { ITEM_NONE, @@ -2759,7 +2988,7 @@ void Server::SendInventory(u16 peer_id) if(!found) { ItemSpec specs[9]; - specs[0] = ItemSpec(ITEM_MATERIAL, CONTENT_COALSTONE); + specs[0] = ItemSpec(ITEM_CRAFT, "lump_of_coal"); specs[3] = ItemSpec(ITEM_CRAFT, "Stick"); if(checkItemCombination(items, specs)) { @@ -2883,11 +3112,103 @@ void Server::BroadcastChatMessage(const std::wstring &message) } } +void Server::sendRemoveNode(v3s16 p, u16 ignore_id) +{ + // 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); + + 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; + + // 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); + } +} + +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; + + // 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::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()); + + /*dstream<<"Sending block ("< queue; @@ -2913,8 +3234,6 @@ void Server::SendBlocks(float dtime) // Lowest is most important. queue.sort(); - JMutexAutoLock conlock(m_con_mutex); - for(u32 i=0; igetValue(); } -Player *Server::emergePlayer(const char *name, const char *password) +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 @@ -2964,9 +3393,34 @@ Player *Server::emergePlayer(const char *name, const char *password) 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_INEXISTENT; + player->peer_id = peer_id; player->updateName(name); /* Set player position */ + + dstream<<"Server: Finding spawn place for player \"" + <getName()<<"\""< groundheight exists - assert(groundheight > GROUNDHEIGHT_VALID_MINVALUE); - // Don't go underwater - if(groundheight < WATER_LEVEL) - groundheight = WATER_LEVEL; + player->setPosition(intToFloat(v3s16( + 0, + 45, //64, + 0 + ), BS)); #endif - #if 1 - v2s16 nodepos; - f32 groundheight = 0; + s16 groundheight = 0; +#if 1 // Try to find a good place a few times - for(s32 i=0; i<100; i++) + for(s32 i=0; i<1000; i++) { - s32 range = 1 + i*5; + s32 range = 1 + i; // We're going to try to throw the player to this position - nodepos = v2s16(-range/2 + (myrand()%range), - -range/2 + (myrand()%range)); + nodepos = v2s16(-range + (myrand()%(range*2)), + -range + (myrand()%(range*2))); v2s16 sectorpos = getNodeSectorPos(nodepos); - // Get sector - m_env.getMap().emergeSector(sectorpos); - // Get ground height at point - groundheight = m_env.getMap().getGroundHeight(nodepos, true); - // The sector should have been generated -> groundheight exists - assert(groundheight > GROUNDHEIGHT_VALID_MINVALUE); + // 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(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 + 1, + groundheight + 5, // Accomodate mud nodepos.Y - ))); + ), BS)); +#endif /* Add player to environment @@ -3055,46 +3532,15 @@ Player *Server::emergePlayer(const char *name, const char *password) if(g_settings.getBool("creative_mode")) { - // 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 - */ - 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); - } - // Sign - { - InventoryItem *item = new MapBlockObjectItem("Sign Example text"); - void* r = player->inventory.addItem("main", item); - assert(r == NULL); - } + 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); @@ -3147,9 +3593,11 @@ Player *Server::emergePlayer(const char *name, const char *password) } return player; - } + + } // create new player } +#if 0 void Server::UpdateBlockWaterPressure(MapBlock *block, core::map &modified_blocks) { @@ -3171,6 +3619,7 @@ void Server::UpdateBlockWaterPressure(MapBlock *block, v.blitBack(modified_blocks); } +#endif void Server::handlePeerChange(PeerChange &c) { @@ -3230,7 +3679,8 @@ void Server::handlePeerChange(PeerChange &c) // Set player client disconnected { Player *player = m_env.getPlayer(c.peer_id); - player->peer_id = 0; + if(player != NULL) + player->peer_id = 0; } // Delete client @@ -3264,4 +3714,50 @@ void Server::handlePeerChanges() } } +void dedicated_server_loop(Server &server, bool &kill) +{ + DSTACK(__FUNCTION_NAME); + + std::cout< 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; + } + } +} +