X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fserver.h;h=4292892c507b149c4e32c041c70ee8ea696207df;hb=dceb9f7d6058785cf60d9dbcc8eecdcee1053412;hp=bc7829f748cafcda5bf29d35b382a4b1a85615c7;hpb=9bccd75e340d7502251c233418e0afccd9c4a49c;p=dragonfireclient.git

diff --git a/src/server.h b/src/server.h
index bc7829f74..4292892c5 100644
--- a/src/server.h
+++ b/src/server.h
@@ -29,10 +29,10 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "mods.h"
 #include "inventorymanager.h"
 #include "subgame.h"
-#include "rollback_interface.h" // Needed for rollbackRevertActions()
 #include "util/numeric.h"
 #include "util/thread.h"
 #include "environment.h"
+#include "clientiface.h"
 #include <string>
 #include <list>
 #include <map>
@@ -49,27 +49,17 @@ class Inventory;
 class Player;
 class PlayerSAO;
 class IRollbackManager;
+class RollbackAction;
 class EmergeManager;
 class GameScripting;
 class ServerEnvironment;
 struct SimpleSoundSpec;
+class ServerThread;
 
-
-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;
+enum ClientDeletionReason {
+	CDR_LEAVE,
+	CDR_TIMEOUT,
+	CDR_DENY
 };
 
 /*
@@ -77,7 +67,6 @@ class ServerError : public std::exception
 */
 v3f findSpawnPos(ServerMap &map);
 
-
 class MapEditEventIgnorer
 {
 public:
@@ -128,47 +117,13 @@ class MapEditEventAreaIgnorer
 	VoxelArea *m_ignorevariable;
 };
 
-class Server;
-class ServerThread;
-
-/*
-	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 < (const PrioritySortedBlockTransfer &other) const
-	{
-		return priority < other.priority;
-	}
-	float priority;
-	v3s16 pos;
-	u16 peer_id;
-};
-
-struct MediaRequest
-{
-	std::string name;
-
-	MediaRequest(const std::string &name_=""):
-		name(name_)
-	{}
-};
-
 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_)
 	{
@@ -208,134 +163,6 @@ struct ServerPlayingSound
 	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;
-
-	bool denied;
-
-	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;
-		denied = 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,
-			std::vector<PrioritySortedBlockTransfer> &dest);
-
-	void GotBlock(v3s16 p);
-
-	void SentBlock(v3s16 p);
-
-	void SetBlockNotSent(v3s16 p);
-	void SetBlocksNotSent(std::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.
-	*/
-	std::set<u16> 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.
-	*/
-	std::set<v3s16> 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)
-	*/
-	std::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;
-};
-
 class Server : public con::PeerHandler, public MapEventReceiver,
 		public InventoryManager, public IGameDef
 {
@@ -347,27 +174,24 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 	Server(
 		const std::string &path_world,
 		const SubgameSpec &gamespec,
-		bool simple_singleplayer_mode
+		bool simple_singleplayer_mode,
+		bool ipv6
 	);
 	~Server();
-	void start(unsigned short port);
+	void start(Address bind_addr);
 	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();
+	PlayerSAO* StageTwoClientInit(u16 peer_id);
 	void ProcessData(u8 *data, u32 datasize, u16 peer_id);
 
 	// Environment must be locked when called
 	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,
@@ -384,17 +208,20 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 	// Connection must be locked when called
 	std::wstring getStatusString();
 
-	void requestShutdown(void)
-	{
-		m_shutdown_requested = true;
-	}
+	// read shutdown state
+	inline bool getShutdownRequested()
+			{ return m_shutdown_requested; }
+
+	// request server to shutdown
+	inline void requestShutdown(void)
+			{ m_shutdown_requested = true; }
 
 	// Returns -1 if failed, sound handle on success
-	// Envlock + conlock
+	// Envlock
 	s32 playSound(const SimpleSoundSpec &spec, const ServerSoundParams &params);
 	void stopSound(s32 handle);
 
-	// Envlock + conlock
+	// 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
@@ -404,22 +231,16 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 	void unsetIpBanned(const std::string &ip_or_name);
 	std::string getBanDescription(const std::string &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, const bool prepend);
-	void notifyPlayers(const std::wstring msg);
+	void notifyPlayer(const char *name, const std::wstring &msg);
+	void notifyPlayers(const std::wstring &msg);
 	void spawnParticle(const char *playername,
 		v3f pos, v3f velocity, v3f acceleration,
 		float expirationtime, float size,
-		bool collisiondetection, std::string texture);
+		bool collisiondetection, bool vertical, std::string texture);
 
 	void spawnParticleAll(v3f pos, v3f velocity, v3f acceleration,
 		float expirationtime, float size,
-		bool collisiondetection, std::string texture);
+		bool collisiondetection, bool vertical, std::string texture);
 
 	u32 addParticleSpawner(const char *playername,
 		u16 amount, float spawntime,
@@ -428,7 +249,7 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 		v3f minacc, v3f maxacc,
 		float minexptime, float maxexptime,
 		float minsize, float maxsize,
-		bool collisiondetection, std::string texture);
+		bool collisiondetection, bool vertical, std::string texture);
 
 	u32 addParticleSpawnerAll(u16 amount, float spawntime,
 		v3f minpos, v3f maxpos,
@@ -436,7 +257,7 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 		v3f minacc, v3f maxacc,
 		float minexptime, float maxexptime,
 		float minsize, float maxsize,
-		bool collisiondetection, std::string texture);
+		bool collisiondetection, bool vertical, std::string texture);
 
 	void deleteParticleSpawner(const char *playername, u32 id);
 	void deleteParticleSpawnerAll(u32 id);
