Move KeyList & InputHandler from game.h to client/inputhandler.h (#5752)
[oweals/minetest.git] / src / server.h
index 555aab692ae7c736f9bb3062cdc7676b07d6c866..2e735e77c62abeded92d77f5f6f30a4fe3618a0c 100644 (file)
@@ -29,20 +29,20 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "mods.h"
 #include "inventorymanager.h"
 #include "subgame.h"
+#include "tileanimation.h" // struct TileAnimationParams
 #include "util/numeric.h"
 #include "util/thread.h"
-#include "environment.h"
+#include "util/basic_macros.h"
+#include "serverenvironment.h"
 #include "chat_interface.h"
 #include "clientiface.h"
-#include "player.h"
+#include "remoteplayer.h"
 #include "network/networkpacket.h"
 #include <string>
 #include <list>
 #include <map>
 #include <vector>
 
-#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
-
 class IWritableItemDefManager;
 class IWritableNodeDefManager;
 class IWritableCraftDefManager;
@@ -53,7 +53,7 @@ class PlayerSAO;
 class IRollbackManager;
 struct RollbackAction;
 class EmergeManager;
-class GameScripting;
+class ServerScripting;
 class ServerEnvironment;
 struct SimpleSoundSpec;
 class ServerThread;
@@ -115,6 +115,7 @@ struct ServerSoundParams
        u16 object;
        float max_hear_distance;
        bool loop;
+       float fade;
 
        ServerSoundParams():
                gain(1.0),
@@ -123,7 +124,8 @@ struct ServerSoundParams
                pos(0,0,0),
                object(0),
                max_hear_distance(32*BS),
-               loop(false)
+               loop(false),
+               fade(0)
        {}
 
        v3f getPos(ServerEnvironment *env, bool *pos_exists) const;
@@ -132,6 +134,7 @@ struct ServerSoundParams
 struct ServerPlayingSound
 {
        ServerSoundParams params;
+       SimpleSoundSpec spec;
        UNORDERED_SET<u16> clients; // peer ids
 };
 
@@ -148,6 +151,7 @@ public:
                const SubgameSpec &gamespec,
                bool simple_singleplayer_mode,
                bool ipv6,
+               bool dedicated,
                ChatInterface *iface = NULL
        );
        ~Server();
@@ -173,7 +177,6 @@ public:
        void handleCommand_Init_Legacy(NetworkPacket* pkt);
        void handleCommand_Init2(NetworkPacket* pkt);
        void handleCommand_RequestMedia(NetworkPacket* pkt);
-       void handleCommand_ReceivedMedia(NetworkPacket* pkt);
        void handleCommand_ClientReady(NetworkPacket* pkt);
        void handleCommand_GotBlocks(NetworkPacket* pkt);
        void handleCommand_PlayerPos(NetworkPacket* pkt);
@@ -181,7 +184,6 @@ public:
        void handleCommand_InventoryAction(NetworkPacket* pkt);
        void handleCommand_ChatMessage(NetworkPacket* pkt);
        void handleCommand_Damage(NetworkPacket* pkt);
-       void handleCommand_Breath(NetworkPacket* pkt);
        void handleCommand_Password(NetworkPacket* pkt);
        void handleCommand_PlayerItem(NetworkPacket* pkt);
        void handleCommand_Respawn(NetworkPacket* pkt);
@@ -197,6 +199,10 @@ public:
 
        void Send(NetworkPacket* pkt);
 
+       // Helper for handleCommand_PlayerPos and handleCommand_Interact
+       void process_PlayerPos(RemotePlayer *player, PlayerSAO *playersao,
+               NetworkPacket *pkt);
+
        // Both setter and getter need no envlock,
        // can be called freely from threads
        void setTimeOfDay(u32 time);
@@ -216,22 +222,19 @@ public:
 
        // Connection must be locked when called
        std::wstring getStatusString();
+       inline double getUptime() const { return m_uptime.m_value; }
 
        // read shutdown state
        inline bool getShutdownRequested() const { return m_shutdown_requested; }
 
        // request server to shutdown
-       void requestShutdown(const std::string &msg, bool reconnect)
-       {
-               m_shutdown_requested = true;
-               m_shutdown_msg = msg;
-               m_shutdown_ask_reconnect = reconnect;
-       }
+       void requestShutdown(const std::string &msg, bool reconnect, float delay = 0.0f);
 
        // Returns -1 if failed, sound handle on success
        // Envlock
        s32 playSound(const SimpleSoundSpec &spec, const ServerSoundParams &params);
        void stopSound(s32 handle);
