X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fserver.h;h=54330856c2d541c8d0606ebea6ede4adc852b21e;hb=cffd40c5d6c1427d2cce7cbcfe57669da73459c6;hp=a1c4a1cd72b79b0bc3d343be5751e60ca62bf89d;hpb=0fa0e0752a28eeb43195f2288c018d5c0b24520b;p=dragonfireclient.git

diff --git a/src/server.h b/src/server.h
index a1c4a1cd7..54330856c 100644
--- a/src/server.h
+++ b/src/server.h
@@ -1,6 +1,6 @@
 /*
 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
@@ -30,7 +30,18 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include <string>
 #include "utility.h"
 #include "porting.h"
+#include "map.h"
+#include "inventory.h"
 
+/*
+	Some random functions
+*/
+v3f findSpawnPos(ServerMap &map);
+
+/*
+	A structure containing the data needed for queueing the fetching
+	of blocks.
+*/
 struct QueuedBlockEmerge
 {
 	v3s16 pos;
@@ -239,13 +250,8 @@ class RemoteClient
 		pending_serialization_version = SER_FMT_VER_INVALID;
 		m_nearest_unsent_d = 0;
 		m_nearest_unsent_reset_timer = 0.0;
-
-		m_blocks_sent_mutex.Init();
-		m_blocks_sending_mutex.Init();
-		
-		/*m_dig_mutex.Init();
-		m_dig_time_remaining = 0;
-		m_dig_tool_item = -1;*/
+		m_nothing_to_send_counter = 0;
+		m_nothing_to_send_pause_timer = 0;
 	}
 	~RemoteClient()
 	{
@@ -279,7 +285,6 @@ class RemoteClient
 
 	s32 SendingCount()
 	{
-		JMutexAutoLock lock(m_blocks_sending_mutex);
 		return m_blocks_sending.size();
 	}
 	
@@ -290,10 +295,8 @@ class RemoteClient
 
 	void PrintInfo(std::ostream &o)
 	{
-		JMutexAutoLock l2(m_blocks_sent_mutex);
-		JMutexAutoLock l3(m_blocks_sending_mutex);
 		o<<"RemoteClient "<<peer_id<<": "
-				<<", m_blocks_sent.size()="<<m_blocks_sent.size()
+				<<"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
@@ -302,30 +305,21 @@ class RemoteClient
 	}
 
 	// Time from last placing or removing blocks
-	MutexedVariable<float> m_time_from_building;
+	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;*/
-
-private:
+	
 	/*
-		All members that are accessed by many threads should
-		obviously be behind a mutex. The threads include:
-		- main thread (calls step())
-		- server thread (calls AsyncRunStep() and Receive())
-		- emerge thread 
+		List of active objects that the client knows of.
+		Value is dummy.
 	*/
-	
-	//TODO: core::map<v3s16, MapBlock*> m_active_blocks
-	//NOTE: Not here, it should be server-wide!
-
-	// Number of blocks in the emerge queue that have this client as
-	// a receiver. Used for throttling network usage.
-	//MutexedVariable<s16> m_num_blocks_in_emerge_queue;
+	core::map<u16, bool> m_known_objects;
 
+private:
 	/*
 		Blocks that have been sent to client.
 		- These don't have to be sent again.
@@ -339,7 +333,7 @@ class RemoteClient
 	s16 m_nearest_unsent_d;
 	v3s16 m_last_center;
 	float m_nearest_unsent_reset_timer;
-	JMutex m_blocks_sent_mutex;
+	
 	/*
 		Blocks that are currently on the line.
 		This is used for throttling the sending of blocks.
@@ -349,7 +343,6 @@ class RemoteClient
 		Value is time from sending. (not used at the moment)
 	*/
 	core::map<v3s16, float> m_blocks_sending;
-	JMutex m_blocks_sending_mutex;
 
 	/*
 		Count of excess GotBlocks().
@@ -359,27 +352,22 @@ class RemoteClient
 		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;
 };
 
-/*struct ServerSettings
-{
-	ServerSettings()
-	{
-		creative_mode = false;
-	}
-	bool creative_mode;
-};*/
-
-class Server : public con::PeerHandler
+class Server : public con::PeerHandler, public MapEventReceiver,
+		public InventoryManager
 {
 public:
 	/*
 		NOTE: Every public method should be thread-safe
 	*/
+
 	Server(
-		std::string mapsavedir,
-		HMParams hm_params,
-		MapParams map_params
+		std::string mapsavedir
 	);
 	~Server();
 	void start(unsigned short port);
@@ -392,72 +380,123 @@ class Server : public con::PeerHandler
 	void Receive();
 	void ProcessData(u8 *data, u32 datasize, u16 peer_id);
 
-	/*void Send(u16 peer_id, u16 channelnum,
-			SharedBuffer<u8> data, bool reliable);*/
+	core::list<PlayerInfo> getPlayerInfo();
 
-	// Environment and Connection must be locked when called
-	void SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver);
-	//TODO: Sending of many blocks in a single packet
+	/*u32 getDayNightRatio()
+	{
+		return time_to_daynight_ratio(m_time_of_day.get());
+	}*/
 	
-	// Environment and Connection must be locked when called
-	//void SendSectorMeta(u16 peer_id, core::list<v2s16> ps, u8 ver);
-
-	core::list<PlayerInfo> getPlayerInfo();
+	// Environment must be locked when called
+	void setTimeOfDay(u32 time)
+	{
+		m_env.setTimeOfDay(time);
+		m_time_of_day_send_timer = 0;
+	}
 
-	u32 getDayNightRatio()
+	bool getShutdownRequested()
 	{
-		s32 d = 8;
-		s32 t = (((m_time_of_day.get() + 24000/d/2)%24000)/(24000/d));
-		if(t == d/4 || t == (d-d/4))
-			return 600;
-		else if(t < d/4 || t > (d-d/4))
-			return 300;
-		else
-			return 1000;
+		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);
+
+	/*
+		Shall be called with the environment and the connection locked.
+	*/
+	Inventory* getInventory(InventoryContext *c, std::string id);
+	void inventoryModified(InventoryContext *c, std::string id);
+
+	// Connection must be locked when called
+	std::wstring getStatusString();
+
+	void requestShutdown(void)
+	{
+		m_shutdown_requested = true;
+	}
+
+
+	// Envlock and conlock should be locked when calling this
+	void SendMovePlayer(Player *player);
+
+
 private:
 
-	// Virtual methods from con::PeerHandler.
+	// con::PeerHandler implementation.
+	// These queue stuff to be processed by handlePeerChanges().
 	// As of now, these create and remove clients and players.
-	// TODO: Make it possible to leave players on server.
 	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);
