X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fserver.h;h=abe466b16f957e042810ff0f7d62aa03d4475f69;hb=13159c1a48690d4ede3dbabc7699ea3d49072860;hp=1e7e41c9673a4a942d62a584b5eae3c954d4c987;hpb=07d000cc54c26001f9f79e5c0d45c2d3c4f614eb;p=dragonfireclient.git

diff --git a/src/server.h b/src/server.h
index 1e7e41c96..abe466b16 100644
--- a/src/server.h
+++ b/src/server.h
@@ -27,8 +27,37 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "porting.h"
 #include "map.h"
 #include "inventory.h"
-#include "auth.h"
 #include "ban.h"
+#include "gamedef.h"
+#include "serialization.h" // For SER_FMT_VER_INVALID
+#include "mods.h"
+#include "inventorymanager.h"
+#include "subgame.h"
+#include "sound.h"
+struct LuaState;
+typedef struct lua_State lua_State;
+class IWritableItemDefManager;
+class IWritableNodeDefManager;
+class IWritableCraftDefManager;
+class EventManager;
+class PlayerSAO;
+
+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
@@ -201,8 +230,6 @@ struct PlayerInfo
 	void PrintLine(std::ostream *s);
 };
 
-u32 PIChecksum(core::list<PlayerInfo> &l);
-
 /*
 	Used for queueing and sorting block transfers in containers
 	
@@ -225,6 +252,61 @@ struct PrioritySortedBlockTransfer
 	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_=""):
+		path(path_),
+		sha1_digest(sha1_digest_)
+	{
+	}
+};
+
+struct ServerSoundParams
+{
+	float gain;
+	std::string to_player;
+	enum Type{
+		SSP_LOCAL=0,
+		SSP_POSITIONAL=1,
+		SSP_OBJECT=2
+	} type;
+	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)
+	{}
+	
+	v3f getPos(ServerEnvironment *env, bool *pos_exists) const;
+};
+
+struct ServerPlayingSound
+{
+	ServerSoundParams params;
+	std::set<u16> clients; // peer ids
+};
+
 class RemoteClient
 {
 public:
@@ -240,6 +322,8 @@ class RemoteClient
 	// 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)
@@ -248,6 +332,7 @@ class RemoteClient
 		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;
@@ -265,17 +350,6 @@ class RemoteClient
 	void GetNextBlocks(Server *server, float dtime,
 			core::array<PrioritySortedBlockTransfer> &dest);
 
-	/*
-		Connection and environment should be locked when this is called.
-		steps() objects of blocks not found in active_blocks, then
-		adds those blocks to active_blocks
-	*/
-	void SendObjectData(
-			Server *server,
-			float dtime,
-			core::map<v3s16, bool> &stepped_blocks
-		);
-
 	void GotBlock(v3s16 p);
 
 	void SentBlock(v3s16 p);
@@ -359,16 +433,19 @@ class RemoteClient
 };
 
 class Server : public con::PeerHandler, public MapEventReceiver,
-		public InventoryManager
+		public InventoryManager, public IGameDef,
+		public IBackgroundBlockEmerger
 {
 public:
 	/*
 		NOTE: Every public method should be thread-safe
 	*/
-
+	
 	Server(
-		std::string mapsavedir,
-		std::string configpath
+		const std::string &path_world,
+		const std::string &path_config,
+		const SubgameSpec &gamespec,
+		bool simple_singleplayer_mode
 	);
 	~Server();
 	void start(unsigned short port);
@@ -383,15 +460,10 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 
 	core::list<PlayerInfo> getPlayerInfo();
 
-	/*u32 getDayNightRatio()
-	{
-		return time_to_daynight_ratio(m_time_of_day.get());
-	}*/
-	
 	// Environment must be locked when called
 	void setTimeOfDay(u32 time)
 	{
-		m_env.setTimeOfDay(time);
+		m_env->setTimeOfDay(time);
 		m_time_of_day_send_timer = 0;
 	}
 
@@ -410,8 +482,9 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 	/*
 		Shall be called with the environment and the connection locked.
 	*/
-	Inventory* getInventory(InventoryContext *c, std::string id);
-	void inventoryModified(InventoryContext *c, std::string id);
+	Inventory* getInventory(const InventoryLocation &loc);
+	std::string getInventoryOwner(const InventoryLocation &loc);
+	void setInventoryModified(const InventoryLocation &loc);
 
 	// Connection must be locked when called
 	std::wstring getStatusString();
@@ -421,33 +494,16 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 		m_shutdown_requested = true;
 	}
 