+       void fadeSound(s32 handle, float step, float gain);
 
        // Envlock
        std::set<std::string> getPlayerEffectivePrivs(const std::string &name);
@@ -249,7 +252,8 @@ public:
                v3f pos, v3f velocity, v3f acceleration,
                float expirationtime, float size,
                bool collisiondetection, bool collision_removal,
-               bool vertical, const std::string &texture);
+               bool vertical, const std::string &texture,
+               const struct TileAnimationParams &animation, u8 glow);
 
        u32 addParticleSpawner(u16 amount, float spawntime,
                v3f minpos, v3f maxpos,
@@ -258,16 +262,18 @@ public:
                float minexptime, float maxexptime,
                float minsize, float maxsize,
                bool collisiondetection, bool collision_removal,
+               ServerActiveObject *attached,
                bool vertical, const std::string &texture,
-               const std::string &playername);
+               const std::string &playername, const struct TileAnimationParams &animation,
+               u8 glow);
 
        void deleteParticleSpawner(const std::string &playername, u32 id);
 
        // Creates or resets inventory
-       Inventory* createDetachedInventory(const std::string &name);
+       Inventory* createDetachedInventory(const std::string &name, const std::string &player="");
 
        // Envlock and conlock should be locked when using scriptapi
-       GameScripting *getScriptIface(){ return m_script; }
+       ServerScripting *getScriptIface(){ return m_script; }
 
        // actions: time-reversed list
        // Return value: success/failure
@@ -279,23 +285,21 @@ public:
        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; }
+       IRollbackManager *getRollbackManager() { return m_rollback; }
        virtual EmergeManager *getEmergeManager() { return m_emerge; }
 
        IWritableItemDefManager* getWritableItemDefManager();
        IWritableNodeDefManager* getWritableNodeDefManager();
        IWritableCraftDefManager* getWritableCraftDefManager();
 
-       const ModSpec* getModSpec(const std::string &modname) const;
+       virtual const std::vector<ModSpec> &getMods() const { return m_mods; }
+       virtual const ModSpec* getModSpec(const std::string &modname) const;
        void getModNames(std::vector<std::string> &modlist);
        std::string getBuiltinLuaPath();
-       inline std::string getWorldPath() const { return m_path_world; }
+       virtual std::string getWorldPath() const { return m_path_world; }
+       virtual std::string getModStoragePath() const;
 
        inline bool isSingleplayer()
                        { return m_simple_singleplayer_mode; }
@@ -306,27 +310,39 @@ public:
        bool showFormspec(const char *name, const std::string &formspec, const std::string &formname);
        Map & getMap() { return m_env->getMap(); }
        ServerEnvironment & getEnv() { return *m_env; }
+       v3f findSpawnPos();
 
-       u32 hudAdd(Player *player, HudElement *element);
-       bool hudRemove(Player *player, u32 id);
-       bool hudChange(Player *player, u32 id, HudElementStat stat, void *value);
+       u32 hudAdd(RemotePlayer *player, HudElement *element);
+       bool hudRemove(RemotePlayer *player, u32 id);
+       bool hudChange(RemotePlayer *player, u32 id, HudElementStat stat, void *value);
        bool hudSetFlags(RemotePlayer *player, u32 flags, u32 mask);
        bool hudSetHotbarItemcount(RemotePlayer *player, s32 hotbar_itemcount);
        s32 hudGetHotbarItemcount(RemotePlayer *player) const
                        { return player->getHotbarItemcount(); }
-       void hudSetHotbarImage(Player *player, std::string name);
-       std::string hudGetHotbarImage(Player *player);
-       void hudSetHotbarSelectedImage(Player *player, std::string name);
-       std::string hudGetHotbarSelectedImage(Player *player);
+       void hudSetHotbarImage(RemotePlayer *player, std::string name);
+       std::string hudGetHotbarImage(RemotePlayer *player);
+       void hudSetHotbarSelectedImage(RemotePlayer *player, std::string name);
+       const std::string &hudGetHotbarSelectedImage(RemotePlayer *player) const
+       {
+               return player->getHotbarSelectedImage();
+       }
 
        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 setLocalPlayerAnimations(RemotePlayer *player, v2s32 animation_frames[4],
+                       f32 frame_speed);
+       bool setPlayerEyeOffset(RemotePlayer *player, v3f first, v3f third);
 
