#include "content/mods.h"
#include "inventorymanager.h"
#include "content/subgames.h"
-#include "tileanimation.h" // struct TileAnimationParams
+#include "tileanimation.h" // TileAnimationParams
+#include "particles.h" // ParticleParams
#include "network/peerhandler.h"
#include "network/address.h"
#include "util/numeric.h"
#include "util/thread.h"
#include "util/basic_macros.h"
+#include "util/metricsbackend.h"
#include "serverenvironment.h"
#include "clientiface.h"
#include "chatmessage.h"
+#include "translation.h"
#include <string>
#include <list>
#include <map>
#include <vector>
+#include <unordered_set>
class ChatEvent;
struct ChatEventChat;
class ServerEnvironment;
struct SimpleSoundSpec;
struct CloudParams;
+struct SkyboxParams;
+struct SunParams;
+struct MoonParams;
+struct StarParams;
+struct Lighting;
class ServerThread;
class ServerModManager;
+class ServerInventoryManager;
+struct PackedValue;
enum ClientDeletionReason {
CDR_LEAVE,
struct MediaInfo
{
std::string path;
- std::string sha1_digest;
+ std::string sha1_digest; // base64-encoded
+ bool no_announce; // true: not announced in TOCLIENT_ANNOUNCE_MEDIA (at player join)
MediaInfo(const std::string &path_="",
const std::string &sha1_digest_=""):
path(path_),
- sha1_digest(sha1_digest_)
+ sha1_digest(sha1_digest_),
+ no_announce(false)
{
}
};
-struct ServerSoundParams
+// Combines the pure sound (SimpleSoundSpec) with positional information
+struct ServerPlayingSound
{
- enum Type {
- SSP_LOCAL,
- SSP_POSITIONAL,
- SSP_OBJECT
- } type = SSP_LOCAL;
- float gain = 1.0f;
- float fade = 0.0f;
- float pitch = 1.0f;
- bool loop = false;
+ SoundLocation type = SoundLocation::Local;
+
+ float gain = 1.0f; // for amplification of the base sound
float max_hear_distance = 32 * BS;
v3f pos;
u16 object = 0;
- std::string to_player = "";
+ std::string to_player;
+ std::string exclude_player;
v3f getPos(ServerEnvironment *env, bool *pos_exists) const;
-};
-struct ServerPlayingSound
-{
- ServerSoundParams params;
SimpleSoundSpec spec;
+
std::unordered_set<session_t> clients; // peer ids
};
+struct MinimapMode {
+ MinimapType type = MINIMAP_TYPE_OFF;
+ std::string label;
+ u16 size = 0;
+ std::string texture;
+ u16 scale = 1;
+};
+
+// structure for everything getClientInfo returns, for convenience
+struct ClientInfo {
+ ClientState state;
+ Address addr;
+ u32 uptime;
+ u8 ser_vers;
+ u16 prot_vers;
+ u8 major, minor, patch;
+ std::string vers_string, lang_code;
+};
+
class Server : public con::PeerHandler, public MapEventReceiver,
- public InventoryManager, public IGameDef
+ public IGameDef
{
public:
/*
bool simple_singleplayer_mode,
Address bind_addr,
bool dedicated,
- ChatInterface *iface = nullptr
+ ChatInterface *iface = nullptr,
+ std::string *on_shutdown_errmsg = nullptr
);
~Server();
DISABLE_CLASS_COPY(Server);
- void init();
void start();
void stop();
// This is mainly a way to pass the time to the server.
- // Actual processing is done in an another thread.
+ // Actual processing is done in another thread.
void step(float dtime);
// This is run by ServerThread and does the actual processing
void AsyncRunStep(bool initial_step=false);
void handleCommand_InventoryAction(NetworkPacket* pkt);
void handleCommand_ChatMessage(NetworkPacket* pkt);
void handleCommand_Damage(NetworkPacket* pkt);
- void handleCommand_Password(NetworkPacket* pkt);
void handleCommand_PlayerItem(NetworkPacket* pkt);
void handleCommand_Respawn(NetworkPacket* pkt);
void handleCommand_Interact(NetworkPacket* pkt);
void handleCommand_FirstSrp(NetworkPacket* pkt);
void handleCommand_SrpBytesA(NetworkPacket* pkt);
void handleCommand_SrpBytesM(NetworkPacket* pkt);
+ void handleCommand_HaveMedia(NetworkPacket *pkt);
void ProcessData(NetworkPacket *pkt);
This is accessed by the map, which is inside the environment,
so it shouldn't be a problem.
*/
- void onMapEditEvent(MapEditEvent *event);
-
- /*
- Shall be called with the environment and the connection locked.
- */
- Inventory* getInventory(const InventoryLocation &loc);
- void setInventoryModified(const InventoryLocation &loc);
+ void onMapEditEvent(const MapEditEvent &event);
// Connection must be locked when called
- std::wstring getStatusString();
- inline double getUptime() const { return m_uptime.m_value; }
+ std::string getStatusString();
+ inline double getUptime() const { return m_uptime_counter->get(); }
// read shutdown state
inline bool isShutdownRequested() const { return m_shutdown_state.is_requested; }
// Returns -1 if failed, sound handle on success
// Envlock
- s32 playSound(const SimpleSoundSpec &spec, const ServerSoundParams ¶ms);
+ s32 playSound(ServerPlayingSound ¶ms, bool ephemeral=false);
void stopSound(s32 handle);
void fadeSound(s32 handle, float step, float gain);
void notifyPlayer(const char *name, const std::wstring &msg);
void notifyPlayers(const std::wstring &msg);
+
void spawnParticle(const std::string &playername,
- v3f pos, v3f velocity, v3f acceleration,
- float expirationtime, float size,
- bool collisiondetection, bool collision_removal, bool object_collision,
- bool vertical, const std::string &texture,
- const struct TileAnimationParams &animation, u8 glow);
-
- u32 addParticleSpawner(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 object_collision,
- ServerActiveObject *attached,
- bool vertical, const std::string &texture,
- const std::string &playername, const struct TileAnimationParams &animation,
- u8 glow);
+ const ParticleParameters &p);
+
+ u32 addParticleSpawner(const ParticleSpawnerParameters &p,
+ ServerActiveObject *attached, const std::string &playername);
void deleteParticleSpawner(const std::string &playername, u32 id);
- // Creates or resets inventory
- Inventory *createDetachedInventory(const std::string &name,
- const std::string &player = "");
- bool removeDetachedInventory(const std::string &name);
+ bool dynamicAddMedia(std::string filepath, u32 token,
+ const std::string &to_player, bool ephemeral);
+
+ ServerInventoryManager *getInventoryMgr() const { return m_inventory_mgr.get(); }
+ void sendDetachedInventory(Inventory *inventory, const std::string &name, session_t peer_id);
// Envlock and conlock should be locked when using scriptapi
ServerScripting *getScriptIface(){ return m_script; }
virtual u16 allocateUnknownNodeId(const std::string &name);
IRollbackManager *getRollbackManager() { return m_rollback; }
virtual EmergeManager *getEmergeManager() { return m_emerge; }
+ virtual ModStorageDatabase *getModStorageDatabase() { return m_mod_storage_database; }
IWritableItemDefManager* getWritableItemDefManager();
NodeDefManager* getWritableNodeDefManager();
virtual const std::vector<ModSpec> &getMods() const;
virtual const ModSpec* getModSpec(const std::string &modname) const;
- void getModNames(std::vector<std::string> &modlist);
- std::string getBuiltinLuaPath();
+ virtual const SubgameSpec* getGameSpec() const { return &m_gamespec; }
+ static std::string getBuiltinLuaPath();
virtual std::string getWorldPath() const { return m_path_world; }
- virtual std::string getModStoragePath() const;
- inline bool isSingleplayer()
+ inline bool isSingleplayer() const
{ return m_simple_singleplayer_mode; }
inline void setAsyncFatalError(const std::string &error)
{ m_async_fatal_error.set(error); }
+ inline void setAsyncFatalError(const LuaError &e)
+ {
+ setAsyncFatalError(std::string("Lua: ") + e.what());
+ }
bool showFormspec(const char *name, const std::string &formspec, const std::string &formname);
Map & getMap() { return m_env->getMap(); }
f32 frame_speed);
void setPlayerEyeOffset(RemotePlayer *player, const v3f &first, const v3f &third);
- void setSky(RemotePlayer *player, const video::SColor &bgcolor,
- const std::string &type, const std::vector<std::string> ¶ms,
- bool &clouds);
+ void setSky(RemotePlayer *player, const SkyboxParams ¶ms);
+ void setSun(RemotePlayer *player, const SunParams ¶ms);
+ void setMoon(RemotePlayer *player, const MoonParams ¶ms);
+ void setStars(RemotePlayer *player, const StarParams ¶ms);
+
void setClouds(RemotePlayer *player, const CloudParams ¶ms);
- bool overrideDayNightRatio(RemotePlayer *player, bool do_override, float brightness);
+ void overrideDayNightRatio(RemotePlayer *player, bool do_override, float brightness);
+
+ void setLighting(RemotePlayer *player, const Lighting &lighting);
+
+ void RespawnPlayer(session_t peer_id);
/* con::PeerHandler implementation. */
void peerAdded(con::Peer *peer);
void deletingPeer(con::Peer *peer, bool timeout);
void DenySudoAccess(session_t peer_id);
- void DenyAccessVerCompliant(session_t peer_id, u16 proto_ver, AccessDeniedCode reason,
- const std::string &str_reason = "", bool reconnect = false);
void DenyAccess(session_t peer_id, AccessDeniedCode reason,
- const std::string &custom_reason = "");
+ const std::string &custom_reason = "", bool reconnect = false);
void acceptAuth(session_t peer_id, bool forSudoMode);
- void DenyAccess_Legacy(session_t peer_id, const std::wstring &reason);
void DisconnectPeer(session_t peer_id);
bool getClientConInfo(session_t peer_id, con::rtt_stat_type type, float *retval);
- bool getClientInfo(session_t peer_id, ClientState *state, u32 *uptime,
- u8* ser_vers, u16* prot_vers, u8* major, u8* minor, u8* patch,
- std::string* vers_string);
+ bool getClientInfo(session_t peer_id, ClientInfo &ret);
void printToConsoleOnly(const std::string &text);
- void SendPlayerHPOrDie(PlayerSAO *player, const PlayerHPChangeReason &reason);
+ void HandlePlayerHPChange(PlayerSAO *sao, const PlayerHPChangeReason &reason);
+ void SendPlayerHP(PlayerSAO *sao, bool effect);
void SendPlayerBreath(PlayerSAO *sao);
void SendInventory(PlayerSAO *playerSAO, bool incremental);
void SendMovePlayer(session_t peer_id);
void SendPlayerSpeed(session_t peer_id, const v3f &added_vel);
+ void SendPlayerFov(session_t peer_id);
- void sendDetachedInventories(session_t peer_id, bool incremental);
+ void SendMinimapModes(session_t peer_id,
+ std::vector<MinimapMode> &modes,
+ size_t wanted_mode);
- virtual bool registerModStorage(ModMetadata *storage);
- virtual void unregisterModStorage(const std::string &name);
+ void sendDetachedInventories(session_t peer_id, bool incremental);
bool joinModChannel(const std::string &channel);
bool leaveModChannel(const std::string &channel);
// Send block to specific player only
bool SendBlock(session_t peer_id, const v3s16 &blockpos);
+ // Get or load translations for a language
+ Translations *getTranslationLanguage(const std::string &lang_code);
+
+ static ModStorageDatabase *openModStorageDatabase(const std::string &world_path);
+
+ static ModStorageDatabase *openModStorageDatabase(const std::string &backend,
+ const std::string &world_path, const Settings &world_mt);
+
+ static bool migrateModStorageDatabase(const GameParams &game_params,
+ const Settings &cmd_args);
+
+ // Lua files registered for init of async env, pair of modname + path
+ std::vector<std::pair<std::string, std::string>> m_async_init_files;
+
+ // Data transferred into async envs at init time
+ std::unique_ptr<PackedValue> m_async_globals_data;
+
// Bind address
Address m_bind_addr;
float m_timer = 0.0f;
};
+ struct PendingDynamicMediaCallback {
+ std::string filename; // only set if media entry and file is to be deleted
+ float expiry_timer;
+ std::unordered_set<session_t> waiting_players;
+ };
+
+ // The standard library does not implement std::hash for pairs so we have this:
+ struct SBCHash {
+ size_t operator() (const std::pair<v3s16, u16> &p) const {
+ return std::hash<v3s16>()(p.first) ^ p.second;
+ }
+ };
+
+ typedef std::unordered_map<std::pair<v3s16, u16>, std::string, SBCHash> SerializedBlockCache;
+
+ void init();
+
void SendMovement(session_t peer_id);
- void SendHP(session_t peer_id, u16 hp);
+ void SendHP(session_t peer_id, u16 hp, bool effect);
void SendBreath(session_t peer_id, u16 breath);
void SendAccessDenied(session_t peer_id, AccessDeniedCode reason,
const std::string &custom_reason, bool reconnect = false);
void SendNodeDef(session_t peer_id, const NodeDefManager *nodedef,
u16 protocol_version);
- /* mark blocks not sent for all clients */
- void SetBlocksNotSent(std::map<v3s16, MapBlock *>& block);
-
virtual void SendChatMessage(session_t peer_id, const ChatMessage &message);
void SendTimeOfDay(session_t peer_id, u16 time, f32 time_speed);
- void SendPlayerHP(session_t peer_id);
void SendLocalPlayerAnimations(session_t peer_id, v2s32 animation_frames[4],
f32 animation_speed);
void SendHUDChange(session_t peer_id, u32 id, HudElementStat stat, void *value);
void SendHUDSetFlags(session_t peer_id, u32 flags, u32 mask);
void SendHUDSetParam(session_t peer_id, u16 param, const std::string &value);
- void SendSetSky(session_t peer_id, const video::SColor &bgcolor,
- const std::string &type, const std::vector<std::string> ¶ms,
- bool &clouds);
+ void SendSetSky(session_t peer_id, const SkyboxParams ¶ms);
+ void SendSetSun(session_t peer_id, const SunParams ¶ms);
+ void SendSetMoon(session_t peer_id, const MoonParams ¶ms);
+ void SendSetStars(session_t peer_id, const StarParams ¶ms);
void SendCloudParams(session_t peer_id, const CloudParams ¶ms);
void SendOverrideDayNightRatio(session_t peer_id, bool do_override, float ratio);
+ void SendSetLighting(session_t peer_id, const Lighting &lighting);
void broadcastModChannelMessage(const std::string &channel,
const std::string &message, session_t from_peer);
void sendAddNode(v3s16 p, MapNode n,
std::unordered_set<u16> *far_players = nullptr,
float far_d_nodes = 100, bool remove_metadata = true);
+ void sendNodeChangePkt(NetworkPacket &pkt, v3s16 block_pos,
+ v3f p, float far_d_nodes, std::unordered_set<u16> *far_players);
- void sendMetadataChanged(const std::list<v3s16> &meta_updates,
+ void sendMetadataChanged(const std::unordered_set<v3s16> &positions,
float far_d_nodes = 100);
// Environment and Connection must be locked when called
- void SendBlockNoLock(session_t peer_id, MapBlock *block, u8 ver, u16 net_proto_version);
+ // `cache` may only be very short lived! (invalidation not handeled)
+ void SendBlockNoLock(session_t peer_id, MapBlock *block, u8 ver,
+ u16 net_proto_version, SerializedBlockCache *cache = nullptr);
// Sends blocks to clients (locks env and con on its own)
void SendBlocks(float dtime);
+ bool addMediaFile(const std::string &filename, const std::string &filepath,
+ std::string *filedata = nullptr, std::string *digest = nullptr);
void fillMediaCache();
void sendMediaAnnouncement(session_t peer_id, const std::string &lang_code);
void sendRequestedMedia(session_t peer_id,
const std::vector<std::string> &tosend);
-
- void sendDetachedInventory(const std::string &name, session_t peer_id);
+ void stepPendingDynMediaCallbacks(float dtime);
// Adds a ParticleSpawner on peer with peer_id (PEER_ID_INEXISTENT == all)
void SendAddParticleSpawner(session_t 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 object_collision,
- u16 attached_id,
- bool vertical, const std::string &texture, u32 id,
- const struct TileAnimationParams &animation, u8 glow);
+ const ParticleSpawnerParameters &p, u16 attached_id, u32 id);
void SendDeleteParticleSpawner(session_t peer_id, u32 id);
// Spawns particle on peer with peer_id (PEER_ID_INEXISTENT == all)
void SendSpawnParticle(session_t peer_id, u16 protocol_version,
- v3f pos, v3f velocity, v3f acceleration,
- float expirationtime, float size,
- bool collisiondetection, bool collision_removal, bool object_collision,
- bool vertical, const std::string &texture,
- const struct TileAnimationParams &animation, u8 glow);
+ const ParticleParameters &p);
- u32 SendActiveObjectRemoveAdd(session_t peer_id, const std::string &datas);
+ void SendActiveObjectRemoveAdd(RemoteClient *client, PlayerSAO *playersao);
void SendActiveObjectMessages(session_t peer_id, const std::string &datas,
bool reliable = true);
void SendCSMRestrictionFlags(session_t peer_id);
Something random
*/
- void DiePlayer(session_t peer_id, const PlayerHPChangeReason &reason);
- void RespawnPlayer(session_t peer_id);
+ void HandlePlayerDeath(PlayerSAO* sao, const PlayerHPChangeReason &reason);
void DeleteClient(session_t peer_id, ClientDeletionReason reason);
void UpdateCrafting(RemotePlayer *player);
bool checkInteractDistance(RemotePlayer *player, const f32 d, const std::string &what);
void handleChatInterfaceEvent(ChatEvent *evt);
// This returns the answer to the sender of wmessage, or "" if there is none
- std::wstring handleChat(const std::string &name, const std::wstring &wname,
- std::wstring wmessage_input,
- bool check_shout_priv = false,
- RemotePlayer *player = NULL);
+ std::wstring handleChat(const std::string &name, std::wstring wmessage_input,
+ bool check_shout_priv = false, RemotePlayer *player = nullptr);
void handleAdminChat(const ChatEventChat *evt);
// When called, connection mutex should be locked
/*
Variables
*/
-
// World directory
std::string m_path_world;
// Subgame specification
u16 m_max_chatmessage_length;
// For "dedicated" server list flag
bool m_dedicated;
+ Settings *m_game_settings = nullptr;
// Thread can set; step() will throw as ServerError
MutexedVariable<std::string> m_async_fatal_error;
// Environment
ServerEnvironment *m_env = nullptr;
+ // Reference to the server map until ServerEnvironment is initialized
+ // after that this variable must be a nullptr
+ ServerMap *m_startup_server_map = nullptr;
+
// server connection
std::shared_ptr<con::Connection> m_con;
// Craft definition manager
IWritableCraftDefManager *m_craftdef;
- // Event manager
- EventManager *m_event;
-
// Mods
std::unique_ptr<ServerModManager> m_modmgr;
+ std::unordered_map<std::string, Translations> server_translations;
+
/*
Threads
*/
-
// A buffer for time steps
// step() increments and AsyncRunStep() run by m_thread reads it.
float m_step_dtime = 0.0f;
std::mutex m_step_dtime_mutex;
- // current server step lag counter
- float m_lag;
-
// The server mainly operates in this thread
ServerThread *m_thread = nullptr;
/*
Time related stuff
*/
-
// Timer for sending time of day over network
float m_time_of_day_send_timer = 0.0f;
- // Uptime of server in seconds
- MutexedVariable<double> m_uptime;
+
/*
- Client interface
- */
+ Client interface
+ */
ClientInterface m_clients;
/*
ChatInterface *m_admin_chat;
std::string m_admin_nick;
+ // if a mod-error occurs in the on_shutdown callback, the error message will
+ // be written into this
+ std::string *const m_on_shutdown_errmsg;
+
/*
Map edit event queue. Automatically receives all map edits.
The constructor of this class registers us to receive them through
// media files known to server
std::unordered_map<std::string, MediaInfo> m_media;
+ // pending dynamic media callbacks, clients inform the server when they have a file fetched
+ std::unordered_map<u32, PendingDynamicMediaCallback> m_pending_dyn_media;
+ float m_step_pending_dyn_media_timer = 0.0f;
+
/*
Sounds
*/
std::unordered_map<s32, ServerPlayingSound> m_playing_sounds;
- s32 m_next_sound_id = 0;
+ s32 m_next_sound_id = 0; // positive values only
+ s32 nextSoundId();
- /*
- Detached inventories (behind m_env_mutex)
- */
- // 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;
-
- std::unordered_map<std::string, ModMetadata *> m_mod_storages;
+ ModStorageDatabase *m_mod_storage_database = nullptr;
float m_mod_storage_save_timer = 10.0f;
// CSM restrictions byteflag
// ModChannel manager
std::unique_ptr<ModChannelMgr> m_modchannel_mgr;
+
+ // Inventory manager
+ std::unique_ptr<ServerInventoryManager> m_inventory_mgr;
+
+ // Global server metrics backend
+ std::unique_ptr<MetricsBackend> m_metrics_backend;
+
+ // Server metrics
+ MetricCounterPtr m_uptime_counter;
+ MetricGaugePtr m_player_gauge;
+ MetricGaugePtr m_timeofday_gauge;
+ MetricGaugePtr m_lag_gauge;
+ MetricCounterPtr m_aom_buffer_counter[2]; // [0] = rel, [1] = unrel
+ MetricCounterPtr m_packet_recv_counter;
+ MetricCounterPtr m_packet_recv_processed_counter;
+ MetricCounterPtr m_map_edit_event_counter;
};
/*
projects / minetest.git / blobdiff