X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=src%2Fserver.h;h=680de57b540f51027ad2fc13d66b5a8318ec329a;hb=7c43cf47c37b0204e34d12670d2e6975eb36b45a;hp=43beb167ae0a5b12c36db1b10763ec36443dfbc6;hpb=0b1d09ff4f4e92986f6abdbc57db97c18707196a;p=oweals%2Fminetest.git

diff --git a/src/server.h b/src/server.h
index 43beb167a..680de57b5 100644
--- a/src/server.h
+++ b/src/server.h
@@ -1,6 +1,6 @@
 /*
-Minetest-c55
-Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
+Minetest
+Copyright (C) 2010-2013 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 Lesser General Public License as published by
@@ -17,254 +17,61 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
-#ifndef SERVER_HEADER
-#define SERVER_HEADER
+#pragma once
 
-#include "connection.h"
-#include "environment.h"
-#include "irrlichttypes_bloated.h"
-#include <string>
-#include "porting.h"
+#include "irr_v3d.h"
 #include "map.h"
-#include "inventory.h"
-#include "ban.h"
+#include "hud.h"
 #include "gamedef.h"
 #include "serialization.h" // For SER_FMT_VER_INVALID
-#include "mods.h"
+#include "content/mods.h"
 #include "inventorymanager.h"
-#include "subgame.h"
-#include "sound.h"
+#include "content/subgames.h"
+#include "tileanimation.h" // struct TileAnimationParams
+#include "network/peerhandler.h"
+#include "network/address.h"
+#include "util/numeric.h"
 #include "util/thread.h"
-#include "util/string.h"
-#include "rollback_interface.h" // Needed for rollbackRevertActions()
-#include <list> // Needed for rollbackRevertActions()
+#include "util/basic_macros.h"
+#include "serverenvironment.h"
+#include "clientiface.h"
+#include "chatmessage.h"
+#include <string>
+#include <list>
+#include <map>
+#include <vector>
 
-struct LuaState;
-typedef struct lua_State lua_State;
+class ChatEvent;
+struct ChatEventChat;
+struct ChatInterface;
 class IWritableItemDefManager;
-class IWritableNodeDefManager;
+class NodeDefManager;
 class IWritableCraftDefManager;
+class BanManager;
 class EventManager;
+class Inventory;
+class ModChannelMgr;
+class RemotePlayer;
 class PlayerSAO;
+struct PlayerHPChangeReason;
 class IRollbackManager;
-
-class ServerError : public std::exception
-{
-public:
-	ServerError(const std::string &s)
-	{
-		m_s = "ServerError: ";
-		m_s += s;
-	}
-	virtual ~ServerError() throw()
-	{}
-	virtual const char * what() const throw()
-	{
-		return m_s.c_str();
-	}
-	std::string m_s;
-};
-
-/*
-	Some random functions
-*/
-v3f findSpawnPos(ServerMap &map);
-
-/*
-	A structure containing the data needed for queueing the fetching
-	of blocks.
-*/
-struct QueuedBlockEmerge
-{
-	v3s16 pos;
-	// key = peer_id, value = flags
-	core::map<u16, u8> peer_ids;
-};
-
-/*
-	This is a thread-safe class.
-*/
-class BlockEmergeQueue
-{
-public:
-	BlockEmergeQueue()
-	{
-		m_mutex.Init();
-	}
-
-	~BlockEmergeQueue()
-	{
-		JMutexAutoLock lock(m_mutex);
-
-		core::list<QueuedBlockEmerge*>::Iterator i;
-		for(i=m_queue.begin(); i!=m_queue.end(); i++)
-		{
-			QueuedBlockEmerge *q = *i;
-			delete q;
-		}
-	}
-	
-	/*
-		peer_id=0 adds with nobody to send to
-	*/
-	void addBlock(u16 peer_id, v3s16 pos, u8 flags)
-	{
-		DSTACK(__FUNCTION_NAME);
-	
-		JMutexAutoLock lock(m_mutex);
-
-		if(peer_id != 0)
-		{
-			/*
-				Find if block is already in queue.
-				If it is, update the peer to it and quit.
-			*/
-			core::list<QueuedBlockEmerge*>::Iterator i;
-			for(i=m_queue.begin(); i!=m_queue.end(); i++)
-			{
-				QueuedBlockEmerge *q = *i;
-				if(q->pos == pos)
-				{
-					q->peer_ids[peer_id] = flags;
-					return;
-				}
-			}
-		}
-		
-		/*
-			Add the block
-		*/
-		QueuedBlockEmerge *q = new QueuedBlockEmerge;
-		q->pos = pos;
-		if(peer_id != 0)
-			q->peer_ids[peer_id] = flags;
-		m_queue.push_back(q);
-	}
-
-	// Returned pointer must be deleted
-	// Returns NULL if queue is empty
-	QueuedBlockEmerge * pop()
-	{
-		JMutexAutoLock lock(m_mutex);
-
-		core::list<QueuedBlockEmerge*>::Iterator i = m_queue.begin();
-		if(i == m_queue.end())
-			return NULL;
-		QueuedBlockEmerge *q = *i;
-		m_queue.erase(i);
-		return q;
-	}
-
-	u32 size()
-	{
-		JMutexAutoLock lock(m_mutex);
-		return m_queue.size();
-	}
-	
-	u32 peerItemCount(u16 peer_id)
-	{
-		JMutexAutoLock lock(m_mutex);
-
-		u32 count = 0;
-
-		core::list<QueuedBlockEmerge*>::Iterator i;
-		for(i=m_queue.begin(); i!=m_queue.end(); i++)
-		{
-			QueuedBlockEmerge *q = *i;
-			if(q->peer_ids.find(peer_id) != NULL)
-				count++;
-		}
-
-		return count;
-	}
-
-private:
-	core::list<QueuedBlockEmerge*> m_queue;
-	JMutex m_mutex;
-};
-
-class Server;
-
-class ServerThread : public SimpleThread
-{
-	Server *m_server;
-
-public:
-
-	ServerThread(Server *server):
-		SimpleThread(),
-		m_server(server)
-	{
-	}
-
-	void * Thread();
-};
-
-class EmergeThread : public SimpleThread
-{
-	Server *m_server;
-
-public:
-
-	EmergeThread(Server *server):
-		SimpleThread(),
-		m_server(server)
-	{
-	}
-
-	void * Thread();
-
-	void trigger()
-	{
-		setRun(true);
-		if(IsRunning() == false)
-		{
-			Start();
-		}
-	}
-};
-
-struct PlayerInfo
-{
-	u16 id;
-	char name[PLAYERNAME_SIZE];
-	v3f position;
-	Address address;
-	float avg_rtt;
-
-	PlayerInfo();
-	void PrintLine(std::ostream *s);
-};
-
-/*
-	Used for queueing and sorting block transfers in containers
-	
-	Lower priority number means higher priority.
-*/
-struct PrioritySortedBlockTransfer
-{
-	PrioritySortedBlockTransfer(float a_priority, v3s16 a_pos, u16 a_peer_id)
-	{
-		priority = a_priority;
-		pos = a_pos;
-		peer_id = a_peer_id;
-	}
-	bool operator < (PrioritySortedBlockTransfer &other)
-	{
-		return priority < other.priority;
-	}
-	float priority;
-	v3s16 pos;
-	u16 peer_id;
-};
-
-struct MediaRequest
-{
-	std::string name;
-
-	MediaRequest(const std::string &name_=""):
-		name(name_)
-	{}
+struct RollbackAction;
+class EmergeManager;
+class ServerScripting;
+class ServerEnvironment;
+struct SimpleSoundSpec;
+struct CloudParams;
+struct SkyboxParams;
+struct SunParams;
+struct MoonParams;
+struct StarParams;
+class ServerThread;
+class ServerModManager;
+
+enum ClientDeletionReason {
+	CDR_LEAVE,
+	CDR_TIMEOUT,
+	CDR_DENY
 };
 
 struct MediaInfo
@@ -272,8 +79,8 @@ struct MediaInfo
 	std::string path;
 	std::string sha1_digest;
 
-	MediaInfo(const std::string path_="",
-			const std::string sha1_digest_=""):
+	MediaInfo(const std::string &path_="",
+	          const std::string &sha1_digest_=""):
 		path(path_),
 		sha1_digest(sha1_digest_)
 	{
@@ -282,208 +89,112 @@ struct MediaInfo
 
 struct ServerSoundParams
 {
-	float gain;
-	std::string to_player;
-	enum Type{
-		SSP_LOCAL=0,
-		SSP_POSITIONAL=1,
-		SSP_OBJECT=2
-	} type;
+	enum Type {
+		SSP_LOCAL,
+		SSP_POSITIONAL,
+		SSP_OBJECT
+	} type = SSP_LOCAL;
+	float gain = 1.0f;
+	float fade = 0.0f;
+	float pitch = 1.0f;
+	bool loop = false;
+	float max_hear_distance = 32 * BS;
 	v3f pos;
-	u16 object;
-	float max_hear_distance;
-	bool loop;
-
-	ServerSoundParams():
-		gain(1.0),
-		to_player(""),
-		type(SSP_LOCAL),
-		pos(0,0,0),
-		object(0),
-		max_hear_distance(32*BS),
-		loop(false)
-	{}
-	
+	u16 object = 0;
+	std::string to_player = "";
+	std::string exclude_player = "";
+
 	v3f getPos(ServerEnvironment *env, bool *pos_exists) const;
 };
 
 struct ServerPlayingSound
 {
 	ServerSoundParams params;
-	std::set<u16> clients; // peer ids
-};
-
-class RemoteClient
-{
-public:
-	// peer_id=0 means this client has no associated peer
-	// NOTE: If client is made allowed to exist while peer doesn't,
-	//       this has to be set to 0 when there is no peer.
-	//       Also, the client must be moved to some other container.
-	u16 peer_id;
-	// The serialization version to use with the client
-	u8 serialization_version;
-	//
-	u16 net_proto_version;
-	// Version is stored in here after INIT before INIT2
-	u8 pending_serialization_version;
-
-	bool definitions_sent;
-
-	RemoteClient():
-		m_time_from_building(9999),
-		m_excess_gotblocks(0)
-	{
-		peer_id = 0;
-		serialization_version = SER_FMT_VER_INVALID;
-		net_proto_version = 0;
-		pending_serialization_version = SER_FMT_VER_INVALID;
-		definitions_sent = false;
-		m_nearest_unsent_d = 0;
-		m_nearest_unsent_reset_timer = 0.0;
-		m_nothing_to_send_counter = 0;
-		m_nothing_to_send_pause_timer = 0;
-	}
-	~RemoteClient()
-	{
-	}
-	
-	/*
-		Finds block that should be sent next to the client.
-		Environment should be locked when this is called.
-		dtime is used for resetting send radius at slow interval
-	*/
-	void GetNextBlocks(Server *server, float dtime,
-			core::array<PrioritySortedBlockTransfer> &dest);
-
-	void GotBlock(v3s16 p);
-
-	void SentBlock(v3s16 p);
-
-	void SetBlockNotSent(v3s16 p);
-	void SetBlocksNotSent(core::map<v3s16, MapBlock*> &blocks);
-
-	s32 SendingCount()
-	{
-		return m_blocks_sending.size();
-	}
-	
-	// Increments timeouts and removes timed-out blocks from list
-	// NOTE: This doesn't fix the server-not-sending-block bug
-	//       because it is related to emerging, not sending.
-	//void RunSendingTimeouts(float dtime, float timeout);
-
-	void PrintInfo(std::ostream &o)
-	{
-		o<<"RemoteClient "<<peer_id<<": "
-				<<"m_blocks_sent.size()="<<m_blocks_sent.size()
-				<<", m_blocks_sending.size()="<<m_blocks_sending.size()
-				<<", m_nearest_unsent_d="<<m_nearest_unsent_d
-				<<", m_excess_gotblocks="<<m_excess_gotblocks
-				<<std::endl;
-		m_excess_gotblocks = 0;
-	}
-
-	// Time from last placing or removing blocks
-	float m_time_from_building;
-	
-	/*JMutex m_dig_mutex;
-	float m_dig_time_remaining;
-	// -1 = not digging
-	s16 m_dig_tool_item;
-	v3s16 m_dig_position;*/
-	
-	/*
-		List of active objects that the client knows of.
-		Value is dummy.
-	*/
-	core::map<u16, bool> m_known_objects;
-
-private:
-	/*
-		Blocks that have been sent to client.
-		- These don't have to be sent again.
-		- A block is cleared from here when client says it has
-		  deleted it from it's memory
-		
-		Key is position, value is dummy.
-		No MapBlock* is stored here because the blocks can get deleted.
-	*/
-	core::map<v3s16, bool> m_blocks_sent;
-	s16 m_nearest_unsent_d;
-	v3s16 m_last_center;
-	float m_nearest_unsent_reset_timer;
-	
-	/*
-		Blocks that are currently on the line.
-		This is used for throttling the sending of blocks.
-		- The size of this list is limited to some value
-		Block is added when it is sent with BLOCKDATA.
-		Block is removed when GOTBLOCKS is received.
-		Value is time from sending. (not used at the moment)
-	*/
-	core::map<v3s16, float> m_blocks_sending;
-
-	/*
-		Count of excess GotBlocks().
-		There is an excess amount because the client sometimes
-		gets a block so late that the server sends it again,
-		and the client then sends two GOTBLOCKs.
-		This is resetted by PrintInfo()
-	*/
-	u32 m_excess_gotblocks;
-	
-	// CPU usage optimization
-	u32 m_nothing_to_send_counter;
-	float m_nothing_to_send_pause_timer;
+	SimpleSoundSpec spec;
+	std::unordered_set<session_t> clients; // peer ids
 };
 
 class Server : public con::PeerHandler, public MapEventReceiver,
-		public InventoryManager, public IGameDef,
-		public IBackgroundBlockEmerger
+		public InventoryManager, public IGameDef
 {
 public:
 	/*
 		NOTE: Every public method should be thread-safe
 	*/
-	
+
 	Server(
 		const std::string &path_world,
-		const std::string &path_config,
 		const SubgameSpec &gamespec,
-		bool simple_singleplayer_mode
+		bool simple_singleplayer_mode,
+		Address bind_addr,
+		bool dedicated,
+		ChatInterface *iface = nullptr
 	);
 	~Server();
-	void start(unsigned short port);
+	DISABLE_CLASS_COPY(Server);
+
+	void init();
+	void start();
 	void stop();
 	// This is mainly a way to pass the time to the server.
 	// Actual processing is done in an another thread.
 	void step(float dtime);
 	// This is run by ServerThread and does the actual processing
-	void AsyncRunStep();
+	void AsyncRunStep(bool initial_step=false);
 	void Receive();
-	void ProcessData(u8 *data, u32 datasize, u16 peer_id);
-
-	core::list<PlayerInfo> getPlayerInfo();
+	PlayerSAO* StageTwoClientInit(session_t peer_id);
 
-	// Environment must be locked when called
-	void setTimeOfDay(u32 time)
-	{
-		m_env->setTimeOfDay(time);
-		m_time_of_day_send_timer = 0;
-	}
+	/*
+	 * Command Handlers
+	 */
+
+	void handleCommand(NetworkPacket* pkt);
+
+	void handleCommand_Null(NetworkPacket* pkt) {};
+	void handleCommand_Deprecated(NetworkPacket* pkt);
+	void handleCommand_Init(NetworkPacket* pkt);
+	void handleCommand_Init2(NetworkPacket* pkt);
+	void handleCommand_ModChannelJoin(NetworkPacket *pkt);
+	void handleCommand_ModChannelLeave(NetworkPacket *pkt);
+	void handleCommand_ModChannelMsg(NetworkPacket *pkt);
+	void handleCommand_RequestMedia(NetworkPacket* pkt);
+	void handleCommand_ClientReady(NetworkPacket* pkt);
+	void handleCommand_GotBlocks(NetworkPacket* pkt);
+	void handleCommand_PlayerPos(NetworkPacket* pkt);
+	void handleCommand_DeletedBlocks(NetworkPacket* pkt);
+	void handleCommand_InventoryAction(NetworkPacket* pkt);
+	void handleCommand_ChatMessage(NetworkPacket* pkt);
+	void handleCommand_Damage(NetworkPacket* pkt);
+	void handleCommand_Password(NetworkPacket* pkt);
+	void handleCommand_PlayerItem(NetworkPacket* pkt);
+	void handleCommand_Respawn(NetworkPacket* pkt);
+	void handleCommand_Interact(NetworkPacket* pkt);
+	void handleCommand_RemovedSounds(NetworkPacket* pkt);
+	void handleCommand_NodeMetaFields(NetworkPacket* pkt);
+	void handleCommand_InventoryFields(NetworkPacket* pkt);
+	void handleCommand_FirstSrp(NetworkPacket* pkt);
+	void handleCommand_SrpBytesA(NetworkPacket* pkt);
+	void handleCommand_SrpBytesM(NetworkPacket* pkt);
+
+	void ProcessData(NetworkPacket *pkt);
+
+	void Send(NetworkPacket *pkt);
+	void Send(session_t peer_id, NetworkPacket *pkt);
+
+	// Helper for handleCommand_PlayerPos and handleCommand_Interact
+	void process_PlayerPos(RemotePlayer *player, PlayerSAO *playersao,
+		NetworkPacket *pkt);
+
+	// Both setter and getter need no envlock,
+	// can be called freely from threads
+	void setTimeOfDay(u32 time);
 
-	bool getShutdownRequested()
-	{
-		return m_shutdown_requested;
-	}
-	
 	/*
 		Shall be called with the environment locked.
 		This is accessed by the map, which is inside the environment,
 		so it shouldn't be a problem.
 	*/
-	void onMapEditEvent(MapEditEvent *event);
+	void onMapEditEvent(const MapEditEvent &event);
 
 	/*
 		Shall be called with the environment and the connection locked.
@@ -493,191 +204,312 @@ public:
 
 	// Connection must be locked when called
 	std::wstring getStatusString();
+	inline double getUptime() const { return m_uptime.m_value; }
 
-	void requestShutdown(void)
-	{
-		m_shutdown_requested = true;
-	}
+	// read shutdown state
+	inline bool isShutdownRequested() const { return m_shutdown_state.is_requested; }
+
+	// request server to shutdown
+	void requestShutdown(const std::string &msg, bool reconnect, float delay = 0.0f);
 
 	// Returns -1 if failed, sound handle on success
-	// Envlock + conlock
-	s32 playSound(const SimpleSoundSpec &spec, const ServerSoundParams &params);
+	// Envlock
+	s32 playSound(const SimpleSoundSpec &spec, const ServerSoundParams &params,
+			bool ephemeral=false);
 	void stopSound(s32 handle);
-	
-	// Envlock + conlock
+	void fadeSound(s32 handle, float step, float gain);
+
+	// Envlock
 	std::set<std::string> getPlayerEffectivePrivs(const std::string &name);
 	bool checkPriv(const std::string &name, const std::string &priv);
 	void reportPrivsModified(const std::string &name=""); // ""=all
 	void reportInventoryFormspecModified(const std::string &name);
+	void reportFormspecPrependModified(const std::string &name);
+
+	void setIpBanned(const std::string &ip, const std::string &name);
+	void unsetIpBanned(const std::string &ip_or_name);
+	std::string getBanDescription(const std::string &ip_or_name);
+
+	void notifyPlayer(const char *name, const std::wstring &msg);
+	void notifyPlayers(const std::wstring &msg);
+	void spawnParticle(const std::string &playername,
+		v3f pos, v3f velocity, v3f acceleration,
+		float expirationtime, float size,
+		bool collisiondetection, bool collision_removal, bool object_collision,
+		bool vertical, const std::string &texture,
+		const struct TileAnimationParams &animation, u8 glow);
+
+	u32 addParticleSpawner(u16 amount, float spawntime,
+		v3f minpos, v3f maxpos,
+		v3f minvel, v3f maxvel,
+		v3f minacc, v3f maxacc,
+		float minexptime, float maxexptime,
+		float minsize, float maxsize,
+		bool collisiondetection, bool collision_removal, bool object_collision,
+		ServerActiveObject *attached,
+		bool vertical, const std::string &texture,
+		const std::string &playername, const struct TileAnimationParams &animation,
+		u8 glow);
+
+	void deleteParticleSpawner(const std::string &playername, u32 id);
 
-	// Saves g_settings to configpath given at initialization
-	void saveConfig();
-
-	void setIpBanned(const std::string &ip, const std::string &name)
-	{
-		m_banmanager.add(ip, name);
-		return;
-	}
-
-	void unsetIpBanned(const std::string &ip_or_name)
-	{
-		m_banmanager.remove(ip_or_name);
-		return;
-	}
-
-	std::string getBanDescription(const std::string &ip_or_name)
-	{
-		return m_banmanager.getBanDescription(ip_or_name);
-	}
-
-	Address getPeerAddress(u16 peer_id)
-	{
-		return m_con.GetPeerAddress(peer_id);
-	}
-	
-	// Envlock and conlock should be locked when calling this
-	void notifyPlayer(const char *name, const std::wstring msg);
-	void notifyPlayers(const std::wstring msg);
-
-	void queueBlockEmerge(v3s16 blockpos, bool allow_generate);
-	
 	// Creates or resets inventory
-	Inventory* createDetachedInventory(const std::string &name);
-	
-	// Envlock and conlock should be locked when using Lua
-	lua_State *getLua(){ return m_lua; }
+	Inventory *createDetachedInventory(const std::string &name,
+			const std::string &player = "");
+	bool removeDetachedInventory(const std::string &name);
+
+	// Envlock and conlock should be locked when using scriptapi
+	ServerScripting *getScriptIface(){ return m_script; }
 
-	// Envlock should be locked when using the rollback manager
-	IRollbackManager *getRollbackManager(){ return m_rollback; }
 	// actions: time-reversed list
 	// Return value: success/failure
 	bool rollbackRevertActions(const std::list<RollbackAction> &actions,
 			std::list<std::string> *log);
-	
+
 	// IGameDef interface
 	// Under envlock
 	virtual IItemDefManager* getItemDefManager();
-	virtual INodeDefManager* getNodeDefManager();
+	virtual const NodeDefManager* getNodeDefManager();
 	virtual ICraftDefManager* getCraftDefManager();
-	virtual ITextureSource* getTextureSource();
-	virtual IShaderSource* getShaderSource();
 	virtual u16 allocateUnknownNodeId(const std::string &name);
-	virtual ISoundManager* getSoundManager();
-	virtual MtEventManager* getEventManager();
-	virtual IRollbackReportSink* getRollbackReportSink();
-	
+	IRollbackManager *getRollbackManager() { return m_rollback; }
+	virtual EmergeManager *getEmergeManager() { return m_emerge; }
+
 	IWritableItemDefManager* getWritableItemDefManager();
-	IWritableNodeDefManager* getWritableNodeDefManager();
+	NodeDefManager* getWritableNodeDefManager();
 	IWritableCraftDefManager* getWritableCraftDefManager();
 
-	const ModSpec* getModSpec(const std::string &modname);
-	void getModNames(core::list<std::string> &modlist);
+	virtual const std::vector<ModSpec> &getMods() const;
+	virtual const ModSpec* getModSpec(const std::string &modname) const;
+	void getModNames(std::vector<std::string> &modlist);
 	std::string getBuiltinLuaPath();
-	
-	std::string getWorldPath(){ return m_path_world; }
+	virtual std::string getWorldPath() const { return m_path_world; }
+	virtual std::string getModStoragePath() const;
 
-	bool isSingleplayer(){ return m_simple_singleplayer_mode; }
+	inline bool isSingleplayer()
+			{ return m_simple_singleplayer_mode; }
 
-	void setAsyncFatalError(const std::string &error)
-	{
-		m_async_fatal_error.set(error);
-	}
+	inline void setAsyncFatalError(const std::string &error)
+			{ m_async_fatal_error.set(error); }
 
 	bool showFormspec(const char *name, const std::string &formspec, const std::string &formname);
-private:
+	Map & getMap() { return m_env->getMap(); }
+	ServerEnvironment & getEnv() { return *m_env; }
+	v3f findSpawnPos();
 
-	// con::PeerHandler implementation.
-	// These queue stuff to be processed by handlePeerChanges().
-	// As of now, these create and remove clients and players.
+	u32 hudAdd(RemotePlayer *player, HudElement *element);
+	bool hudRemove(RemotePlayer *player, u32 id);
+	bool hudChange(RemotePlayer *player, u32 id, HudElementStat stat, void *value);
+	bool hudSetFlags(RemotePlayer *player, u32 flags, u32 mask);
+	bool hudSetHotbarItemcount(RemotePlayer *player, s32 hotbar_itemcount);
+	void hudSetHotbarImage(RemotePlayer *player, const std::string &name);
+	void hudSetHotbarSelectedImage(RemotePlayer *player, const std::string &name);
+
+	Address getPeerAddress(session_t peer_id);
+
+	void setLocalPlayerAnimations(RemotePlayer *player, v2s32 animation_frames[4],
+			f32 frame_speed);
+	void setPlayerEyeOffset(RemotePlayer *player, const v3f &first, const v3f &third);
+
+	void setSky(RemotePlayer *player, const SkyboxParams &params);
+	void setSun(RemotePlayer *player, const SunParams &params);
+	void setMoon(RemotePlayer *player, const MoonParams &params);
+	void setStars(RemotePlayer *player, const StarParams &params);
+
+	void setClouds(RemotePlayer *player, const CloudParams &params);
+
+	bool overrideDayNightRatio(RemotePlayer *player, bool do_override, float brightness);
+
+	/* con::PeerHandler implementation. */
 	void peerAdded(con::Peer *peer);
 	void deletingPeer(con::Peer *peer, bool timeout);
-	
-	/*
-		Static send methods
-	*/
-	
-	static void SendHP(con::Connection &con, u16 peer_id, u8 hp);
-	static void SendAccessDenied(con::Connection &con, u16 peer_id,
-			const std::wstring &reason);
-	static void SendDeathscreen(con::Connection &con, u16 peer_id,
-			bool set_camera_point_target, v3f camera_point_target);
-	static void SendItemDef(con::Connection &con, u16 peer_id,
-			IItemDefManager *itemdef);
-	static void SendNodeDef(con::Connection &con, u16 peer_id,
-			INodeDefManager *nodedef, u16 protocol_version);
-	
-	/*
-		Non-static send methods.
-		Conlock should be always used.
-		Envlock usage is documented badly but it's easy to figure out
-		which ones access the environment.
-	*/
 
-	// Envlock and conlock should be locked when calling these
-	void SendInventory(u16 peer_id);
-	void SendChatMessage(u16 peer_id, const std::wstring &message);
-	void BroadcastChatMessage(const std::wstring &message);
-	void SendPlayerHP(u16 peer_id);
-	void SendMovePlayer(u16 peer_id);
-	void SendPlayerPrivileges(u16 peer_id);
-	void SendPlayerInventoryFormspec(u16 peer_id);
-	void SendShowFormspecMessage(u16 peer_id, const std::string formspec, const std::string formname);
+	void DenySudoAccess(session_t peer_id);
+	void DenyAccessVerCompliant(session_t peer_id, u16 proto_ver, AccessDeniedCode reason,
+		const std::string &str_reason = "", bool reconnect = false);
+	void DenyAccess(session_t peer_id, AccessDeniedCode reason,
+		const std::string &custom_reason = "");
+	void acceptAuth(session_t peer_id, bool forSudoMode);
+	void DenyAccess_Legacy(session_t peer_id, const std::wstring &reason);
+	void DisconnectPeer(session_t peer_id);
+	bool getClientConInfo(session_t peer_id, con::rtt_stat_type type, float *retval);
+	bool getClientInfo(session_t peer_id, ClientState *state, u32 *uptime,
+			u8* ser_vers, u16* prot_vers, u8* major, u8* minor, u8* patch,
+			std::string* vers_string);
+
+	void printToConsoleOnly(const std::string &text);
+
+	void SendPlayerHPOrDie(PlayerSAO *player, const PlayerHPChangeReason &reason);
+	void SendPlayerBreath(PlayerSAO *sao);
+	void SendInventory(PlayerSAO *playerSAO, bool incremental);
+	void SendMovePlayer(session_t peer_id);
+	void SendPlayerSpeed(session_t peer_id, const v3f &added_vel);
+	void SendPlayerFov(session_t peer_id);
+
+	void sendDetachedInventories(session_t peer_id, bool incremental);
+
+	virtual bool registerModStorage(ModMetadata *storage);
+	virtual void unregisterModStorage(const std::string &name);
+
+	bool joinModChannel(const std::string &channel);
+	bool leaveModChannel(const std::string &channel);
+	bool sendModChannelMessage(const std::string &channel, const std::string &message);
+	ModChannel *getModChannel(const std::string &channel);
+
+	// Send block to specific player only
+	bool SendBlock(session_t peer_id, const v3s16 &blockpos);
+
+	// Bind address
+	Address m_bind_addr;
+
+	// Environment mutex (envlock)
+	std::mutex m_env_mutex;
+
+private:
+	friend class EmergeThread;
+	friend class RemoteClient;
+	friend class TestServerShutdownState;
+
+	struct ShutdownState {
+		friend class TestServerShutdownState;
+		public:
+			bool is_requested = false;
+			bool should_reconnect = false;
+			std::string message;
+
+			void reset();
+			void trigger(float delay, const std::string &msg, bool reconnect);
+			void tick(float dtime, Server *server);
+			std::wstring getShutdownTimerMessage() const;
+			bool isTimerRunning() const { return m_timer > 0.0f; }
+		private:
+			float m_timer = 0.0f;
+	};
+
+	void SendMovement(session_t peer_id);
+	void SendHP(session_t peer_id, u16 hp);
+	void SendBreath(session_t peer_id, u16 breath);
+	void SendAccessDenied(session_t peer_id, AccessDeniedCode reason,
+		const std::string &custom_reason, bool reconnect = false);
+	void SendAccessDenied_Legacy(session_t peer_id, const std::wstring &reason);
+	void SendDeathscreen(session_t peer_id, bool set_camera_point_target,
+		v3f camera_point_target);
+	void SendItemDef(session_t peer_id, IItemDefManager *itemdef, u16 protocol_version);
+	void SendNodeDef(session_t peer_id, const NodeDefManager *nodedef,
+		u16 protocol_version);
+
+	/* mark blocks not sent for all clients */
+	void SetBlocksNotSent(std::map<v3s16, MapBlock *>& block);
+
+
+	virtual void SendChatMessage(session_t peer_id, const ChatMessage &message);
+	void SendTimeOfDay(session_t peer_id, u16 time, f32 time_speed);
+	void SendPlayerHP(session_t peer_id);
+
+	void SendLocalPlayerAnimations(session_t peer_id, v2s32 animation_frames[4],
+		f32 animation_speed);
+	void SendEyeOffset(session_t peer_id, v3f first, v3f third);
+	void SendPlayerPrivileges(session_t peer_id);
+	void SendPlayerInventoryFormspec(session_t peer_id);
+	void SendPlayerFormspecPrepend(session_t peer_id);
+	void SendShowFormspecMessage(session_t peer_id, const std::string &formspec,
+		const std::string &formname);
+	void SendHUDAdd(session_t peer_id, u32 id, HudElement *form);
+	void SendHUDRemove(session_t peer_id, u32 id);
+	void SendHUDChange(session_t peer_id, u32 id, HudElementStat stat, void *value);
+	void SendHUDSetFlags(session_t peer_id, u32 flags, u32 mask);
+	void SendHUDSetParam(session_t peer_id, u16 param, const std::string &value);
+	void SendSetSky(session_t peer_id, const SkyboxParams &params);
+	void SendSetSun(session_t peer_id, const SunParams &params);
+	void SendSetMoon(session_t peer_id, const MoonParams &params);
+	void SendSetStars(session_t peer_id, const StarParams &params);
+	void SendCloudParams(session_t peer_id, const CloudParams &params);
+	void SendOverrideDayNightRatio(session_t peer_id, bool do_override, float ratio);
+	void broadcastModChannelMessage(const std::string &channel,
+			const std::string &message, session_t from_peer);
+
 	/*
 		Send a node removal/addition event to all clients except ignore_id.
 		Additionally, if far_players!=NULL, players further away than
 		far_d_nodes are ignored and their peer_ids are added to far_players
 	*/
 	// Envlock and conlock should be locked when calling these
-	void sendRemoveNode(v3s16 p, u16 ignore_id=0,
-			core::list<u16> *far_players=NULL, float far_d_nodes=100);
-	void sendAddNode(v3s16 p, MapNode n, u16 ignore_id=0,
-			core::list<u16> *far_players=NULL, float far_d_nodes=100);
-	void setBlockNotSent(v3s16 p);
-	
+	void sendRemoveNode(v3s16 p, std::unordered_set<u16> *far_players = nullptr,
+			float far_d_nodes = 100);
+	void sendAddNode(v3s16 p, MapNode n,
+			std::unordered_set<u16> *far_players = nullptr,
+			float far_d_nodes = 100, bool remove_metadata = true);
+
+	void sendMetadataChanged(const std::list<v3s16> &meta_updates,
+			float far_d_nodes = 100);
+
 	// Environment and Connection must be locked when called
-	void SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver);
-	
+	void SendBlockNoLock(session_t peer_id, MapBlock *block, u8 ver, u16 net_proto_version);
+
 	// Sends blocks to clients (locks env and con on its own)
 	void SendBlocks(float dtime);
-	
+
 	void fillMediaCache();
-	void sendMediaAnnouncement(u16 peer_id);
-	void sendRequestedMedia(u16 peer_id,
-			const core::list<MediaRequest> &tosend);
-	
-	void sendDetachedInventory(const std::string &name, u16 peer_id);
-	void sendDetachedInventoryToAll(const std::string &name);
-	void sendDetachedInventories(u16 peer_id);
+	void sendMediaAnnouncement(session_t peer_id, const std::string &lang_code);
+	void sendRequestedMedia(session_t peer_id,
+			const std::vector<std::string> &tosend);
+
+	void sendDetachedInventory(const std::string &name, session_t peer_id);
+
+	// Adds a ParticleSpawner on peer with peer_id (PEER_ID_INEXISTENT == all)
+	void SendAddParticleSpawner(session_t peer_id, u16 protocol_version,
+		u16 amount, float spawntime,
+		v3f minpos, v3f maxpos,
+		v3f minvel, v3f maxvel,
+		v3f minacc, v3f maxacc,
+		float minexptime, float maxexptime,
+		float minsize, float maxsize,
+		bool collisiondetection, bool collision_removal, bool object_collision,
+		u16 attached_id,
+		bool vertical, const std::string &texture, u32 id,
+		const struct TileAnimationParams &animation, u8 glow);
+
+	void SendDeleteParticleSpawner(session_t peer_id, u32 id);
+
+	// Spawns particle on peer with peer_id (PEER_ID_INEXISTENT == all)
+	void SendSpawnParticle(session_t peer_id, u16 protocol_version,
+		v3f pos, v3f velocity, v3f acceleration,
+		float expirationtime, float size,
+		bool collisiondetection, bool collision_removal, bool object_collision,
+		bool vertical, const std::string &texture,
+		const struct TileAnimationParams &animation, u8 glow);
+
+	void SendActiveObjectRemoveAdd(RemoteClient *client, PlayerSAO *playersao);
+	void SendActiveObjectMessages(session_t peer_id, const std::string &datas,
+		bool reliable = true);
+	void SendCSMRestrictionFlags(session_t peer_id);
 
 	/*
 		Something random
 	*/
-	
-	void DiePlayer(u16 peer_id);
-	void RespawnPlayer(u16 peer_id);
-	
-	void UpdateCrafting(u16 peer_id);
-	
+
+	void DiePlayer(session_t peer_id, const PlayerHPChangeReason &reason);
+	void RespawnPlayer(session_t peer_id);
+	void DeleteClient(session_t peer_id, ClientDeletionReason reason);
+	void UpdateCrafting(RemotePlayer *player);
+	bool checkInteractDistance(RemotePlayer *player, const f32 d, const std::string &what);
+
+	void handleChatInterfaceEvent(ChatEvent *evt);
+
+	// This returns the answer to the sender of wmessage, or "" if there is none
+	std::wstring handleChat(const std::string &name, const std::wstring &wname,
+		std::wstring wmessage_input,
+		bool check_shout_priv = false,
+		RemotePlayer *player = NULL);
+	void handleAdminChat(const ChatEventChat *evt);
+
 	// When called, connection mutex should be locked
-	RemoteClient* getClient(u16 peer_id);
-	
-	// When called, environment mutex should be locked
-	std::string getPlayerName(u16 peer_id)
-	{
-		Player *player = m_env->getPlayer(peer_id);
-		if(player == NULL)
-			return "[id="+itos(peer_id)+"]";
-		return player->getName();
-	}
+	RemoteClient* getClient(session_t peer_id, ClientState state_min = CS_Active);
+	RemoteClient* getClientNoEx(session_t peer_id, ClientState state_min = CS_Active);
 
 	// When called, environment mutex should be locked
-	PlayerSAO* getPlayerSAO(u16 peer_id)
-	{
-		Player *player = m_env->getPlayer(peer_id);
-		if(player == NULL)
-			return NULL;
-		return player->getPlayerSAO();
-	}
+	std::string getPlayerName(session_t peer_id);
+	PlayerSAO *getPlayerSAO(session_t peer_id);
 
 	/*
 		Get a player from memory or creates one.
@@ -686,129 +518,113 @@ private:
 
 		Call with env and con locked.
 	*/
-	PlayerSAO *emergePlayer(const char *name, u16 peer_id);
-	
-	// Locks environment and connection by its own
-	struct PeerChange;
-	void handlePeerChange(PeerChange &c);
+	PlayerSAO *emergePlayer(const char *name, session_t peer_id, u16 proto_version);
+
 	void handlePeerChanges();
 
 	/*
 		Variables
 	*/
-	
 	// World directory
 	std::string m_path_world;
-	// Path to user's configuration file ("" = no configuration file)
-	std::string m_path_config;
 	// Subgame specification
 	SubgameSpec m_gamespec;
 	// If true, do not allow multiple players and hide some multiplayer
 	// functionality
 	bool m_simple_singleplayer_mode;
+	u16 m_max_chatmessage_length;
+	// For "dedicated" server list flag
+	bool m_dedicated;
 
 	// Thread can set; step() will throw as ServerError
 	MutexedVariable<std::string> m_async_fatal_error;
-	
+
 	// Some timers
-	float m_liquid_transform_timer;
-	float m_print_info_timer;
-	float m_objectdata_timer;
-	float m_emergethread_trigger_timer;
-	float m_savemap_timer;
+	float m_liquid_transform_timer = 0.0f;
+	float m_liquid_transform_every = 1.0f;
+	float m_masterserver_timer = 0.0f;
+	float m_emergethread_trigger_timer = 0.0f;
+	float m_savemap_timer = 0.0f;
 	IntervalLimiter m_map_timer_and_unload_interval;
-	
-	// NOTE: If connection and environment are both to be locked,
-	// environment shall be locked first.
 
 	// Environment
-	ServerEnvironment *m_env;
-	JMutex m_env_mutex;
-	
-	// Connection
-	con::Connection m_con;
-	JMutex m_con_mutex;
-	// Connected clients (behind the con mutex)
-	core::map<u16, RemoteClient*> m_clients;
-
-	// Bann checking
-	BanManager m_banmanager;
+	ServerEnvironment *m_env = nullptr;
+
+	// server connection
+	std::shared_ptr<con::Connection> m_con;
+
+	// Ban checking
+	BanManager *m_banmanager = nullptr;
 
 	// Rollback manager (behind m_env_mutex)
-	IRollbackManager *m_rollback;
-	bool m_rollback_sink_enabled;
-	bool m_enable_rollback_recording; // Updated once in a while
+	IRollbackManager *m_rollback = nullptr;
+
+	// Emerge manager
+	EmergeManager *m_emerge = nullptr;
 
 	// Scripting
 	// Envlock and conlock should be locked when using Lua
-	lua_State *m_lua;
+	ServerScripting *m_script = nullptr;
 
 	// Item definition manager
 	IWritableItemDefManager *m_itemdef;
-	
+
 	// Node definition manager
-	IWritableNodeDefManager *m_nodedef;
-	
+	NodeDefManager *m_nodedef;
+
 	// Craft definition manager
 	IWritableCraftDefManager *m_craftdef;
-	
+
 	// Event manager
 	EventManager *m_event;
-	
+
 	// Mods
-	core::list<ModSpec> m_mods;
-	
+	std::unique_ptr<ServerModManager> m_modmgr;
+
 	/*
 		Threads
 	*/
-	
 	// A buffer for time steps
 	// step() increments and AsyncRunStep() run by m_thread reads it.
-	float m_step_dtime;
-	JMutex m_step_dtime_mutex;
+	float m_step_dtime = 0.0f;
+	std::mutex m_step_dtime_mutex;
+
+	// current server step lag counter
+	float m_lag;
 
 	// The server mainly operates in this thread
-	ServerThread m_thread;
-	// This thread fetches and generates map
-	EmergeThread m_emergethread;
-	// Queue of block coordinates to be processed by the emerge thread
-	BlockEmergeQueue m_emerge_queue;
-	
+	ServerThread *m_thread = nullptr;
+
 	/*
 		Time related stuff
 	*/
-
 	// Timer for sending time of day over network
-	float m_time_of_day_send_timer;
+	float m_time_of_day_send_timer = 0.0f;
 	// Uptime of server in seconds
 	MutexedVariable<double> m_uptime;
-	
+
+	/*
+	 	Client interface
+	*/
+	ClientInterface m_clients;
+
 	/*
 		Peer change queue.
 		Queues stuff from peerAdded() and deletingPeer() to
 		handlePeerChanges()
 	*/
-	enum PeerChangeType
-	{
-		PEER_ADDED,
-		PEER_REMOVED
-	};
-	struct PeerChange
-	{
-		PeerChangeType type;
-		u16 peer_id;
-		bool timeout;
-	};
-	Queue<PeerChange> m_peer_change_queue;
+	std::queue<con::PeerChange> m_peer_change_queue;
+
+	std::unordered_map<session_t, std::string> m_formspec_state_data;
 
 	/*
 		Random stuff
 	*/
-	
-	// Mod parent directory paths
-	core::list<std::string> m_modspaths;
 
-	bool m_shutdown_requested;
+	ShutdownState m_shutdown_state;
+
+	ChatInterface *m_admin_chat;
+	std::string m_admin_nick;
 
 	/*
 		Map edit event queue. Automatically receives all map edits.
@@ -823,13 +639,7 @@ private:
 		Queue of map edits from the environment for sending to the clients
 		This is behind m_env_mutex
 	*/
-	Queue<MapEditEvent*> m_unsent_map_edit_queue;
-	/*
-		Set to true when the server itself is modifying the map and does
-		all sending of information by itself.
-		This is behind m_env_mutex
-	*/
-	bool m_ignore_map_edit_events;
+	std::queue<MapEditEvent*> m_unsent_map_edit_queue;
 	/*
 		If a non-empty area, map edit events contained within are left
 		unsent. Done at map generation time to speed up editing of the
@@ -837,37 +647,39 @@ private:
 		This is behind m_env_mutex
 	*/
 	VoxelArea m_ignore_map_edit_events_area;
-	/*
-		If set to !=0, the incoming MapEditEvents are modified to have
-		this peed id as the disabled recipient
-		This is behind m_env_mutex
-	*/
-	u16 m_ignore_map_edit_events_peer_id;
 
-	friend class EmergeThread;
-	friend class RemoteClient;
-
-	std::map<std::string,MediaInfo> m_media;
+	// media files known to server
+	std::unordered_map<std::string, MediaInfo> m_media;
 
 	/*
 		Sounds
 	*/
-	std::map<s32, ServerPlayingSound> m_playing_sounds;
-	s32 m_next_sound_id;
+	std::unordered_map<s32, ServerPlayingSound> m_playing_sounds;
+	s32 m_next_sound_id = 0; // positive values only
+	s32 nextSoundId();
 
 	/*
 		Detached inventories (behind m_env_mutex)
 	*/
 	// key = name
 	std::map<std::string, Inventory*> m_detached_inventories;
+	// value = "" (visible to all players) or player name
+	std::map<std::string, std::string> m_detached_inventories_player;
+
+	std::unordered_map<std::string, ModMetadata *> m_mod_storages;
+	float m_mod_storage_save_timer = 10.0f;
+
+	// CSM restrictions byteflag
+	u64 m_csm_restriction_flags = CSMRestrictionFlags::CSM_RF_NONE;
+	u32 m_csm_restriction_noderange = 8;
+
+	// ModChannel manager
+	std::unique_ptr<ModChannelMgr> m_modchannel_mgr;
 };
 
 /*
 	Runs a simple dedicated server loop.
 
-	Shuts down when run is set to false.
+	Shuts down when kill is set to true.
 */
-void dedicated_server_loop(Server &server, bool &run);
-
-#endif
-
+void dedicated_server_loop(Server &server, bool &kill);