X-Git-Url: https://git.lizzy.rs/?a=blobdiff_plain;f=src%2Fenvironment.h;h=a25a12db37c9b3aba4b1e861eb086619841abc8d;hb=ab04b7fe941003cf33350d7def69e4c1cc751314;hp=055e2b1f68c0fc5ab78e4082ffab09e779c3f5ae;hpb=520b470217331787b26ca7633f9de26308b14bbc;p=dragonfireclient.git diff --git a/src/environment.h b/src/environment.h index 055e2b1f6..a25a12db3 100644 --- a/src/environment.h +++ b/src/environment.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. */ @@ -26,21 +26,31 @@ with this program; if not, write to the Free Software Foundation, Inc., - The map - Players - Other objects - - The current time in the game (actually it only contains the brightness) + - The current time in the game - etc. */ +#include #include -#include "common_irrlicht.h" -#include "player.h" -#include "map.h" -#include -#include "utility.h" +#include +#include +#include "irr_v3d.h" #include "activeobject.h" +#include "util/numeric.h" +#include "mapnode.h" +#include "mapblock.h" +#include "jthread/jmutex.h" -class Server; +class ServerEnvironment; class ActiveBlockModifier; class ServerActiveObject; +class ITextureSource; +class IGameDef; +class Map; +class ServerMap; +class ClientMap; +class GameScripting; +class Player; class Environment { @@ -61,35 +71,101 @@ class Environment virtual void addPlayer(Player *player); void removePlayer(u16 peer_id); + void removePlayer(const char *name); Player * getPlayer(u16 peer_id); Player * getPlayer(const char *name); Player * getRandomConnectedPlayer(); Player * getNearestConnectedPlayer(v3f pos); - core::list getPlayers(); - core::list getPlayers(bool ignore_disconnected); - void printPlayers(std::ostream &o); - - //void setDayNightRatio(u32 r); + std::vector getPlayers(); + std::vector getPlayers(bool ignore_disconnected); + u32 getDayNightRatio(); - + // 0-23999 - virtual void setTimeOfDay(u32 time) - { - m_time_of_day = time; - } + virtual void setTimeOfDay(u32 time); + u32 getTimeOfDay(); + float getTimeOfDayF(); - u32 getTimeOfDay() + void stepTimeOfDay(float dtime); + + void setTimeOfDaySpeed(float speed); + float getTimeOfDaySpeed(); + + void setDayNightRatioOverride(bool enable, u32 value) { - return m_time_of_day; + m_enable_day_night_ratio_override = enable; + m_day_night_ratio_override = value; } + // counter used internally when triggering ABMs + u32 m_added_objects; + protected: // peer_ids in here should be unique, except that there may be many 0s - core::list m_players; - // Brightness - //u32 m_daynight_ratio; + std::vector m_players; // Time of day in milli-hours (0-23999); determines day and night u32 m_time_of_day; + // Time of day in 0...1 + float m_time_of_day_f; + float m_time_of_day_speed; + // Used to buffer dtime for adding to m_time_of_day + float m_time_counter; + // Overriding the day-night ratio is useful for custom sky visuals + bool m_enable_day_night_ratio_override; + u32 m_day_night_ratio_override; + + /* TODO: Add a callback function so these can be updated when a setting + * changes. At this point in time it doesn't matter (e.g. /set + * is documented to change server settings only) + * + * TODO: Local caching of settings is not optimal and should at some stage + * be updated to use a global settings object for getting thse values + * (as opposed to the this local caching). This can be addressed in + * a later release. + */ + bool m_cache_enable_shaders; + +private: + JMutex m_timeofday_lock; + JMutex m_time_lock; + +}; + +/* + Active block modifier interface. + + These are fed into ServerEnvironment at initialization time; + ServerEnvironment handles deleting them. +*/ + +class ActiveBlockModifier +{ +public: + ActiveBlockModifier(){}; + virtual ~ActiveBlockModifier(){}; + + // Set of contents to trigger on + virtual std::set getTriggerContents()=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(); } + // Trigger interval in seconds + virtual float getTriggerInterval() = 0; + // Random chance of (1 / return value), 0 is disallowed + virtual u32 getTriggerChance() = 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, + u32 active_object_count, u32 active_object_count_wider){}; +}; + +struct ABMWithState +{ + ActiveBlockModifier *abm; + float timer; + + ABMWithState(ActiveBlockModifier *abm_); }; /* @@ -99,20 +175,21 @@ class Environment class ActiveBlockList { public: - void update(core::list &active_positions, + void update(std::vector &active_positions, s16 radius, - core::map &blocks_removed, - core::map &blocks_added); + std::set &blocks_removed, + std::set &blocks_added); bool contains(v3s16 p){ - return (m_list.find(p) != NULL); + return (m_list.find(p) != m_list.end()); } void clear(){ m_list.clear(); } - core::map m_list; + std::set m_list; + std::set m_forceloaded_list; private: }; @@ -126,37 +203,34 @@ class ActiveBlockList class ServerEnvironment : public Environment { public: - ServerEnvironment(ServerMap *map, Server *server); + ServerEnvironment(ServerMap *map, GameScripting *scriptIface, + IGameDef *gamedef, const std::string &path_world); ~ServerEnvironment(); - Map & getMap() - { - return *m_map; - } + Map & getMap(); - ServerMap & getServerMap() - { - return *m_map; - } + ServerMap & getServerMap(); - Server * getServer() - { - return m_server; - } + //TODO find way to remove this fct! + GameScripting* getScriptIface() + { return m_script; } - void step(f32 dtime); - - /* - Save players - */ - void serializePlayers(const std::string &savedir); - void deSerializePlayers(const std::string &savedir); + IGameDef *getGameDef() + { return m_gamedef; } + + float getSendRecommendedInterval() + { return m_recommended_send_interval; } + + // Save players + void saveLoadedPlayers(); + void savePlayer(const std::string &playername); + Player *loadPlayer(const std::string &playername); /* Save and load time of day and game timer */ - void saveMeta(const std::string &savedir); - void loadMeta(const std::string &savedir); + void saveMeta(); + void loadMeta(); /* External ActiveObject interface @@ -174,23 +248,34 @@ class ServerEnvironment : public Environment Returns 0 if not added and thus deleted. */ u16 addActiveObject(ServerActiveObject *object); - + + /* + Add an active object as a static object to the corresponding + MapBlock. + Caller allocates memory, ServerEnvironment frees memory. + Return value: true if succeeded, false if failed. + (note: not used, pending removal from engine) + */ + //bool addActiveObjectAsStatic(ServerActiveObject *object); + /* Find out what new objects have been added to inside a radius around a position */ void getAddedActiveObjects(v3s16 pos, s16 radius, - core::map ¤t_objects, - core::map &added_objects); + s16 player_radius, + std::set ¤t_objects, + std::set &added_objects); /* Find out what new objects have been removed from inside a radius around a position */ void getRemovedActiveObjects(v3s16 pos, s16 radius, - core::map ¤t_objects, - core::map &removed_objects); - + s16 player_radius, + std::set ¤t_objects, + std::set &removed_objects); + /* Get the next message emitted by some active object. Returns a message with id=0 if no messages are available. @@ -204,12 +289,41 @@ class ServerEnvironment : public Environment void activateBlock(MapBlock *block, u32 additional_dtime=0); /* - ActiveBlockModifiers (TODO) + ActiveBlockModifiers ------------------------------------------- */ void addActiveBlockModifier(ActiveBlockModifier *abm); + /* + Other stuff + ------------------------------------------- + */ + + // Script-aware node setters + bool setNode(v3s16 p, const MapNode &n); + bool removeNode(v3s16 p); + bool swapNode(v3s16 p, const MapNode &n); + + // Find all active objects inside a radius around a point + void getObjectsInsideRadius(std::vector &objects, v3f pos, float radius); + + // Clear all objects, loading and going through every MapBlock + void clearAllObjects(); + + // 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; } + + 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; }; + private: /* @@ -227,18 +341,18 @@ class ServerEnvironment : public Environment Returns the id of the object. Returns 0 if not added and thus deleted. */ - u16 addActiveObjectRaw(ServerActiveObject *object, bool set_changed); - + u16 addActiveObjectRaw(ServerActiveObject *object, bool set_changed, u32 dtime_s); + /* Remove all objects that satisfy (m_removed && m_known_by_count==0) */ void removeRemovedObjects(); - + /* Convert stored objects from block to active */ - void activateObjects(MapBlock *block); - + void activateObjects(MapBlock *block, u32 dtime_s); + /* Convert objects that are not in active blocks to static. @@ -253,57 +367,45 @@ class ServerEnvironment : public Environment /* Member variables */ - + // The map ServerMap *m_map; - // Pointer to server (which is handling this environment) - Server *m_server; + // Lua state + GameScripting* m_script; + // Game definition + IGameDef *m_gamedef; + // World path + const std::string m_path_world; // Active object list - core::map m_active_objects; + std::map m_active_objects; // Outgoing network message buffer for active objects - Queue m_active_object_messages; + std::queue m_active_object_messages; // Some timers - float m_random_spawn_timer; // used for experimental code float m_send_recommended_timer; IntervalLimiter m_object_management_interval; // List of active blocks ActiveBlockList m_active_blocks; IntervalLimiter m_active_blocks_management_interval; - IntervalLimiter m_active_blocks_test_interval; + IntervalLimiter m_active_block_modifier_interval; IntervalLimiter m_active_blocks_nodemetadata_interval; + int m_active_block_interval_overload_skip; // Time from the beginning of the game in seconds. // Incremented in step(). u32 m_game_time; // A helper variable for incrementing the latter float m_game_time_fraction_counter; -}; - -/* - Active block modifier interface. - - These are fed into ServerEnvironment at initialization time; - ServerEnvironment handles deleting them. -*/ - -class ActiveBlockModifier -{ -public: - ActiveBlockModifier(){}; - virtual ~ActiveBlockModifier(){}; - - //virtual core::list update(ServerEnvironment *env) = 0; - virtual u32 getTriggerContentCount(){ return 1;} - virtual u8 getTriggerContent(u32 i) = 0; - virtual float getActiveInterval() = 0; - // chance of (1 / return value), 0 is disallowed - virtual u32 getActiveChance() = 0; - // This is called usually at interval for 1/chance of the nodes - virtual void triggerEvent(ServerEnvironment *env, v3s16 p) = 0; + std::vector m_abms; + // An interval for generally sending object positions and stuff + float m_recommended_send_interval; + // 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; }; #ifndef SERVER #include "clientobject.h" +class ClientSimpleObject; /* The client-side environment. @@ -316,63 +418,55 @@ class ActiveBlockModifier enum ClientEnvEventType { CEE_NONE, - CEE_PLAYER_DAMAGE + CEE_PLAYER_DAMAGE, + CEE_PLAYER_BREATH }; struct ClientEnvEvent { ClientEnvEventType type; union { - struct{ - } none; + //struct{ + //} none; struct{ u8 amount; + bool send_to_server; } player_damage; + struct{ + u16 amount; + } player_breath; }; }; class ClientEnvironment : public Environment { public: - ClientEnvironment(ClientMap *map, scene::ISceneManager *smgr); + ClientEnvironment(ClientMap *map, scene::ISceneManager *smgr, + ITextureSource *texturesource, IGameDef *gamedef, + IrrlichtDevice *device); ~ClientEnvironment(); - Map & getMap() - { - return *m_map; - } + Map & getMap(); + ClientMap & getClientMap(); - ClientMap & getClientMap() - { - return *m_map; - } + IGameDef *getGameDef() + { return m_gamedef; } void step(f32 dtime); virtual void addPlayer(Player *player); LocalPlayer * getLocalPlayer(); - void updateMeshes(v3s16 blockpos); - void expireMeshes(bool only_daynight_diffed); - - void setTimeOfDay(u32 time) - { - u32 old_dr = getDayNightRatio(); - - Environment::setTimeOfDay(time); + /* + ClientSimpleObjects + */ - if(getDayNightRatio() != old_dr) - { - dout_client< expiring meshes"< &dest); - + std::vector &dest); + // Get event from queue. CEE_NONE is returned if queue is empty. ClientEnvEvent getClientEvent(); - + + u16 m_attachements[USHRT_MAX]; + + std::list getPlayerNames() + { return m_player_names; } + void addPlayerName(std::string name) + { m_player_names.push_back(name); } + void removePlayerName(std::string name) + { m_player_names.remove(name); } + void updateCameraOffset(v3s16 camera_offset) + { m_camera_offset = camera_offset; } + v3s16 getCameraOffset() + { return m_camera_offset; } + private: ClientMap *m_map; scene::ISceneManager *m_smgr; - core::map m_active_objects; - Queue m_client_event_queue; + ITextureSource *m_texturesource; + IGameDef *m_gamedef; + IrrlichtDevice *m_irr; + std::map m_active_objects; + std::vector m_simple_objects; + std::list m_client_event_queue; IntervalLimiter m_active_object_light_update_interval; IntervalLimiter m_lava_hurt_interval; + IntervalLimiter m_drowning_interval; + IntervalLimiter m_breathing_interval; + std::list m_player_names; + v3s16 m_camera_offset; }; #endif