51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
-#ifndef SERVER_HEADER
-#define SERVER_HEADER
+#pragma once
-#include "network/connection.h"
#include "irr_v3d.h"
#include "map.h"
#include "hud.h"
#include "gamedef.h"
#include "serialization.h" // For SER_FMT_VER_INVALID
-#include "mods.h"
+#include "content/mods.h"
#include "inventorymanager.h"
-#include "subgame.h"
+#include "content/subgames.h"
+#include "tileanimation.h" // struct TileAnimationParams
+#include "network/peerhandler.h"
+#include "network/address.h"
#include "util/numeric.h"
#include "util/thread.h"
-#include "environment.h"
-#include "chat_interface.h"
+#include "util/basic_macros.h"
+#include "serverenvironment.h"
#include "clientiface.h"
-#include "player.h"
-#include "network/networkpacket.h"
+#include "chatmessage.h"
#include <string>
#include <list>
#include <map>
#include <vector>
-#define PP(x) "("<<(x).X<<","<<(x).Y<<","<<(x).Z<<")"
-
+class ChatEvent;
+struct ChatEventChat;
+struct ChatInterface;
class IWritableItemDefManager;
-class IWritableNodeDefManager;
+class NodeDefManager;
class IWritableCraftDefManager;
class BanManager;
class EventManager;
class Inventory;
+class ModChannelMgr;
+class RemotePlayer;
class PlayerSAO;
+struct PlayerHPChangeReason;
class IRollbackManager;
struct RollbackAction;
class EmergeManager;
-class GameScripting;
+class ServerScripting;
class ServerEnvironment;
struct SimpleSoundSpec;
+struct CloudParams;
class ServerThread;
+class ServerModManager;
enum ClientDeletionReason {
CDR_LEAVE,
CDR_DENY
};
-class MapEditEventIgnorer
-{
-public:
- MapEditEventIgnorer(bool *flag):
- m_flag(flag)
- {
- if(*m_flag == false)
- *m_flag = true;
- else
- m_flag = NULL;
- }
-
- ~MapEditEventIgnorer()
- {
- if(m_flag)
- {
- assert(*m_flag);
- *m_flag = false;
- }
- }
-
-private:
- bool *m_flag;
-};
-
-class MapEditEventAreaIgnorer
-{
-public:
- MapEditEventAreaIgnorer(VoxelArea *ignorevariable, const VoxelArea &a):
- m_ignorevariable(ignorevariable)
- {
- if(m_ignorevariable->getVolume() == 0)
- *m_ignorevariable = a;
- else
- m_ignorevariable = NULL;
- }
-
- ~MapEditEventAreaIgnorer()
- {
- if(m_ignorevariable)
- {
- assert(m_ignorevariable->getVolume() != 0);
- *m_ignorevariable = VoxelArea();
- }
- }
-
-private:
- VoxelArea *m_ignorevariable;
-};
-
struct MediaInfo
{
std::string path;
struct ServerSoundParams
{
- float gain;
- std::string to_player;
- enum Type{
- SSP_LOCAL=0,
- SSP_POSITIONAL=1,
- SSP_OBJECT=2
- } type;
+ 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;
+ float max_hear_distance = 32 * BS;
v3f pos;
- u16 object;
- float max_hear_distance;
- bool loop;
-
- ServerSoundParams():
- gain(1.0),
- to_player(""),
- type(SSP_LOCAL),
- pos(0,0,0),
- object(0),
- max_hear_distance(32*BS),
- loop(false)
- {}
+ u16 object = 0;
+ std::string to_player = "";
+ std::string exclude_player = "";
v3f getPos(ServerEnvironment *env, bool *pos_exists) const;
};
struct ServerPlayingSound
{
ServerSoundParams params;
- UNORDERED_SET<u16> clients; // peer ids
+ SimpleSoundSpec spec;
+ std::unordered_set<session_t> clients; // peer ids
};
class Server : public con::PeerHandler, public MapEventReceiver,
const std::string &path_world,
const SubgameSpec &gamespec,
bool simple_singleplayer_mode,
- bool ipv6,
- ChatInterface *iface = NULL
+ Address bind_addr,
+ bool dedicated,
+ ChatInterface *iface = nullptr
);
~Server();
- void start(Address bind_addr);
+ 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.
// This is run by ServerThread and does the actual processing
void AsyncRunStep(bool initial_step=false);
void Receive();
- PlayerSAO* StageTwoClientInit(u16 peer_id);
+ PlayerSAO* StageTwoClientInit(session_t peer_id);
/*
* Command Handlers
void handleCommand_Null(NetworkPacket* pkt) {};
void handleCommand_Deprecated(NetworkPacket* pkt);
void handleCommand_Init(NetworkPacket* pkt);
- void handleCommand_Init_Legacy(NetworkPacket* pkt);
void handleCommand_Init2(NetworkPacket* pkt);
+ void handleCommand_ModChannelJoin(NetworkPacket *pkt);
+ void handleCommand_ModChannelLeave(NetworkPacket *pkt);
+ void handleCommand_ModChannelMsg(NetworkPacket *pkt);
void handleCommand_RequestMedia(NetworkPacket* pkt);
- void handleCommand_ReceivedMedia(NetworkPacket* pkt);
void handleCommand_ClientReady(NetworkPacket* pkt);
void handleCommand_GotBlocks(NetworkPacket* pkt);
void handleCommand_PlayerPos(NetworkPacket* pkt);
void handleCommand_InventoryAction(NetworkPacket* pkt);
void handleCommand_ChatMessage(NetworkPacket* pkt);
void handleCommand_Damage(NetworkPacket* pkt);
- void handleCommand_Breath(NetworkPacket* pkt);
void handleCommand_Password(NetworkPacket* pkt);
void handleCommand_PlayerItem(NetworkPacket* pkt);
void handleCommand_Respawn(NetworkPacket* pkt);
void ProcessData(NetworkPacket *pkt);
- void Send(NetworkPacket* pkt);
+ void Send(NetworkPacket *pkt);
+ void Send(session_t peer_id, NetworkPacket *pkt);
+
+ // Helper for handleCommand_PlayerPos and handleCommand_Interact
+ void process_PlayerPos(RemotePlayer *player, PlayerSAO *playersao,
+ NetworkPacket *pkt);
// Both setter and getter need no envlock,
// can be called freely from threads
This is accessed by the map, which is inside the environment,
so it shouldn't be a problem.
*/
- void onMapEditEvent(MapEditEvent *event);
+ void onMapEditEvent(const MapEditEvent &event);
/*
Shall be called with the environment and the connection locked.
*/
Inventory* getInventory(const InventoryLocation &loc);
- void setInventoryModified(const InventoryLocation &loc, bool playerSend = true);
+ void setInventoryModified(const InventoryLocation &loc);
// Connection must be locked when called
std::wstring getStatusString();
+ inline double getUptime() const { return m_uptime.m_value; }
// read shutdown state
- inline bool getShutdownRequested() const { return m_shutdown_requested; }
+ inline bool isShutdownRequested() const { return m_shutdown_state.is_requested; }
// request server to shutdown
- void requestShutdown(const std::string &msg, bool reconnect)
- {
- m_shutdown_requested = true;
- m_shutdown_msg = msg;
- m_shutdown_ask_reconnect = reconnect;
- }
+ void requestShutdown(const std::string &msg, bool reconnect, float delay = 0.0f);
// Returns -1 if failed, sound handle on success
// Envlock
- s32 playSound(const SimpleSoundSpec &spec, const ServerSoundParams ¶ms);
+ s32 playSound(const SimpleSoundSpec &spec, const ServerSoundParams ¶ms,
+ bool ephemeral=false);
void stopSound(s32 handle);
+ void fadeSound(s32 handle, float step, float gain);
// Envlock
std::set<std::string> getPlayerEffectivePrivs(const std::string &name);
bool checkPriv(const std::string &name, const std::string &priv);
void reportPrivsModified(const std::string &name=""); // ""=all
void reportInventoryFormspecModified(const std::string &name);
+ void reportFormspecPrependModified(const std::string &name);
void setIpBanned(const std::string &ip, const std::string &name);
void unsetIpBanned(const std::string &ip_or_name);
void spawnParticle(const std::string &playername,
v3f pos, v3f velocity, v3f acceleration,
float expirationtime, float size,
- bool collisiondetection, bool collision_removal,
- bool vertical, const std::string &texture);
+ 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 minacc, v3f maxacc,
float minexptime, float maxexptime,
float minsize, float maxsize,
- bool collisiondetection, bool collision_removal,
+ bool collisiondetection, bool collision_removal, bool object_collision,
+ ServerActiveObject *attached,
bool vertical, const std::string &texture,
- const std::string &playername);
+ const std::string &playername, const struct TileAnimationParams &animation,
+ u8 glow);
void deleteParticleSpawner(const std::string &playername, u32 id);
- void deleteParticleSpawnerAll(u32 id);
// Creates or resets inventory
- Inventory* createDetachedInventory(const std::string &name);
+ Inventory *createDetachedInventory(const std::string &name,
+ const std::string &player = "");
+ bool removeDetachedInventory(const std::string &name);
// Envlock and conlock should be locked when using scriptapi
- GameScripting *getScriptIface(){ return m_script; }
+ ServerScripting *getScriptIface(){ return m_script; }
// actions: time-reversed list
// Return value: success/failure
// IGameDef interface
// Under envlock
virtual IItemDefManager* getItemDefManager();
- virtual INodeDefManager* getNodeDefManager();
+ virtual const NodeDefManager* getNodeDefManager();
virtual ICraftDefManager* getCraftDefManager();
- virtual ITextureSource* getTextureSource();
- virtual IShaderSource* getShaderSource();
virtual u16 allocateUnknownNodeId(const std::string &name);
- virtual ISoundManager* getSoundManager();
- virtual MtEventManager* getEventManager();
- virtual scene::ISceneManager* getSceneManager();
- virtual IRollbackManager *getRollbackManager() { return m_rollback; }
+ IRollbackManager *getRollbackManager() { return m_rollback; }
virtual EmergeManager *getEmergeManager() { return m_emerge; }
IWritableItemDefManager* getWritableItemDefManager();
- IWritableNodeDefManager* getWritableNodeDefManager();
+ NodeDefManager* getWritableNodeDefManager();
IWritableCraftDefManager* getWritableCraftDefManager();
- const ModSpec* getModSpec(const std::string &modname) const;
+ 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();
- inline std::string getWorldPath() const { return m_path_world; }
+ virtual std::string getWorldPath() const { return m_path_world; }
+ virtual std::string getModStoragePath() const;
inline bool isSingleplayer()
{ return m_simple_singleplayer_mode; }
bool showFormspec(const char *name, const std::string &formspec, const std::string &formname);
Map & getMap() { return m_env->getMap(); }
ServerEnvironment & getEnv() { return *m_env; }
+ v3f findSpawnPos();
- u32 hudAdd(Player *player, HudElement *element);
- bool hudRemove(Player *player, u32 id);
- bool hudChange(Player *player, u32 id, HudElementStat stat, void *value);
+ u32 hudAdd(RemotePlayer *player, HudElement *element);
+ bool hudRemove(RemotePlayer *player, u32 id);
+ bool hudChange(RemotePlayer *player, u32 id, HudElementStat stat, void *value);
bool hudSetFlags(RemotePlayer *player, u32 flags, u32 mask);
bool hudSetHotbarItemcount(RemotePlayer *player, s32 hotbar_itemcount);
- s32 hudGetHotbarItemcount(RemotePlayer *player) const
- { return player->getHotbarItemcount(); }
- void hudSetHotbarImage(Player *player, std::string name);
- std::string hudGetHotbarImage(Player *player);
- void hudSetHotbarSelectedImage(Player *player, std::string name);
- std::string hudGetHotbarSelectedImage(Player *player);
+ void hudSetHotbarImage(RemotePlayer *player, const std::string &name);
+ void hudSetHotbarSelectedImage(RemotePlayer *player, const std::string &name);
- inline Address getPeerAddress(u16 peer_id)
- { return m_con.GetPeerAddress(peer_id); }
+ Address getPeerAddress(session_t peer_id);
- bool setLocalPlayerAnimations(Player *player, v2s32 animation_frames[4], f32 frame_speed);
- bool setPlayerEyeOffset(Player *player, v3f first, v3f third);
+ void setLocalPlayerAnimations(RemotePlayer *player, v2s32 animation_frames[4],
+ f32 frame_speed);
+ void setPlayerEyeOffset(RemotePlayer *player, const v3f &first, const v3f &third);
- bool setSky(Player *player, const video::SColor &bgcolor,
- const std::string &type, const std::vector<std::string> ¶ms);
+ void setSky(RemotePlayer *player, const video::SColor &bgcolor,
+ const std::string &type, const std::vector<std::string> ¶ms,
+ bool &clouds);
+ void setClouds(RemotePlayer *player, const CloudParams ¶ms);
bool overrideDayNightRatio(RemotePlayer *player, bool do_override, float brightness);
void peerAdded(con::Peer *peer);
void deletingPeer(con::Peer *peer, bool timeout);
- void DenySudoAccess(u16 peer_id);
- void DenyAccessVerCompliant(u16 peer_id, u16 proto_ver, AccessDeniedCode reason,
+ 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(u16 peer_id, AccessDeniedCode reason, const std::string &custom_reason="");
- void acceptAuth(u16 peer_id, bool forSudoMode);
- void DenyAccess_Legacy(u16 peer_id, const std::wstring &reason);
- bool getClientConInfo(u16 peer_id, con::rtt_stat_type type,float* retval);
- bool getClientInfo(u16 peer_id,ClientState* state, u32* uptime,
+ void DenyAccess(session_t peer_id, AccessDeniedCode reason,
+ const std::string &custom_reason = "");
+ 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);
void printToConsoleOnly(const std::string &text);
- void SendPlayerHPOrDie(PlayerSAO *player);
- void SendPlayerBreath(u16 peer_id);
- void SendInventory(PlayerSAO* playerSAO);
- void SendMovePlayer(u16 peer_id);
+ void SendPlayerHPOrDie(PlayerSAO *player, const PlayerHPChangeReason &reason);
+ 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);
+
+ virtual bool registerModStorage(ModMetadata *storage);
+ virtual void unregisterModStorage(const std::string &name);
+
+ bool joinModChannel(const std::string &channel);
+ bool leaveModChannel(const std::string &channel);
+ bool sendModChannelMessage(const std::string &channel, const std::string &message);
+ ModChannel *getModChannel(const std::string &channel);
+
+ // Send block to specific player only
+ bool SendBlock(session_t peer_id, const v3s16 &blockpos);
// Bind address
Address m_bind_addr;
// Environment mutex (envlock)
- Mutex m_env_mutex;
+ std::mutex m_env_mutex;
private:
-
friend class EmergeThread;
friend class RemoteClient;
-
- void SendMovement(u16 peer_id);
- void SendHP(u16 peer_id, u8 hp);
- void SendBreath(u16 peer_id, u16 breath);
- void SendAccessDenied(u16 peer_id, AccessDeniedCode reason,
+ friend class TestServerShutdownState;
+
+ struct ShutdownState {
+ friend class TestServerShutdownState;
+ public:
+ bool is_requested = false;
+ bool should_reconnect = false;
+ std::string message;
+
+ void reset();
+ void trigger(float delay, const std::string &msg, bool reconnect);
+ void tick(float dtime, Server *server);
+ std::wstring getShutdownTimerMessage() const;
+ bool isTimerRunning() const { return m_timer > 0.0f; }
+ private:
+ float m_timer = 0.0f;
+ };
+
+ void SendMovement(session_t peer_id);
+ void SendHP(session_t peer_id, u16 hp);
+ 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 SendAccessDenied_Legacy(u16 peer_id, const std::wstring &reason);
- void SendDeathscreen(u16 peer_id,bool set_camera_point_target, v3f camera_point_target);
- void SendItemDef(u16 peer_id,IItemDefManager *itemdef, u16 protocol_version);
- void SendNodeDef(u16 peer_id,INodeDefManager *nodedef, u16 protocol_version);
+ void SendAccessDenied_Legacy(session_t peer_id, const std::wstring &reason);
+ void SendDeathscreen(session_t peer_id, bool set_camera_point_target,
+ v3f camera_point_target);
+ void SendItemDef(session_t peer_id, IItemDefManager *itemdef, u16 protocol_version);
+ 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);
- void SendChatMessage(u16 peer_id, const std::wstring &message);
- void SendTimeOfDay(u16 peer_id, u16 time, f32 time_speed);
- void SendPlayerHP(u16 peer_id);
-
- void SendLocalPlayerAnimations(u16 peer_id, v2s32 animation_frames[4], f32 animation_speed);
- void SendEyeOffset(u16 peer_id, v3f first, v3f third);
- void SendPlayerPrivileges(u16 peer_id);
- void SendPlayerInventoryFormspec(u16 peer_id);
- void SendShowFormspecMessage(u16 peer_id, const std::string &formspec, const std::string &formname);
- void SendHUDAdd(u16 peer_id, u32 id, HudElement *form);
- void SendHUDRemove(u16 peer_id, u32 id);
- void SendHUDChange(u16 peer_id, u32 id, HudElementStat stat, void *value);
- void SendHUDSetFlags(u16 peer_id, u32 flags, u32 mask);
- void SendHUDSetParam(u16 peer_id, u16 param, const std::string &value);
- void SendSetSky(u16 peer_id, const video::SColor &bgcolor,
- const std::string &type, const std::vector<std::string> ¶ms);
- void SendOverrideDayNightRatio(u16 peer_id, bool do_override, float ratio);
+ 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 SendEyeOffset(session_t peer_id, v3f first, v3f third);
+ void SendPlayerPrivileges(session_t peer_id);
+ void SendPlayerInventoryFormspec(session_t peer_id);
+ void SendPlayerFormspecPrepend(session_t peer_id);
+ void SendShowFormspecMessage(session_t peer_id, const std::string &formspec,
+ const std::string &formname);
+ void SendHUDAdd(session_t peer_id, u32 id, HudElement *form);
+ void SendHUDRemove(session_t peer_id, u32 id);
+ 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 SendCloudParams(session_t peer_id, const CloudParams ¶ms);
+ void SendOverrideDayNightRatio(session_t peer_id, bool do_override, float ratio);
+ void broadcastModChannelMessage(const std::string &channel,
+ const std::string &message, session_t from_peer);
/*
Send a node removal/addition event to all clients except ignore_id.
far_d_nodes are ignored and their peer_ids are added to far_players
*/
// Envlock and conlock should be locked when calling these
- void sendRemoveNode(v3s16 p, u16 ignore_id=0,
- std::vector<u16> *far_players=NULL, float far_d_nodes=100);
- void sendAddNode(v3s16 p, MapNode n, u16 ignore_id=0,
- std::vector<u16> *far_players=NULL, float far_d_nodes=100,
- bool remove_metadata=true);
- void setBlockNotSent(v3s16 p);
+ void sendRemoveNode(v3s16 p, std::unordered_set<u16> *far_players = nullptr,
+ float far_d_nodes = 100);
+ void sendAddNode(v3s16 p, MapNode n,
+ std::unordered_set<u16> *far_players = nullptr,
+ float far_d_nodes = 100, bool remove_metadata = true);
+
+ void sendMetadataChanged(const std::list<v3s16> &meta_updates,
+ float far_d_nodes = 100);
// Environment and Connection must be locked when called
- void SendBlockNoLock(u16 peer_id, MapBlock *block, u8 ver, u16 net_proto_version);
+ void SendBlockNoLock(session_t peer_id, MapBlock *block, u8 ver, u16 net_proto_version);
// Sends blocks to clients (locks env and con on its own)
void SendBlocks(float dtime);
void fillMediaCache();
- void sendMediaAnnouncement(u16 peer_id);
- void sendRequestedMedia(u16 peer_id,
+ 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, u16 peer_id);
- void sendDetachedInventories(u16 peer_id);
+ void sendDetachedInventory(const std::string &name, session_t peer_id);
// Adds a ParticleSpawner on peer with peer_id (PEER_ID_INEXISTENT == all)
- void SendAddParticleSpawner(u16 peer_id, u16 amount, float spawntime,
+ 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 vertical, const std::string &texture, u32 id);
+ 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);
- void SendDeleteParticleSpawner(u16 peer_id, u32 id);
+ void SendDeleteParticleSpawner(session_t peer_id, u32 id);
// Spawns particle on peer with peer_id (PEER_ID_INEXISTENT == all)
- void SendSpawnParticle(u16 peer_id,
+ 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 vertical, const std::string &texture);
+ bool collisiondetection, bool collision_removal, bool object_collision,
+ bool vertical, const std::string &texture,
+ const struct TileAnimationParams &animation, u8 glow);
+
+ 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);
- u32 SendActiveObjectRemoveAdd(u16 peer_id, const std::string &datas);
- void SendActiveObjectMessages(u16 peer_id, const std::string &datas, bool reliable = true);
/*
Something random
*/
- void DiePlayer(u16 peer_id);
- void RespawnPlayer(u16 peer_id);
- void DeleteClient(u16 peer_id, ClientDeletionReason reason);
+ void DiePlayer(session_t peer_id, const PlayerHPChangeReason &reason);
+ void RespawnPlayer(session_t peer_id);
+ 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,
- const std::wstring &wmessage,
+ std::wstring wmessage_input,
bool check_shout_priv = false,
RemotePlayer *player = NULL);
void handleAdminChat(const ChatEventChat *evt);
- v3f findSpawnPos();
-
// When called, connection mutex should be locked
- RemoteClient* getClient(u16 peer_id,ClientState state_min=CS_Active);
- RemoteClient* getClientNoEx(u16 peer_id,ClientState state_min=CS_Active);
+ RemoteClient* getClient(session_t peer_id, ClientState state_min = CS_Active);
+ RemoteClient* getClientNoEx(session_t peer_id, ClientState state_min = CS_Active);
// When called, environment mutex should be locked
- std::string getPlayerName(u16 peer_id);
- PlayerSAO* getPlayerSAO(u16 peer_id);
+ std::string getPlayerName(session_t peer_id);
+ PlayerSAO *getPlayerSAO(session_t peer_id);
/*
Get a player from memory or creates one.
Call with env and con locked.
*/
- PlayerSAO *emergePlayer(const char *name, u16 peer_id, u16 proto_version);
+ PlayerSAO *emergePlayer(const char *name, session_t peer_id, u16 proto_version);
void handlePeerChanges();
/*
Variables
*/
-
// World directory
std::string m_path_world;
// Subgame specification
// functionality
bool m_simple_singleplayer_mode;
u16 m_max_chatmessage_length;
+ // For "dedicated" server list flag
+ bool m_dedicated;
// Thread can set; step() will throw as ServerError
MutexedVariable<std::string> m_async_fatal_error;
// Some timers
- float m_liquid_transform_timer;
- float m_liquid_transform_every;
- float m_print_info_timer;
- float m_masterserver_timer;
- float m_objectdata_timer;
- float m_emergethread_trigger_timer;
- float m_savemap_timer;
+ float m_liquid_transform_timer = 0.0f;
+ float m_liquid_transform_every = 1.0f;
+ float m_masterserver_timer = 0.0f;
+ float m_emergethread_trigger_timer = 0.0f;
+ float m_savemap_timer = 0.0f;
IntervalLimiter m_map_timer_and_unload_interval;
// Environment
- ServerEnvironment *m_env;
+ ServerEnvironment *m_env = nullptr;
// server connection
- con::Connection m_con;
+ std::shared_ptr<con::Connection> m_con;
// Ban checking
- BanManager *m_banmanager;
+ BanManager *m_banmanager = nullptr;
// Rollback manager (behind m_env_mutex)
- IRollbackManager *m_rollback;
- bool m_enable_rollback_recording; // Updated once in a while
+ IRollbackManager *m_rollback = nullptr;
// Emerge manager
- EmergeManager *m_emerge;
+ EmergeManager *m_emerge = nullptr;
// Scripting
// Envlock and conlock should be locked when using Lua
- GameScripting *m_script;
+ ServerScripting *m_script = nullptr;
// Item definition manager
IWritableItemDefManager *m_itemdef;
// Node definition manager
- IWritableNodeDefManager *m_nodedef;
+ NodeDefManager *m_nodedef;
// Craft definition manager
IWritableCraftDefManager *m_craftdef;
EventManager *m_event;
// Mods
- std::vector<ModSpec> m_mods;
+ std::unique_ptr<ServerModManager> m_modmgr;
/*
Threads
*/
-
// A buffer for time steps
// step() increments and AsyncRunStep() run by m_thread reads it.
- float m_step_dtime;
- Mutex m_step_dtime_mutex;
+ 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;
+ ServerThread *m_thread = nullptr;
/*
Time related stuff
*/
-
// Timer for sending time of day over network
- float m_time_of_day_send_timer;
+ 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;
/*
*/
std::queue<con::PeerChange> m_peer_change_queue;
+ std::unordered_map<session_t, std::string> m_formspec_state_data;
+
/*
Random stuff
*/
- bool m_shutdown_requested;
- std::string m_shutdown_msg;
- bool m_shutdown_ask_reconnect;
+ ShutdownState m_shutdown_state;
ChatInterface *m_admin_chat;
std::string m_admin_nick;
This is behind m_env_mutex
*/
std::queue<MapEditEvent*> m_unsent_map_edit_queue;
- /*
- Set to true when the server itself is modifying the map and does
- all sending of information by itself.
- This is behind m_env_mutex
- */
- bool m_ignore_map_edit_events;
/*
If a non-empty area, map edit events contained within are left
unsent. Done at map generation time to speed up editing of the
This is behind m_env_mutex
*/
VoxelArea m_ignore_map_edit_events_area;
- /*
- If set to !=0, the incoming MapEditEvents are modified to have
- this peed id as the disabled recipient
- This is behind m_env_mutex
- */
- u16 m_ignore_map_edit_events_peer_id;
// media files known to server
- UNORDERED_MAP<std::string, MediaInfo> m_media;
+ std::unordered_map<std::string, MediaInfo> m_media;
/*
Sounds
*/
- UNORDERED_MAP<s32, ServerPlayingSound> m_playing_sounds;
- s32 m_next_sound_id;
+ std::unordered_map<s32, ServerPlayingSound> m_playing_sounds;
+ 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;
- DISABLE_CLASS_COPY(Server);
+ std::unordered_map<std::string, ModMetadata *> m_mod_storages;
+ float m_mod_storage_save_timer = 10.0f;
+
+ // CSM restrictions byteflag
+ u64 m_csm_restriction_flags = CSMRestrictionFlags::CSM_RF_NONE;
+ u32 m_csm_restriction_noderange = 8;
+
+ // ModChannel manager
+ std::unique_ptr<ModChannelMgr> m_modchannel_mgr;
};
/*
Shuts down when kill is set to true.
*/
void dedicated_server_loop(Server &server, bool &kill);
-
-#endif
-