51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-/*
-(c) 2010 Perttu Ahola <celeron55@gmail.com>
-*/
-
#include "server.h"
#include "utility.h"
#include <iostream>
while(getRun())
{
try{
- m_server->AsyncRunStep();
+ //TimeTaker timer("AsyncRunStep() + Receive()");
+
+ {
+ //TimeTaker timer("AsyncRunStep()");
+ m_server->AsyncRunStep();
+ }
//dout_server<<"Running m_server->Receive()"<<std::endl;
m_server->Receive();
#if 0
/*
- EXPERIMENTAL: Create a few other blocks too
+ While we're at it, generate some other blocks too
*/
-
- map.emergeBlock(
- p + v3s16(0,1,0),
- only_from_disk,
- changed_blocks,
- lighting_invalidated_blocks);
-
- map.emergeBlock(
- p + v3s16(0,-1,0),
- only_from_disk,
- changed_blocks,
- lighting_invalidated_blocks);
-#if 0
- map.emergeBlock(
- p + v3s16(0,2,0),
- only_from_disk,
- changed_blocks,
- lighting_invalidated_blocks);
-
- map.emergeBlock(
- p + v3s16(0,-2,0),
- only_from_disk,
- changed_blocks,
- lighting_invalidated_blocks);
-#endif
+ try
+ {
+ map.emergeBlock(
+ p+v3s16(0,1,0),
+ only_from_disk,
+ changed_blocks,
+ lighting_invalidated_blocks);
+ map.emergeBlock(
+ p+v3s16(0,-1,0),
+ only_from_disk,
+ changed_blocks,
+ lighting_invalidated_blocks);
+ }
+ catch(InvalidPositionException &e)
+ {
+ }
#endif
}
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 "<<lighting_invalidated_blocks.size()
+ <<" blocks"<<std::endl;*/
+
+ // 50-100ms for single block generation
+ //TimeTaker timer("** EmergeThread updateLighting");
+
+ // Update lighting without locking the environment mutex,
+ // add modified blocks to changed blocks
+ map.updateLighting(lighting_invalidated_blocks, modified_blocks);
+ }
+
+ // Add all from changed_blocks to modified_blocks
for(core::map<v3s16, MapBlock*>::Iterator i = changed_blocks.getIterator();
i.atEnd() == false; i++)
{
MapBlock *block = i.getNode()->getValue();
modified_blocks.insert(block->getPos(), block);
}
-
- /*dstream<<"lighting "<<lighting_invalidated_blocks.size()
- <<" blocks"<<std::endl;*/
-
- //TimeTaker timer("** updateLighting");
-
- // Update lighting without locking the environment mutex,
- // add modified blocks to changed blocks
- map.updateLighting(lighting_invalidated_blocks, modified_blocks);
}
// If we got no block, there should be no invalidated blocks
else
DSTACK(__FUNCTION_NAME);
// Increment timers
- {
- JMutexAutoLock lock(m_blocks_sent_mutex);
- m_nearest_unsent_reset_timer += dtime;
- }
+ m_nearest_unsent_reset_timer += dtime;
// Won't send anything if already sending
+ if(m_blocks_sending.size() >= 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."<<std::endl;
- return;
- }
+ //dstream<<"Not sending any blocks, Queue full."<<std::endl;
+ return;
}
Player *player = server->m_env.getPlayer(peer_id);
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 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="
- <<m_nearest_unsent_reset_timer<<std::endl;*/
- if(m_nearest_unsent_reset_timer > 5.0)
- {
- m_nearest_unsent_reset_timer = 0;
- m_nearest_unsent_d = 0;
- //dstream<<"Resetting m_nearest_unsent_d"<<std::endl;
- }
+ 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="
+ <<m_nearest_unsent_reset_timer<<std::endl;*/
+ if(m_nearest_unsent_reset_timer > 5.0)
+ {
+ m_nearest_unsent_reset_timer = 0;
+ m_nearest_unsent_d = 0;
+ //dstream<<"Resetting m_nearest_unsent_d"<<std::endl;
}
+ last_nearest_unsent_d = m_nearest_unsent_d;
+
+ d_start = m_nearest_unsent_d;
+
u16 maximum_simultaneous_block_sends_setting = g_settings.getU16
("max_simultaneous_block_sends_per_client");
u16 maximum_simultaneous_block_sends =
Decrease send rate if player is building stuff.
*/
+ m_time_from_building += dtime;
+ if(m_time_from_building < g_settings.getFloat(
+ "full_block_send_enable_min_time_from_building"))
{
- SharedPtr<JMutexAutoLock> 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
*/
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");
{
//dstream<<"RemoteClient::SendBlocks(): d="<<d<<std::endl;
- //if(has_incomplete_blocks == false)
+ /*
+ If m_nearest_unsent_d was changed by the EmergeThread
+ (it can change it to 0 through SetBlockNotSent),
+ update our d to it.
+ Else update m_nearest_unsent_d
+ */
+ if(m_nearest_unsent_d != last_nearest_unsent_d)
{
- JMutexAutoLock lock(m_blocks_sent_mutex);
- /*
- If m_nearest_unsent_d was changed by the EmergeThread
- (it can change it to 0 through SetBlockNotSent),
- update our d to it.
- Else update m_nearest_unsent_d
- */
- if(m_nearest_unsent_d != last_nearest_unsent_d)
- {
- d = m_nearest_unsent_d;
- last_nearest_unsent_d = m_nearest_unsent_d;
- }
+ d = m_nearest_unsent_d;
+ last_nearest_unsent_d = m_nearest_unsent_d;
}
/*
maximum_simultaneous_block_sends_setting;
}
+ // Limit is dynamically lowered when building
+ if(num_blocks_selected
+ >= 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. "
- <<m_blocks_sending.size()
- <<std::endl;*/
- goto queue_full;
- }
-
- if(m_blocks_sending.find(p) != NULL)
- continue;
+ /*dstream<<"Not sending more blocks. Queue full. "
+ <<m_blocks_sending.size()
+ <<std::endl;*/
+ goto queue_full;
}
-
+
+ if(m_blocks_sending.find(p) != NULL)
+ continue;
+
/*
Do not go over-limit
*/
#endif
/*
- Don't draw if not in sight
+ Don't generate or send if not in sight
*/
if(isBlockInSight(p, camera_pos, camera_dir, 10000*BS) == false)
Don't send already sent blocks
*/
{
- JMutexAutoLock lock(m_blocks_sent_mutex);
-
if(m_blocks_sent.find(p) != NULL)
continue;
}
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;
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;
- /*MapChunk *chunk = map->getChunk(chunkpos);
- if(chunk == NULL)
- block_is_invalid = true;
- else if(chunk->getIsVolatile() == true)
- block_is_invalid = true;*/
}
/*
*/
if(block == NULL || surely_not_found_on_disk || block_is_invalid)
{
- //dstream<<"asd"<<std::endl;
-
- /*SharedPtr<JMutexAutoLock> 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"<<std::endl;
}
/*
- Add block to queue
+ Add block to send queue
*/
PrioritySortedBlockTransfer q((float)d, p, peer_id);
if(new_nearest_unsent_d != -1)
{
- JMutexAutoLock lock(m_blocks_sent_mutex);
m_nearest_unsent_d = new_nearest_unsent_d;
}
}
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 = g_settings.getS16("active_object_range");
Ignore blocks that haven't been sent to the client
*/
{
- JMutexAutoLock sentlock(m_blocks_sent_mutex);
if(m_blocks_sent.find(p) == NULL)
continue;
}
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
void RemoteClient::SentBlock(v3s16 p)
{
- JMutexAutoLock lock(m_blocks_sending_mutex);
- /*if(m_blocks_sending.size() > 15)
- {
- dstream<<"RemoteClient::SentBlock(): "
- <<"m_blocks_sending.size()="
- <<m_blocks_sending.size()<<std::endl;
- }*/
if(m_blocks_sending.find(p) == NULL)
m_blocks_sending.insert(p, 0.0);
else
void RemoteClient::SetBlockNotSent(v3s16 p)
{
- JMutexAutoLock sendinglock(m_blocks_sending_mutex);
- JMutexAutoLock sentlock(m_blocks_sent_mutex);
-
m_nearest_unsent_d = 0;
if(m_blocks_sending.find(p) != NULL)
void RemoteClient::SetBlocksNotSent(core::map<v3s16, MapBlock*> &blocks)
{
- JMutexAutoLock sendinglock(m_blocks_sending_mutex);
- JMutexAutoLock sentlock(m_blocks_sent_mutex);
-
m_nearest_unsent_d = 0;
for(core::map<v3s16, MapBlock*>::Iterator
Server::Server(
std::string mapsavedir
):
- m_env(new ServerMap(mapsavedir), dout_server),
+ m_env(new ServerMap(mapsavedir), this),
m_con(PROTOCOL_ID, 512, CONNECTION_TIMEOUT, this),
m_thread(this),
m_emergethread(this),
m_time_counter(0),
m_time_of_day_send_timer(0),
m_uptime(0),
- m_mapsavedir(mapsavedir)
+ m_mapsavedir(mapsavedir),
+ m_shutdown_requested(false),
+ m_ignore_map_edit_events(false),
+ m_ignore_map_edit_events_peer_id(0)
{
- //m_flowwater_timer = 0.0;
m_liquid_transform_timer = 0.0;
m_print_info_timer = 0.0;
m_objectdata_timer = 0.0;
m_step_dtime_mutex.Init();
m_step_dtime = 0.0;
+ m_env.getMap().addEventReceiver(this);
+
// Load players
m_env.deSerializePlayers(m_mapsavedir);
}
Server::~Server()
{
- // Save players
+ /*
+ Send shutdown message
+ */
+ {
+ JMutexAutoLock conlock(m_con_mutex);
+
+ std::wstring line = L"*** Server shutting down";
+
+ /*
+ Send the message to clients
+ */
+ for(core::map<u16, RemoteClient*>::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;
+
+ SendChatMessage(client->peer_id, line);
+ }
+ }
+
+ /*
+ Save players
+ */
m_env.serializePlayers(m_mapsavedir);
- // Stop threads
+ /*
+ Stop threads
+ */
stop();
-
- JMutexAutoLock clientslock(m_con_mutex);
-
- for(core::map<u16, RemoteClient*>::Iterator
- i = m_clients.getIterator();
- i.atEnd() == false; i++)
+
+ /*
+ Delete clients
+ */
{
- /*// Delete player
- // NOTE: These are removed by env destructor
+ JMutexAutoLock clientslock(m_con_mutex);
+
+ for(core::map<u16, RemoteClient*>::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();
+ }
}
}
m_thread.setRun(true);
m_thread.Start();
- dout_server<<"Server started on port "<<port<<std::endl;
+ dout_server<<"Server: Started on port "<<port<<std::endl;
}
void Server::stop()
{
DSTACK(__FUNCTION_NAME);
+
// Stop threads (set run=false first so both start stopping)
m_thread.setRun(false);
m_emergethread.setRun(false);
m_thread.stop();
m_emergethread.stop();
- dout_server<<"Server threads stopped"<<std::endl;
+ dout_server<<"Server: Threads stopped"<<std::endl;
+
+ dout_server<<"Server: Saving players"<<std::endl;
+ // Save players
+ // FIXME: Apparently this does not do anything here
+ //m_env.serializePlayers(m_mapsavedir);
}
void Server::step(float dtime)
}
}
- /*
- 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<u16, RemoteClient*>::Iterator
i = m_clients.getIterator();
{
RemoteClient *client = i.getNode()->getValue();
Player *player = m_env.getPlayer(client->peer_id);
+ if(player==NULL)
+ continue;
+ v3s16 pos = floatToInt(player->getPosition(), BS);
+
+ core::map<u16, bool> removed_objects;
+ core::map<u16, bool> 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;
- JMutexAutoLock digmutex(client->m_dig_mutex);
+ char buf[4];
+
+ // Handle removed objects
+ writeU16((u8*)buf, removed_objects.size());
+ data_buffer.append(buf, 2);
+ for(core::map<u16, bool>::Iterator
+ i = removed_objects.getIterator();
+ i.atEnd()==false; i++)
+ {
+ // Get object
+ u16 id = i.getNode()->getKey();
+ ServerActiveObject* obj = m_env.getActiveObject(id);
- if(client->m_dig_tool_item == -1)
- continue;
+ // 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());
- client->m_dig_time_remaining -= dtime;
+ if(obj && obj->m_known_by_count > 0)
+ obj->m_known_by_count--;
+ }
- if(client->m_dig_time_remaining > 0)
+ // Handle added objects
+ writeU16((u8*)buf, added_objects.size());
+ data_buffer.append(buf, 2);
+ for(core::map<u16, bool>::Iterator
+ i = added_objects.getIterator();
+ i.atEnd()==false; i++)
{
- client->m_time_from_building.set(0.0);
- continue;
+ // 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"<<std::endl;
+ else
+ type = obj->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++;
}
- v3s16 p_under = client->m_dig_position;
-
- // Mandatory parameter; actually used for nothing
- core::map<v3s16, MapBlock*> modified_blocks;
+ // Send packet
+ SharedBuffer<u8> 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);
- u8 material;
+ dstream<<"INFO: Server: Sent object remove/add: "
+ <<removed_objects.size()<<" removed, "
+ <<added_objects.size()<<" added, "
+ <<"packet size is "<<reply.getSize()<<std::endl;
+ }
+ }
- try
+ /*
+ Send object messages
+ */
+ {
+ JMutexAutoLock envlock(m_env_mutex);
+ JMutexAutoLock conlock(m_con_mutex);
+
+ // Key = object id
+ // Value = data sent by object
+ core::map<u16, core::list<ActiveObjectMessage>* > buffered_messages;
+
+ // Get active object messages from environment
+ for(;;)
+ {
+ ActiveObjectMessage aom = m_env.getActiveObjectMessage();
+ if(aom.id == 0)
+ break;
+
+ core::list<ActiveObjectMessage>* message_list = NULL;
+ core::map<u16, core::list<ActiveObjectMessage>* >::Node *n;
+ n = buffered_messages.find(aom.id);
+ if(n == NULL)
{
- // Get material at position
- material = m_env.getMap().getNode(p_under).d;
- // If it's not diggable, do nothing
- if(content_diggable(material) == false)
+ message_list = new core::list<ActiveObjectMessage>;
+ 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<u16, RemoteClient*>::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<u16, core::list<ActiveObjectMessage>* >::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<ActiveObjectMessage>* list = j.getNode()->getValue();
+ // Go through every message
+ for(core::list<ActiveObjectMessage>::Iterator
+ k = list->begin(); k != list->end(); k++)
{
- derr_server<<"Server: Not finishing digging: Node not diggable"
- <<std::endl;
- client->m_dig_tool_item = -1;
- break;
+ // 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;
}
}
- catch(InvalidPositionException &e)
+ /*
+ reliable_data and unreliable_data are now ready.
+ Send them.
+ */
+ if(reliable_data.size() > 0)
{
- derr_server<<"Server: Not finishing digging: Node not found"
- <<std::endl;
- client->m_dig_tool_item = -1;
- break;
+ SharedBuffer<u8> 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);
}
-
- // Create packet
- u32 replysize = 8;
- SharedBuffer<u8> 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);
-
- if(g_settings.getBool("creative_mode") == false)
+ if(unreliable_data.size() > 0)
{
- // Add to inventory and send inventory
- InventoryItem *item = new MaterialItem(material, 1);
- player->inventory.addItem("main", item);
- SendInventory(player->peer_id);
+ SharedBuffer<u8> 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);
}
- /*
- 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
- */
-
- // Update water pressure around modification
- // This also adds it to m_flow_active_nodes if appropriate
+ /*if(reliable_data.size() > 0 || unreliable_data.size() > 0)
+ {
+ dstream<<"INFO: Server: Size of object message data: "
+ <<"reliable: "<<reliable_data.size()
+ <<", unreliable: "<<unreliable_data.size()
+ <<std::endl;
+ }*/
+ }
- 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));
+ // Clear buffered_messages
+ for(core::map<u16, core::list<ActiveObjectMessage>* >::Iterator
+ i = buffered_messages.getIterator();
+ i.atEnd()==false; i++)
+ {
+ delete i.getNode()->getValue();
+ }
+ }
- try
+ } // 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"<<std::endl;
+ sendAddNode(event->p, event->n, event->already_known_by_peer);
}
- catch(ProcessingLimitException &e)
+ else if(event->type == MEET_REMOVENODE)
{
- dstream<<"Processing limit reached (1)"<<std::endl;
+ dstream<<"Server: MEET_REMOVENODE"<<std::endl;
+ sendRemoveNode(event->p, event->already_known_by_peer);
}
-
- v.blitBack(modified_blocks);
+ else if(event->type == MEET_OTHER)
+ {
+ dstream<<"WARNING: Server: MEET_OTHER not implemented"
+ <<std::endl;
+ }
+ else
+ {
+ dstream<<"WARNING: Server: Unknown MapEditEvent "
+ <<((u32)event->type)<<std::endl;
+ }
+
+ delete event;
}
}
-#endif
- // Send object positions
+ /*
+ Send object positions
+ TODO: Get rid of MapBlockObjects
+ */
{
float &counter = m_objectdata_timer;
counter += dtime;
JMutexAutoLock lock(m_env_mutex);
- // 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)
+ if(((ServerMap*)(&m_env.getMap()))->isSavingEnabled() == true)
{
- dout_server<<"Server: Unloaded "<<deleted_count
- <<" sectors from memory"<<std::endl;
- }
+ // 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 "<<deleted_count
+ <<" sectors from memory"<<std::endl;
+ }
- // Save players
- m_env.serializePlayers(m_mapsavedir);
+ // Save players
+ m_env.serializePlayers(m_mapsavedir);
+ }
}
}
}
return;
}
- //u8 peer_ser_ver = peer->serialization_version;
u8 peer_ser_ver = getClient(peer->id)->serialization_version;
try
// Now answer with a TOCLIENT_INIT
- SharedBuffer<u8> reply(2+1+6);
+ SharedBuffer<u8> 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);
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<<L"# Server: ";
- // Uptime
- os<<L"uptime="<<m_uptime.get();
- // Information about clients
- os<<L", clients={";
- for(core::map<u16, RemoteClient*>::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<<name<<L",";
- }
- os<<L"}";
- // Send message
- SendChatMessage(peer_id, os.str());
- }
+ SendChatMessage(peer_id, getStatusString());
// Send information about joining in chat
{
0: start digging
1: place block
2: stop digging (all parameters ignored)
+ 3: digging completed
*/
u8 action = readU8(&data[2]);
v3s16 p_under;
{
derr_server<<"Server: Not finishing digging: Node not diggable"
<<std::endl;
+
+ // Client probably has wrong data.
+ // Set block not sent, so that client will get
+ // a valid one.
+ dstream<<"Client "<<peer_id<<" tried to dig "
+ <<"node from invalid position; setting"
+ <<" MapBlock not sent."<<std::endl;
+ RemoteClient *client = getClient(peer_id);
+ v3s16 blockpos = getNodeBlockPos(p_under);
+ client->SetBlockNotSent(blockpos);
+
return;
}
// Get mineral
/*
Send the removal to all other clients
*/
-
- // Create packet
- u32 replysize = 8;
- SharedBuffer<u8> 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<u16, RemoteClient*>::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
}
/*
- Add digged item to inventory
+ Add dug item to inventory
*/
InventoryItem *item = NULL;
if(mineral != MINERAL_NONE)
item = getDiggedMineralItem(mineral);
-
+
+ // If not mineral
if(item == NULL)
- item = new MaterialItem(material, 1);
-
- player->inventory.addItem("main", item);
+ {
+ 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);
+ // Send inventory
+ SendInventory(player->peer_id);
+ }
}
/*
Remove the node
(this takes some time so it is done after the quick stuff)
*/
- m_env.getMap().removeNodeAndUpdate(p_under, modified_blocks);
-
-#if 0
- /*
- 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)"<<std::endl;
- }
-
- v.blitBack(modified_blocks);
-#endif
+ m_ignore_map_edit_events = true;
+ m_env.getMap().removeNodeAndUpdate(p_under, modified_blocks);
+ m_ignore_map_edit_events = false;
}
/*
}
// Reset build time counter
- getClient(peer->id)->m_time_from_building.set(0.0);
+ getClient(peer->id)->m_time_from_building = 0.0;
// Create node data
MaterialItem *mitem = (MaterialItem*)item;
n.d = mitem->getMaterial();
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<u8> 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<v3s16, MapBlock*> modified_blocks;
- m_env.getMap().addNodeAndUpdate(p_over, n, modified_blocks);
-#endif
-#if 0
/*
Handle inventory
*/
// Send inventory
SendInventory(peer_id);
}
-
+
/*
Add node.
This takes some time so it is done after the quick stuff
*/
core::map<v3s16, MapBlock*> 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<u16, RemoteClient*>::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
-
-#if 0
- /*
- 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)"<<std::endl;
- }
-
- v.blitBack(modified_blocks);
-#endif
+ }*/
}
/*
Handle other items
}
v3s16 block_pos_i_on_map = block->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="
// 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: "<<wide_to_narrow(line)<<std::endl;
-
- /*
- Send the message to all other clients
- */
- for(core::map<u16, RemoteClient*>::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<<DTIME<<" Server: Operator requested shutdown."
+ <<std::endl;
+ m_shutdown_requested.set(true);
+
+ line += L"*** Server shutting down (operator request)";
+ send_to_sender = true;
+ valid_command = true;
+ }
+ else if(message_s.substr(0,8) == "setting ")
+ {
+ std::string confline = message_s.substr(8);
+ g_settings.parseConfigLine(confline);
+ line += L"-!- Setting changed.";
+ send_to_sender = true;
+ valid_command = true;
+ }
+ }
+
+ if(valid_command == false)
+ {
+ line += L"-!- Invalid command: " + message;
+ send_to_sender = true;
+ }
+ }
+ else
{
- // 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;
+ line += L"<";
+ /*if(is_operator)
+ line += L"@";*/
+ line += name;
+ line += L"> ";
+ line += message;
+ send_to_others = true;
+ }
+
+ if(line != L"")
+ {
+ dstream<<"CHAT: "<<wide_to_narrow(line)<<std::endl;
- // Don't send if it's the same one
- if(peer_id == client->peer_id)
- continue;
+ /*
+ Send the message to clients
+ */
+ for(core::map<u16, RemoteClient*>::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;
- SendChatMessage(client->peer_id, line);
+ // 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
}
}
-/*void Server::Send(u16 peer_id, u16 channelnum,
- SharedBuffer<u8> 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)
+void Server::onMapEditEvent(MapEditEvent *event)
{
- 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<u8> blockdata((u8*)s.c_str(), s.size());
-
- u32 replysize = 8 + blockdata.getSize();
- SharedBuffer<u8> 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 ("<<p.X<<","<<p.Y<<","<<p.Z<<")"
- <<": \tpacket size: "<<replysize<<std::endl;*/
-
- /*
- Send packet
- */
- m_con.Send(peer_id, 1, reply, true);
+ dstream<<"Server::onMapEditEvent()"<<std::endl;
+ if(m_ignore_map_edit_events)
+ return;
+ MapEditEvent *e = event->clone();
+ m_unsent_map_edit_queue.push_back(e);
}
core::list<PlayerInfo> Server::getPlayerInfo()
return list;
}
+
void Server::peerAdded(con::Peer *peer)
{
DSTACK(__FUNCTION_NAME);
m_con.SendToAll(0, data, true);
}
+/*
+ Craft checking system
+*/
+
enum ItemSpecType
{
ITEM_NONE,
}
}
+void Server::sendRemoveNode(v3s16 p, u16 ignore_id)
+{
+ // Create packet
+ u32 replysize = 8;
+ SharedBuffer<u8> 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<u16, RemoteClient*>::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<u16, RemoteClient*>::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<u8> 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<u8> blockdata((u8*)s.c_str(), s.size());
+
+ u32 replysize = 8 + blockdata.getSize();
+ SharedBuffer<u8> 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 ("<<p.X<<","<<p.Y<<","<<p.Z<<")"
+ <<": \tpacket size: "<<replysize<<std::endl;*/
+
+ /*
+ Send packet
+ */
+ m_con.Send(peer_id, 1, reply, true);
+}
+
void Server::SendBlocks(float dtime)
{
DSTACK(__FUNCTION_NAME);
JMutexAutoLock envlock(m_env_mutex);
+ JMutexAutoLock conlock(m_con_mutex);
+
+ //TimeTaker timer("Server::SendBlocks");
core::array<PrioritySortedBlockTransfer> queue;
// Lowest is most important.
queue.sort();
- JMutexAutoLock conlock(m_con_mutex);
-
for(u32 i=0; i<queue.size(); i++)
{
//TODO: Calculate limit dynamically
return n->getValue();
}
+std::wstring Server::getStatusString()
+{
+ std::wostringstream os(std::ios_base::binary);
+ os<<L"# Server: ";
+ // Uptime
+ os<<L"uptime="<<m_uptime.get();
+ // Information about clients
+ os<<L", clients={";
+ for(core::map<u16, RemoteClient*>::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<<name<<L",";
+ }
+ os<<L"}";
+ if(((ServerMap*)(&m_env.getMap()))->isSavingEnabled() == false)
+ os<<" WARNING: Map saving is disabled."<<std::endl;
+ return os.str();
+}
+
+
void setCreativeInventory(Player *player)
{
player->resetInventory();
/*
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; i<PLAYER_INVENTORY_SIZE; i++)
+ {
+ if(*mip == CONTENT_IGNORE)
+ break;
+
+ InventoryItem *item = new MaterialItem(*mip, 1);
+ player->inventory.addItem("main", item);
+
+ mip++;
+ }
+
+#if 0
assert(USEFUL_CONTENT_COUNT <= PLAYER_INVENTORY_SIZE);
// add torch first
InventoryItem *item = new MaterialItem(i, 1);
player->inventory.addItem("main", item);
}
+#endif
+
// Sign
{
InventoryItem *item = new MapBlockObjectItem("Sign Example text");
<<player->getName()<<"\""<<std::endl;
v2s16 nodepos;
-#if 1
+#if 0
player->setPosition(intToFloat(v3s16(
0,
45, //64,
0
- )));
+ ), BS));
#endif
-#if 0
- f32 groundheight = 0;
-#if 0
+#if 1
+ s16 groundheight = 0;
+#if 1
// Try to find a good place a few times
- for(s32 i=0; i<500; i++)
+ 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
- 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"<<std::endl;
continue;
}
-#if 0 // Doesn't work, generating blocks is a bit too complicated for doing here
+ // Don't go to high places
+ if(groundheight > WATER_LEVEL + 4)
+ {
+ //dstream<<"-> Underwater"<<std::endl;
+ continue;
+ }
+
+#if 0
+// Doesn't work, generating blocks is a bit too complicated for doing here
// Get block at point
v3s16 nodepos3d;
nodepos3d = v3s16(nodepos.X, groundheight+1, nodepos.Y);
continue;
}
#endif
+
// Found a good place
dstream<<"Searched through "<<i<<" places."<<std::endl;
break;
player->setPosition(intToFloat(v3s16(
nodepos.X,
- //groundheight + 1,
- groundheight + 15,
+ groundheight + 5, // Accomodate mud
nodepos.Y
- )));
+ ), BS));
#endif
/*
}
}
-void dedicated_server_loop(Server &server)
+void dedicated_server_loop(Server &server, bool &kill)
{
DSTACK(__FUNCTION_NAME);
- std::cout<<std::endl;
+ std::cout<<DTIME<<std::endl;
std::cout<<"========================"<<std::endl;
std::cout<<"Running dedicated server"<<std::endl;
std::cout<<"========================"<<std::endl;
sleep_ms(30);
server.step(0.030);
+ if(server.getShutdownRequested() || kill)
+ {
+ std::cout<<DTIME<<" dedicated_server_loop(): Quitting."<<std::endl;
+ break;
+ }
+
static int counter = 0;
counter--;
if(counter <= 0)