X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fserver.h;h=34515faf7acc788a46047daeccbf5c5f0a4aaf51;hb=cde3d38766a19ddbe001e70573eb521eaf62cc66;hp=f1c7b6e01cdc1b333b23713ef85dece373caab6f;hpb=4a92df6ff021f1bfa645f97fd551c648d1ef8e3b;p=dragonfireclient.git diff --git a/src/server.h b/src/server.h index f1c7b6e01..34515faf7 100644 --- a/src/server.h +++ b/src/server.h @@ -1,38 +1,79 @@ /* Minetest-c55 -Copyright (C) 2010 celeron55, Perttu Ahola +Copyright (C) 2010-2011 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. */ -/* -(c) 2010 Perttu Ahola -*/ - #ifndef SERVER_HEADER #define SERVER_HEADER #include "connection.h" #include "environment.h" -#include "common_irrlicht.h" +#include "irrlichttypes_bloated.h" #include -#include "utility.h" #include "porting.h" #include "map.h" #include "inventory.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() + +struct LuaState; +typedef struct lua_State lua_State; +class IWritableItemDefManager; +class IWritableNodeDefManager; +class IWritableCraftDefManager; +class EventManager; +class PlayerSAO; +class IRollbackManager; + +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; @@ -62,14 +103,14 @@ class BlockEmergeQueue delete q; } } - + /* 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) @@ -89,7 +130,7 @@ class BlockEmergeQueue } } } - + /* Add the block */ @@ -119,7 +160,7 @@ class BlockEmergeQueue JMutexAutoLock lock(m_mutex); return m_queue.size(); } - + u32 peerItemCount(u16 peer_id) { JMutexAutoLock lock(m_mutex); @@ -195,11 +236,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 @@ -219,6 +258,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: @@ -229,23 +323,31 @@ class RemoteClient 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. @@ -254,17 +356,6 @@ class RemoteClient 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 - ); - void GotBlock(v3s16 p); void SentBlock(v3s16 p); @@ -276,7 +367,7 @@ class RemoteClient { 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. @@ -285,7 +376,7 @@ class RemoteClient void PrintInfo(std::ostream &o) { o<<"RemoteClient "< &actions, + std::list *log); + + // 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 IRollbackReportSink* getRollbackReportSink(); + + IWritableItemDefManager* getWritableItemDefManager(); + IWritableNodeDefManager* getWritableNodeDefManager(); + IWritableCraftDefManager* getWritableCraftDefManager(); + + const ModSpec* getModSpec(const std::string &modname); + void getModNames(core::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: - // 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. 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, u16 protocol_version); + + /* + 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); void SendChatMessage(u16 peer_id, const std::wstring &message); void BroadcastChatMessage(const std::wstring &message); - void sendRemoveNode(v3s16 p, u16 ignore_id=0); - void sendAddNode(v3s16 p, MapNode n, u16 ignore_id=0); - - // Environment and Connection must be locked when called + 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 + far_d_nodes are ignored and their peer_ids are added to far_players + */ + // 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); + void sendAddNode(v3s16 p, MapNode n, u16 ignore_id=0, + core::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 + + // 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 &tosend); + + void sendDetachedInventory(const std::string &name, u16 peer_id); + void sendDetachedInventoryToAll(const std::string &name); + void sendDetachedInventories(u16 peer_id); + + /* + Something random + */ + + 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); - - // Connection must be locked when called - std::wstring getStatusString(); - + + // 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(); + } + + // 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 + 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); - /* - Update water pressure. - This also adds suitable nodes to active_nodes. - - environment has to be locked when calling. - */ - /*void UpdateBlockWaterPressure(MapBlock *block, - core::map &modified_blocks);*/ - // Locks environment and connection by its own struct PeerChange; void handlePeerChange(PeerChange &c); void handlePeerChanges(); - - //float m_flowwater_timer; + + /* + 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_print_info_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; - ServerEnvironment m_env; - JMutex m_con_mutex; + // Connection con::Connection m_con; - core::map m_clients; // Behind the con mutex + JMutex m_con_mutex; + // Connected clients (behind the con mutex) + core::map m_clients; + + // 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; + + // 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 + 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; + // 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 m_flow_active_nodes; - - // 0-23999 - MutexedVariable m_time_of_day; - // Used to buffer dtime for adding to m_time_of_day - float m_time_counter; + + /* + Time related stuff + */ + + // 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 + handlePeerChanges() + */ enum PeerChangeType { PEER_ADDED, PEER_REMOVED }; - struct PeerChange { PeerChangeType type; u16 peer_id; bool timeout; }; - Queue m_peer_change_queue; - std::string m_mapsavedir; + /* + Random stuff + */ + + // Mod parent directory paths + core::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 + onMapEditEvent + + NOTE: Should these be moved to actually be members of + ServerEnvironment? + */ - MutexedVariable m_shutdown_requested; - /* Queue of map edits from the environment for sending to the clients This is behind m_env_mutex @@ -506,6 +837,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 @@ -515,6 +853,20 @@ 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; }; /*