@@ -447,9 +268,6 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 	// Envlock and conlock should be locked when using scriptapi
 	GameScripting *getScriptIface(){ return m_script; }
 
-	// Envlock should be locked when using the rollback manager
-	IRollbackManager *getRollbackManager(){ return m_rollback; }
-
 	//TODO: determine what (if anything) should be locked to access EmergeManager
 	EmergeManager *getEmergeManager(){ return m_emerge; }
 
@@ -468,7 +286,9 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 	virtual u16 allocateUnknownNodeId(const std::string &name);
 	virtual ISoundManager* getSoundManager();
 	virtual MtEventManager* getEventManager();
-	virtual IRollbackReportSink* getRollbackReportSink();
+	virtual scene::ISceneManager* getSceneManager();
+	virtual IRollbackManager *getRollbackManager() { return m_rollback; }
+
 
 	IWritableItemDefManager* getWritableItemDefManager();
 	IWritableNodeDefManager* getWritableNodeDefManager();
@@ -477,15 +297,14 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 	const ModSpec* getModSpec(const std::string &modname);
 	void getModNames(std::list<std::string> &modlist);
 	std::string getBuiltinLuaPath();
+	inline std::string getWorldPath()
+			{ return m_path_world; }
 
-	std::string getWorldPath(){ return m_path_world; }
+	inline bool isSingleplayer()
+			{ return m_simple_singleplayer_mode; }
 
-	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);
 	Map & getMap() { return m_env->getMap(); }
@@ -499,54 +318,65 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 	void hudSetHotbarImage(Player *player, std::string name);
 	void hudSetHotbarSelectedImage(Player *player, std::string name);
 
-private:
+	inline Address getPeerAddress(u16 peer_id)
+			{ return m_con.GetPeerAddress(peer_id); }
+			
+	bool setLocalPlayerAnimations(Player *player, v2s32 animation_frames[4], f32 frame_speed);
+	bool setPlayerEyeOffset(Player *player, v3f first, v3f third);
 
-	// con::PeerHandler implementation.
-	// These queue stuff to be processed by handlePeerChanges().
-	// As of now, these create and remove clients and players.
+	bool setSky(Player *player, const video::SColor &bgcolor,
+			const std::string &type, const std::vector<std::string> &params);
+	
+	bool overrideDayNightRatio(Player *player, bool do_override,
+			float brightness);
+
+	/* con::PeerHandler implementation. */
 	void peerAdded(con::Peer *peer);
 	void deletingPeer(con::Peer *peer, bool timeout);
 
