X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fserver.h;h=813dc9828dc6fc4d67e9427dde21e9b6a8e166eb;hb=0e07a7157f4865c26b4d7d0ba6fb12f1de59373c;hp=e1a5838260815cd9c1d782df870f660f1c5e7e1e;hpb=c6fd2986d4261cf742d3bc21e8c12be59ab89f95;p=dragonfireclient.git diff --git a/src/server.h b/src/server.h index e1a583826..813dc9828 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. */ @@ -22,135 +22,107 @@ with this program; if not, write to the Free Software Foundation, Inc., #include "connection.h" #include "environment.h" -#include "common_irrlicht.h" +#include "irrlichttypes_bloated.h" #include #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" +#include "util/thread.h" +#include "util/string.h" +#include "rollback_interface.h" // Needed for rollbackRevertActions() +#include // Needed for rollbackRevertActions() +#include + +#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")" + struct LuaState; typedef struct lua_State lua_State; -class IWritableToolDefManager; +class IWritableItemDefManager; class IWritableNodeDefManager; +class IWritableCraftDefManager; +class EventManager; +class PlayerSAO; +class IRollbackManager; +class EmergeManager; + +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 peer_ids; -}; -/* - This is a thread-safe class. -*/ -class BlockEmergeQueue +class MapEditEventIgnorer { public: - BlockEmergeQueue() + MapEditEventIgnorer(bool *flag): + m_flag(flag) { - m_mutex.Init(); + if(*m_flag == false) + *m_flag = true; + else + m_flag = NULL; } - ~BlockEmergeQueue() + ~MapEditEventIgnorer() { - JMutexAutoLock lock(m_mutex); - - core::list::Iterator i; - for(i=m_queue.begin(); i!=m_queue.end(); i++) + if(m_flag) { - QueuedBlockEmerge *q = *i; - delete q; + assert(*m_flag); + *m_flag = false; } } - - /* - 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::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); - } +private: + bool *m_flag; +}; - // Returned pointer must be deleted - // Returns NULL if queue is empty - QueuedBlockEmerge * pop() +class MapEditEventAreaIgnorer +{ +public: + MapEditEventAreaIgnorer(VoxelArea *ignorevariable, const VoxelArea &a): + m_ignorevariable(ignorevariable) { - 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; + if(m_ignorevariable->getVolume() == 0) + *m_ignorevariable = a; + else + m_ignorevariable = NULL; } - u32 size() + ~MapEditEventAreaIgnorer() { - 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_ignorevariable) { - QueuedBlockEmerge *q = *i; - if(q->peer_ids.find(peer_id) != NULL) - count++; + assert(m_ignorevariable->getVolume() != 0); + *m_ignorevariable = VoxelArea(); } - - return count; } private: - core::list m_queue; - JMutex m_mutex; + VoxelArea *m_ignorevariable; }; class Server; @@ -170,30 +142,6 @@ class ServerThread : public SimpleThread 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; @@ -206,11 +154,9 @@ struct PlayerInfo void PrintLine(std::ostream *s); }; -u32 PIChecksum(core::list &l); - /* Used for queueing and sorting block transfers in containers - + Lower priority number means higher priority. */ struct PrioritySortedBlockTransfer @@ -221,7 +167,7 @@ struct PrioritySortedBlockTransfer pos = a_pos; peer_id = a_peer_id; } - bool operator < (PrioritySortedBlockTransfer &other) + bool operator < (const PrioritySortedBlockTransfer &other) const { return priority < other.priority; } @@ -230,6 +176,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 clients; // peer ids +}; + class RemoteClient { public: @@ -245,6 +246,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) @@ -253,6 +256,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; @@ -261,38 +265,27 @@ class RemoteClient ~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); - - /* - 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 &stepped_blocks - ); + std::vector &dest); void GotBlock(v3s16 p); void SentBlock(v3s16 p); void SetBlockNotSent(v3s16 p); - void SetBlocksNotSent(core::map &blocks); + void SetBlocksNotSent(std::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. @@ -311,18 +304,18 @@ class RemoteClient // 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 m_known_objects; + std::set m_known_objects; private: /* @@ -330,15 +323,15 @@ class RemoteClient - 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 m_blocks_sent; + std::set 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. @@ -347,7 +340,7 @@ class RemoteClient Block is removed when GOTBLOCKS is received. Value is time from sending. (not used at the moment) */ - core::map m_blocks_sending; + std::map m_blocks_sending; /* Count of excess GotBlocks(). @@ -357,14 +350,15 @@ 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; }; class Server : public con::PeerHandler, public MapEventReceiver, - public InventoryManager, public IGameDef + public InventoryManager, public IGameDef, + public IBackgroundBlockEmerger { public: /* @@ -372,8 +366,10 @@ class Server : public con::PeerHandler, public MapEventReceiver, */ 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); @@ -386,13 +382,8 @@ class Server : public con::PeerHandler, public MapEventReceiver, void Receive(); void ProcessData(u8 *data, u32 datasize, u16 peer_id); - core::list getPlayerInfo(); + std::list getPlayerInfo(); - /*u32 getDayNightRatio() - { - return time_to_daynight_ratio(m_time_of_day.get()); - }*/ - // Environment must be locked when called void setTimeOfDay(u32 time) { @@ -404,7 +395,7 @@ class Server : public con::PeerHandler, public MapEventReceiver, { return m_shutdown_requested; } - + /* Shall be called with the environment locked. This is accessed by the map, which is inside the environment, @@ -415,8 +406,8 @@ 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); + void setInventoryModified(const InventoryLocation &loc); // Connection must be locked when called std::wstring getStatusString(); @@ -426,33 +417,17 @@ class Server : public con::PeerHandler, public MapEventReceiver, m_shutdown_requested = true; } + // Returns -1 if failed, sound handle on success + // Envlock + conlock + s32 playSound(const SimpleSoundSpec &spec, const ServerSoundParams ¶ms); + void stopSound(s32 handle); - // 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 setPlayerAuthPrivs(const std::string &name, u64 privs) - { - try{ - return m_authmanager.setPrivs(name, privs); - } - catch(AuthNotFoundException &e) - { - dstream<<"WARNING: Auth not found for "< &actions, + std::list *log); + // IGameDef interface // Under envlock - virtual IToolDefManager* getToolDefManager(); + 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 IRollbackReportSink* getRollbackReportSink(); + + IWritableItemDefManager* getWritableItemDefManager(); + IWritableNodeDefManager* getWritableNodeDefManager(); + IWritableCraftDefManager* getWritableCraftDefManager(); + + const ModSpec* getModSpec(const std::string &modname); + void getModNames(std::list &modlist); + std::string getBuiltinLuaPath(); + + 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); + } + bool showFormspec(const char *name, const std::string &formspec, const std::string &formname); private: // con::PeerHandler implementation. @@ -498,32 +544,38 @@ class Server : public con::PeerHandler, public MapEventReceiver, // 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 SendMovement(con::Connection &con, u16 peer_id); 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 + 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); + void SendPlayerInventoryFormspec(u16 peer_id); + void SendShowFormspecMessage(u16 peer_id, const std::string formspec, const std::string formname); /* Send a node removal/addition event to all clients except ignore_id. Additionally, if far_players!=NULL, players further away than @@ -531,100 +583,183 @@ 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); void setBlockNotSent(v3s16 p); - + // Environment and Connection must be locked when called void SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver); - + // 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 std::list &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 + 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); + + // 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 + 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); + /* 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); - + // 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 "[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 m_async_fatal_error; + // 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 con::Connection m_con; JMutex m_con_mutex; // Connected clients (behind the con mutex) - core::map m_clients; - - // User authentication - AuthManager m_authmanager; + std::map m_clients; + u16 m_clients_number; //for announcing masterserver // Bann 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 + EmergeManager *m_emerge; + + // Biome Definition Manager + BiomeDefManager *m_biomedef; + // Scripting // Envlock and conlock should be locked when using Lua lua_State *m_lua; - // Tool definition manager - IWritableToolDefManager *m_toolmgr; - + // Item definition manager + IWritableItemDefManager *m_itemdef; + // Node definition manager - IWritableNodeDefManager *m_nodemgr; - + IWritableNodeDefManager *m_nodedef; + + // Craft definition manager + IWritableCraftDefManager *m_craftdef; + + // Event manager + EventManager *m_event; + + // 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; @@ -632,24 +767,16 @@ class Server : public con::PeerHandler, public MapEventReceiver, // 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; - + /* 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; - + /* Peer change queue. Queues stuff from peerAdded() and deletingPeer() to @@ -672,14 +799,11 @@ 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 + std::list 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 @@ -700,6 +824,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 @@ -709,6 +840,25 @@ class Server : public con::PeerHandler, public MapEventReceiver, friend class EmergeThread; friend class RemoteClient; + + std::map m_media; + + /* + Sounds + */ + std::map m_playing_sounds; + s32 m_next_sound_id; + + /* + Detached inventories (behind m_env_mutex) + */ + // key = name + std::map m_detached_inventories; + + /* + Particles + */ + std::vector m_particlespawner_ids; }; /*