+	
+	/*
+		Non-static send methods
+	*/
+
 	// Envlock and conlock should be locked when calling these
 	void SendObjectData(float dtime);
 	void SendPlayerInfos();
 	void SendInventory(u16 peer_id);
 	void SendChatMessage(u16 peer_id, const std::wstring &message);
 	void BroadcastChatMessage(const std::wstring &message);
+	void SendPlayerHP(Player *player);
+	/*
+		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
+	*/
+	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);
+	
+	// Environment and Connection must be locked when called
+	void SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver);
 	
 	// Sends blocks to clients
 	void SendBlocks(float dtime);
+
+	/*
+		Something random
+	*/
+	
+	void UpdateCrafting(u16 peer_id);
 	
 	// When called, connection mutex should be locked
 	RemoteClient* getClient(u16 peer_id);
-
-	// Gets a player from memory or creates one.
-	// Caller should check isClientConnected() and set it appropriately.
-	// 
-	// Call with env and con locked.
-	Player *emergePlayer(const char *name, const char *password);
-
+	
 	/*
-		Update water pressure.
-		This also adds suitable nodes to active_nodes.
+		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.
 
-		environment has to be locked when calling.
+		Call with env and con locked.
 	*/
-	/*void UpdateBlockWaterPressure(MapBlock *block,
-			core::map<v3s16, MapBlock*> &modified_blocks);*/
+	Player *emergePlayer(const char *name, const char *password, u16 peer_id);
 	
 	// Locks environment and connection by its own
 	struct PeerChange;
 	void handlePeerChange(PeerChange &c);
 	void handlePeerChanges();
+
+	/*
+		Variables
+	*/
 	
-	float m_flowwater_timer;
+	// Some timers
+	float m_liquid_transform_timer;
 	float m_print_info_timer;
 	float m_objectdata_timer;
 	float m_emergethread_trigger_timer;
@@ -465,50 +504,110 @@ class Server : public con::PeerHandler
 	
 	// NOTE: If connection and environment are both to be locked,
 	// environment shall be locked first.
-	JMutex m_env_mutex;
-	Environment m_env;
 
-	JMutex m_con_mutex;
+	// Environment
+	ServerEnvironment m_env;
+	JMutex m_env_mutex;
+	
+	// Connection
 	con::Connection m_con;
-	core::map<u16, RemoteClient*> m_clients; // Behind the con mutex
-
+	JMutex m_con_mutex;
+	// Connected clients (behind the con mutex)
+	core::map<u16, RemoteClient*> m_clients;
+	
+	/*
+		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;
 
+	// 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;
 	
-	// Nodes that are destinations of flowing liquid at the moment
-	//core::map<v3s16, u8> m_flow_active_nodes;
+	/*
+		Time related stuff
+	*/
 
 	// 0-23999
-	MutexedVariable<u32> m_time_of_day;
+	//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
 	MutexedVariable<double> m_uptime;
-
+	
+	/*
+		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;
 
+	/*
+		Random stuff
+	*/
+
+	// Map directory
+	std::string m_mapsavedir;
+
+	bool m_shutdown_requested;
+	
+	/*
+		Map edit event queue. Automatically receives all map edits.
+		The constructor of this class registers us to receive them through
+		onMapEditEvent
+
+		NOTE: Should these be moved to actually be members of
+		ServerEnvironment?
+	*/
+
+	/*
+		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;
+	/*
+		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;
 };
 
+/*
+	Runs a simple dedicated server loop.
+
+	Shuts down when run is set to false.
+*/
+void dedicated_server_loop(Server &server, bool &run);
+
 #endif