X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fserver.h;h=e9cf0a25c984ddadef2e28382ed1d2ebaca048db;hb=6ba5d7771f79880f33721baccb81cace2f0a6746;hp=4948b8ba1de4540b2e8ecafa77a0ca1edfdcfdba;hpb=7f7fb9750df3aceec48f65cee657e15364e0a911;p=minetest.git diff --git a/src/server.h b/src/server.h index 4948b8ba1..e9cf0a25c 100644 --- a/src/server.h +++ b/src/server.h @@ -1,18 +1,18 @@ /* -Minetest-c55 -Copyright (C) 2010-2011 celeron55, Perttu Ahola +Minetest +Copyright (C) 2010-2013 celeron55, Perttu Ahola 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 -the Free Software Foundation; either version 2 of the License, or +it under the terms of the GNU Lesser General Public License as published by +the Free Software Foundation; either version 2.1 of the License, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -GNU General Public License for more details. +GNU Lesser General Public License for more details. -You should have received a copy of the GNU General Public License along +You should have received a copy of the GNU Lesser General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ @@ -21,41 +21,45 @@ with this program; if not, write to the Free Software Foundation, Inc., #define SERVER_HEADER #include "connection.h" -#include "environment.h" -#include "common_irrlicht.h" -#include -#include "porting.h" +#include "irr_v3d.h" #include "map.h" -#include "inventory.h" -#include "auth.h" -#include "ban.h" +#include "hud.h" #include "gamedef.h" #include "serialization.h" // For SER_FMT_VER_INVALID -#include "serverremoteplayer.h" #include "mods.h" #include "inventorymanager.h" #include "subgame.h" -struct LuaState; -typedef struct lua_State lua_State; +#include "util/numeric.h" +#include "util/thread.h" +#include "environment.h" +#include "clientiface.h" +#include +#include +#include +#include + +#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")" + class IWritableItemDefManager; class IWritableNodeDefManager; class IWritableCraftDefManager; - -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; +class BanManager; +class EventManager; +class Inventory; +class Player; +class PlayerSAO; +class IRollbackManager; +struct RollbackAction; +class EmergeManager; +class GameScripting; +class ServerEnvironment; +struct SimpleSoundSpec; +class ServerThread; + +enum ClientDeletionReason { + CDR_LEAVE, + CDR_TIMEOUT, + CDR_DENY }; /* @@ -63,385 +67,131 @@ class ServerError : public std::exception */ 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 peer_ids; -}; - -/* - This is a thread-safe class. -*/ -class BlockEmergeQueue +class MapEditEventIgnorer { public: - BlockEmergeQueue() - { - m_mutex.Init(); - } - - ~BlockEmergeQueue() - { - JMutexAutoLock lock(m_mutex); - - core::list::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) + MapEditEventIgnorer(bool *flag): + m_flag(flag) { - 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::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); + if(*m_flag == false) + *m_flag = true; + else + m_flag = NULL; } - // Returned pointer must be deleted - // Returns NULL if queue is empty - QueuedBlockEmerge * pop() + ~MapEditEventIgnorer() { - JMutexAutoLock lock(m_mutex); - - core::list::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::Iterator i; - for(i=m_queue.begin(); i!=m_queue.end(); i++) + if(m_flag) { - QueuedBlockEmerge *q = *i; - if(q->peer_ids.find(peer_id) != NULL) - count++; + assert(*m_flag); + *m_flag = false; } - - return count; } private: - core::list m_queue; - JMutex m_mutex; + bool *m_flag; }; -class Server; - -class ServerThread : public SimpleThread +class MapEditEventAreaIgnorer { - Server *m_server; - public: - - ServerThread(Server *server): - SimpleThread(), - m_server(server) + MapEditEventAreaIgnorer(VoxelArea *ignorevariable, const VoxelArea &a): + m_ignorevariable(ignorevariable) { + if(m_ignorevariable->getVolume() == 0) + *m_ignorevariable = a; + else + m_ignorevariable = NULL; } - void * Thread(); -}; - -class EmergeThread : public SimpleThread -{ - Server *m_server; - -public: - - EmergeThread(Server *server): - SimpleThread(), - m_server(server) + ~MapEditEventAreaIgnorer() { - } - - void * Thread(); - - void trigger() - { - setRun(true); - if(IsRunning() == false) + if(m_ignorevariable) { - Start(); + assert(m_ignorevariable->getVolume() != 0); + *m_ignorevariable = VoxelArea(); } } -}; - -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 TextureRequest -{ - std::string name; - - TextureRequest(const std::string &name_=""): - name(name_) - {} +private: + VoxelArea *m_ignorevariable; }; -struct TextureInformation +struct MediaInfo { std::string path; std::string sha1_digest; - TextureInformation(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_) { } }; -class RemoteClient +struct ServerSoundParams { -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 &dest); - - void GotBlock(v3s16 p); - - void SentBlock(v3s16 p); - - void SetBlockNotSent(v3s16 p); - void SetBlocksNotSent(core::map &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 "< 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 m_blocks_sending; + v3f getPos(ServerEnvironment *env, bool *pos_exists) const; +}; - /* - 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; +struct ServerPlayingSound +{ + ServerSoundParams params; + std::set 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 + const SubgameSpec &gamespec, + 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); - core::list 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_time_of_day_send_timer = 0; - } + 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, @@ -453,136 +203,180 @@ class Server : public con::PeerHandler, public MapEventReceiver, Shall be called with the environment and the connection locked. */ 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(); - void requestShutdown(void) - { - m_shutdown_requested = true; - } - - - // Envlock and conlock should be locked when calling this - void SendMovePlayer(Player *player); - - u64 getPlayerAuthPrivs(const std::string &name) - { - try{ - return m_authmanager.getPrivs(name); - } - catch(AuthNotFoundException &e) - { - dstream<<"WARNING: Auth not found for "< 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 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 char *playername, + v3f pos, v3f velocity, v3f acceleration, + float expirationtime, float size, + bool collisiondetection, bool vertical, std::string texture); + + void spawnParticleAll(v3f pos, v3f velocity, v3f acceleration, + float expirationtime, float size, + bool collisiondetection, bool vertical, std::string texture); + + u32 addParticleSpawner(const char *playername, + 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 vertical, std::string texture); + + u32 addParticleSpawnerAll(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 vertical, std::string texture); + + void deleteParticleSpawner(const char *playername, u32 id); + void deleteParticleSpawnerAll(u32 id); + + // Creates or resets inventory + Inventory* createDetachedInventory(const std::string &name); + + // Envlock and conlock should be locked when using scriptapi + GameScripting *getScriptIface(){ return m_script; } + + //TODO: determine what (if anything) should be locked to access EmergeManager + EmergeManager *getEmergeManager(){ return m_emerge; } + + // actions: time-reversed list + // Return value: success/failure + bool rollbackRevertActions(const std::list &actions, + std::list *log); - 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 IShaderSource* getShaderSource(); virtual u16 allocateUnknownNodeId(const std::string &name); - + virtual ISoundManager* getSoundManager(); + virtual MtEventManager* getEventManager(); + virtual scene::ISceneManager* getSceneManager(); + virtual IRollbackManager *getRollbackManager() { return m_rollback; } + + IWritableItemDefManager* getWritableItemDefManager(); IWritableNodeDefManager* getWritableNodeDefManager(); IWritableCraftDefManager* getWritableCraftDefManager(); const ModSpec* getModSpec(const std::string &modname); - - std::string getWorldPath(){ return m_path_world; } + void getModNames(std::list &modlist); + std::string getBuiltinLuaPath(); + inline std::string getWorldPath() + { return m_path_world; } + + inline bool isSingleplayer() + { return m_simple_singleplayer_mode; } + + 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(); } + ServerEnvironment & getEnv() { return *m_env; } + + u32 hudAdd(Player *player, HudElement *element); + bool hudRemove(Player *player, u32 id); + bool hudChange(Player *player, u32 id, HudElementStat stat, void *value); + bool hudSetFlags(Player *player, u32 flags, u32 mask); + bool hudSetHotbarItemcount(Player *player, s32 hotbar_itemcount); + void hudSetHotbarImage(Player *player, std::string name); + void hudSetHotbarSelectedImage(Player *player, std::string name); + + 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); + + bool setSky(Player *player, const video::SColor &bgcolor, + const std::string &type, const std::vector ¶ms); + + bool overrideDayNightRatio(Player *player, bool do_override, + float brightness); + + /* con::PeerHandler implementation. */ + void peerAdded(con::Peer *peer); + void deletingPeer(con::Peer *peer, bool timeout); + + 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); private: - // con::PeerHandler implementation. - // These queue stuff to be processed by handlePeerChanges(). - // As of now, these create and remove clients and players. - 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); - - /* - 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& block); // Envlock and conlock should be locked when calling these void SendInventory(u16 peer_id); - // send wielded item info about player to all - void SendWieldedItem(const ServerRemotePlayer *srp); - // 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 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 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 ¶ms); + 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 @@ -590,43 +384,59 @@ class Server : public con::PeerHandler, public MapEventReceiver, */ // Envlock and conlock should be locked when calling these void sendRemoveNode(v3s16 p, u16 ignore_id=0, - core::list *far_players=NULL, float far_d_nodes=100); + std::list *far_players=NULL, float far_d_nodes=100); void sendAddNode(v3s16 p, MapNode n, u16 ignore_id=0, - core::list *far_players=NULL, float far_d_nodes=100); + std::list *far_players=NULL, float far_d_nodes=100, + bool remove_metadata=true); void setBlockNotSent(v3s16 p); - + // Environment and Connection must be locked when called - void SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver); - + void SendBlockNoLock(u16 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 PrepareTextures(); - void SendTextureAnnouncement(u16 peer_id); + void fillMediaCache(); + void sendMediaAnnouncement(u16 peer_id); + void sendRequestedMedia(u16 peer_id, + const std::list &tosend); + + void sendDetachedInventory(const std::string &name, u16 peer_id); + void sendDetachedInventories(u16 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, bool vertical, std::string texture, u32 id); + + void SendDeleteParticleSpawner(u16 peer_id, u32 id); - void SendTexturesRequested(u16 peer_id,core::list tosend); + // 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, bool vertical, std::string texture); /* Something random */ - - void DiePlayer(Player *player); - void RespawnPlayer(Player *player); - + + void DiePlayer(u16 peer_id); + void RespawnPlayer(u16 peer_id); + 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* 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) - { - Player *player = m_env->getPlayer(peer_id); - if(player == NULL) - return "[id="+itos(peer_id)+"]"; - return player->getName(); - } + std::string getPlayerName(u16 peer_id); + PlayerSAO* getPlayerSAO(u16 peer_id); /* Get a player from memory or creates one. @@ -635,125 +445,113 @@ class Server : public con::PeerHandler, public MapEventReceiver, Call with env and con locked. */ - ServerRemotePlayer *emergePlayer(const char *name, u16 peer_id); - - // Locks environment and connection by its own - struct PeerChange; - void handlePeerChange(PeerChange &c); - void handlePeerChanges(); + PlayerSAO *emergePlayer(const char *name, u16 peer_id); - u64 getPlayerPrivs(Player *player); + 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; + + // Thread can set; step() will throw as ServerError + MutexedVariable m_async_fatal_error; - // Equivalent of /usr/share/minetest/server - std::string m_path_share; - // Some timers float m_liquid_transform_timer; + float m_liquid_transform_every; float m_print_info_timer; + float m_masterserver_timer; float m_objectdata_timer; float m_emergethread_trigger_timer; 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) - core::map m_clients; - // User authentication - AuthManager m_authmanager; + // Ban checking + BanManager *m_banmanager; - // Bann checking - BanManager m_banmanager; + // Rollback manager (behind m_env_mutex) + IRollbackManager *m_rollback; + bool m_enable_rollback_recording; // Updated once in a while + + // Emerge manager + EmergeManager *m_emerge; // Scripting // Envlock and conlock should be locked when using Lua - lua_State *m_lua; + GameScripting *m_script; // 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 m_mods; - + std::vector m_mods; + /* 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; + // 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; + /* Time related stuff */ - // 0-23999 - //MutexedVariable 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 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 m_peer_change_queue; + Queue m_peer_change_queue; /* Random stuff */ - + // Mod parent directory paths - core::list m_modspaths; + std::list m_modspaths; bool m_shutdown_requested; @@ -777,6 +575,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 @@ -784,10 +589,25 @@ 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 m_media; + + /* + Sounds + */ + std::map m_playing_sounds; + s32 m_next_sound_id; - std::map m_Textures; + /* + Detached inventories (behind m_env_mutex) + */ + // key = name + std::map m_detached_inventories; + + /* + Particles + */ + std::vector m_particlespawner_ids; }; /*