-
-	// Envlock and conlock should be locked when calling this
-	void SendMovePlayer(Player *player);
+	// Returns -1 if failed, sound handle on success
+	// Envlock + conlock
+	s32 playSound(const SimpleSoundSpec &spec, const ServerSoundParams &params);
+	void stopSound(s32 handle);
 	
-	u64 getPlayerAuthPrivs(const std::string &name)
-	{
-		try{
-			return m_authmanager.getPrivs(name);
-		}
-		catch(AuthNotFoundException &e)
-		{
-			dstream<<"WARNING: Auth not found for "<<name<<std::endl;
-			return 0;
-		}
-	}
+	// Envlock + conlock
+	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 setPlayerAuthPrivs(const std::string &name, u64 privs)
-	{
-		try{
-			return m_authmanager.setPrivs(name, privs);
-		}
-		catch(AuthNotFoundException &e)
-		{
-			dstream<<"WARNING: Auth not found for "<<name<<std::endl;
-		}
-	}
-	
 	// Saves g_settings to configpath given at initialization
 	void saveConfig();
 
@@ -468,13 +524,44 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 		return m_banmanager.getBanDescription(ip_or_name);
 	}
 
-	con::Peer* getPeerNoEx(u16 peer_id)
+	Address getPeerAddress(u16 peer_id)
 	{
-		return m_con.GetPeerNoEx(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);
+	
+	// Envlock and conlock should be locked when using Lua
+	lua_State *getLua(){ return m_lua; }
+	
+	// IGameDef interface
+	// Under envlock
+	virtual IItemDefManager* getItemDefManager();
+	virtual INodeDefManager* getNodeDefManager();
+	virtual ICraftDefManager* getCraftDefManager();
+	virtual ITextureSource* getTextureSource();
+	virtual u16 allocateUnknownNodeId(const std::string &name);
+	virtual ISoundManager* getSoundManager();
+	virtual MtEventManager* getEventManager();
+	
+	IWritableItemDefManager* getWritableItemDefManager();
+	IWritableNodeDefManager* getWritableNodeDefManager();
+	IWritableCraftDefManager* getWritableCraftDefManager();
+
+	const ModSpec* getModSpec(const std::string &modname);
+	
+	std::string getWorldPath(){ return m_path_world; }
+
+	bool isSingleplayer(){ return m_simple_singleplayer_mode; }
+
+	void setAsyncFatalError(const std::string &error)
+	{
+		m_async_fatal_error.set(error);
+	}
 
 private:
 
@@ -493,22 +580,25 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 			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);
 	
 	/*
-		Non-static send methods
+		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 SendObjectData(float dtime);
-	void SendPlayerInfos();
 	void SendInventory(u16 peer_id);
-	// send wielded item info about player to all
-	void SendWieldedItem(const Player *player);
-	// send wielded item info about all players to all players
-	void SendPlayerItems();
 	void SendChatMessage(u16 peer_id, const std::wstring &message);
 	void BroadcastChatMessage(const std::wstring &message);
-	void SendPlayerHP(Player *player);
+	void SendPlayerHP(u16 peer_id);
+	void SendMovePlayer(u16 peer_id);
+	void SendPlayerPrivileges(u16 peer_id);
 	/*
 		Send a node removal/addition event to all clients except ignore_id.
 		Additionally, if far_players!=NULL, players further away than
@@ -526,13 +616,18 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 	
 	// 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);
 
 	/*
 		Something random
 	*/
 	