-	/*
-		Static send methods
-	*/
+	void DenyAccess(u16 peer_id, const std::wstring &reason);
+	bool getClientConInfo(u16 peer_id, con::rtt_stat_type type,float* retval);
+	bool getClientInfo(u16 peer_id,ClientState* state, u32* uptime,
+			u8* ser_vers, u16* prot_vers, u8* major, u8* minor, u8* patch,
+			std::string* vers_string);
 
-	static void SendMovement(con::Connection &con, u16 peer_id);
-	static void SendHP(con::Connection &con, u16 peer_id, u8 hp);
-	static void SendBreath(con::Connection &con, u16 peer_id, u16 breath);
-	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, u16 protocol_version);
-	static void SendNodeDef(con::Connection &con, u16 peer_id,
-			INodeDefManager *nodedef, u16 protocol_version);
+private:
 
-	/*
-		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.
-	*/
+	friend class EmergeThread;
+	friend class RemoteClient;
+
+	void SendMovement(u16 peer_id);
+	void SendHP(u16 peer_id, u8 hp);
+	void SendBreath(u16 peer_id, u16 breath);
+	void SendAccessDenied(u16 peer_id,const std::wstring &reason);
+	void SendDeathscreen(u16 peer_id,bool set_camera_point_target, v3f camera_point_target);
+	void SendItemDef(u16 peer_id,IItemDefManager *itemdef, u16 protocol_version);
+	void SendNodeDef(u16 peer_id,INodeDefManager *nodedef, u16 protocol_version);
+
+	/* mark blocks not sent for all clients */
+	void SetBlocksNotSent(std::map<v3s16, MapBlock *>& block);
 
 	// 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 SendTimeOfDay(u16 peer_id, u16 time, f32 time_speed);
 	void SendPlayerHP(u16 peer_id);
 	void SendPlayerBreath(u16 peer_id);
 	void SendMovePlayer(u16 peer_id);
+	void SendLocalPlayerAnimations(u16 peer_id, v2s32 animation_frames[4], f32 animation_speed);
+	void SendEyeOffset(u16 peer_id, v3f first, v3f third);
 	void SendPlayerPrivileges(u16 peer_id);
 	void SendPlayerInventoryFormspec(u16 peer_id);
-	void SendShowFormspecMessage(u16 peer_id, const std::string formspec, const std::string formname);
+	void SendShowFormspecMessage(u16 peer_id, const std::string &formspec, const std::string &formname);
 	void SendHUDAdd(u16 peer_id, u32 id, HudElement *form);
 	void SendHUDRemove(u16 peer_id, u32 id);
 	void SendHUDChange(u16 peer_id, u32 id, HudElementStat stat, void *value);
 	void SendHUDSetFlags(u16 peer_id, u32 flags, u32 mask);
 	void SendHUDSetParam(u16 peer_id, u16 param, const std::string &value);
