/*
Minetest-c55
-Copyright (C) 2010 celeron55, Perttu Ahola <celeron55@gmail.com>
+Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
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>
#include "voxel.h"
#include "materials.h"
#include "mineral.h"
+#include "config.h"
+#include "servercommand.h"
+#include "filesys.h"
+#include "content_mapnode.h"
+#include "content_craft.h"
+#include "content_nodemeta.h"
+#include "mapblock.h"
+#include "serverobject.h"
#define BLOCK_EMERGE_FLAG_FROMDISK (1<<0)
+class MapEditEventIgnorer
+{
+public:
+ MapEditEventIgnorer(bool *flag):
+ m_flag(flag)
+ {
+ if(*m_flag == false)
+ *m_flag = true;
+ else
+ m_flag = NULL;
+ }
+
+ ~MapEditEventIgnorer()
+ {
+ if(m_flag)
+ {
+ assert(*m_flag);
+ *m_flag = false;
+ }
+ }
+
+private:
+ bool *m_flag;
+};
+
void * ServerThread::Thread()
{
ThreadStarted();
DSTACK(__FUNCTION_NAME);
- bool debug=false;
-
BEGIN_DEBUG_EXCEPTION_HANDLER
+ bool enable_mapgen_debug_info = g_settings.getBool("enable_mapgen_debug_info");
+
/*
Get block info from queue, emerge them and send them
to clients.
SharedPtr<QueuedBlockEmerge> q(qptr);
v3s16 &p = q->pos;
-
+ v2s16 p2d(p.X,p.Z);
+
+ /*
+ Do not generate over-limit
+ */
+ if(p.X < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+ || p.X > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+ || p.Y < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+ || p.Y > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+ || p.Z < -MAP_GENERATION_LIMIT / MAP_BLOCKSIZE
+ || p.Z > MAP_GENERATION_LIMIT / MAP_BLOCKSIZE)
+ continue;
+
//derr_server<<"EmergeThread::Thread(): running"<<std::endl;
//TimeTaker timer("block emerge");
Also decrement the emerge queue count in clients.
*/
- bool optional = true;
+ bool only_from_disk = true;
{
core::map<u16, u8>::Iterator i;
// Check flags
u8 flags = i.getNode()->getValue();
if((flags & BLOCK_EMERGE_FLAG_FROMDISK) == false)
- optional = false;
+ only_from_disk = false;
}
}
-
- /*dstream<<"EmergeThread: p="
- <<"("<<p.X<<","<<p.Y<<","<<p.Z<<") "
- <<"optional="<<optional<<std::endl;*/
+
+ if(enable_mapgen_debug_info)
+ dstream<<"EmergeThread: p="
+ <<"("<<p.X<<","<<p.Y<<","<<p.Z<<") "
+ <<"only_from_disk="<<only_from_disk<<std::endl;
ServerMap &map = ((ServerMap&)m_server->m_env.getMap());
- core::map<v3s16, MapBlock*> changed_blocks;
- core::map<v3s16, MapBlock*> lighting_invalidated_blocks;
+ //core::map<v3s16, MapBlock*> changed_blocks;
+ //core::map<v3s16, MapBlock*> lighting_invalidated_blocks;
MapBlock *block = NULL;
bool got_block = true;
core::map<v3s16, MapBlock*> modified_blocks;
- {//envlock
-
- //TimeTaker envlockwaittimer("block emerge envlock wait time");
-
- // 0-50ms
- JMutexAutoLock envlock(m_server->m_env_mutex);
-
- //envlockwaittimer.stop();
-
- //TimeTaker timer("block emerge (while env locked)");
-
- try{
- bool only_from_disk = false;
-
- if(optional)
- only_from_disk = true;
+ /*
+ Fetch block from map or generate a single block
+ */
+ {
+ JMutexAutoLock envlock(m_server->m_env_mutex);
- // First check if the block already exists
- //block = map.getBlockNoCreate(p);
+ // Load sector if it isn't loaded
+ if(map.getSectorNoGenerateNoEx(p2d) == NULL)
+ //map.loadSectorFull(p2d);
+ map.loadSectorMeta(p2d);
- if(block == NULL)
+ block = map.getBlockNoCreateNoEx(p);
+ if(!block || block->isDummy() || !block->isGenerated())
{
- //dstream<<"Calling emergeBlock"<<std::endl;
- block = map.emergeBlock(
- p,
- only_from_disk,
- changed_blocks,
- lighting_invalidated_blocks);
- }
+ if(enable_mapgen_debug_info)
+ dstream<<"EmergeThread: not in memory, loading"<<std::endl;
- // If it is a dummy, block was not found on disk
- if(block->isDummy())
- {
- //dstream<<"EmergeThread: Got a dummy block"<<std::endl;
- got_block = false;
+ // Get, load or create sector
+ /*ServerMapSector *sector =
+ (ServerMapSector*)map.createSector(p2d);*/
+
+ // Load/generate block
+ /*block = map.emergeBlock(p, sector, changed_blocks,
+ lighting_invalidated_blocks);*/
+
+ block = map.loadBlock(p);
+
if(only_from_disk == false)
{
- dstream<<"EmergeThread: wanted to generate a block but got a dummy"<<std::endl;
- assert(0);
+ if(block == NULL || block->isGenerated() == false)
+ {
+ if(enable_mapgen_debug_info)
+ dstream<<"EmergeThread: generating"<<std::endl;
+ block = map.generateBlock(p, modified_blocks);
+ }
+ }
+
+ if(enable_mapgen_debug_info)
+ dstream<<"EmergeThread: ended up with: "
+ <<analyze_block(block)<<std::endl;
+
+ if(block == NULL)
+ {
+ got_block = false;
+ }
+ else
+ {
+ /*
+ Ignore map edit events, they will not need to be
+ sent to anybody because the block hasn't been sent
+ to anybody
+ */
+ MapEditEventIgnorer ign(&m_server->m_ignore_map_edit_events);
+
+ // Activate objects and stuff
+ m_server->m_env.activateBlock(block, 3600);
}
}
+ else
+ {
+ /*if(block->getLightingExpired()){
+ lighting_invalidated_blocks[block->getPos()] = block;
+ }*/
+ }
+
+ // TODO: Some additional checking and lighting updating,
+ // see emergeBlock
}
- catch(InvalidPositionException &e)
- {
- // Block not found.
- // This happens when position is over limit.
- got_block = false;
- }
+
+ {//envlock
+ JMutexAutoLock envlock(m_server->m_env_mutex);
if(got_block)
{
- if(debug && changed_blocks.size() > 0)
- {
- dout_server<<DTIME<<"Got changed_blocks: ";
- for(core::map<v3s16, MapBlock*>::Iterator i = changed_blocks.getIterator();
- i.atEnd() == false; i++)
- {
- MapBlock *block = i.getNode()->getValue();
- v3s16 p = block->getPos();
- dout_server<<"("<<p.X<<","<<p.Y<<","<<p.Z<<") ";
- }
- dout_server<<std::endl;
- }
-
/*
Collect a list of blocks that have been modified in
addition to the fetched one.
*/
- // Add all the "changed blocks" to modified_blocks
+#if 0
+ 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);
+#endif
}
// If we got no block, there should be no invalidated blocks
else
{
- assert(lighting_invalidated_blocks.size() == 0);
+ //assert(lighting_invalidated_blocks.size() == 0);
}
}//envlock
{
DSTACK(__FUNCTION_NAME);
+ /*u32 timer_result;
+ TimeTaker timer("RemoteClient::GetNextBlocks", &timer_result);*/
+
// Increment timers
+ m_nothing_to_send_pause_timer -= dtime;
+
+ if(m_nothing_to_send_pause_timer >= 0)
{
- JMutexAutoLock lock(m_blocks_sent_mutex);
- m_nearest_unsent_reset_timer += dtime;
+ // Keep this reset
+ m_nearest_unsent_reset_timer = 0;
+ return;
}
// 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;
}
+ //TimeTaker timer("RemoteClient::GetNextBlocks");
+
Player *player = server->m_env.getPlayer(peer_id);
assert(player != NULL);
v3f playerpos = player->getPosition();
v3f playerspeed = player->getSpeed();
+ v3f playerspeeddir(0,0,0);
+ if(playerspeed.getLength() > 1.0*BS)
+ playerspeeddir = playerspeed / playerspeed.getLength();
+ // Predict to next block
+ v3f playerpos_predicted = playerpos + playerspeeddir*MAP_BLOCKSIZE*BS;
- v3s16 center_nodepos = floatToInt(playerpos);
+ v3s16 center_nodepos = floatToInt(playerpos_predicted, BS);
v3s16 center = getNodeBlockPos(center_nodepos);
camera_dir.rotateYZBy(player->getPitch());
camera_dir.rotateXZBy(player->getYaw());
+ /*dstream<<"camera_dir=("<<camera_dir.X<<","<<camera_dir.Y<<","
+ <<camera_dir.Z<<")"<<std::endl;*/
+
/*
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="
- <<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;*/
+
+ // This has to be incremented only when the nothing to send pause
+ // is not active
+ m_nearest_unsent_reset_timer += dtime;
+
+ // Reset periodically to avoid possible bugs or other mishaps
+ if(m_nearest_unsent_reset_timer > 10.0)
+ {
+ m_nearest_unsent_reset_timer = 0;
+ m_nearest_unsent_d = 0;
+ /*dstream<<"Resetting m_nearest_unsent_d for "
+ <<server->getPlayerName(peer_id)<<std::endl;*/
}
- u16 maximum_simultaneous_block_sends_setting = g_settings.getU16
+ //s16 last_nearest_unsent_d = m_nearest_unsent_d;
+ s16 d_start = m_nearest_unsent_d;
+
+ //dstream<<"d_start="<<d_start<<std::endl;
+
+ u16 max_simul_sends_setting = g_settings.getU16
("max_simultaneous_block_sends_per_client");
- u16 maximum_simultaneous_block_sends =
- maximum_simultaneous_block_sends_setting;
+ u16 max_simul_sends_usually = max_simul_sends_setting;
/*
Check the time from last addNode/removeNode.
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;
- }
+ max_simul_sends_usually
+ = LIMITED_MAX_SIMULTANEOUS_BLOCK_SENDS;
}
- u32 num_blocks_selected;
- {
- JMutexAutoLock lock(m_blocks_sending_mutex);
- num_blocks_selected = m_blocks_sending.size();
- }
+ /*
+ Number of blocks sending + number of blocks selected for sending
+ */
+ 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");
+ // Don't loop very much at a time
+ if(d_max > d_start+1)
+ d_max = d_start+1;
+ /*if(d_max_gen > d_start+2)
+ d_max_gen = d_start+2;*/
+
//dstream<<"Starting from "<<d_start<<std::endl;
- for(s16 d = d_start; d <= d_max; d++)
+ bool sending_something = false;
+
+ bool no_blocks_found_for_sending = true;
+
+ bool queue_is_full = false;
+
+ s16 d;
+ for(d = d_start; d <= d_max; d++)
{
//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;
+ }*/
/*
Get the border/face dot coordinates of a "d-radiused"
Also, don't send blocks that are already flying.
*/
- u16 maximum_simultaneous_block_sends_now =
- maximum_simultaneous_block_sends;
+ // Start with the usual maximum
+ u16 max_simul_dynamic = max_simul_sends_usually;
+ // If block is very close, allow full maximum
if(d <= BLOCK_SEND_DISABLE_LIMITS_MAX_D)
- {
- maximum_simultaneous_block_sends_now =
- maximum_simultaneous_block_sends_setting;
- }
+ max_simul_dynamic = max_simul_sends_setting;
+ // Don't select too many blocks for sending
+ if(num_blocks_selected >= max_simul_dynamic)
{
- 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;
+ queue_is_full = true;
+ goto queue_full_break;
}
+ // Don't send blocks that are currently being transferred
+ if(m_blocks_sending.find(p) != NULL)
+ continue;
+
/*
Do not go over-limit
*/
continue;
}
-#if 0
+#if 1
/*
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.
+ near ground level.
*/
- if(d > 4)
+ if(d >= 4)
{
- 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;
- }
+ #if 1
+ // Block center y in nodes
+ f32 y = (f32)(p.Y * MAP_BLOCKSIZE + MAP_BLOCKSIZE/2);
+ // Don't generate if it's very high or very low
+ if(y < -64 || y > 64)
+ generate = false;
+ #endif
+ #if 0
+ v2s16 p2d_nodes_center(
+ MAP_BLOCKSIZE*p.X,
+ MAP_BLOCKSIZE*p.Z);
+
+ // Get ground height in nodes
+ s16 gh = server->m_env.getServerMap().findGroundLevel(
+ p2d_nodes_center);
+
+ // If differs a lot, don't generate
+ if(fabs(gh - y) > MAP_BLOCKSIZE*2)
+ generate = false;
+ // Actually, don't even send it
+ //continue;
+ #endif
}
#endif
+ //dstream<<"d="<<d<<std::endl;
+
/*
- 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;
- }*/
+ // Reset usage timer, this block will be of use in the future.
+ block->resetUsageTimer();
+ // Block is dummy if data doesn't exist.
+ // It means it has been not found from disk and not generated
if(block->isDummy())
{
surely_not_found_on_disk = true;
}
-
+
+ // Block is valid if lighting is up-to-date and data exists
if(block->isValid() == false)
{
block_is_invalid = true;
}
+ /*if(block->isFullyGenerated() == false)
+ {
+ block_is_invalid = true;
+ }*/
+
+#if 0
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)
+#endif
+ if(block->isGenerated() == false)
block_is_invalid = true;
- else if(chunk->getIsVolatile() == true)
- block_is_invalid = true;*/
+#if 1
+ /*
+ If block is not close, don't send it unless it is near
+ ground level.
+
+ Block is near ground level if night-time mesh
+ differs from day-time mesh.
+ */
+ if(d > 3)
+ {
+ if(block->dayNightDiffed() == false)
+ continue;
+ }
+#endif
}
/*
}
/*
- Record the lowest d from which a a block has been
+ Record the lowest d from which a block has been
found being not sent and possibly to exist
*/
- if(new_nearest_unsent_d == -1 || d < new_nearest_unsent_d)
+ if(no_blocks_found_for_sending)
{
- new_nearest_unsent_d = d;
+ if(generate == true)
+ new_nearest_unsent_d = d;
}
+
+ no_blocks_found_for_sending = false;
/*
Add inexistent block to emerge queue.
*/
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)
+ // Allow two blocks in queue per client
+ 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);
dest.push_back(q);
num_blocks_selected += 1;
+ sending_something = true;
}
}
-queue_full:
+queue_full_break:
- if(new_nearest_unsent_d != -1)
+ //dstream<<"Stopped at "<<d<<std::endl;
+
+ if(no_blocks_found_for_sending)
{
- JMutexAutoLock lock(m_blocks_sent_mutex);
+ if(queue_is_full == false)
+ new_nearest_unsent_d = d;
+ }
+
+ if(new_nearest_unsent_d != -1)
m_nearest_unsent_d = new_nearest_unsent_d;
+
+ if(sending_something == false)
+ {
+ m_nothing_to_send_counter++;
+ if((s16)m_nothing_to_send_counter >=
+ g_settings.getS16("max_block_send_distance"))
+ {
+ // Pause time in seconds
+ m_nothing_to_send_pause_timer = 1.0;
+ /*dstream<<"nothing to send to "
+ <<server->getPlayerName(peer_id)
+ <<" (d="<<d<<")"<<std::endl;*/
+ }
+ }
+ else
+ {
+ m_nothing_to_send_counter = 0;
}
+
+ /*timer_result = timer.stop(true);
+ if(timer_result != 0)
+ dstream<<"GetNextBlocks duration: "<<timer_result<<" (!=0)"<<std::endl;*/
}
void RemoteClient::SendObjectData(
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;
}
*/
if(stepped_blocks.find(p) == NULL)
{
- block->stepObjects(dtime, true, server->getDayNightRatio());
+ block->stepObjects(dtime, true, server->m_env.getDayNightRatio());
stepped_blocks.insert(p, true);
block->setChangedFlag();
}
bos.write((char*)buf, 6);
// Write objects
- block->serializeObjects(bos, serialization_version);
+ //block->serializeObjects(bos, serialization_version); // DEPRECATED
+ // count=0
+ writeU16(bos, 0);
blockcount++;
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
PlayerInfo::PlayerInfo()
{
name[0] = 0;
+ avg_rtt = 0;
}
void PlayerInfo::PrintLine(std::ostream *s)
*/
Server::Server(
- std::string mapsavedir
+ std::string mapsavedir,
+ std::string configpath
):
- m_env(new ServerMap(mapsavedir), dout_server),
+ m_env(new ServerMap(mapsavedir), this),
m_con(PROTOCOL_ID, 512, CONNECTION_TIMEOUT, this),
+ m_authmanager(mapsavedir+"/auth.txt"),
m_thread(this),
m_emergethread(this),
- m_time_of_day(9000),
m_time_counter(0),
m_time_of_day_send_timer(0),
m_uptime(0),
m_mapsavedir(mapsavedir),
- m_shutdown_requested(false)
+ m_configpath(configpath),
+ 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_con_mutex.Init();
m_step_dtime_mutex.Init();
m_step_dtime = 0.0;
+
+ // Register us to receive map edit events
+ m_env.getMap().addEventReceiver(this);
+
+ // If file exists, load environment metadata
+ if(fs::PathExists(m_mapsavedir+"/env_meta.txt"))
+ {
+ dstream<<"Server: Loading environment metadata"<<std::endl;
+ m_env.loadMeta(m_mapsavedir);
+ }
// Load players
+ dstream<<"Server: Loading players"<<std::endl;
m_env.deSerializePlayers(m_mapsavedir);
}
Server::~Server()
{
+ dstream<<"Server::~Server()"<<std::endl;
+
/*
Send shutdown message
*/
if(client->serialization_version == SER_FMT_VER_INVALID)
continue;
- SendChatMessage(client->peer_id, line);
+ try{
+ SendChatMessage(client->peer_id, line);
+ }
+ catch(con::PeerNotFoundException &e)
+ {}
}
}
/*
Save players
*/
+ dstream<<"Server: Saving players"<<std::endl;
m_env.serializePlayers(m_mapsavedir);
+
+ /*
+ Save environment metadata
+ */
+ dstream<<"Server: Saving environment metadata"<<std::endl;
+ m_env.saveMeta(m_mapsavedir);
/*
Stop threads
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;
}
void Server::step(float dtime)
dtime = m_step_dtime;
}
- // Send blocks to clients
- SendBlocks(dtime);
+ {
+ ScopeProfiler sp(&g_profiler, "Server: selecting and sending "
+ "blocks to clients");
+ // Send blocks to clients
+ SendBlocks(dtime);
+ }
if(dtime < 0.001)
return;
-
+
//dstream<<"Server steps "<<dtime<<std::endl;
//dstream<<"Server::AsyncRunStep(): dtime="<<dtime<<std::endl;
}
/*
- Update m_time_of_day
+ Update m_time_of_day and overall game time
*/
{
+ JMutexAutoLock envlock(m_env_mutex);
+
m_time_counter += dtime;
f32 speed = g_settings.getFloat("time_speed") * 24000./(24.*3600);
u32 units = (u32)(m_time_counter*speed);
m_time_counter -= (f32)units / speed;
- m_time_of_day.set((m_time_of_day.get() + units) % 24000);
+
+ m_env.setTimeOfDay((m_env.getTimeOfDay() + units) % 24000);
//dstream<<"Server: m_time_of_day = "<<m_time_of_day.get()<<std::endl;
//Player *player = m_env.getPlayer(client->peer_id);
SharedBuffer<u8> data = makePacket_TOCLIENT_TIME_OF_DAY(
- m_time_of_day.get());
+ m_env.getTimeOfDay());
// Send as reliable
m_con.Send(client->peer_id, 0, data, true);
}
{
// Process connection's timeouts
JMutexAutoLock lock2(m_con_mutex);
+ ScopeProfiler sp(&g_profiler, "Server: connection timeout processing");
m_con.RunTimeouts(dtime);
}
{
// This has to be called so that the client list gets synced
// with the peer list of the connection
+ ScopeProfiler sp(&g_profiler, "Server: peer change handling");
handlePeerChanges();
}
{
- // Step environment
- // This also runs Map's timers
JMutexAutoLock lock(m_env_mutex);
+ // Step environment
+ ScopeProfiler sp(&g_profiler, "Server: environment step");
m_env.step(dtime);
}
+
+ const float map_timer_and_unload_dtime = 5.15;
+ if(m_map_timer_and_unload_interval.step(dtime, map_timer_and_unload_dtime))
+ {
+ JMutexAutoLock lock(m_env_mutex);
+ // Run Map's timers and unload unused data
+ ScopeProfiler sp(&g_profiler, "Server: map timer and unload");
+ m_env.getMap().timerUpdate(map_timer_and_unload_dtime,
+ g_settings.getFloat("server_unload_unused_data_timeout"));
+ }
/*
Do background stuff
m_liquid_transform_timer -= 1.00;
JMutexAutoLock lock(m_env_mutex);
-
+
+ ScopeProfiler sp(&g_profiler, "Server: liquid transform");
+
core::map<v3s16, MapBlock*> modified_blocks;
m_env.getMap().transformLiquids(modified_blocks);
#if 0
{
//u16 peer_id = i.getNode()->getKey();
RemoteClient *client = i.getNode()->getValue();
+ Player *player = m_env.getPlayer(client->peer_id);
+ if(player==NULL)
+ continue;
+ std::cout<<player->getName()<<"\t";
client->PrintInfo(std::cout);
}
}
}
- /*
- 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
{
+ //dstream<<"Server: Checking added and deleted active objects"<<std::endl;
JMutexAutoLock envlock(m_env_mutex);
JMutexAutoLock conlock(m_con_mutex);
+ ScopeProfiler sp(&g_profiler, "Server: checking added and deleted objects");
+
+ // Radius inside which objects are active
+ s16 radius = 32;
+
for(core::map<u16, RemoteClient*>::Iterator
i = m_clients.getIterator();
i.atEnd() == false; i++)
{
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)
+ {
+ // This can happen if the client timeouts somehow
+ /*dstream<<"WARNING: "<<__FUNCTION_NAME<<": Client "
+ <<client->peer_id
+ <<" has no associated player"<<std::endl;*/
continue;
-
- client->m_dig_time_remaining -= dtime;
-
- if(client->m_dig_time_remaining > 0)
+ }
+ 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)
{
- client->m_time_from_building.set(0.0);
+ //dstream<<"INFO: active objects: none changed"<<std::endl;
continue;
}
+
+ std::string data_buffer;
- v3s16 p_under = client->m_dig_position;
+ char buf[4];
- // Mandatory parameter; actually used for nothing
- core::map<v3s16, MapBlock*> modified_blocks;
+ // 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);
- u8 material;
+ // 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());
- try
- {
- // 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"
- <<std::endl;
- client->m_dig_tool_item = -1;
- break;
- }
+ if(obj && obj->m_known_by_count > 0)
+ obj->m_known_by_count--;
}
- catch(InvalidPositionException &e)
+
+ // 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++)
{
- derr_server<<"Server: Not finishing digging: Node not found"
- <<std::endl;
- client->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"<<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);
+
+ if(obj)
+ data_buffer.append(serializeLongString(
+ obj->getClientInitializationData()));
+ else
+ data_buffer.append(serializeLongString(""));
+
+ // 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<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 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.SendToAll(0, reply, true);
-
- if(g_settings.getBool("creative_mode") == false)
+ m_con.Send(client->peer_id, 0, reply, true);
+
+ dstream<<"INFO: Server: Sent object remove/add: "
+ <<removed_objects.size()<<" removed, "
+ <<added_objects.size()<<" added, "
+ <<"packet size is "<<reply.getSize()<<std::endl;
+ }
+
+#if 0
+ /*
+ Collect a list of all the objects known by the clients
+ and report it back to the environment.
+ */
+
+ core::map<u16, bool> all_known_objects;
+
+ for(core::map<u16, RemoteClient*>::Iterator
+ i = m_clients.getIterator();
+ i.atEnd() == false; i++)
+ {
+ RemoteClient *client = i.getNode()->getValue();
+ // Go through all known objects of client
+ for(core::map<u16, bool>::Iterator
+ i = client->m_known_objects.getIterator();
+ i.atEnd()==false; i++)
{
- // Add to inventory and send inventory
- InventoryItem *item = new MaterialItem(material, 1);
- player->inventory.addItem("main", item);
- SendInventory(player->peer_id);
+ u16 id = i.getNode()->getKey();
+ all_known_objects[id] = true;
}
+ }
+
+ m_env.setKnownActiveObjects(whatever);
+#endif
- /*
- Remove the node
- (this takes some time so it is done after the quick stuff)
- */
- m_env.getMap().removeNodeAndUpdate(p_under, modified_blocks);
+ }
+
+ /*
+ Send object messages
+ */
+ {
+ JMutexAutoLock envlock(m_env_mutex);
+ JMutexAutoLock conlock(m_con_mutex);
+
+ ScopeProfiler sp(&g_profiler, "Server: sending object messages");
+
+ // 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)
+ {
+ 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++)
+ {
+ // 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;
+ }
+ }
/*
- 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<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);
+ }
+ if(unreliable_data.size() > 0)
+ {
+ 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);
+ }
+
+ /*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;
+ }*/
+ }
+
+ // Clear buffered_messages
+ for(core::map<u16, core::list<ActiveObjectMessage>* >::Iterator
+ i = buffered_messages.getIterator();
+ i.atEnd()==false; i++)
+ {
+ delete i.getNode()->getValue();
+ }
+ }
+
+ } // enable_experimental
+
+ /*
+ Send queued-for-sending map edit events.
+ */
+ {
+ // Don't send too many at a time
+ //u32 count = 0;
+
+ // Single change sending is disabled if queue size is not small
+ bool disable_single_change_sending = false;
+ if(m_unsent_map_edit_queue.size() >= 4)
+ disable_single_change_sending = true;
+
+ bool got_any_events = false;
+
+ // We'll log the amount of each
+ Profiler prof;
+
+ while(m_unsent_map_edit_queue.size() != 0)
+ {
+ got_any_events = true;
- MapVoxelManipulator v(&m_env.getMap());
- v.m_disable_water_climb =
- g_settings.getBool("disable_water_climb");
+ MapEditEvent* event = m_unsent_map_edit_queue.pop_front();
- VoxelArea area(p_under-v3s16(1,1,1), p_under+v3s16(1,1,1));
+ // Players far away from the change are stored here.
+ // Instead of sending the changes, MapBlocks are set not sent
+ // for them.
+ core::list<u16> far_players;
- try
+ if(event->type == MEET_ADDNODE)
+ {
+ //dstream<<"Server: MEET_ADDNODE"<<std::endl;
+ prof.add("MEET_ADDNODE", 1);
+ if(disable_single_change_sending)
+ sendAddNode(event->p, event->n, event->already_known_by_peer,
+ &far_players, 5);
+ else
+ sendAddNode(event->p, event->n, event->already_known_by_peer,
+ &far_players, 30);
+ }
+ else if(event->type == MEET_REMOVENODE)
+ {
+ //dstream<<"Server: MEET_REMOVENODE"<<std::endl;
+ prof.add("MEET_REMOVENODE", 1);
+ if(disable_single_change_sending)
+ sendRemoveNode(event->p, event->already_known_by_peer,
+ &far_players, 5);
+ else
+ sendRemoveNode(event->p, event->already_known_by_peer,
+ &far_players, 30);
+ }
+ else if(event->type == MEET_BLOCK_NODE_METADATA_CHANGED)
{
- v.updateAreaWaterPressure(area, m_flow_active_nodes);
+ dstream<<"Server: MEET_BLOCK_NODE_METADATA_CHANGED"<<std::endl;
+ prof.add("MEET_BLOCK_NODE_METADATA_CHANGED", 1);
+ setBlockNotSent(event->p);
}
- catch(ProcessingLimitException &e)
+ else if(event->type == MEET_OTHER)
{
- dstream<<"Processing limit reached (1)"<<std::endl;
+ prof.add("MEET_OTHER", 1);
+ dstream<<"WARNING: Server: MEET_OTHER not implemented"
+ <<std::endl;
+ }
+ else
+ {
+ prof.add("unknown", 1);
+ dstream<<"WARNING: Server: Unknown MapEditEvent "
+ <<((u32)event->type)<<std::endl;
}
- v.blitBack(modified_blocks);
+ /*
+ Set blocks not sent to far players
+ */
+ if(far_players.size() > 0)
+ {
+ // Convert list format to that wanted by SetBlocksNotSent
+ core::map<v3s16, MapBlock*> modified_blocks2;
+ for(core::map<v3s16, bool>::Iterator
+ i = event->modified_blocks.getIterator();
+ i.atEnd()==false; i++)
+ {
+ v3s16 p = i.getNode()->getKey();
+ modified_blocks2.insert(p,
+ m_env.getMap().getBlockNoCreateNoEx(p));
+ }
+ // Set blocks not sent
+ for(core::list<u16>::Iterator
+ i = far_players.begin();
+ i != far_players.end(); i++)
+ {
+ u16 peer_id = *i;
+ RemoteClient *client = getClient(peer_id);
+ if(client==NULL)
+ continue;
+ client->SetBlocksNotSent(modified_blocks2);
+ }
+ }
+
+ delete event;
+
+ /*// Don't send too many at a time
+ count++;
+ if(count >= 1 && m_unsent_map_edit_queue.size() < 100)
+ break;*/
+ }
+
+ if(got_any_events)
+ {
+ dstream<<"Server: MapEditEvents:"<<std::endl;
+ prof.print(dstream);
}
+
}
-#endif
- // Send object positions
+ /*
+ Send object positions
+ TODO: Get rid of MapBlockObjects
+ */
{
float &counter = m_objectdata_timer;
counter += dtime;
{
JMutexAutoLock lock1(m_env_mutex);
JMutexAutoLock lock2(m_con_mutex);
+
+ ScopeProfiler sp(&g_profiler, "Server: sending mbo positions");
+
SendObjectData(counter);
counter = 0.0;
}
}
- // Save map
+ // Save map, players and auth stuff
{
float &counter = m_savemap_timer;
counter += dtime;
{
counter = 0.0;
+ ScopeProfiler sp(&g_profiler, "Server: saving stuff");
+
+ // Auth stuff
+ if(m_authmanager.isModified())
+ m_authmanager.save();
+
+ // Map
JMutexAutoLock lock(m_env_mutex);
- if(((ServerMap*)(&m_env.getMap()))->isSavingEnabled() == true)
- {
- // Save only changed parts
- m_env.getMap().save(true);
+ /*// Unload unused data (delete from memory)
+ m_env.getMap().unloadUnusedData(
+ g_settings.getFloat("server_unload_unused_sectors_timeout"));
+ */
+ /*u32 deleted_count = m_env.getMap().unloadUnusedData(
+ g_settings.getFloat("server_unload_unused_sectors_timeout"));
+ */
- // 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 only changed parts
+ m_env.getMap().save(true);
- // Save players
- m_env.serializePlayers(m_mapsavedir);
- }
+ /*if(deleted_count > 0)
+ {
+ dout_server<<"Server: Unloaded "<<deleted_count
+ <<" blocks from memory"<<std::endl;
+ }*/
+
+ // Save players
+ m_env.serializePlayers(m_mapsavedir);
+
+ // Save environment metadata
+ m_env.saveMeta(m_mapsavedir);
}
}
}
return;
}
- //u8 peer_ser_ver = peer->serialization_version;
u8 peer_ser_ver = getClient(peer->id)->serialization_version;
try
// [0] u16 TOSERVER_INIT
// [2] u8 SER_FMT_VER_HIGHEST
// [3] u8[20] player_name
+ // [23] u8[28] password <--- can be sent without this, from old versions
- if(datasize < 3)
+ if(datasize < 2+1+PLAYERNAME_SIZE)
return;
derr_server<<DTIME<<"Server: Got TOSERVER_INIT from "
derr_server<<DTIME<<"Server: Cannot negotiate "
"serialization version with peer "
<<peer_id<<std::endl;
+ SendAccessDenied(m_con, peer_id,
+ L"Your client is too old (map format)");
+ return;
+ }
+
+ /*
+ Read and check network protocol version
+ */
+
+ u16 net_proto_version = 0;
+ if(datasize >= 2+1+PLAYERNAME_SIZE+PASSWORD_SIZE+2)
+ {
+ net_proto_version = readU16(&data[2+1+PLAYERNAME_SIZE+PASSWORD_SIZE]);
+ }
+
+ getClient(peer->id)->net_proto_version = net_proto_version;
+
+ if(net_proto_version == 0)
+ {
+ SendAccessDenied(m_con, peer_id,
+ L"Your client is too old. Please upgrade.");
return;
}
*/
// Get player name
- const u32 playername_size = 20;
- char playername[playername_size];
- for(u32 i=0; i<playername_size-1; i++)
+ char playername[PLAYERNAME_SIZE];
+ for(u32 i=0; i<PLAYERNAME_SIZE-1; i++)
{
playername[i] = data[3+i];
}
- playername[playername_size-1] = 0;
+ playername[PLAYERNAME_SIZE-1] = 0;
+
+ if(playername[0]=='\0')
+ {
+ derr_server<<DTIME<<"Server: Player has empty name"<<std::endl;
+ SendAccessDenied(m_con, peer_id,
+ L"Empty name");
+ return;
+ }
+
+ if(string_allowed(playername, PLAYERNAME_ALLOWED_CHARS)==false)
+ {
+ derr_server<<DTIME<<"Server: Player has invalid name"<<std::endl;
+ SendAccessDenied(m_con, peer_id,
+ L"Name contains unallowed characters");
+ return;
+ }
+
+ // Get password
+ char password[PASSWORD_SIZE];
+ if(datasize < 2+1+PLAYERNAME_SIZE+PASSWORD_SIZE)
+ {
+ // old version - assume blank password
+ password[0] = 0;
+ }
+ else
+ {
+ for(u32 i=0; i<PASSWORD_SIZE-1; i++)
+ {
+ password[i] = data[23+i];
+ }
+ password[PASSWORD_SIZE-1] = 0;
+ }
+
+ std::string checkpwd;
+ if(m_authmanager.exists(playername))
+ {
+ checkpwd = m_authmanager.getPassword(playername);
+ }
+ else
+ {
+ checkpwd = g_settings.get("default_password");
+ }
+
+ /*dstream<<"Server: Client gave password '"<<password
+ <<"', the correct one is '"<<checkpwd<<"'"<<std::endl;*/
+
+ if(password != checkpwd && m_authmanager.exists(playername))
+ {
+ derr_server<<DTIME<<"Server: peer_id="<<peer_id
+ <<": supplied invalid password for "
+ <<playername<<std::endl;
+ SendAccessDenied(m_con, peer_id, L"Invalid password");
+ return;
+ }
+ // Add player to auth manager
+ if(m_authmanager.exists(playername) == false)
+ {
+ derr_server<<DTIME<<"Server: adding player "<<playername
+ <<" to auth manager"<<std::endl;
+ m_authmanager.add(playername);
+ m_authmanager.setPassword(playername, checkpwd);
+ m_authmanager.setPrivs(playername,
+ stringToPrivs(g_settings.get("default_privs")));
+ m_authmanager.save();
+ }
+
// Get player
- Player *player = emergePlayer(playername, "", peer_id);
- //Player *player = m_env.getPlayer(peer_id);
+ Player *player = emergePlayer(playername, password, peer_id);
+
/*{
// DEBUG: Test serialization
data[20+3-1] = 0;
player->updateName((const char*)&data[3]);
}*/
-
- // Now answer with a TOCLIENT_INIT
- SharedBuffer<u8> reply(2+1+6);
- writeU16(&reply[0], TOCLIENT_INIT);
- writeU8(&reply[2], deployed);
- writeV3S16(&reply[3], floatToInt(player->getPosition()+v3f(0,BS/2,0)));
- // Send as reliable
- m_con.Send(peer_id, 0, reply, true);
+ /*
+ Answer with a TOCLIENT_INIT
+ */
+ {
+ SharedBuffer<u8> reply(2+1+6+8);
+ writeU16(&reply[0], TOCLIENT_INIT);
+ writeU8(&reply[2], deployed);
+ 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);
+ }
+
+ /*
+ Send complete position information
+ */
+ SendMovePlayer(player);
return;
}
+
if(command == TOSERVER_INIT2)
{
derr_server<<DTIME<<"Server: Got TOSERVER_INIT2 from "
SendPlayerInfos();
// Send inventory to player
+ UpdateCrafting(peer->id);
SendInventory(peer->id);
+
+ // Send HP
+ {
+ Player *player = m_env.getPlayer(peer_id);
+ SendPlayerHP(player);
+ }
// Send time of day
{
SharedBuffer<u8> data = makePacket_TOCLIENT_TIME_OF_DAY(
- m_time_of_day.get());
+ m_env.getTimeOfDay());
m_con.Send(peer->id, 0, data, true);
}
message += L" joined game";
BroadcastChatMessage(message);
}
+
+ // Warnings about protocol version can be issued here
+ /*if(getClient(peer->id)->net_proto_version == 0)
+ {
+ SendChatMessage(peer_id, L"# Server: NOTE: YOUR CLIENT IS OLD AND DOES NOT WORK PROPERLY WITH THIS SERVER");
+ }*/
return;
}
if(datasize < 13)
return;
+ if((getPlayerPrivs(player) & PRIV_BUILD) == 0)
+ return;
+
/*
[0] u16 command
[2] u8 button (0=left, 1=right)
// Add to inventory and send inventory
ilist->addItem(item);
+ UpdateCrafting(player->peer_id);
SendInventory(player->peer_id);
}
block->removeObject(id);
}
}
+ else if(command == TOSERVER_CLICK_ACTIVEOBJECT)
+ {
+ if(datasize < 7)
+ return;
+
+ if((getPlayerPrivs(player) & PRIV_BUILD) == 0)
+ return;
+
+ /*
+ length: 7
+ [0] u16 command
+ [2] u8 button (0=left, 1=right)
+ [3] u16 id
+ [5] u16 item
+ */
+ u8 button = readU8(&data[2]);
+ u16 id = readS16(&data[3]);
+ u16 item_i = readU16(&data[11]);
+
+ ServerActiveObject *obj = m_env.getActiveObject(id);
+
+ if(obj == NULL)
+ {
+ derr_server<<"Server: CLICK_ACTIVEOBJECT: object not found"
+ <<std::endl;
+ return;
+ }
+
+ // Skip if object has been removed
+ if(obj->m_removed)
+ return;
+
+ //TODO: Check that object is reasonably close
+
+ // Left click, pick object up (usually)
+ if(button == 0)
+ {
+ /*
+ Try creating inventory item
+ */
+ InventoryItem *item = obj->createPickedUpItem();
+
+ if(item)
+ {
+ InventoryList *ilist = player->inventory.getList("main");
+ if(ilist != NULL)
+ {
+ if(g_settings.getBool("creative_mode") == false)
+ {
+ // Skip if inventory has no free space
+ if(ilist->getUsedSlots() == ilist->getSize())
+ {
+ dout_server<<"Player inventory has no free space"<<std::endl;
+ return;
+ }
+
+ // Add to inventory and send inventory
+ ilist->addItem(item);
+ UpdateCrafting(player->peer_id);
+ SendInventory(player->peer_id);
+ }
+
+ // Remove object from environment
+ obj->m_removed = true;
+ }
+ }
+ else
+ {
+ /*
+ Item cannot be picked up. Punch it instead.
+ */
+
+ ToolItem *titem = NULL;
+ std::string toolname = "";
+
+ InventoryList *mlist = player->inventory.getList("main");
+ if(mlist != NULL)
+ {
+ InventoryItem *item = mlist->getItem(item_i);
+ if(item && (std::string)item->getName() == "ToolItem")
+ {
+ titem = (ToolItem*)item;
+ toolname = titem->getToolName();
+ }
+ }
+
+ v3f playerpos = player->getPosition();
+ v3f objpos = obj->getBasePosition();
+ v3f dir = (objpos - playerpos).normalize();
+
+ u16 wear = obj->punch(toolname, dir);
+
+ if(titem)
+ {
+ bool weared_out = titem->addWear(wear);
+ if(weared_out)
+ mlist->deleteItem(item_i);
+ SendInventory(player->peer_id);
+ }
+ }
+ }
+ // Right click, do something with object
+ if(button == 1)
+ {
+ // Track hp changes super-crappily
+ u16 oldhp = player->hp;
+
+ // Do stuff
+ obj->rightClick(player);
+
+ // Send back stuff
+ if(player->hp != oldhp)
+ {
+ SendPlayerHP(player);
+ }
+ }
+ }
else if(command == TOSERVER_GROUND_ACTION)
{
if(datasize < 17)
// Mandatory parameter; actually used for nothing
core::map<v3s16, MapBlock*> modified_blocks;
- u8 material;
+ content_t material = CONTENT_IGNORE;
u8 mineral = MINERAL_NONE;
+ bool cannot_remove_node = false;
+
try
{
MapNode n = m_env.getMap().getNode(p_under);
+ // Get mineral
+ mineral = n.getMineral();
// Get material at position
- material = n.d;
- // If it's not diggable, do nothing
- if(content_diggable(material) == false)
+ material = n.getContent();
+ // If not yet cancelled
+ if(cannot_remove_node == false)
{
- derr_server<<"Server: Not finishing digging: Node not diggable"
- <<std::endl;
- return;
+ // If it's not diggable, do nothing
+ if(content_diggable(material) == false)
+ {
+ derr_server<<"Server: Not finishing digging: "
+ <<"Node not diggable"
+ <<std::endl;
+ cannot_remove_node = true;
+ }
+ }
+ // If not yet cancelled
+ if(cannot_remove_node == false)
+ {
+ // Get node metadata
+ NodeMetadata *meta = m_env.getMap().getNodeMetadata(p_under);
+ if(meta && meta->nodeRemovalDisabled() == true)
+ {
+ derr_server<<"Server: Not finishing digging: "
+ <<"Node metadata disables removal"
+ <<std::endl;
+ cannot_remove_node = true;
+ }
}
- // Get mineral
- mineral = n.getMineral();
}
catch(InvalidPositionException &e)
{
<<std::endl;
m_emerge_queue.addBlock(peer_id,
getNodeBlockPos(p_over), BLOCK_EMERGE_FLAG_FROMDISK);
- return;
+ cannot_remove_node = true;
}
-
- /*
- 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++)
+ // Make sure the player is allowed to do it
+ if((getPlayerPrivs(player) & PRIV_BUILD) == 0)
{
- // 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;
+ dstream<<"Player "<<player->getName()<<" cannot remove node"
+ <<" because privileges are "<<getPlayerPrivs(player)
+ <<std::endl;
+ cannot_remove_node = true;
+ }
- // Send as reliable
- m_con.Send(client->peer_id, 0, reply, true);
+ /*
+ If node can't be removed, set block to be re-sent to
+ client and quit.
+ */
+ if(cannot_remove_node)
+ {
+ derr_server<<"Server: Not finishing digging."<<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; but node cannot be removed."
+ <<" setting MapBlock not sent."<<std::endl;
+ RemoteClient *client = getClient(peer_id);
+ v3s16 blockpos = getNodeBlockPos(p_under);
+ client->SetBlockNotSent(blockpos);
+
+ return;
}
+ /*
+ Send the removal to all close-by players.
+ - If other player is close, send REMOVENODE
+ - Otherwise set blocks not sent
+ */
+ core::list<u16> far_players;
+ sendRemoveNode(p_under, peer_id, &far_players, 30);
+
/*
Update and send inventory
*/
player->inventory.addItem("main", item);
// Send inventory
+ UpdateCrafting(player->peer_id);
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);
+ {
+ MapEditEventIgnorer ign(&m_ignore_map_edit_events);
-#if 0
+ m_env.getMap().removeNodeAndUpdate(p_under, modified_blocks);
+ }
/*
- Update water
+ Set blocks not sent to far players
*/
-
- // 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)
+ for(core::list<u16>::Iterator
+ i = far_players.begin();
+ i != far_players.end(); i++)
{
- dstream<<"Processing limit reached (1)"<<std::endl;
+ u16 peer_id = *i;
+ RemoteClient *client = getClient(peer_id);
+ if(client==NULL)
+ continue;
+ client->SetBlocksNotSent(modified_blocks);
}
-
- v.blitBack(modified_blocks);
-#endif
}
/*
try{
// Don't add a node if this is not a free space
MapNode n2 = m_env.getMap().getNode(p_over);
- if(content_buildable_to(n2.d) == false)
+ bool no_enough_privs =
+ ((getPlayerPrivs(player) & PRIV_BUILD)==0);
+ if(no_enough_privs)
+ dstream<<"Player "<<player->getName()<<" cannot add node"
+ <<" because privileges are "<<getPlayerPrivs(player)
+ <<std::endl;
+
+ if(content_features(n2).buildable_to == false
+ || no_enough_privs)
{
// Client probably has wrong data.
// Set block not sent, so that client will get
}
// 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;
MapNode n;
- n.d = mitem->getMaterial();
- if(content_features(n.d).wall_mounted)
- n.dir = packDir(p_under - p_over);
+ n.setContent(mitem->getMaterial());
-#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
- */
- InventoryList *ilist = player->inventory.getList("main");
- if(g_settings.getBool("creative_mode") == false && ilist)
+ // Calculate direction for wall mounted stuff
+ if(content_features(n).wall_mounted)
+ n.param2 = packDir(p_under - p_over);
+
+ // Calculate the direction for furnaces and chests and stuff
+ if(content_features(n).param_type == CPT_FACEDIR_SIMPLE)
{
- // Remove from inventory and send inventory
- if(mitem->getCount() == 1)
- ilist->deleteItem(item_i);
- else
- mitem->remove(1);
- // Send inventory
- SendInventory(peer_id);
+ v3f playerpos = player->getPosition();
+ v3f blockpos = intToFloat(p_over, BS) - playerpos;
+ blockpos = blockpos.normalize();
+ n.param1 = 0;
+ if (fabs(blockpos.X) > fabs(blockpos.Z)) {
+ if (blockpos.X < 0)
+ n.param1 = 3;
+ else
+ n.param1 = 1;
+ } else {
+ if (blockpos.Z < 0)
+ n.param1 = 2;
+ else
+ n.param1 = 0;
+ }
}
-
- /*
- Add node.
- This takes some time so it is done after the quick stuff
+ /*
+ Send to all close-by players
*/
- core::map<v3s16, MapBlock*> modified_blocks;
- m_env.getMap().addNodeAndUpdate(p_over, n, modified_blocks);
-#endif
-#if 0
+ core::list<u16> far_players;
+ sendAddNode(p_over, n, 0, &far_players, 30);
+
/*
Handle inventory
*/
else
mitem->remove(1);
// Send inventory
+ UpdateCrafting(peer_id);
SendInventory(peer_id);
}
-
+
/*
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);
+ {
+ MapEditEventIgnorer ign(&m_ignore_map_edit_events);
+ m_env.getMap().addNodeAndUpdate(p_over, n, modified_blocks);
+ }
/*
- Set the modified blocks unsent for all the clients
+ Set blocks not sent to far players
*/
-
- //JMutexAutoLock lock2(m_con_mutex);
-
- for(core::map<u16, RemoteClient*>::Iterator
- i = m_clients.getIterator();
- i.atEnd() == false; i++)
+ for(core::list<u16>::Iterator
+ i = far_players.begin();
+ i != far_players.end(); i++)
{
- RemoteClient *client = i.getNode()->getValue();
-
- if(modified_blocks.size() > 0)
- {
- // Remove block from sent history
- client->SetBlocksNotSent(modified_blocks);
- }
+ u16 peer_id = *i;
+ RemoteClient *client = getClient(peer_id);
+ if(client==NULL)
+ continue;
+ client->SetBlocksNotSent(modified_blocks);
}
-#endif
-#if 0
/*
- Update water
+ Calculate special events
*/
- // 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)
+ /*if(n.d == CONTENT_MESE)
{
- dstream<<"Processing limit reached (1)"<<std::endl;
- }
-
- v.blitBack(modified_blocks);
-#endif
+ 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 other items
+ Place other item (not a block)
*/
else
{
v3s16 blockpos = getNodeBlockPos(p_over);
-
- MapBlock *block = NULL;
- try
- {
- block = m_env.getMap().getBlockNoCreate(blockpos);
- }
- catch(InvalidPositionException &e)
+
+ /*
+ Check that the block is loaded so that the item
+ can properly be added to the static list too
+ */
+ MapBlock *block = m_env.getMap().getBlockNoCreateNoEx(blockpos);
+ if(block==NULL)
{
derr_server<<"Error while placing object: "
"block not found"<<std::endl;
return;
}
- v3s16 block_pos_i_on_map = block->getPosRelative();
- v3f block_pos_f_on_map = intToFloat(block_pos_i_on_map);
-
- v3f pos = intToFloat(p_over);
- pos -= block_pos_f_on_map;
+ dout_server<<"Placing a miscellaneous item on map"
+ <<std::endl;
- /*dout_server<<"pos="
- <<"("<<pos.X<<","<<pos.Y<<","<<pos.Z<<")"
- <<std::endl;*/
-
- MapBlockObject *obj = NULL;
-
- /*
- Handle block object items
- */
- if(std::string("MBOItem") == item->getName())
- {
- MapBlockObjectItem *oitem = (MapBlockObjectItem*)item;
+ // Calculate a position for it
+ v3f pos = intToFloat(p_over, BS);
+ //pos.Y -= BS*0.45;
+ pos.Y -= BS*0.25; // let it drop a bit
+ // Randomize a bit
+ pos.X += BS*0.2*(float)myrand_range(-1000,1000)/1000.0;
+ pos.Z += BS*0.2*(float)myrand_range(-1000,1000)/1000.0;
- /*dout_server<<"Trying to place a MapBlockObjectItem: "
- "inventorystring=\""
- <<oitem->getInventoryString()
- <<"\""<<std::endl;*/
-
- obj = oitem->createObject
- (pos, player->getYaw(), player->getPitch());
- }
/*
- Handle other items
+ Create the object
*/
- else
- {
- dout_server<<"Placing a miscellaneous item on map"
- <<std::endl;
- /*
- Create an ItemObject that contains the item.
- */
- ItemObject *iobj = new ItemObject(NULL, -1, pos);
- std::ostringstream os(std::ios_base::binary);
- item->serialize(os);
- dout_server<<"Item string is \""<<os.str()<<"\""<<std::endl;
- iobj->setItemString(os.str());
- obj = iobj;
- }
+ ServerActiveObject *obj = item->createSAO(&m_env, 0, pos);
if(obj == NULL)
{
}
else
{
- block->addObject(obj);
-
+ // Add the object to the environment
+ m_env.addActiveObject(obj);
+
dout_server<<"Placed object"<<std::endl;
- InventoryList *ilist = player->inventory.getList("main");
- if(g_settings.getBool("creative_mode") == false && ilist)
+ if(g_settings.getBool("creative_mode") == false)
{
- // Remove from inventory and send inventory
- ilist->deleteItem(item_i);
+ // Delete the right amount of items from the slot
+ u16 dropcount = item->getDropCount();
+
+ // Delete item if all gone
+ if(item->getCount() <= dropcount)
+ {
+ if(item->getCount() < dropcount)
+ dstream<<"WARNING: Server: dropped more items"
+ <<" than the slot contains"<<std::endl;
+
+ InventoryList *ilist = player->inventory.getList("main");
+ if(ilist)
+ // Remove from inventory and send inventory
+ ilist->deleteItem(item_i);
+ }
+ // Else decrement it
+ else
+ item->remove(dropcount);
+
// Send inventory
+ UpdateCrafting(peer_id);
SendInventory(peer_id);
}
}
#endif
else if(command == TOSERVER_SIGNTEXT)
{
+ if((getPlayerPrivs(player) & PRIV_BUILD) == 0)
+ return;
/*
u16 command
v3s16 blockpos
obj->getBlock()->setChangedFlag();
}
+ else if(command == TOSERVER_SIGNNODETEXT)
+ {
+ if((getPlayerPrivs(player) & PRIV_BUILD) == 0)
+ return;
+ /*
+ u16 command
+ v3s16 p
+ u16 textlen
+ textdata
+ */
+ std::string datastring((char*)&data[2], datasize-2);
+ std::istringstream is(datastring, std::ios_base::binary);
+ u8 buf[6];
+ // Read stuff
+ is.read((char*)buf, 6);
+ v3s16 p = readV3S16(buf);
+ is.read((char*)buf, 2);
+ u16 textlen = readU16(buf);
+ std::string text;
+ for(u16 i=0; i<textlen; i++)
+ {
+ is.read((char*)buf, 1);
+ text += (char)buf[0];
+ }
+
+ NodeMetadata *meta = m_env.getMap().getNodeMetadata(p);
+ if(!meta)
+ return;
+ if(meta->typeId() != CONTENT_SIGN_WALL)
+ return;
+ SignNodeMetadata *signmeta = (SignNodeMetadata*)meta;
+ signmeta->setText(text);
+
+ v3s16 blockpos = getNodeBlockPos(p);
+ MapBlock *block = m_env.getMap().getBlockNoCreateNoEx(blockpos);
+ if(block)
+ {
+ block->setChangedFlag();
+ }
+
+ for(core::map<u16, RemoteClient*>::Iterator
+ i = m_clients.getIterator();
+ i.atEnd()==false; i++)
+ {
+ RemoteClient *client = i.getNode()->getValue();
+ client->SetBlockNotSent(blockpos);
+ }
+ }
else if(command == TOSERVER_INVENTORY_ACTION)
{
/*// Ignore inventory changes if in creative mode
InventoryAction *a = InventoryAction::deSerialize(is);
if(a != NULL)
{
+ // Create context
+ InventoryContext c;
+ c.current_player = player;
+
/*
Handle craftresult specially if not in creative mode
*/
&& g_settings.getBool("creative_mode") == false)
{
IMoveAction *ma = (IMoveAction*)a;
- // Don't allow moving anything to craftresult
- if(ma->to_name == "craftresult")
- {
- // Do nothing
- disable_action = true;
- }
- // When something is removed from craftresult
- if(ma->from_name == "craftresult")
+ if(ma->to_inv == "current_player" &&
+ ma->from_inv == "current_player")
{
- disable_action = true;
- // Remove stuff from craft
+ InventoryList *rlist = player->inventory.getList("craftresult");
+ assert(rlist);
InventoryList *clist = player->inventory.getList("craft");
- if(clist)
+ assert(clist);
+ InventoryList *mlist = player->inventory.getList("main");
+ assert(mlist);
+ /*
+ Craftresult is no longer preview if something
+ is moved into it
+ */
+ if(ma->to_list == "craftresult"
+ && ma->from_list != "craftresult")
{
- u16 count = ma->count;
- if(count == 0)
- count = 1;
- clist->decrementMaterials(count);
+ // If it currently is a preview, remove
+ // its contents
+ if(player->craftresult_is_preview)
+ {
+ rlist->deleteItem(0);
+ }
+ player->craftresult_is_preview = false;
}
- // 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)
+ /*
+ Crafting takes place if this condition is true.
+ */
+ if(player->craftresult_is_preview &&
+ ma->from_list == "craftresult")
+ {
+ player->craftresult_is_preview = false;
+ clist->decrementMaterials(1);
+ }
+ /*
+ If the craftresult is placed on itself, move it to
+ main inventory instead of doing the action
+ */
+ if(ma->to_list == "craftresult"
+ && ma->from_list == "craftresult")
{
+ disable_action = true;
+
InventoryItem *item1 = rlist->changeItem(0, NULL);
mlist->addItem(item1);
}
}
}
+
if(disable_action == false)
{
// Feed action to player inventory
- a->apply(&player->inventory);
- // Eat it
+ a->apply(&c, this);
+ // Eat the action
delete a;
}
- // Send inventory
- SendInventory(player->peer_id);
+ else
+ {
+ // Send inventory
+ UpdateCrafting(player->peer_id);
+ SendInventory(player->peer_id);
+ }
}
else
{
// Whether to send to other players
bool send_to_others = false;
+ // Local player gets all privileges regardless of
+ // what's set on their account.
+ u64 privs = getPlayerPrivs(player);
+
// 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)
+
+ WStrfnd f1(message);
+ f1.next(L" "); // Skip over /#whatever
+ std::wstring paramstring = f1.next(L"");
+
+ ServerCommandContext *ctx = new ServerCommandContext(
+ str_split(message, L' '),
+ paramstring,
+ this,
+ &m_env,
+ player,
+ privs);
+
+ line += processServerCommand(ctx);
+ send_to_sender = ctx->flags & 1;
+ send_to_others = ctx->flags & 2;
+ delete ctx;
+
+ }
+ else
+ {
+ if(privs & PRIV_SHOUT)
{
- 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;
- }
+ line += L"<";
+ line += name;
+ line += L"> ";
+ line += message;
+ send_to_others = true;
}
-
- if(valid_command == false)
+ else
{
- line += L"-!- Invalid command: " + message;
+ line += L"Server: You are not allowed to shout";
send_to_sender = true;
}
}
- else
- {
- line += L"<";
- /*if(is_operator)
- line += L"@";*/
- line += name;
- line += L"> ";
- line += message;
- send_to_others = true;
- }
if(line != L"")
{
}
}
}
- else
+ else if(command == TOSERVER_DAMAGE)
{
- derr_server<<"WARNING: Server::ProcessData(): Ignoring "
- "unknown command "<<command<<std::endl;
+ if(g_settings.getBool("enable_damage"))
+ {
+ std::string datastring((char*)&data[2], datasize-2);
+ std::istringstream is(datastring, std::ios_base::binary);
+ u8 damage = readU8(is);
+ if(player->hp > damage)
+ {
+ player->hp -= damage;
+ }
+ else
+ {
+ player->hp = 0;
+
+ dstream<<"TODO: Server: TOSERVER_HP_DECREMENT: Player dies"
+ <<std::endl;
+
+ v3f pos = findSpawnPos(m_env.getServerMap());
+ player->setPosition(pos);
+ player->hp = 20;
+ SendMovePlayer(player);
+ SendPlayerHP(player);
+
+ //TODO: Throw items around
+ }
+ }
+
+ SendPlayerHP(player);
}
-
- } //try
- catch(SendFailedException &e)
+ else if(command == TOSERVER_PASSWORD)
{
- derr_server<<"Server::ProcessData(): SendFailedException: "
- <<"what="<<e.what()
- <<std::endl;
- }
-}
+ /*
+ [0] u16 TOSERVER_PASSWORD
+ [2] u8[28] old password
+ [30] u8[28] new password
+ */
-/*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);
-}*/
+ if(datasize != 2+PASSWORD_SIZE*2)
+ return;
+ /*char password[PASSWORD_SIZE];
+ for(u32 i=0; i<PASSWORD_SIZE-1; i++)
+ password[i] = data[2+i];
+ password[PASSWORD_SIZE-1] = 0;*/
+ std::string oldpwd;
+ for(u32 i=0; i<PASSWORD_SIZE-1; i++)
+ {
+ char c = data[2+i];
+ if(c == 0)
+ break;
+ oldpwd += c;
+ }
+ std::string newpwd;
+ for(u32 i=0; i<PASSWORD_SIZE-1; i++)
+ {
+ char c = data[2+PASSWORD_SIZE+i];
+ if(c == 0)
+ break;
+ newpwd += c;
+ }
-void Server::SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver)
-{
- DSTACK(__FUNCTION_NAME);
- /*
- Create a packet with the block in the right format
- */
+ dstream<<"Server: Client requests a password change from "
+ <<"'"<<oldpwd<<"' to '"<<newpwd<<"'"<<std::endl;
+
+ std::string playername = player->getName();
+
+ if(m_authmanager.exists(playername) == false)
+ {
+ dstream<<"Server: playername not found in authmanager"<<std::endl;
+ // Wrong old password supplied!!
+ SendChatMessage(peer_id, L"playername not found in authmanager");
+ return;
+ }
+
+ std::string checkpwd = m_authmanager.getPassword(playername);
+
+ if(oldpwd != checkpwd)
+ {
+ dstream<<"Server: invalid old password"<<std::endl;
+ // Wrong old password supplied!!
+ SendChatMessage(peer_id, L"Invalid old password supplied. Password NOT changed.");
+ return;
+ }
+
+ m_authmanager.setPassword(playername, newpwd);
+
+ dstream<<"Server: password change successful for "<<playername
+ <<std::endl;
+ SendChatMessage(peer_id, L"Password change successful");
+ }
+ else
+ {
+ derr_server<<"WARNING: Server::ProcessData(): Ignoring "
+ "unknown command "<<command<<std::endl;
+ }
- 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());
+ } //try
+ catch(SendFailedException &e)
+ {
+ derr_server<<"Server::ProcessData(): SendFailedException: "
+ <<"what="<<e.what()
+ <<std::endl;
+ }
+}
- 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());
+void Server::onMapEditEvent(MapEditEvent *event)
+{
+ //dstream<<"Server::onMapEditEvent()"<<std::endl;
+ if(m_ignore_map_edit_events)
+ return;
+ MapEditEvent *e = event->clone();
+ m_unsent_map_edit_queue.push_back(e);
+}
- /*dstream<<"Sending block ("<<p.X<<","<<p.Y<<","<<p.Z<<")"
- <<": \tpacket size: "<<replysize<<std::endl;*/
+Inventory* Server::getInventory(InventoryContext *c, std::string id)
+{
+ if(id == "current_player")
+ {
+ assert(c->current_player);
+ return &(c->current_player->inventory);
+ }
- /*
- Send packet
- */
- m_con.Send(peer_id, 1, reply, true);
+ Strfnd fn(id);
+ std::string id0 = fn.next(":");
+
+ if(id0 == "nodemeta")
+ {
+ v3s16 p;
+ p.X = stoi(fn.next(","));
+ p.Y = stoi(fn.next(","));
+ p.Z = stoi(fn.next(","));
+ NodeMetadata *meta = m_env.getMap().getNodeMetadata(p);
+ if(meta)
+ return meta->getInventory();
+ dstream<<"nodemeta at ("<<p.X<<","<<p.Y<<","<<p.Z<<"): "
+ <<"no metadata found"<<std::endl;
+ return NULL;
+ }
+
+ dstream<<__FUNCTION_NAME<<": unknown id "<<id<<std::endl;
+ return NULL;
+}
+void Server::inventoryModified(InventoryContext *c, std::string id)
+{
+ if(id == "current_player")
+ {
+ assert(c->current_player);
+ // Send inventory
+ UpdateCrafting(c->current_player->peer_id);
+ SendInventory(c->current_player->peer_id);
+ return;
+ }
+
+ Strfnd fn(id);
+ std::string id0 = fn.next(":");
+
+ if(id0 == "nodemeta")
+ {
+ v3s16 p;
+ p.X = stoi(fn.next(","));
+ p.Y = stoi(fn.next(","));
+ p.Z = stoi(fn.next(","));
+ v3s16 blockpos = getNodeBlockPos(p);
+
+ NodeMetadata *meta = m_env.getMap().getNodeMetadata(p);
+ if(meta)
+ meta->inventoryModified();
+
+ for(core::map<u16, RemoteClient*>::Iterator
+ i = m_clients.getIterator();
+ i.atEnd()==false; i++)
+ {
+ RemoteClient *client = i.getNode()->getValue();
+ client->SetBlockNotSent(blockpos);
+ }
+
+ return;
+ }
+
+ dstream<<__FUNCTION_NAME<<": unknown id "<<id<<std::endl;
}
core::list<PlayerInfo> Server::getPlayerInfo()
m_peer_change_queue.push_back(c);
}
+/*
+ Static send methods
+*/
+
+void Server::SendHP(con::Connection &con, u16 peer_id, u8 hp)
+{
+ DSTACK(__FUNCTION_NAME);
+ std::ostringstream os(std::ios_base::binary);
+
+ writeU16(os, TOCLIENT_HP);
+ writeU8(os, hp);
+
+ // Make data buffer
+ std::string s = os.str();
+ SharedBuffer<u8> data((u8*)s.c_str(), s.size());
+ // Send as reliable
+ con.Send(peer_id, 0, data, true);
+}
+
+void Server::SendAccessDenied(con::Connection &con, u16 peer_id,
+ const std::wstring &reason)
+{
+ DSTACK(__FUNCTION_NAME);
+ std::ostringstream os(std::ios_base::binary);
+
+ writeU16(os, TOCLIENT_ACCESS_DENIED);
+ os<<serializeWideString(reason);
+
+ // Make data buffer
+ std::string s = os.str();
+ SharedBuffer<u8> data((u8*)s.c_str(), s.size());
+ // Send as reliable
+ con.Send(peer_id, 0, data, true);
+}
+
+/*
+ Non-static send methods
+*/
+
void Server::SendObjectData(float dtime)
{
DSTACK(__FUNCTION_NAME);
m_con.SendToAll(0, data, true);
}
-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; y<specs_h; y++)
- for(u16 x=0; x<specs_w; x++)
- {
- u16 items_x = items_min_x + x;
- u16 items_y = items_min_y + y;
- u16 specs_x = specs_min_x + x;
- u16 specs_y = specs_min_y + y;
- InventoryItem *item = items[items_y * 3 + items_x];
- ItemSpec &spec = specs[specs_y * 3 + specs_x];
-
- if(spec.type == ITEM_NONE)
- {
- // Has to be no item
- if(item != NULL)
- return false;
- continue;
- }
-
- // There should be an item
- if(item == NULL)
- return false;
-
- std::string itemname = item->getName();
-
- if(spec.type == ITEM_MATERIAL)
- {
- if(itemname != "MaterialItem")
- return false;
- MaterialItem *mitem = (MaterialItem*)item;
- if(mitem->getMaterial() != 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++)
- {
- 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)
- {
- 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;
- }
- }
-
- // Torch
- if(!found)
- {
- 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)
- {
- 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;
- }
- }
-
- // Stone pick
- if(!found)
- {
- 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;
- }
- }
-
- // Mese pick
- if(!found)
- {
- 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
+ assert(player);
/*
Serialize it
}
}
-void Server::SendBlocks(float dtime)
+void Server::SendPlayerHP(Player *player)
+{
+ SendHP(m_con, player->peer_id, player->hp);
+}
+
+void Server::SendMovePlayer(Player *player)
{
DSTACK(__FUNCTION_NAME);
+ std::ostringstream os(std::ios_base::binary);
- JMutexAutoLock envlock(m_env_mutex);
+ writeU16(os, TOCLIENT_MOVE_PLAYER);
+ writeV3F1000(os, player->getPosition());
+ writeF1000(os, player->getPitch());
+ writeF1000(os, player->getYaw());
+
+ {
+ v3f pos = player->getPosition();
+ f32 pitch = player->getPitch();
+ f32 yaw = player->getYaw();
+ dstream<<"Server sending TOCLIENT_MOVE_PLAYER"
+ <<" pos=("<<pos.X<<","<<pos.Y<<","<<pos.Z<<")"
+ <<" pitch="<<pitch
+ <<" yaw="<<yaw
+ <<std::endl;
+ }
- //TimeTaker timer("Server::SendBlocks");
+ // Make data buffer
+ std::string s = os.str();
+ SharedBuffer<u8> data((u8*)s.c_str(), s.size());
+ // Send as reliable
+ m_con.Send(player->peer_id, 0, data, true);
+}
- core::array<PrioritySortedBlockTransfer> queue;
+void Server::sendRemoveNode(v3s16 p, u16 ignore_id,
+ core::list<u16> *far_players, float far_d_nodes)
+{
+ float maxd = far_d_nodes*BS;
+ v3f p_f = intToFloat(p, BS);
- s32 total_sending = 0;
+ // 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;
- total_sending += client->SendingCount();
+ // Don't send if it's the same one
+ if(client->peer_id == ignore_id)
+ continue;
+ if(far_players)
+ {
+ // Get player
+ Player *player = m_env.getPlayer(client->peer_id);
+ if(player)
+ {
+ // If player is far away, only set modified blocks not sent
+ v3f player_pos = player->getPosition();
+ if(player_pos.getDistanceFrom(p_f) > maxd)
+ {
+ far_players->push_back(client->peer_id);
+ continue;
+ }
+ }
+ }
+
+ // Send as reliable
+ m_con.Send(client->peer_id, 0, reply, true);
+ }
+}
+
+void Server::sendAddNode(v3s16 p, MapNode n, u16 ignore_id,
+ core::list<u16> *far_players, float far_d_nodes)
+{
+ float maxd = far_d_nodes*BS;
+ v3f p_f = intToFloat(p, BS);
+
+ 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;
-
- client->GetNextBlocks(this, dtime, queue);
+
+ // Don't send if it's the same one
+ if(client->peer_id == ignore_id)
+ continue;
+
+ if(far_players)
+ {
+ // Get player
+ Player *player = m_env.getPlayer(client->peer_id);
+ if(player)
+ {
+ // If player is far away, only set modified blocks not sent
+ v3f player_pos = player->getPosition();
+ if(player_pos.getDistanceFrom(p_f) > maxd)
+ {
+ far_players->push_back(client->peer_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::setBlockNotSent(v3s16 p)
+{
+ for(core::map<u16, RemoteClient*>::Iterator
+ i = m_clients.getIterator();
+ i.atEnd()==false; i++)
+ {
+ RemoteClient *client = i.getNode()->getValue();
+ client->SetBlockNotSent(p);
+ }
+}
+
+void Server::SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver)
+{
+ DSTACK(__FUNCTION_NAME);
+
+ v3s16 p = block->getPos();
+
+#if 0
+ // Analyze it a bit
+ bool completely_air = true;
+ for(s16 z0=0; z0<MAP_BLOCKSIZE; z0++)
+ for(s16 x0=0; x0<MAP_BLOCKSIZE; x0++)
+ for(s16 y0=0; y0<MAP_BLOCKSIZE; y0++)
+ {
+ if(block->getNodeNoEx(v3s16(x0,y0,z0)).d != CONTENT_AIR)
+ {
+ completely_air = false;
+ x0 = y0 = z0 = MAP_BLOCKSIZE; // Break out
+ }
+ }
+
+ // Print result
+ dstream<<"Server: Sending block ("<<p.X<<","<<p.Y<<","<<p.Z<<"): ";
+ if(completely_air)
+ dstream<<"[completely air] ";
+ dstream<<std::endl;
+#endif
+
+ /*
+ 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);
+ 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<<"Server: 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;
+
+ s32 total_sending = 0;
+
+ {
+ ScopeProfiler sp(&g_profiler, "Server: selecting blocks for sending");
+
+ for(core::map<u16, RemoteClient*>::Iterator
+ i = m_clients.getIterator();
+ i.atEnd() == false; i++)
+ {
+ RemoteClient *client = i.getNode()->getValue();
+ assert(client->peer_id == i.getNode()->getKey());
+
+ total_sending += client->SendingCount();
+
+ if(client->serialization_version == SER_FMT_VER_INVALID)
+ continue;
+
+ client->GetNextBlocks(this, dtime, queue);
+ }
}
// Sort.
// Lowest is most important.
queue.sort();
- JMutexAutoLock conlock(m_con_mutex);
-
for(u32 i=0; i<queue.size(); i++)
{
//TODO: Calculate limit dynamically
}
}
+/*
+ Something random
+*/
+
+void Server::UpdateCrafting(u16 peer_id)
+{
+ DSTACK(__FUNCTION_NAME);
+
+ Player* player = m_env.getPlayer(peer_id);
+ assert(player);
+
+ /*
+ Calculate crafting stuff
+ */
+ if(g_settings.getBool("creative_mode") == false)
+ {
+ InventoryList *clist = player->inventory.getList("craft");
+ InventoryList *rlist = player->inventory.getList("craftresult");
+
+ if(rlist->getUsedSlots() == 0)
+ player->craftresult_is_preview = true;
+
+ if(rlist && player->craftresult_is_preview)
+ {
+ rlist->clearItems();
+ }
+ if(clist && rlist && player->craftresult_is_preview)
+ {
+ InventoryItem *items[9];
+ for(u16 i=0; i<9; i++)
+ {
+ items[i] = clist->getItem(i);
+ }
+
+ // Get result of crafting grid
+ InventoryItem *result = craft_get_result(items);
+ if(result)
+ rlist->addItem(result);
+ }
+
+ } // if creative_mode == false
+}
RemoteClient* Server::getClient(u16 peer_id)
{
{
std::wostringstream os(std::ios_base::binary);
os<<L"# Server: ";
+ // Version
+ os<<L"version="<<narrow_to_wide(VERSION_STRING);
// Uptime
- os<<L"uptime="<<m_uptime.get();
+ os<<L", uptime="<<m_uptime.get();
// Information about clients
os<<L", clients={";
for(core::map<u16, RemoteClient*>::Iterator
}
os<<L"}";
if(((ServerMap*)(&m_env.getMap()))->isSavingEnabled() == false)
- os<<" WARNING: Map saving is disabled."<<std::endl;
+ os<<std::endl<<L"# Server: "<<" WARNING: Map saving is disabled.";
+ if(g_settings.get("motd") != "")
+ os<<std::endl<<L"# Server: "<<narrow_to_wide(g_settings.get("motd"));
return os.str();
}
-
-void setCreativeInventory(Player *player)
+v3f findSpawnPos(ServerMap &map)
{
- player->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);
- }
+ //return v3f(50,50,50)*BS;
- /*
- Give materials
- */
- assert(USEFUL_CONTENT_COUNT <= PLAYER_INVENTORY_SIZE);
+ v2s16 nodepos;
+ s16 groundheight = 0;
- // add torch first
- InventoryItem *item = new MaterialItem(CONTENT_TORCH, 1);
- player->inventory.addItem("main", item);
-
- // Then others
- for(u16 i=0; i<USEFUL_CONTENT_COUNT; i++)
+#if 0
+ nodepos = v2s16(0,0);
+ groundheight = 20;
+#endif
+
+#if 1
+ // Try to find a good place a few times
+ for(s32 i=0; i<1000; i++)
{
- // Skip some materials
- if(i == CONTENT_WATER || i == CONTENT_TORCH
- || i == CONTENT_COALSTONE)
+ 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 = map.findGroundLevel(nodepos);
+ // Don't go underwater
+ if(groundheight < WATER_LEVEL)
+ {
+ //dstream<<"-> Underwater"<<std::endl;
+ continue;
+ }
+ // Don't go to high places
+ if(groundheight > WATER_LEVEL + 4)
+ {
+ //dstream<<"-> Underwater"<<std::endl;
continue;
+ }
- InventoryItem *item = new MaterialItem(i, 1);
- player->inventory.addItem("main", item);
- }
- // Sign
- {
- InventoryItem *item = new MapBlockObjectItem("Sign Example text");
- void* r = player->inventory.addItem("main", item);
- assert(r == NULL);
+ // Found a good place
+ //dstream<<"Searched through "<<i<<" places."<<std::endl;
+ break;
}
+#endif
+
+ // If no suitable place was not found, go above water at least.
+ if(groundheight < WATER_LEVEL)
+ groundheight = WATER_LEVEL;
+
+ return intToFloat(v3s16(
+ nodepos.X,
+ groundheight + 3,
+ nodepos.Y
+ ), BS);
}
-Player *Server::emergePlayer(const char *name, const char *password,
- u16 peer_id)
+Player *Server::emergePlayer(const char *name, const char *password, u16 peer_id)
{
/*
Try to get an existing player
// Reset inventory to creative if in creative mode
if(g_settings.getBool("creative_mode"))
{
- setCreativeInventory(player);
+ // Warning: double code below
+ // Backup actual inventory
+ player->inventory_backup = new Inventory();
+ *(player->inventory_backup) = player->inventory;
+ // Set creative inventory
+ craft_set_creative_inventory(player);
}
return player;
//player->peer_id = PEER_ID_INEXISTENT;
player->peer_id = peer_id;
player->updateName(name);
+ m_authmanager.add(name);
+ m_authmanager.setPassword(name, password);
+ m_authmanager.setPrivs(name,
+ stringToPrivs(g_settings.get("default_privs")));
/*
Set player position
dstream<<"Server: Finding spawn place for player \""
<<player->getName()<<"\""<<std::endl;
- v2s16 nodepos;
-#if 1
- player->setPosition(intToFloat(v3s16(
- 0,
- 45, //64,
- 0
- )));
-#endif
-#if 0
- f32 groundheight = 0;
-#if 0
- // Try to find a good place a few times
- for(s32 i=0; i<500; 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);
- // 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
- // Get block at point
- v3s16 nodepos3d;
- nodepos3d = v3s16(nodepos.X, groundheight+1, nodepos.Y);
- v3s16 blockpos = getNodeBlockPos(nodepos3d);
- ((ServerMap*)(&m_env.getMap()))->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"<<std::endl;
- // In ground
- continue;
- }
- }catch(InvalidPositionException &e)
- {
- dstream<<"-> Invalid position"<<std::endl;
- // Ignore invalid position
- continue;
- }
-#endif
- // Found a good place
- dstream<<"Searched through "<<i<<" places."<<std::endl;
- break;
- }
-#endif
-
- // If no suitable place was not found, go above water at least.
- if(groundheight < WATER_LEVEL)
- groundheight = WATER_LEVEL;
-
- player->setPosition(intToFloat(v3s16(
- nodepos.X,
- //groundheight + 1,
- groundheight + 15,
- nodepos.Y
- )));
-#endif
+ v3f pos = findSpawnPos(m_env.getServerMap());
+
+ player->setPosition(pos);
/*
Add player to environment
if(g_settings.getBool("creative_mode"))
{
- setCreativeInventory(player);
+ // Warning: double code above
+ // Backup actual inventory
+ player->inventory_backup = new Inventory();
+ *(player->inventory_backup) = player->inventory;
+ // Set creative inventory
+ craft_set_creative_inventory(player);
}
- else
+ else if(g_settings.getBool("give_initial_stuff"))
{
- /*{
- 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);
- }*/
+ craft_give_initial_stuff(player);
}
return player;
} // create new player
}
-#if 0
-void Server::UpdateBlockWaterPressure(MapBlock *block,
- core::map<v3s16, MapBlock*> &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)"<<std::endl;
- }
-
- v.blitBack(modified_blocks);
-}
-#endif
-
void Server::handlePeerChange(PeerChange &c)
{
JMutexAutoLock envlock(m_env_mutex);
// The client should exist
assert(n != NULL);
+ /*
+ Mark objects to be not known by the client
+ */
+ RemoteClient *client = n->getValue();
+ // Handle objects
+ for(core::map<u16, bool>::Iterator
+ i = client->m_known_objects.getIterator();
+ i.atEnd()==false; i++)
+ {
+ // Get object
+ u16 id = i.getNode()->getKey();
+ ServerActiveObject* obj = m_env.getActiveObject(id);
+
+ if(obj && obj->m_known_by_count > 0)
+ obj->m_known_by_count--;
+ }
+
// Collect information about leaving in chat
std::wstring message;
{
}
}
+u64 Server::getPlayerPrivs(Player *player)
+{
+ if(player==NULL)
+ return 0;
+ std::string playername = player->getName();
+ // Local player gets all privileges regardless of
+ // what's set on their account.
+ if(g_settings.get("name") == playername)
+ {
+ return PRIV_ALL;
+ }
+ else
+ {
+ return getPlayerAuthPrivs(playername);
+ }
+}
+
void dedicated_server_loop(Server &server, bool &kill)
{
DSTACK(__FUNCTION_NAME);
- std::cout<<DTIME<<std::endl;
- std::cout<<"========================"<<std::endl;
- std::cout<<"Running dedicated server"<<std::endl;
- std::cout<<"========================"<<std::endl;
- std::cout<<std::endl;
+ dstream<<DTIME<<std::endl;
+ dstream<<"========================"<<std::endl;
+ dstream<<"Running dedicated server"<<std::endl;
+ dstream<<"========================"<<std::endl;
+ dstream<<std::endl;
+
+ IntervalLimiter m_profiler_interval;
for(;;)
{
// This is kind of a hack but can be done like this
// because server.step() is very light
- sleep_ms(30);
+ {
+ ScopeProfiler sp(&g_profiler, "dedicated server sleep");
+ sleep_ms(30);
+ }
server.step(0.030);
if(server.getShutdownRequested() || kill)
{
- std::cout<<DTIME<<" dedicated_server_loop(): Quitting."<<std::endl;
+ dstream<<DTIME<<" dedicated_server_loop(): Quitting."<<std::endl;
break;
}
+ /*
+ Profiler
+ */
+ float profiler_print_interval =
+ g_settings.getFloat("profiler_print_interval");
+ if(profiler_print_interval != 0)
+ {
+ if(m_profiler_interval.step(0.030, profiler_print_interval))
+ {
+ dstream<<"Profiler:"<<std::endl;
+ g_profiler.print(dstream);
+ g_profiler.clear();
+ }
+ }
+
+ /*
+ Player info
+ */
static int counter = 0;
counter--;
if(counter <= 0)
u32 sum = PIChecksum(list);
if(sum != sum_old)
{
- std::cout<<DTIME<<"Player info:"<<std::endl;
+ dstream<<DTIME<<"Player info:"<<std::endl;
for(i=list.begin(); i!=list.end(); i++)
{
- i->PrintLine(&std::cout);
+ i->PrintLine(&dstream);
}
}
sum_old = sum;
projects / dragonfireclient.git / blobdiff