Don't ignore server disconnects in client code

[dragonfireclient.git] / src / serverenvironment.h

diff --git a/src/serverenvironment.h b/src/serverenvironment.h
index cc4ecd797eae3f829d90f63dd12ffa3da15d41d8..5dc329a60e8f531a686ac4020cea6607a0bc3f1a 100644 (file)
--- a/src/serverenvironment.h
+++ b/src/serverenvironment.h
@@ -25,6 +25,7 @@ with this program; if not, write to the Free Software Foundation, Inc.,
 #include "settings.h"
 #include "server/activeobjectmgr.h"
 #include "util/numeric.h"
+#include "util/metricsbackend.h"
 #include <set>
 #include <random>
 
@@ -67,6 +68,10 @@ class ActiveBlockModifier
        virtual u32 getTriggerChance() = 0;
        // Whether to modify chance to simulate time lost by an unnattended block
        virtual bool getSimpleCatchUp() = 0;
+       // get min Y for apply abm
+       virtual s16 getMinY() = 0;
+       // get max Y for apply abm
+       virtual s16 getMaxY() = 0;
        // This is called usually at interval for 1/chance of the nodes
        virtual void trigger(ServerEnvironment *env, v3s16 p, MapNode n){};
        virtual void trigger(ServerEnvironment *env, v3s16 p, MapNode n,
@@ -163,19 +168,21 @@ class ActiveBlockList
                std::set<v3s16> &blocks_removed,
                std::set<v3s16> &blocks_added);
 
-       bool contains(v3s16 p){
+       bool contains(v3s16 p) const {
                return (m_list.find(p) != m_list.end());
        }
 
-       void clear(){
+       auto size() const {
+               return m_list.size();
+       }
+
+       void clear() {
                m_list.clear();
        }
 
        std::set<v3s16> m_list;
        std::set<v3s16> m_abm_list;
        std::set<v3s16> m_forceloaded_list;
-
-private:
 };
 
 /*
@@ -190,19 +197,11 @@ enum ClearObjectsMode {
                CLEAR_OBJECTS_MODE_QUICK,
 };
 
-/*
-       The server-side environment.
-
-       This is not thread-safe. Server uses an environment mutex.
-*/
-
-typedef std::unordered_map<u16, ServerActiveObject *> ServerActiveObjectMap;
-
 class ServerEnvironment : public Environment
 {
 public:
        ServerEnvironment(ServerMap *map, ServerScripting *scriptIface,
-               Server *server, const std::string &path_world);
+               Server *server, const std::string &path_world, MetricsBackend *mb);
        ~ServerEnvironment();
 
        Map & getMap();
@@ -289,9 +288,9 @@ class ServerEnvironment : public Environment
 
        /*
                Get the next message emitted by some active object.
-               Returns a message with id=0 if no messages are available.
+               Returns false if no messages are available, true otherwise.
        */
-       ActiveObjectMessage getActiveObjectMessage();
+       bool getActiveObjectMessage(ActiveObjectMessage *dest);
 
        virtual void getSelectedActiveObjects(
                const core::line3d<f32> &shootline_on_map,
@@ -322,10 +321,21 @@ class ServerEnvironment : public Environment
        bool removeNode(v3s16 p);
        bool swapNode(v3s16 p, const MapNode &n);
 
+       // Find the daylight value at pos with a Depth First Search
+       u8 findSunlight(v3s16 pos) const;
+
        // Find all active objects inside a radius around a point
-       void getObjectsInsideRadius(std::vector<u16> &objects, const v3f &pos, float radius)
+       void getObjectsInsideRadius(std::vector<ServerActiveObject *> &objects, const v3f &pos, float radius,
+                       std::function<bool(ServerActiveObject *obj)> include_obj_cb)
        {
-               return m_ao_manager.getObjectsInsideRadius(pos, radius, objects);
+               return m_ao_manager.getObjectsInsideRadius(pos, radius, objects, include_obj_cb);
+       }
+
+       // Find all active objects inside a box
+       void getObjectsInArea(std::vector<ServerActiveObject *> &objects, const aabb3f &box,
+                       std::function<bool(ServerActiveObject *obj)> include_obj_cb)
+       {
+               return m_ao_manager.getObjectsInArea(box, objects, include_obj_cb);
        }
 
        // Clear objects, loading and going through every MapBlock
@@ -334,22 +344,21 @@ class ServerEnvironment : public Environment
        // This makes stuff happen
        void step(f32 dtime);
 
-       /*!
-        * Returns false if the given line intersects with a
-        * non-air node, true otherwise.
-        * \param pos1 start of the line
-        * \param pos2 end of the line
-        * \param p output, position of the first non-air node
-        * the line intersects
-        */
-       bool line_of_sight(v3f pos1, v3f pos2, v3s16 *p = NULL);
-
        u32 getGameTime() const { return m_game_time; }
 
        void reportMaxLagEstimate(float f) { m_max_lag_estimate = f; }
        float getMaxLagEstimate() { return m_max_lag_estimate; }
 
-       std::set<v3s16>* getForceloadedBlocks() { return &m_active_blocks.m_forceloaded_list; };
+       std::set<v3s16>* getForceloadedBlocks() { return &m_active_blocks.m_forceloaded_list; }
+
+       // Sorted by how ready a mapblock is
+       enum BlockStatus {
+               BS_UNKNOWN,
+               BS_EMERGING,
+               BS_LOADED,
+               BS_ACTIVE // always highest value
+       };
+       BlockStatus getBlockStatus(v3s16 blockpos);
 
        // Sets the static object status all the active objects in the specified block
        // This is only really needed for deleting blocks from the map
@@ -358,6 +367,7 @@ class ServerEnvironment : public Environment
 
        RemotePlayer *getPlayer(const session_t peer_id);
        RemotePlayer *getPlayer(const char* name);
+       const std::vector<RemotePlayer *> getPlayers() const { return m_players; }
        u32 getPlayerCount() const { return m_players.size(); }
 
        static bool migratePlayersDatabase(const GameParams &game_params,
@@ -447,6 +457,8 @@ class ServerEnvironment : public Environment
        IntervalLimiter m_active_blocks_management_interval;
        IntervalLimiter m_active_block_modifier_interval;
        IntervalLimiter m_active_blocks_nodemetadata_interval;
+       // Whether the variables below have been read from file yet
+       bool m_meta_loaded = false;
        // Time from the beginning of the game in seconds.
        // Incremented in step().
        u32 m_game_time = 0;
@@ -477,4 +489,11 @@ class ServerEnvironment : public Environment
        IntervalLimiter m_particle_management_interval;
        std::unordered_map<u32, float> m_particle_spawners;
        std::unordered_map<u32, u16> m_particle_spawner_attachments;
+
+       // Environment metrics
+       MetricCounterPtr m_step_time_counter;
+       MetricGaugePtr m_active_block_gauge;
+       MetricGaugePtr m_active_object_gauge;
+
+       ServerActiveObject* createSAO(ActiveObjectType type, v3f pos, const std::string &data);
 };