X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fserverenvironment.h;h=bb40a33ce221c09bbfb5eda439fcc238fa2fab86;hb=5c248c2d7de3db54e85f7c388743a2eb8e36fee4;hp=b7056c00cd8687ef984debefaed99be8d75a3aeb;hpb=430d3b28e46b16e1411ec0ecb6c0d0ab9d6feb63;p=minetest.git diff --git a/src/serverenvironment.h b/src/serverenvironment.h index b7056c00c..bb40a33ce 100644 --- a/src/serverenvironment.h +++ b/src/serverenvironment.h @@ -17,23 +17,30 @@ with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA. */ -#ifndef SERVER_ENVIRONMENT_HEADER -#define SERVER_ENVIRONMENT_HEADER +#pragma once +#include "activeobject.h" #include "environment.h" -#include "mapnode.h" -#include "mapblock.h" +#include "map.h" +#include "settings.h" +#include "server/activeobjectmgr.h" +#include "util/numeric.h" +#include "util/metricsbackend.h" #include +#include class IGameDef; -class ServerMap; +struct GameParams; class RemotePlayer; +class PlayerDatabase; +class AuthDatabase; class PlayerSAO; class ServerEnvironment; class ActiveBlockModifier; +struct StaticObject; class ServerActiveObject; class Server; -class GameScripting; +class ServerScripting; /* {Active, Loading} block modifier interface. @@ -45,21 +52,24 @@ class GameScripting; class ActiveBlockModifier { public: - ActiveBlockModifier(){}; - virtual ~ActiveBlockModifier(){}; + ActiveBlockModifier() = default; + virtual ~ActiveBlockModifier() = default; // Set of contents to trigger on - virtual std::set getTriggerContents()=0; + virtual const std::vector &getTriggerContents() const = 0; // Set of required neighbors (trigger doesn't happen if none are found) // Empty = do not check neighbors - virtual std::set getRequiredNeighbors() - { return std::set(); } + virtual const std::vector &getRequiredNeighbors() const = 0; // Trigger interval in seconds virtual float getTriggerInterval() = 0; // Random chance of (1 / return value), 0 is disallowed 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, @@ -69,7 +79,7 @@ class ActiveBlockModifier struct ABMWithState { ActiveBlockModifier *abm; - float timer; + float timer = 0.0f; ABMWithState(ActiveBlockModifier *abm_); }; @@ -79,16 +89,18 @@ struct LoadingBlockModifierDef // Set of contents to trigger on std::set trigger_contents; std::string name; - bool run_at_every_load; + bool run_at_every_load = false; - virtual ~LoadingBlockModifierDef() {} - virtual void trigger(ServerEnvironment *env, v3s16 p, MapNode n){}; + virtual ~LoadingBlockModifierDef() = default; + + virtual void trigger(ServerEnvironment *env, v3s16 p, + MapNode n, float dtime_s) {}; }; struct LBMContentMapping { - typedef std::map > container_map; - container_map map; + typedef std::unordered_map> lbm_map; + lbm_map map; std::vector lbm_list; @@ -103,10 +115,7 @@ struct LBMContentMapping class LBMManager { public: - LBMManager(): - m_query_mode(false) - {} - + LBMManager() = default; ~LBMManager(); // Don't call this after loadIntroductionTimes() ran. @@ -119,7 +128,8 @@ class LBMManager std::string createIntroductionTimesString(); // Don't call this before loadIntroductionTimes() ran. - void applyLBMs(ServerEnvironment *env, MapBlock *block, u32 stamp); + void applyLBMs(ServerEnvironment *env, MapBlock *block, + u32 stamp, float dtime_s); // Warning: do not make this std::unordered_map, order is relevant here typedef std::map lbm_lookup_map; @@ -127,7 +137,7 @@ class LBMManager private: // Once we set this to true, we can only query, // not modify - bool m_query_mode; + bool m_query_mode = false; // For m_query_mode == false: // The key of the map is the LBM def's name. @@ -152,23 +162,43 @@ class LBMManager class ActiveBlockList { public: - void update(std::vector &active_positions, - s16 radius, + void update(std::vector &active_players, + s16 active_block_range, + s16 active_object_range, std::set &blocks_removed, std::set &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(); } + void remove(v3s16 p) { + m_list.erase(p); + m_abm_list.erase(p); + } + std::set m_list; + std::set m_abm_list; + // list of blocks that are always active, not modified by this class std::set m_forceloaded_list; +}; -private: +/* + ServerEnvironment::m_on_mapblocks_changed_receiver +*/ +struct OnMapblocksChangedReceiver : public MapEventReceiver { + std::unordered_set modified_blocks; + bool receiving = false; + + void onMapEditEvent(const MapEditEvent &event) override; }; /* @@ -183,27 +213,21 @@ enum ClearObjectsMode { CLEAR_OBJECTS_MODE_QUICK, }; -/* - The server-side environment. - - This is not thread-safe. Server uses an environment mutex. -*/ - -typedef UNORDERED_MAP ActiveObjectMap; - -class ServerEnvironment : public Environment +class ServerEnvironment final : public Environment { public: - ServerEnvironment(ServerMap *map, GameScripting *scriptIface, - Server *server, const std::string &path_world); + ServerEnvironment(ServerMap *map, ServerScripting *script_iface, + Server *server, const std::string &path_world, MetricsBackend *mb); ~ServerEnvironment(); + void init(); + Map & getMap(); ServerMap & getServerMap(); //TODO find way to remove this fct! - GameScripting* getScriptIface() + ServerScripting* getScriptIface() { return m_script; } Server *getGameDef() @@ -215,20 +239,19 @@ class ServerEnvironment : public Environment void kickAllPlayers(AccessDeniedCode reason, const std::string &str_reason, bool reconnect); // Save players - void saveLoadedPlayers(); + void saveLoadedPlayers(bool force = false); void savePlayer(RemotePlayer *player); - RemotePlayer *loadPlayer(const std::string &playername, PlayerSAO *sao); + PlayerSAO *loadPlayer(RemotePlayer *player, bool *new_player, session_t peer_id, + bool is_singleplayer); void addPlayer(RemotePlayer *player); void removePlayer(RemotePlayer *player); + bool removePlayerFromDatabase(const std::string &name); /* Save and load time of day and game timer */ void saveMeta(); void loadMeta(); - // to be called instead of loadMeta if - // env_meta.txt doesn't exist (e.g. new world) - void loadDefaultMeta(); u32 addParticleSpawner(float exptime); u32 addParticleSpawner(float exptime, u16 attached_id); @@ -239,7 +262,10 @@ class ServerEnvironment : public Environment ------------------------------------------- */ - ServerActiveObject* getActiveObject(u16 id); + ServerActiveObject* getActiveObject(u16 id) + { + return m_ao_manager.getActiveObject(id); + } /* Add an active object to the environment. @@ -280,9 +306,14 @@ 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 &shootline_on_map, + std::vector &objects + ); /* Activate objects and dynamically modify for the dtime determined @@ -308,8 +339,22 @@ 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 &objects, v3f pos, float radius); + void getObjectsInsideRadius(std::vector &objects, const v3f &pos, float radius, + std::function include_obj_cb) + { + return m_ao_manager.getObjectsInsideRadius(pos, radius, objects, include_obj_cb); + } + + // Find all active objects inside a box + void getObjectsInArea(std::vector &objects, const aabb3f &box, + std::function include_obj_cb) + { + return m_ao_manager.getObjectsInArea(box, objects, include_obj_cb); + } // Clear objects, loading and going through every MapBlock void clearObjects(ClearObjectsMode mode); @@ -317,25 +362,49 @@ class ServerEnvironment : public Environment // This makes stuff happen void step(f32 dtime); - //check if there's a line of sight between two positions - bool line_of_sight(v3f pos1, v3f pos2, float stepsize=1.0, v3s16 *p=NULL); - - u32 getGameTime() { return m_game_time; } + 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* getForceloadedBlocks() { return &m_active_blocks.m_forceloaded_list; }; + std::set* 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 void setStaticForActiveObjectsInBlock(v3s16 blockpos, bool static_exists, v3s16 static_block=v3s16(0,0,0)); - RemotePlayer *getPlayer(const u16 peer_id); + RemotePlayer *getPlayer(const session_t peer_id); RemotePlayer *getPlayer(const char* name); + const std::vector getPlayers() const { return m_players; } + u32 getPlayerCount() const { return m_players.size(); } + + static bool migratePlayersDatabase(const GameParams &game_params, + const Settings &cmd_args); + + AuthDatabase *getAuthDatabase() { return m_auth_database; } + static bool migrateAuthDatabase(const GameParams &game_params, + const Settings &cmd_args); private: + /** + * called if env_meta.txt doesn't exist (e.g. new world) + */ + void loadDefaultMeta(); + + static PlayerDatabase *openPlayerDatabase(const std::string &name, + const std::string &savedir, const Settings &conf); + static AuthDatabase *openAuthDatabase(const std::string &name, + const std::string &savedir, const Settings &conf); /* Internal ActiveObject interface ------------------------------------------- @@ -354,7 +423,7 @@ class ServerEnvironment : public Environment u16 addActiveObjectRaw(ServerActiveObject *object, bool set_changed, u32 dtime_s); /* - Remove all objects that satisfy (m_removed && m_known_by_count==0) + Remove all objects that satisfy (isGone() && m_known_by_count==0) */ void removeRemovedObjects(); @@ -374,6 +443,14 @@ class ServerEnvironment : public Environment */ void deactivateFarObjects(bool force_delete); + /* + A few helpers used by the three above methods + */ + void deleteStaticFromBlock( + ServerActiveObject *obj, u16 id, u32 mod_reason, bool no_emerge); + bool saveStaticToBlock(v3s16 blockpos, u16 store_id, + ServerActiveObject *obj, const StaticObject &s_obj, u32 mod_reason); + /* Member variables */ @@ -381,48 +458,63 @@ class ServerEnvironment : public Environment // The map ServerMap *m_map; // Lua state - GameScripting* m_script; + ServerScripting* m_script; // Server definition Server *m_server; + // Active Object Manager + server::ActiveObjectMgr m_ao_manager; + // on_mapblocks_changed map event receiver + OnMapblocksChangedReceiver m_on_mapblocks_changed_receiver; // World path const std::string m_path_world; - // Active object list - ActiveObjectMap m_active_objects; // Outgoing network message buffer for active objects std::queue m_active_object_messages; // Some timers - float m_send_recommended_timer; + float m_send_recommended_timer = 0.0f; IntervalLimiter m_object_management_interval; // List of active blocks ActiveBlockList m_active_blocks; - IntervalLimiter m_active_blocks_management_interval; + int m_fast_active_block_divider = 1; + IntervalLimiter m_active_blocks_mgmt_interval; IntervalLimiter m_active_block_modifier_interval; IntervalLimiter m_active_blocks_nodemetadata_interval; - int m_active_block_interval_overload_skip; + // 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; + u32 m_game_time = 0; // A helper variable for incrementing the latter - float m_game_time_fraction_counter; + float m_game_time_fraction_counter = 0.0f; // Time of last clearObjects call (game time). // When a mapblock older than this is loaded, its objects are cleared. - u32 m_last_clear_objects_time; + u32 m_last_clear_objects_time = 0; // Active block modifiers std::vector m_abms; LBMManager m_lbm_mgr; // An interval for generally sending object positions and stuff - float m_recommended_send_interval; + float m_recommended_send_interval = 0.1f; // Estimate for general maximum lag as determined by server. // Can raise to high values like 15s with eg. map generation mods. - float m_max_lag_estimate; + float m_max_lag_estimate = 0.1f; // peer_ids in here should be unique, except that there may be many 0s std::vector m_players; + PlayerDatabase *m_player_database = nullptr; + AuthDatabase *m_auth_database = nullptr; + + // Pseudo random generator for shuffling, etc. + std::mt19937 m_rgen; + // Particles IntervalLimiter m_particle_management_interval; - UNORDERED_MAP m_particle_spawners; - UNORDERED_MAP m_particle_spawner_attachments; -}; + std::unordered_map m_particle_spawners; + std::unordered_map m_particle_spawner_attachments; -#endif + // 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); +};