-
+	void SendSetSky(u16 peer_id, const video::SColor &bgcolor,
+			const std::string &type, const std::vector<std::string> &params);
+	void SendOverrideDayNightRatio(u16 peer_id, bool do_override, float ratio);
+	
 	/*
 		Send a node removal/addition event to all clients except ignore_id.
 		Additionally, if far_players!=NULL, players further away than
@@ -556,7 +386,8 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 	void sendRemoveNode(v3s16 p, u16 ignore_id=0,
 			std::list<u16> *far_players=NULL, float far_d_nodes=100);
 	void sendAddNode(v3s16 p, MapNode n, u16 ignore_id=0,
-			std::list<u16> *far_players=NULL, float far_d_nodes=100);
+			std::list<u16> *far_players=NULL, float far_d_nodes=100,
+			bool remove_metadata=true);
 	void setBlockNotSent(v3s16 p);
 
 	// Environment and Connection must be locked when called
@@ -568,46 +399,27 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 	void fillMediaCache();
 	void sendMediaAnnouncement(u16 peer_id);
 	void sendRequestedMedia(u16 peer_id,
-			const std::list<MediaRequest> &tosend);
+			const std::list<std::string> &tosend);
 
 	void sendDetachedInventory(const std::string &name, u16 peer_id);
-	void sendDetachedInventoryToAll(const std::string &name);
 	void sendDetachedInventories(u16 peer_id);
 
-	// Adds a ParticleSpawner on peer with peer_id
+	// Adds a ParticleSpawner on peer with peer_id (PEER_ID_INEXISTENT == all)
 	void SendAddParticleSpawner(u16 peer_id, 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, std::string texture, u32 id);
+		bool collisiondetection, bool vertical, std::string texture, u32 id);
 
-	// Adds a ParticleSpawner on all peers
-	void SendAddParticleSpawnerAll(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, std::string texture, u32 id);
-
-	// Deletes ParticleSpawner on a single client
 	void SendDeleteParticleSpawner(u16 peer_id, u32 id);
 
-	// Deletes ParticleSpawner on all clients
-	void SendDeleteParticleSpawnerAll(u32 id);
-
-	// Spawns particle on single client
+	// Spawns particle on peer with peer_id (PEER_ID_INEXISTENT == all)
 	void SendSpawnParticle(u16 peer_id,
 		v3f pos, v3f velocity, v3f acceleration,
 		float expirationtime, float size,
-		bool collisiondetection, std::string texture);
-
-	// Spawns particle on all clients
-	void SendSpawnParticleAll(v3f pos, v3f velocity, v3f acceleration,
-		float expirationtime, float size,
-		bool collisiondetection, std::string texture);
+		bool collisiondetection, bool vertical, std::string texture);
 
 	/*
 		Something random
@@ -615,20 +427,12 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 
 	void DiePlayer(u16 peer_id);
 	void RespawnPlayer(u16 peer_id);
-	void DenyAccess(u16 peer_id, const std::wstring &reason);
-
-	enum ClientDeletionReason {
-		CDR_LEAVE,
-		CDR_TIMEOUT,
-		CDR_DENY
-	};
 	void DeleteClient(u16 peer_id, ClientDeletionReason reason);
-
 	void UpdateCrafting(u16 peer_id);
 
 	// When called, connection mutex should be locked
-	RemoteClient* getClient(u16 peer_id);
-	RemoteClient* getClientNoEx(u16 peer_id);
+	RemoteClient* getClient(u16 peer_id,ClientState state_min=CS_Active);
+	RemoteClient* getClientNoEx(u16 peer_id,ClientState state_min=CS_Active);
 
 	// When called, environment mutex should be locked
 	std::string getPlayerName(u16 peer_id);
@@ -643,9 +447,6 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 	*/
 	PlayerSAO *emergePlayer(const char *name, u16 peer_id);
 
-	// Locks environment and connection by its own
-	struct PeerChange;
-	void handlePeerChange(PeerChange &c);
 	void handlePeerChanges();
 
 	/*
@@ -673,26 +474,18 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 	float m_savemap_timer;
 	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
+	// server connection
 	con::Connection m_con;
-	JMutex m_con_mutex;
-	// Connected clients (behind the con mutex)
-	std::map<u16, RemoteClient*> m_clients;
-	u16 m_clients_number; //for announcing masterserver
 
 	// Ban checking
 	BanManager *m_banmanager;
 
 	// Rollback manager (behind m_env_mutex)
 	IRollbackManager *m_rollback;
-	bool m_rollback_sink_enabled;
 	bool m_enable_rollback_recording; // Updated once in a while
 
 	// Emerge manager
@@ -726,6 +519,9 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 	float m_step_dtime;
 	JMutex m_step_dtime_mutex;
 
+	// current server step lag counter
+	float m_lag;
+
 	// The server mainly operates in this thread
 	ServerThread *m_thread;
 
@@ -738,23 +534,17 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 	// 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;
+	Queue<con::PeerChange> m_peer_change_queue;
 
 	/*
 		Random stuff
@@ -799,9 +589,7 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 	*/
 	u16 m_ignore_map_edit_events_peer_id;
 
-	friend class EmergeThread;
-	friend class RemoteClient;
-
+	// media files known to server
 	std::map<std::string,MediaInfo> m_media;
 
 	/*