-	void HandlePlayerHP(Player *player, s16 damage);
-	void RespawnPlayer(Player *player);
+	void DiePlayer(u16 peer_id);
+	void RespawnPlayer(u16 peer_id);
 	
 	void UpdateCrafting(u16 peer_id);
 	
@@ -542,33 +637,52 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 	// When called, environment mutex should be locked
 	std::string getPlayerName(u16 peer_id)
 	{
-		Player *player = m_env.getPlayer(peer_id);
+		Player *player = m_env->getPlayer(peer_id);
 		if(player == NULL)
-			return "[id="+itos(peer_id);
+			return "[id="+itos(peer_id)+"]";
 		return player->getName();
 	}
 
+	// 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();
+	}
+
 	/*
 		Get a player from memory or creates one.
 		If player is already connected, return NULL
-		The password is not checked here - it is only used to
-		set the password if a new player is created.
+		Does not verify/modify auth info and password.
 
 		Call with env and con locked.
 	*/
-	Player *emergePlayer(const char *name, const char *password, u16 peer_id);
+	PlayerSAO *emergePlayer(const char *name, u16 peer_id);
 	
 	// Locks environment and connection by its own
 	struct PeerChange;
 	void handlePeerChange(PeerChange &c);
 	void handlePeerChanges();
 
-	u64 getPlayerPrivs(Player *player);
-
 	/*
 		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;
+
+	// 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;
@@ -581,7 +695,7 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 	// environment shall be locked first.
 
 	// Environment
-	ServerEnvironment m_env;
+	ServerEnvironment *m_env;
 	JMutex m_env_mutex;
 	
 	// Connection
@@ -590,11 +704,27 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 	// Connected clients (behind the con mutex)
 	core::map<u16, RemoteClient*> m_clients;
 
-	// User authentication
-	AuthManager m_authmanager;
-
 	// Bann checking
 	BanManager m_banmanager;
+
+	// Scripting
+	// Envlock and conlock should be locked when using Lua
+	lua_State *m_lua;
+
+	// Item definition manager
+	IWritableItemDefManager *m_itemdef;
+	
+	// Node definition manager
+	IWritableNodeDefManager *m_nodedef;
+	
+	// Craft definition manager
+	IWritableCraftDefManager *m_craftdef;
+	
+	// Event manager
+	EventManager *m_event;
+	
+	// Mods
+	core::list<ModSpec> m_mods;
 	
 	/*
 		Threads
@@ -616,10 +746,6 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 		Time related stuff
 	*/
 
-	// 0-23999
-	//MutexedVariable<u32> m_time_of_day;
-	// Used to buffer dtime for adding to m_time_of_day
-	float m_time_counter;
 	// Timer for sending time of day over network
 	float m_time_of_day_send_timer;
 	// Uptime of server in seconds
@@ -646,15 +772,12 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 	/*
 		Random stuff
 	*/
-
-	// Map directory
-	std::string m_mapsavedir;
-
-	// Configuration path ("" = no configuration file)
-	std::string m_configpath;
+	
+	// Mod parent directory paths
+	core::list<std::string> m_modspaths;
 
 	bool m_shutdown_requested;
-	
+
 	/*
 		Map edit event queue. Automatically receives all map edits.
 		The constructor of this class registers us to receive them through
@@ -675,6 +798,13 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 		This is behind m_env_mutex
 	*/
 	bool m_ignore_map_edit_events;
+	/*
+		If a non-empty area, map edit events contained within are left
+		unsent. Done at map generation time to speed up editing of the
+		generated area, as it will be sent anyway.
+		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
@@ -682,10 +812,16 @@ class Server : public con::PeerHandler, public MapEventReceiver,
 	*/
 	u16 m_ignore_map_edit_events_peer_id;
 
-	Profiler *m_profiler;
-
 	friend class EmergeThread;
 	friend class RemoteClient;
+
+	std::map<std::string,MediaInfo> m_media;
+
+	/*
+		Sounds
+	*/
+	std::map<s32, ServerPlayingSound> m_playing_sounds;
+	s32 m_next_sound_id;
 };
 
 /*