-       bool setSky(Player *player, const video::SColor &bgcolor,
-                       const std::string &type, const std::vector<std::string> &params);
+       bool setSky(RemotePlayer *player, const video::SColor &bgcolor,
+                       const std::string &type, const std::vector<std::string> &params,
+                       bool &clouds);
+       bool setClouds(RemotePlayer *player, float density,
+                       const video::SColor &color_bright,
+                       const video::SColor &color_ambient,
+                       float height,
+                       float thickness,
+                       const v2f &speed);
 
        bool overrideDayNightRatio(RemotePlayer *player, bool do_override, float brightness);
 
@@ -348,10 +364,13 @@ public:
        void printToConsoleOnly(const std::string &text);
 
        void SendPlayerHPOrDie(PlayerSAO *player);
-       void SendPlayerBreath(u16 peer_id);
+       void SendPlayerBreath(PlayerSAO *sao);
        void SendInventory(PlayerSAO* playerSAO);
        void SendMovePlayer(u16 peer_id);
 
+       virtual bool registerModStorage(ModMetadata *storage);
+       virtual void unregisterModStorage(const std::string &name);
+
        // Bind address
        Address m_bind_addr;
 
@@ -392,7 +411,14 @@ private:
        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<std::string> &params);
+                       const std::string &type, const std::vector<std::string> &params,
+                       bool &clouds);
+       void SendCloudParams(u16 peer_id, float density,
+                       const video::SColor &color_bright,
+                       const video::SColor &color_ambient,
+                       float height,
+                       float thickness,
+                       const v2f &speed);
        void SendOverrideDayNightRatio(u16 peer_id, bool do_override, float ratio);
 
        /*
@@ -423,23 +449,27 @@ private:
        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,
+       void SendAddParticleSpawner(u16 peer_id, u16 protocol_version,
+               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 collision_removal,
-               bool vertical, const std::string &texture, u32 id);
+               u16 attached_id,
+               bool vertical, const std::string &texture, u32 id,
+               const struct TileAnimationParams &animation, u8 glow);
 
        void SendDeleteParticleSpawner(u16 peer_id, u32 id);
 
        // Spawns particle on peer with peer_id (PEER_ID_INEXISTENT == all)
-       void SendSpawnParticle(u16 peer_id,
+       void SendSpawnParticle(u16 peer_id, u16 protocol_version,
                v3f pos, v3f velocity, v3f acceleration,
                float expirationtime, float size,
                bool collisiondetection, bool collision_removal,
-               bool vertical, const std::string &texture);
+               bool vertical, const std::string &texture,
+               const struct TileAnimationParams &animation, u8 glow);
 
        u32 SendActiveObjectRemoveAdd(u16 peer_id, const std::string &datas);
        void SendActiveObjectMessages(u16 peer_id, const std::string &datas, bool reliable = true);
@@ -461,8 +491,6 @@ private:
                RemotePlayer *player = NULL);
        void handleAdminChat(const ChatEventChat *evt);
 
-       v3f findSpawnPos();
-
        // When called, connection mutex should be locked
        RemoteClient* getClient(u16 peer_id,ClientState state_min=CS_Active);
        RemoteClient* getClientNoEx(u16 peer_id,ClientState state_min=CS_Active);
@@ -494,6 +522,8 @@ private:
        // functionality
        bool m_simple_singleplayer_mode;
        u16 m_max_chatmessage_length;
+       // For "dedicated" server list flag
+       bool m_dedicated;
 
        // Thread can set; step() will throw as ServerError
        MutexedVariable<std::string> m_async_fatal_error;
@@ -524,7 +554,7 @@ private:
 
        // Scripting
        // Envlock and conlock should be locked when using Lua
-       GameScripting *m_script;
+       ServerScripting *m_script;
 
        // Item definition manager
        IWritableItemDefManager *m_itemdef;
@@ -564,7 +594,6 @@ private:
        float m_time_of_day_send_timer;
        // Uptime of server in seconds
        MutexedVariable<double> m_uptime;
-
        /*
         Client interface
         */
@@ -584,6 +613,7 @@ private:
        bool m_shutdown_requested;
        std::string m_shutdown_msg;
        bool m_shutdown_ask_reconnect;
+       float m_shutdown_timer;
 
        ChatInterface *m_admin_chat;
        std::string m_admin_nick;
@@ -636,6 +666,11 @@ private:
        */
        // key = name
        std::map<std::string, Inventory*> m_detached_inventories;
+       // value = "" (visible to all players) or player name
+       std::map<std::string, std::string> m_detached_inventories_player;
+
+       UNORDERED_MAP<std::string, ModMetadata *> m_mod_storages;
+       float m_mod_storage_save_timer;
 
        DISABLE_CLASS_COPY(Server);
 };