2017-01-08 11:01:35 +01:00
|
|
|
/*
|
|
|
|
Minetest
|
|
|
|
Copyright (C) 2010-2017 celeron55, Perttu Ahola <celeron55@gmail.com>
|
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
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 Lesser General Public License for more details.
|
|
|
|
|
|
|
|
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.
|
|
|
|
*/
|
|
|
|
|
2017-08-17 22:19:39 +02:00
|
|
|
#pragma once
|
2017-01-08 11:01:35 +01:00
|
|
|
|
2017-08-18 19:25:07 +02:00
|
|
|
#include "activeobject.h"
|
2017-01-08 11:01:35 +01:00
|
|
|
#include "environment.h"
|
2022-09-04 04:05:07 +02:00
|
|
|
#include "map.h"
|
2017-08-18 19:25:07 +02:00
|
|
|
#include "settings.h"
|
2018-12-13 20:18:54 +01:00
|
|
|
#include "server/activeobjectmgr.h"
|
2017-08-18 19:25:07 +02:00
|
|
|
#include "util/numeric.h"
|
2022-05-09 21:20:58 +02:00
|
|
|
#include "util/metricsbackend.h"
|
2017-01-11 09:03:07 +01:00
|
|
|
#include <set>
|
2019-07-08 08:23:00 +02:00
|
|
|
#include <random>
|
2017-01-08 11:01:35 +01:00
|
|
|
|
|
|
|
class IGameDef;
|
2017-04-23 14:35:08 +02:00
|
|
|
struct GameParams;
|
2017-01-08 11:01:35 +01:00
|
|
|
class RemotePlayer;
|
2017-04-23 14:35:08 +02:00
|
|
|
class PlayerDatabase;
|
2018-08-05 13:13:38 +02:00
|
|
|
class AuthDatabase;
|
2017-01-08 11:01:35 +01:00
|
|
|
class PlayerSAO;
|
|
|
|
class ServerEnvironment;
|
|
|
|
class ActiveBlockModifier;
|
2017-09-15 12:19:01 +02:00
|
|
|
struct StaticObject;
|
2017-01-08 11:01:35 +01:00
|
|
|
class ServerActiveObject;
|
2017-01-09 20:39:22 +01:00
|
|
|
class Server;
|
2017-01-21 15:02:08 +01:00
|
|
|
class ServerScripting;
|
2023-03-08 22:58:47 +01:00
|
|
|
enum AccessDeniedCode : u8;
|
|
|
|
typedef u16 session_t;
|
2017-01-08 11:01:35 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
{Active, Loading} block modifier interface.
|
|
|
|
|
|
|
|
These are fed into ServerEnvironment at initialization time;
|
|
|
|
ServerEnvironment handles deleting them.
|
|
|
|
*/
|
|
|
|
|
|
|
|
class ActiveBlockModifier
|
|
|
|
{
|
|
|
|
public:
|
2017-08-19 14:25:35 +02:00
|
|
|
ActiveBlockModifier() = default;
|
|
|
|
virtual ~ActiveBlockModifier() = default;
|
2017-01-08 11:01:35 +01:00
|
|
|
|
|
|
|
// Set of contents to trigger on
|
2017-09-11 15:51:40 +02:00
|
|
|
virtual const std::vector<std::string> &getTriggerContents() const = 0;
|
2017-01-08 11:01:35 +01:00
|
|
|
// Set of required neighbors (trigger doesn't happen if none are found)
|
|
|
|
// Empty = do not check neighbors
|
2017-09-11 15:51:40 +02:00
|
|
|
virtual const std::vector<std::string> &getRequiredNeighbors() const = 0;
|
2017-01-08 11:01:35 +01:00
|
|
|
// 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;
|
2021-06-20 17:21:35 +02:00
|
|
|
// get min Y for apply abm
|
|
|
|
virtual s16 getMinY() = 0;
|
|
|
|
// get max Y for apply abm
|
|
|
|
virtual s16 getMaxY() = 0;
|
2017-01-08 11:01:35 +01:00
|
|
|
// 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;
|
2017-06-18 19:55:15 +02:00
|
|
|
float timer = 0.0f;
|
2017-01-08 11:01:35 +01:00
|
|
|
|
|
|
|
ABMWithState(ActiveBlockModifier *abm_);
|
|
|
|
};
|
|
|
|
|
|
|
|
struct LoadingBlockModifierDef
|
|
|
|
{
|
|
|
|
// Set of contents to trigger on
|
|
|
|
std::set<std::string> trigger_contents;
|
|
|
|
std::string name;
|
2017-06-18 19:55:15 +02:00
|
|
|
bool run_at_every_load = false;
|
2017-01-08 11:01:35 +01:00
|
|
|
|
2017-08-19 14:25:35 +02:00
|
|
|
virtual ~LoadingBlockModifierDef() = default;
|
|
|
|
|
2022-12-04 12:35:14 +01:00
|
|
|
virtual void trigger(ServerEnvironment *env, v3s16 p,
|
|
|
|
MapNode n, float dtime_s) {};
|
2017-01-08 11:01:35 +01:00
|
|
|
};
|
|
|
|
|
|
|
|
struct LBMContentMapping
|
|
|
|
{
|
2017-07-18 08:23:37 +02:00
|
|
|
typedef std::unordered_map<content_t, std::vector<LoadingBlockModifierDef *>> lbm_map;
|
|
|
|
lbm_map map;
|
2017-01-08 11:01:35 +01:00
|
|
|
|
|
|
|
std::vector<LoadingBlockModifierDef *> lbm_list;
|
|
|
|
|
|
|
|
// Needs to be separate method (not inside destructor),
|
|
|
|
// because the LBMContentMapping may be copied and destructed
|
|
|
|
// many times during operation in the lbm_lookup_map.
|
|
|
|
void deleteContents();
|
|
|
|
void addLBM(LoadingBlockModifierDef *lbm_def, IGameDef *gamedef);
|
|
|
|
const std::vector<LoadingBlockModifierDef *> *lookup(content_t c) const;
|
|
|
|
};
|
|
|
|
|
|
|
|
class LBMManager
|
|
|
|
{
|
|
|
|
public:
|
2017-08-19 14:25:35 +02:00
|
|
|
LBMManager() = default;
|
2017-01-08 11:01:35 +01:00
|
|
|
~LBMManager();
|
|
|
|
|
|
|
|
// Don't call this after loadIntroductionTimes() ran.
|
|
|
|
void addLBMDef(LoadingBlockModifierDef *lbm_def);
|
|
|
|
|
|
|
|
void loadIntroductionTimes(const std::string ×,
|
|
|
|
IGameDef *gamedef, u32 now);
|
|
|
|
|
|
|
|
// Don't call this before loadIntroductionTimes() ran.
|
|
|
|
std::string createIntroductionTimesString();
|
|
|
|
|
|
|
|
// Don't call this before loadIntroductionTimes() ran.
|
2022-12-04 12:35:14 +01:00
|
|
|
void applyLBMs(ServerEnvironment *env, MapBlock *block,
|
|
|
|
u32 stamp, float dtime_s);
|
2017-01-08 11:01:35 +01:00
|
|
|
|
|
|
|
// Warning: do not make this std::unordered_map, order is relevant here
|
|
|
|
typedef std::map<u32, LBMContentMapping> lbm_lookup_map;
|
|
|
|
|
|
|
|
private:
|
|
|
|
// Once we set this to true, we can only query,
|
|
|
|
// not modify
|
2017-06-18 19:55:15 +02:00
|
|
|
bool m_query_mode = false;
|
2017-01-08 11:01:35 +01:00
|
|
|
|
|
|
|
// For m_query_mode == false:
|
|
|
|
// The key of the map is the LBM def's name.
|
|
|
|
// TODO make this std::unordered_map
|
|
|
|
std::map<std::string, LoadingBlockModifierDef *> m_lbm_defs;
|
|
|
|
|
|
|
|
// For m_query_mode == true:
|
|
|
|
// The key of the map is the LBM def's first introduction time.
|
|
|
|
lbm_lookup_map m_lbm_lookup;
|
|
|
|
|
|
|
|
// Returns an iterator to the LBMs that were introduced
|
|
|
|
// after the given time. This is guaranteed to return
|
|
|
|
// valid values for everything
|
|
|
|
lbm_lookup_map::const_iterator getLBMsIntroducedAfter(u32 time)
|
|
|
|
{ return m_lbm_lookup.lower_bound(time); }
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
List of active blocks, used by ServerEnvironment
|
|
|
|
*/
|
|
|
|
|
|
|
|
class ActiveBlockList
|
|
|
|
{
|
|
|
|
public:
|
2017-12-04 02:51:58 +01:00
|
|
|
void update(std::vector<PlayerSAO*> &active_players,
|
|
|
|
s16 active_block_range,
|
|
|
|
s16 active_object_range,
|
2017-01-08 11:01:35 +01:00
|
|
|
std::set<v3s16> &blocks_removed,
|
|
|
|
std::set<v3s16> &blocks_added);
|
|
|
|
|
2022-05-09 21:20:58 +02:00
|
|
|
bool contains(v3s16 p) const {
|
2017-01-08 11:01:35 +01:00
|
|
|
return (m_list.find(p) != m_list.end());
|
|
|
|
}
|
|
|
|
|
2022-05-09 21:20:58 +02:00
|
|
|
auto size() const {
|
|
|
|
return m_list.size();
|
|
|
|
}
|
|
|
|
|
|
|
|
void clear() {
|
2017-01-08 11:01:35 +01:00
|
|
|
m_list.clear();
|
|
|
|
}
|
|
|
|
|
2022-05-26 22:22:48 +02:00
|
|
|
void remove(v3s16 p) {
|
|
|
|
m_list.erase(p);
|
|
|
|
m_abm_list.erase(p);
|
|
|
|
}
|
|
|
|
|
2017-01-08 11:01:35 +01:00
|
|
|
std::set<v3s16> m_list;
|
2017-12-04 02:51:58 +01:00
|
|
|
std::set<v3s16> m_abm_list;
|
2022-05-26 22:22:48 +02:00
|
|
|
// list of blocks that are always active, not modified by this class
|
2017-01-08 11:01:35 +01:00
|
|
|
std::set<v3s16> m_forceloaded_list;
|
|
|
|
};
|
|
|
|
|
2022-09-04 04:05:07 +02:00
|
|
|
/*
|
|
|
|
ServerEnvironment::m_on_mapblocks_changed_receiver
|
|
|
|
*/
|
|
|
|
struct OnMapblocksChangedReceiver : public MapEventReceiver {
|
|
|
|
std::unordered_set<v3s16> modified_blocks;
|
|
|
|
bool receiving = false;
|
|
|
|
|
|
|
|
void onMapEditEvent(const MapEditEvent &event) override;
|
|
|
|
};
|
|
|
|
|
2017-01-08 11:01:35 +01:00
|
|
|
/*
|
|
|
|
Operation mode for ServerEnvironment::clearObjects()
|
|
|
|
*/
|
|
|
|
enum ClearObjectsMode {
|
|
|
|
// Load and go through every mapblock, clearing objects
|
|
|
|
CLEAR_OBJECTS_MODE_FULL,
|
|
|
|
|
|
|
|
// Clear objects immediately in loaded mapblocks;
|
|
|
|
// clear objects in unloaded mapblocks only when the mapblocks are next activated.
|
|
|
|
CLEAR_OBJECTS_MODE_QUICK,
|
|
|
|
};
|
|
|
|
|
2022-09-27 22:22:11 +02:00
|
|
|
class ServerEnvironment final : public Environment
|
2017-01-08 11:01:35 +01:00
|
|
|
{
|
|
|
|
public:
|
2022-09-27 22:22:11 +02:00
|
|
|
ServerEnvironment(ServerMap *map, ServerScripting *script_iface,
|
2022-05-09 21:20:58 +02:00
|
|
|
Server *server, const std::string &path_world, MetricsBackend *mb);
|
2017-01-08 11:01:35 +01:00
|
|
|
~ServerEnvironment();
|
|
|
|
|
2022-09-27 22:22:11 +02:00
|
|
|
void init();
|
|
|
|
|
2017-01-08 11:01:35 +01:00
|
|
|
Map & getMap();
|
|
|
|
|
|
|
|
ServerMap & getServerMap();
|
|
|
|
|
|
|
|
//TODO find way to remove this fct!
|
2017-01-21 15:02:08 +01:00
|
|
|
ServerScripting* getScriptIface()
|
2017-01-08 11:01:35 +01:00
|
|
|
{ return m_script; }
|
|
|
|
|
2017-01-09 20:39:22 +01:00
|
|
|
Server *getGameDef()
|
|
|
|
{ return m_server; }
|
2017-01-08 11:01:35 +01:00
|
|
|
|
|
|
|
float getSendRecommendedInterval()
|
|
|
|
{ return m_recommended_send_interval; }
|
|
|
|
|
|
|
|
void kickAllPlayers(AccessDeniedCode reason,
|
|
|
|
const std::string &str_reason, bool reconnect);
|
|
|
|
// Save players
|
2019-02-03 09:11:45 +01:00
|
|
|
void saveLoadedPlayers(bool force = false);
|
2017-01-08 11:01:35 +01:00
|
|
|
void savePlayer(RemotePlayer *player);
|
2017-09-27 19:47:36 +02:00
|
|
|
PlayerSAO *loadPlayer(RemotePlayer *player, bool *new_player, session_t peer_id,
|
2017-04-23 14:35:08 +02:00
|
|
|
bool is_singleplayer);
|
2017-01-08 11:01:35 +01:00
|
|
|
void addPlayer(RemotePlayer *player);
|
|
|
|
void removePlayer(RemotePlayer *player);
|
2017-04-23 14:35:08 +02:00
|
|
|
bool removePlayerFromDatabase(const std::string &name);
|
2017-01-08 11:01:35 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
Save and load time of day and game timer
|
|
|
|
*/
|
|
|
|
void saveMeta();
|
|
|
|
void loadMeta();
|
|
|
|
|
|
|
|
u32 addParticleSpawner(float exptime);
|
|
|
|
u32 addParticleSpawner(float exptime, u16 attached_id);
|
|
|
|
void deleteParticleSpawner(u32 id, bool remove_from_object = true);
|
|
|
|
|
|
|
|
/*
|
|
|
|
External ActiveObject interface
|
|
|
|
-------------------------------------------
|
|
|
|
*/
|
|
|
|
|
2018-12-13 20:18:54 +01:00
|
|
|
ServerActiveObject* getActiveObject(u16 id)
|
|
|
|
{
|
|
|
|
return m_ao_manager.getActiveObject(id);
|
|
|
|
}
|
2017-01-08 11:01:35 +01:00
|
|
|
|
|
|
|
/*
|
|
|
|
Add an active object to the environment.
|
|
|
|
Environment handles deletion of object.
|
|
|
|
Object may be deleted by environment immediately.
|
|
|
|
If id of object is 0, assigns a free id to it.
|
|
|
|
Returns the id of the object.
|
|
|
|
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(PlayerSAO *playersao, s16 radius,
|
|
|
|
s16 player_radius,
|
|
|
|
std::set<u16> ¤t_objects,
|
|
|
|
std::queue<u16> &added_objects);
|
|
|
|
|
|
|
|
/*
|
|
|
|
Find out what new objects have been removed from
|
|
|
|
inside a radius around a position
|
|
|
|
*/
|
|
|
|
void getRemovedActiveObjects(PlayerSAO *playersao, s16 radius,
|
|
|
|
s16 player_radius,
|
|
|
|
std::set<u16> ¤t_objects,
|
|
|
|
std::queue<u16> &removed_objects);
|
|
|
|
|
|
|
|
/*
|
|
|
|
Get the next message emitted by some active object.
|
2020-05-26 17:38:31 +02:00
|
|
|
Returns false if no messages are available, true otherwise.
|
2017-01-08 11:01:35 +01:00
|
|
|
*/
|
2020-05-26 17:38:31 +02:00
|
|
|
bool getActiveObjectMessage(ActiveObjectMessage *dest);
|
2017-01-08 11:01:35 +01:00
|
|
|
|
2016-07-23 21:11:20 +02:00
|
|
|
virtual void getSelectedActiveObjects(
|
|
|
|
const core::line3d<f32> &shootline_on_map,
|
|
|
|
std::vector<PointedThing> &objects
|
|
|
|
);
|
|
|
|
|
2017-01-08 11:01:35 +01:00
|
|
|
/*
|
|
|
|
Activate objects and dynamically modify for the dtime determined
|
|
|
|
from timestamp and additional_dtime
|
|
|
|
*/
|
|
|
|
void activateBlock(MapBlock *block, u32 additional_dtime=0);
|
|
|
|
|
|
|
|
/*
|
|
|
|
{Active,Loading}BlockModifiers
|
|
|
|
-------------------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
void addActiveBlockModifier(ActiveBlockModifier *abm);
|
|
|
|
void addLoadingBlockModifierDef(LoadingBlockModifierDef *lbm);
|
|
|
|
|
|
|
|
/*
|
|
|
|
Other stuff
|
|
|
|
-------------------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
// Script-aware node setters
|
|
|
|
bool setNode(v3s16 p, const MapNode &n);
|
|
|
|
bool removeNode(v3s16 p);
|
|
|
|
bool swapNode(v3s16 p, const MapNode &n);
|
|
|
|
|
2020-10-06 20:49:46 +02:00
|
|
|
// Find the daylight value at pos with a Depth First Search
|
|
|
|
u8 findSunlight(v3s16 pos) const;
|
|
|
|
|
2017-01-08 11:01:35 +01:00
|
|
|
// Find all active objects inside a radius around a point
|
2020-04-16 08:25:48 +02:00
|
|
|
void getObjectsInsideRadius(std::vector<ServerActiveObject *> &objects, const v3f &pos, float radius,
|
|
|
|
std::function<bool(ServerActiveObject *obj)> include_obj_cb)
|
2018-12-13 20:18:54 +01:00
|
|
|
{
|
2020-04-16 08:25:48 +02:00
|
|
|
return m_ao_manager.getObjectsInsideRadius(pos, radius, objects, include_obj_cb);
|
2018-12-13 20:18:54 +01:00
|
|
|
}
|
2021-01-22 16:09:26 +01:00
|
|
|
|
2020-12-29 16:50:09 +01:00
|
|
|
// 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);
|
|
|
|
}
|
2017-01-08 11:01:35 +01:00
|
|
|
|
|
|
|
// Clear objects, loading and going through every MapBlock
|
|
|
|
void clearObjects(ClearObjectsMode mode);
|
|
|
|
|
|
|
|
// This makes stuff happen
|
|
|
|
void step(f32 dtime);
|
|
|
|
|
2017-03-17 07:48:29 +01:00
|
|
|
u32 getGameTime() const { return m_game_time; }
|
2017-01-08 11:01:35 +01:00
|
|
|
|
|
|
|
void reportMaxLagEstimate(float f) { m_max_lag_estimate = f; }
|
|
|
|
float getMaxLagEstimate() { return m_max_lag_estimate; }
|
|
|
|
|
2021-05-30 20:24:12 +02:00
|
|
|
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);
|
2017-01-08 11:01:35 +01:00
|
|
|
|
|
|
|
// 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));
|
|
|
|
|
2017-09-27 19:47:36 +02:00
|
|
|
RemotePlayer *getPlayer(const session_t peer_id);
|
2017-01-08 11:01:35 +01:00
|
|
|
RemotePlayer *getPlayer(const char* name);
|
2020-02-12 19:49:48 +01:00
|
|
|
const std::vector<RemotePlayer *> getPlayers() const { return m_players; }
|
2017-09-09 00:36:48 +02:00
|
|
|
u32 getPlayerCount() const { return m_players.size(); }
|
2017-04-23 14:35:08 +02:00
|
|
|
|
|
|
|
static bool migratePlayersDatabase(const GameParams &game_params,
|
|
|
|
const Settings &cmd_args);
|
2018-08-05 13:13:38 +02:00
|
|
|
|
|
|
|
AuthDatabase *getAuthDatabase() { return m_auth_database; }
|
|
|
|
static bool migrateAuthDatabase(const GameParams &game_params,
|
|
|
|
const Settings &cmd_args);
|
2017-01-08 11:01:35 +01:00
|
|
|
private:
|
|
|
|
|
2018-03-16 08:52:42 +01:00
|
|
|
/**
|
|
|
|
* called if env_meta.txt doesn't exist (e.g. new world)
|
|
|
|
*/
|
|
|
|
void loadDefaultMeta();
|
|
|
|
|
2017-04-23 14:35:08 +02:00
|
|
|
static PlayerDatabase *openPlayerDatabase(const std::string &name,
|
|
|
|
const std::string &savedir, const Settings &conf);
|
2018-08-05 13:13:38 +02:00
|
|
|
static AuthDatabase *openAuthDatabase(const std::string &name,
|
|
|
|
const std::string &savedir, const Settings &conf);
|
2017-01-08 11:01:35 +01:00
|
|
|
/*
|
|
|
|
Internal ActiveObject interface
|
|
|
|
-------------------------------------------
|
|
|
|
*/
|
|
|
|
|
|
|
|
/*
|
|
|
|
Add an active object to the environment.
|
|
|
|
|
|
|
|
Called by addActiveObject.
|
|
|
|
|
|
|
|
Object may be deleted by environment immediately.
|
|
|
|
If id of object is 0, assigns a free id to it.
|
|
|
|
Returns the id of the object.
|
|
|
|
Returns 0 if not added and thus deleted.
|
|
|
|
*/
|
|
|
|
u16 addActiveObjectRaw(ServerActiveObject *object, bool set_changed, u32 dtime_s);
|
|
|
|
|
|
|
|
/*
|
2017-09-15 12:19:01 +02:00
|
|
|
Remove all objects that satisfy (isGone() && m_known_by_count==0)
|
2017-01-08 11:01:35 +01:00
|
|
|
*/
|
|
|
|
void removeRemovedObjects();
|
|
|
|
|
|
|
|
/*
|
|
|
|
Convert stored objects from block to active
|
|
|
|
*/
|
|
|
|
void activateObjects(MapBlock *block, u32 dtime_s);
|
|
|
|
|
|
|
|
/*
|
|
|
|
Convert objects that are not in active blocks to static.
|
|
|
|
|
|
|
|
If m_known_by_count != 0, active object is not deleted, but static
|
|
|
|
data is still updated.
|
|
|
|
|
|
|
|
If force_delete is set, active object is deleted nevertheless. It
|
|
|
|
shall only be set so in the destructor of the environment.
|
|
|
|
*/
|
|
|
|
void deactivateFarObjects(bool force_delete);
|
|
|
|
|
2017-09-15 12:19:01 +02:00
|
|
|
/*
|
|
|
|
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);
|
|
|
|
|
2017-01-08 11:01:35 +01:00
|
|
|
/*
|
|
|
|
Member variables
|
|
|
|
*/
|
|
|
|
|
|
|
|
// The map
|
|
|
|
ServerMap *m_map;
|
|
|
|
// Lua state
|
2017-01-21 15:02:08 +01:00
|
|
|
ServerScripting* m_script;
|
2017-01-09 20:39:22 +01:00
|
|
|
// Server definition
|
|
|
|
Server *m_server;
|
2018-12-13 20:18:54 +01:00
|
|
|
// Active Object Manager
|
|
|
|
server::ActiveObjectMgr m_ao_manager;
|
2022-09-04 04:05:07 +02:00
|
|
|
// on_mapblocks_changed map event receiver
|
|
|
|
OnMapblocksChangedReceiver m_on_mapblocks_changed_receiver;
|
2017-01-08 11:01:35 +01:00
|
|
|
// World path
|
|
|
|
const std::string m_path_world;
|
|
|
|
// Outgoing network message buffer for active objects
|
|
|
|
std::queue<ActiveObjectMessage> m_active_object_messages;
|
|
|
|
// Some timers
|
2017-06-18 19:55:15 +02:00
|
|
|
float m_send_recommended_timer = 0.0f;
|
2017-01-08 11:01:35 +01:00
|
|
|
IntervalLimiter m_object_management_interval;
|
|
|
|
// List of active blocks
|
|
|
|
ActiveBlockList m_active_blocks;
|
2022-11-11 00:25:38 +01:00
|
|
|
int m_fast_active_block_divider = 1;
|
2022-05-26 22:14:22 +02:00
|
|
|
IntervalLimiter m_active_blocks_mgmt_interval;
|
2017-01-08 11:01:35 +01:00
|
|
|
IntervalLimiter m_active_block_modifier_interval;
|
|
|
|
IntervalLimiter m_active_blocks_nodemetadata_interval;
|
2020-05-07 21:39:04 +02:00
|
|
|
// Whether the variables below have been read from file yet
|
|
|
|
bool m_meta_loaded = false;
|
2017-01-08 11:01:35 +01:00
|
|
|
// Time from the beginning of the game in seconds.
|
|
|
|
// Incremented in step().
|
2017-06-18 19:55:15 +02:00
|
|
|
u32 m_game_time = 0;
|
2017-01-08 11:01:35 +01:00
|
|
|
// A helper variable for incrementing the latter
|
2017-06-18 19:55:15 +02:00
|
|
|
float m_game_time_fraction_counter = 0.0f;
|
2017-01-08 11:01:35 +01:00
|
|
|
// Time of last clearObjects call (game time).
|
|
|
|
// When a mapblock older than this is loaded, its objects are cleared.
|
2017-06-18 19:55:15 +02:00
|
|
|
u32 m_last_clear_objects_time = 0;
|
2017-01-08 11:01:35 +01:00
|
|
|
// Active block modifiers
|
|
|
|
std::vector<ABMWithState> m_abms;
|
|
|
|
LBMManager m_lbm_mgr;
|
|
|
|
// An interval for generally sending object positions and stuff
|
2017-06-18 19:55:15 +02:00
|
|
|
float m_recommended_send_interval = 0.1f;
|
2017-01-08 11:01:35 +01:00
|
|
|
// Estimate for general maximum lag as determined by server.
|
|
|
|
// Can raise to high values like 15s with eg. map generation mods.
|
2017-06-18 19:55:15 +02:00
|
|
|
float m_max_lag_estimate = 0.1f;
|
2017-01-08 11:01:35 +01:00
|
|
|
|
|
|
|
// peer_ids in here should be unique, except that there may be many 0s
|
|
|
|
std::vector<RemotePlayer*> m_players;
|
|
|
|
|
2017-06-18 19:55:15 +02:00
|
|
|
PlayerDatabase *m_player_database = nullptr;
|
2018-08-05 13:13:38 +02:00
|
|
|
AuthDatabase *m_auth_database = nullptr;
|
2017-04-23 14:35:08 +02:00
|
|
|
|
2019-07-08 08:23:00 +02:00
|
|
|
// Pseudo random generator for shuffling, etc.
|
|
|
|
std::mt19937 m_rgen;
|
|
|
|
|
2017-01-08 11:01:35 +01:00
|
|
|
// Particles
|
|
|
|
IntervalLimiter m_particle_management_interval;
|
2017-06-04 21:00:04 +02:00
|
|
|
std::unordered_map<u32, float> m_particle_spawners;
|
|
|
|
std::unordered_map<u32, u16> m_particle_spawner_attachments;
|
2020-04-11 11:22:15 +02:00
|
|
|
|
2022-05-09 21:20:58 +02:00
|
|
|
// Environment metrics
|
|
|
|
MetricCounterPtr m_step_time_counter;
|
|
|
|
MetricGaugePtr m_active_block_gauge;
|
|
|
|
MetricGaugePtr m_active_object_gauge;
|
|
|
|
|
2020-04-11 11:22:15 +02:00
|
|
|
ServerActiveObject* createSAO(ActiveObjectType type, v3f pos, const std::string &data);
|
2017-01-08 11:01:35 +01:00
|
|
|
};
|