2010-11-29 21:13:04 +03:00
|
|
|
/*
|
2013-02-24 21:40:43 +04:00
|
|
|
Minetest
|
2013-02-24 22:38:45 +04:00
|
|
|
Copyright (C) 2010-2013 celeron55, Perttu Ahola <celeron55@gmail.com>
|
2010-11-29 21:13:04 +03:00
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
2012-06-05 18:56:56 +04:00
|
|
|
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
|
2010-11-29 21:13:04 +03:00
|
|
|
(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
|
2012-06-05 18:56:56 +04:00
|
|
|
GNU Lesser General Public License for more details.
|
2010-11-29 21:13:04 +03:00
|
|
|
|
2012-06-05 18:56:56 +04:00
|
|
|
You should have received a copy of the GNU Lesser General Public License along
|
2010-11-29 21:13:04 +03:00
|
|
|
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 23:19:39 +03:00
|
|
|
#pragma once
|
2010-11-27 02:02:21 +03:00
|
|
|
|
2013-08-11 06:09:45 +04:00
|
|
|
#include "irr_v3d.h"
|
2011-02-23 03:49:57 +03:00
|
|
|
#include "map.h"
|
2013-04-14 02:20:22 +04:00
|
|
|
#include "hud.h"
|
2011-11-14 02:19:48 +04:00
|
|
|
#include "gamedef.h"
|
2011-11-15 23:00:39 +04:00
|
|
|
#include "serialization.h" // For SER_FMT_VER_INVALID
|
2018-04-17 16:54:50 +03:00
|
|
|
#include "content/mods.h"
|
2011-12-06 17:21:56 +04:00
|
|
|
#include "inventorymanager.h"
|
2018-04-17 16:54:50 +03:00
|
|
|
#include "content/subgames.h"
|
2017-01-14 18:48:49 +03:00
|
|
|
#include "tileanimation.h" // struct TileAnimationParams
|
2017-08-24 09:28:54 +03:00
|
|
|
#include "network/peerhandler.h"
|
|
|
|
#include "network/address.h"
|
2013-08-11 06:09:45 +04:00
|
|
|
#include "util/numeric.h"
|
|
|
|
#include "util/thread.h"
|
2016-12-14 01:16:26 +03:00
|
|
|
#include "util/basic_macros.h"
|
2017-01-08 13:01:35 +03:00
|
|
|
#include "serverenvironment.h"
|
2014-01-31 03:24:00 +04:00
|
|
|
#include "clientiface.h"
|
2017-07-16 11:47:31 +03:00
|
|
|
#include "chatmessage.h"
|
2013-08-11 06:09:45 +04:00
|
|
|
#include <string>
|
|
|
|
#include <list>
|
|
|
|
#include <map>
|
|
|
|
#include <vector>
|
2012-06-17 03:40:36 +04:00
|
|
|
|
2017-08-16 23:11:45 +03:00
|
|
|
class ChatEvent;
|
|
|
|
struct ChatEventChat;
|
|
|
|
struct ChatInterface;
|
2012-01-12 09:10:39 +04:00
|
|
|
class IWritableItemDefManager;
|
2018-02-10 23:04:16 +03:00
|
|
|
class NodeDefManager;
|
2011-11-17 04:28:46 +04:00
|
|
|
class IWritableCraftDefManager;
|
2013-08-11 06:09:45 +04:00
|
|
|
class BanManager;
|
2012-03-23 22:23:03 +04:00
|
|
|
class EventManager;
|
2013-08-11 06:09:45 +04:00
|
|
|
class Inventory;
|
2017-09-26 01:11:20 +03:00
|
|
|
class ModChannelMgr;
|
2017-08-18 20:25:07 +03:00
|
|
|
class RemotePlayer;
|
2012-03-19 06:04:16 +04:00
|
|
|
class PlayerSAO;
|
2018-03-28 18:05:18 +03:00
|
|
|
struct PlayerHPChangeReason;
|
2012-07-26 23:06:45 +04:00
|
|
|
class IRollbackManager;
|
2014-12-08 11:06:31 +03:00
|
|
|
struct RollbackAction;
|
2013-02-14 07:43:15 +04:00
|
|
|
class EmergeManager;
|
2017-01-21 17:02:08 +03:00
|
|
|
class ServerScripting;
|
2013-08-11 06:09:45 +04:00
|
|
|
class ServerEnvironment;
|
|
|
|
struct SimpleSoundSpec;
|
2018-03-09 00:19:25 +03:00
|
|
|
struct CloudParams;
|
2014-01-31 03:24:00 +04:00
|
|
|
class ServerThread;
|
2018-03-16 10:41:33 +03:00
|
|
|
class ServerModManager;
|
2013-05-25 02:51:02 +04:00
|
|
|
|
2014-01-31 03:24:00 +04:00
|
|
|
enum ClientDeletionReason {
|
|
|
|
CDR_LEAVE,
|
|
|
|
CDR_TIMEOUT,
|
|
|
|
CDR_DENY
|
|
|
|
};
|
2010-11-27 02:02:21 +03:00
|
|
|
|
2012-03-25 12:50:29 +04:00
|
|
|
struct MediaInfo
|
2012-01-02 15:31:50 +04:00
|
|
|
{
|
|
|
|
std::string path;
|
|
|
|
std::string sha1_digest;
|
|
|
|
|
2014-02-28 00:12:59 +04:00
|
|
|
MediaInfo(const std::string &path_="",
|
|
|
|
const std::string &sha1_digest_=""):
|
2012-01-02 15:31:50 +04:00
|
|
|
path(path_),
|
|
|
|
sha1_digest(sha1_digest_)
|
|
|
|
{
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2012-03-24 21:01:26 +04:00
|
|
|
struct ServerSoundParams
|
|
|
|
{
|
2017-06-11 14:58:26 +03:00
|
|
|
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;
|
2017-06-18 20:55:15 +03:00
|
|
|
float max_hear_distance = 32 * BS;
|
|
|
|
v3f pos;
|
2017-06-11 14:58:26 +03:00
|
|
|
u16 object = 0;
|
|
|
|
std::string to_player = "";
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2012-03-19 06:04:16 +04:00
|
|
|
v3f getPos(ServerEnvironment *env, bool *pos_exists) const;
|
2012-03-24 21:01:26 +04:00
|
|
|
};
|
|
|
|
|
|
|
|
struct ServerPlayingSound
|
|
|
|
{
|
|
|
|
ServerSoundParams params;
|
2016-07-10 08:08:26 +03:00
|
|
|
SimpleSoundSpec spec;
|
2017-09-27 20:47:36 +03:00
|
|
|
std::unordered_set<session_t> clients; // peer ids
|
2012-03-24 21:01:26 +04:00
|
|
|
};
|
|
|
|
|
2011-04-04 16:13:19 +04:00
|
|
|
class Server : public con::PeerHandler, public MapEventReceiver,
|
2013-08-11 06:09:45 +04:00
|
|
|
public InventoryManager, public IGameDef
|
2010-11-27 02:02:21 +03:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
/*
|
|
|
|
NOTE: Every public method should be thread-safe
|
|
|
|
*/
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2010-11-27 02:02:21 +03:00
|
|
|
Server(
|
2012-03-11 16:54:23 +04:00
|
|
|
const std::string &path_world,
|
2012-03-15 17:20:20 +04:00
|
|
|
const SubgameSpec &gamespec,
|
2014-03-07 04:00:03 +04:00
|
|
|
bool simple_singleplayer_mode,
|
2017-09-28 14:47:30 +03:00
|
|
|
Address bind_addr,
|
2015-10-15 20:04:15 +03:00
|
|
|
bool dedicated,
|
2017-06-18 20:55:15 +03:00
|
|
|
ChatInterface *iface = nullptr
|
2010-11-29 11:52:07 +03:00
|
|
|
);
|
2010-11-27 02:02:21 +03:00
|
|
|
~Server();
|
2017-06-10 14:49:15 +03:00
|
|
|
DISABLE_CLASS_COPY(Server);
|
|
|
|
|
2018-06-13 22:58:34 +03:00
|
|
|
void init();
|
2017-09-28 14:47:30 +03:00
|
|
|
void start();
|
2010-11-27 02:02:21 +03:00
|
|
|
void stop();
|
2010-11-29 11:52:07 +03:00
|
|
|
// This is mainly a way to pass the time to the server.
|
|
|
|
// Actual processing is done in an another thread.
|
2010-11-27 02:02:21 +03:00
|
|
|
void step(float dtime);
|
2010-11-29 11:52:07 +03:00
|
|
|
// This is run by ServerThread and does the actual processing
|
2014-01-06 23:05:28 +04:00
|
|
|
void AsyncRunStep(bool initial_step=false);
|
2010-11-27 02:02:21 +03:00
|
|
|
void Receive();
|
2017-09-27 20:47:36 +03:00
|
|
|
PlayerSAO* StageTwoClientInit(session_t peer_id);
|
2015-01-12 19:01:41 +03:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Command Handlers
|
|
|
|
*/
|
|
|
|
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 13:37:49 +03:00
|
|
|
void handleCommand(NetworkPacket* pkt);
|
|
|
|
|
|
|
|
void handleCommand_Null(NetworkPacket* pkt) {};
|
|
|
|
void handleCommand_Deprecated(NetworkPacket* pkt);
|
2015-03-13 18:35:21 +03:00
|
|
|
void handleCommand_Init(NetworkPacket* pkt);
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 13:37:49 +03:00
|
|
|
void handleCommand_Init2(NetworkPacket* pkt);
|
2017-09-26 01:11:20 +03:00
|
|
|
void handleCommand_ModChannelJoin(NetworkPacket *pkt);
|
|
|
|
void handleCommand_ModChannelLeave(NetworkPacket *pkt);
|
|
|
|
void handleCommand_ModChannelMsg(NetworkPacket *pkt);
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 13:37:49 +03:00
|
|
|
void handleCommand_RequestMedia(NetworkPacket* pkt);
|
|
|
|
void handleCommand_ClientReady(NetworkPacket* pkt);
|
|
|
|
void handleCommand_GotBlocks(NetworkPacket* pkt);
|
|
|
|
void handleCommand_PlayerPos(NetworkPacket* pkt);
|
|
|
|
void handleCommand_DeletedBlocks(NetworkPacket* pkt);
|
|
|
|
void handleCommand_InventoryAction(NetworkPacket* pkt);
|
|
|
|
void handleCommand_ChatMessage(NetworkPacket* pkt);
|
|
|
|
void handleCommand_Damage(NetworkPacket* pkt);
|
2015-03-13 18:35:21 +03:00
|
|
|
void handleCommand_Password(NetworkPacket* pkt);
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 13:37:49 +03:00
|
|
|
void handleCommand_PlayerItem(NetworkPacket* pkt);
|
|
|
|
void handleCommand_Respawn(NetworkPacket* pkt);
|
|
|
|
void handleCommand_Interact(NetworkPacket* pkt);
|
|
|
|
void handleCommand_RemovedSounds(NetworkPacket* pkt);
|
|
|
|
void handleCommand_NodeMetaFields(NetworkPacket* pkt);
|
|
|
|
void handleCommand_InventoryFields(NetworkPacket* pkt);
|
2015-04-12 05:49:13 +03:00
|
|
|
void handleCommand_FirstSrp(NetworkPacket* pkt);
|
|
|
|
void handleCommand_SrpBytesA(NetworkPacket* pkt);
|
|
|
|
void handleCommand_SrpBytesM(NetworkPacket* pkt);
|
2015-01-12 19:01:41 +03:00
|
|
|
|
2015-03-31 11:35:51 +03:00
|
|
|
void ProcessData(NetworkPacket *pkt);
|
2010-11-27 02:02:21 +03:00
|
|
|
|
2017-09-26 01:11:20 +03:00
|
|
|
void Send(NetworkPacket *pkt);
|
2017-09-27 20:47:36 +03:00
|
|
|
void Send(session_t peer_id, NetworkPacket *pkt);
|
[Patch 2/4] Network rework: packet writing, sending and cleanups
NetworkPacket.cpp:
* Remove some deprecated functions, we must use streaming interface
* m_data converted from u8* to std::vector<u8>
* Add an exporter to forge packet to Connection object
* implement operator << std::wstring. n
* implement operator << std::string
* dynamic resize when write packet content.
* fix string writing and performances.
* create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Reliability
* Transmit channel
* Implement putRawString for some ugly char (_INIT packet), and use it.
* Many packet read and write migrated
* Implement oldForgePacket to interface writing with current connection
* fix U8/char/bool writing
* fix string writing and performances.
* add some missing functions
* Use v3s16 read instead of reading x,y,z separately
* Add irr::video::SColor support into packets
* Add some missing handlers
* Add a template function to increase offset
* Throw a serialization error on packet reading (must be improved)
PacketFactories:
* Create ServerCommandFactory, used by client to get useful informations about packet processing (sending).
* Create ClientCommandFactory, used by server to get useful informations about packet processing (sending).
Client.cpp:
* implement NetworkPacket ::Send interface.
* Move packet handlers to a dedicated file
* Remove Client::Send(SharedBuffer)
Server.cpp:
* implement NetworkPacket ::Send interface.
* Rewrite all packets using NetworkPacket
* Move packet handlers to a dedicated file
* Remove Server::Send(SharedBuffer)
ClientIface.cpp:
* Remove sendToAll(SharedBuffer<u8>)
Connection.hpp rework:
* Remove duplicate include
* Remove duplicate negation
* Remove a useless variable
* Improve code performance by using a m_peers_list instead of scanning m_peers map
* Remove Connection::Send(SharedBuffer)
* Fix useafterfree into NetworkPacket Sending
* Remove unused Connection::sendToAll
Test.cpp:
* Remove dead code
* Update tests to use NetworkPackets
Misc:
* add new wrappers to Send packets in client, using NetworkPacket
* Add NetworkPacket methods for Connection
* coding style fix
* dead code since changes cleanup
* Use v3s16 read instead of reading x,y,z separately in some packets
* Use different files to handle packets received by client and server
* Cleanup: Remove useless includes
ok @Zeno-
Tested by @Zeno- @VanessaE and @nerzhul on running servers
2015-01-16 13:37:49 +03:00
|
|
|
|
2016-11-12 10:22:39 +03:00
|
|
|
// Helper for handleCommand_PlayerPos and handleCommand_Interact
|
|
|
|
void process_PlayerPos(RemotePlayer *player, PlayerSAO *playersao,
|
|
|
|
NetworkPacket *pkt);
|
|
|
|
|
2015-10-27 23:03:59 +03:00
|
|
|
// Both setter and getter need no envlock,
|
|
|
|
// can be called freely from threads
|
2013-08-11 06:09:45 +04:00
|
|
|
void setTimeOfDay(u32 time);
|
2011-05-16 13:41:19 +04:00
|
|
|
|
2011-02-23 03:49:57 +03:00
|
|
|
/*
|
|
|
|
Shall be called with the environment locked.
|
|
|
|
This is accessed by the map, which is inside the environment,
|
|
|
|
so it shouldn't be a problem.
|
|
|
|
*/
|
|
|
|
void onMapEditEvent(MapEditEvent *event);
|
2011-02-15 17:11:24 +03:00
|
|
|
|
2011-04-04 16:13:19 +04:00
|
|
|
/*
|
|
|
|
Shall be called with the environment and the connection locked.
|
|
|
|
*/
|
2011-12-06 17:21:56 +04:00
|
|
|
Inventory* getInventory(const InventoryLocation &loc);
|
2015-03-24 11:36:54 +03:00
|
|
|
void setInventoryModified(const InventoryLocation &loc, bool playerSend = true);
|
2011-04-04 16:13:19 +04:00
|
|
|
|
2011-05-16 13:41:19 +04:00
|
|
|
// Connection must be locked when called
|
|
|
|
std::wstring getStatusString();
|
2016-11-02 19:36:58 +03:00
|
|
|
inline double getUptime() const { return m_uptime.m_value; }
|
2011-05-16 13:41:19 +04:00
|
|
|
|
2014-01-31 03:24:00 +04:00
|
|
|
// read shutdown state
|
2018-06-13 22:58:34 +03:00
|
|
|
inline bool isShutdownRequested() const { return m_shutdown_state.is_requested; }
|
2014-01-31 03:24:00 +04:00
|
|
|
|
|
|
|
// request server to shutdown
|
2017-04-16 00:19:18 +03:00
|
|
|
void requestShutdown(const std::string &msg, bool reconnect, float delay = 0.0f);
|
2011-05-16 13:41:19 +04:00
|
|
|
|
2012-03-24 21:01:26 +04:00
|
|
|
// Returns -1 if failed, sound handle on success
|
2014-01-31 03:24:00 +04:00
|
|
|
// Envlock
|
2012-03-24 21:01:26 +04:00
|
|
|
s32 playSound(const SimpleSoundSpec &spec, const ServerSoundParams ¶ms);
|
|
|
|
void stopSound(s32 handle);
|
2016-07-10 08:08:26 +03:00
|
|
|
void fadeSound(s32 handle, float step, float gain);
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2014-01-31 03:24:00 +04:00
|
|
|
// Envlock
|
2012-03-30 19:42:18 +04:00
|
|
|
std::set<std::string> getPlayerEffectivePrivs(const std::string &name);
|
|
|
|
bool checkPriv(const std::string &name, const std::string &priv);
|
2012-03-31 17:23:26 +04:00
|
|
|
void reportPrivsModified(const std::string &name=""); // ""=all
|
2012-07-19 15:09:16 +04:00
|
|
|
void reportInventoryFormspecModified(const std::string &name);
|
2018-03-28 18:04:41 +03:00
|
|
|
void reportFormspecPrependModified(const std::string &name);
|
2011-11-20 23:16:15 +04:00
|
|
|
|
2013-08-11 06:09:45 +04:00
|
|
|
void setIpBanned(const std::string &ip, const std::string &name);
|
|
|
|
void unsetIpBanned(const std::string &ip_or_name);
|
|
|
|
std::string getBanDescription(const std::string &ip_or_name);
|
2011-08-12 14:11:27 +04:00
|
|
|
|
2014-02-28 00:12:59 +04:00
|
|
|
void notifyPlayer(const char *name, const std::wstring &msg);
|
|
|
|
void notifyPlayers(const std::wstring &msg);
|
2015-07-25 12:56:24 +03:00
|
|
|
void spawnParticle(const std::string &playername,
|
2013-01-23 21:32:02 +04:00
|
|
|
v3f pos, v3f velocity, v3f acceleration,
|
|
|
|
float expirationtime, float size,
|
2016-05-28 07:08:23 +03:00
|
|
|
bool collisiondetection, bool collision_removal,
|
2017-01-14 18:48:49 +03:00
|
|
|
bool vertical, const std::string &texture,
|
|
|
|
const struct TileAnimationParams &animation, u8 glow);
|
2013-01-23 21:32:02 +04:00
|
|
|
|
2015-07-25 12:56:24 +03:00
|
|
|
u32 addParticleSpawner(u16 amount, float spawntime,
|
2013-01-23 21:32:02 +04:00
|
|
|
v3f minpos, v3f maxpos,
|
|
|
|
v3f minvel, v3f maxvel,
|
|
|
|
v3f minacc, v3f maxacc,
|
|
|
|
float minexptime, float maxexptime,
|
|
|
|
float minsize, float maxsize,
|
2016-05-28 07:08:23 +03:00
|
|
|
bool collisiondetection, bool collision_removal,
|
2016-08-04 23:09:21 +03:00
|
|
|
ServerActiveObject *attached,
|
2016-05-28 07:08:23 +03:00
|
|
|
bool vertical, const std::string &texture,
|
2017-01-14 18:48:49 +03:00
|
|
|
const std::string &playername, const struct TileAnimationParams &animation,
|
|
|
|
u8 glow);
|
2013-01-23 21:32:02 +04:00
|
|
|
|
2015-07-25 12:56:24 +03:00
|
|
|
void deleteParticleSpawner(const std::string &playername, u32 id);
|
2013-01-23 21:32:02 +04:00
|
|
|
|
2012-07-24 21:57:17 +04:00
|
|
|
// Creates or resets inventory
|
2016-11-26 19:35:25 +03:00
|
|
|
Inventory* createDetachedInventory(const std::string &name, const std::string &player="");
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2013-05-25 02:51:02 +04:00
|
|
|
// Envlock and conlock should be locked when using scriptapi
|
2017-01-21 17:02:08 +03:00
|
|
|
ServerScripting *getScriptIface(){ return m_script; }
|
2012-07-26 23:06:45 +04:00
|
|
|
|
|
|
|
// actions: time-reversed list
|
|
|
|
// Return value: success/failure
|
|
|
|
bool rollbackRevertActions(const std::list<RollbackAction> &actions,
|
|
|
|
std::list<std::string> *log);
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2011-11-14 02:19:48 +04:00
|
|
|
// IGameDef interface
|
|
|
|
// Under envlock
|
2012-01-12 09:10:39 +04:00
|
|
|
virtual IItemDefManager* getItemDefManager();
|
2018-02-10 23:04:16 +03:00
|
|
|
virtual const NodeDefManager* getNodeDefManager();
|
2011-11-17 04:28:46 +04:00
|
|
|
virtual ICraftDefManager* getCraftDefManager();
|
2011-11-16 15:03:28 +04:00
|
|
|
virtual u16 allocateUnknownNodeId(const std::string &name);
|
2017-01-09 22:39:22 +03:00
|
|
|
IRollbackManager *getRollbackManager() { return m_rollback; }
|
2015-04-17 06:37:50 +03:00
|
|
|
virtual EmergeManager *getEmergeManager() { return m_emerge; }
|
2014-06-26 04:28:41 +04:00
|
|
|
|
2012-01-12 09:10:39 +04:00
|
|
|
IWritableItemDefManager* getWritableItemDefManager();
|
2018-02-10 23:04:16 +03:00
|
|
|
NodeDefManager* getWritableNodeDefManager();
|
2011-11-17 04:28:46 +04:00
|
|
|
IWritableCraftDefManager* getWritableCraftDefManager();
|
2011-08-12 03:13:42 +04:00
|
|
|
|
2018-03-16 10:41:33 +03:00
|
|
|
virtual const std::vector<ModSpec> &getMods() const;
|
2017-01-21 17:02:08 +03:00
|
|
|
virtual const ModSpec* getModSpec(const std::string &modname) const;
|
2015-03-05 12:43:08 +03:00
|
|
|
void getModNames(std::vector<std::string> &modlist);
|
2012-04-01 11:08:52 +04:00
|
|
|
std::string getBuiltinLuaPath();
|
2017-03-16 09:53:39 +03:00
|
|
|
virtual std::string getWorldPath() const { return m_path_world; }
|
|
|
|
virtual std::string getModStoragePath() const;
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2014-01-31 03:24:00 +04:00
|
|
|
inline bool isSingleplayer()
|
|
|
|
{ return m_simple_singleplayer_mode; }
|
2012-03-28 14:22:48 +04:00
|
|
|
|
2014-01-31 03:24:00 +04:00
|
|
|
inline void setAsyncFatalError(const std::string &error)
|
|
|
|
{ m_async_fatal_error.set(error); }
|
2012-03-11 22:45:43 +04:00
|
|
|
|
2013-01-03 21:59:28 +04:00
|
|
|
bool showFormspec(const char *name, const std::string &formspec, const std::string &formname);
|
2012-10-23 01:18:44 +04:00
|
|
|
Map & getMap() { return m_env->getMap(); }
|
2013-09-17 06:52:24 +04:00
|
|
|
ServerEnvironment & getEnv() { return *m_env; }
|
2017-04-23 15:35:08 +03:00
|
|
|
v3f findSpawnPos();
|
2015-01-12 19:01:41 +03:00
|
|
|
|
2016-10-08 13:21:41 +03:00
|
|
|
u32 hudAdd(RemotePlayer *player, HudElement *element);
|
|
|
|
bool hudRemove(RemotePlayer *player, u32 id);
|
|
|
|
bool hudChange(RemotePlayer *player, u32 id, HudElementStat stat, void *value);
|
2016-10-08 11:38:04 +03:00
|
|
|
bool hudSetFlags(RemotePlayer *player, u32 flags, u32 mask);
|
|
|
|
bool hudSetHotbarItemcount(RemotePlayer *player, s32 hotbar_itemcount);
|
2016-10-08 13:21:41 +03:00
|
|
|
void hudSetHotbarImage(RemotePlayer *player, std::string name);
|
|
|
|
void hudSetHotbarSelectedImage(RemotePlayer *player, std::string name);
|
2013-09-03 21:51:40 +04:00
|
|
|
|
2017-09-27 20:47:36 +03:00
|
|
|
Address getPeerAddress(session_t peer_id);
|
2015-01-12 19:01:41 +03:00
|
|
|
|
2018-03-09 00:19:25 +03:00
|
|
|
void setLocalPlayerAnimations(RemotePlayer *player, v2s32 animation_frames[4],
|
2016-10-08 13:21:41 +03:00
|
|
|
f32 frame_speed);
|
2018-03-09 00:19:25 +03:00
|
|
|
void setPlayerEyeOffset(RemotePlayer *player, const v3f &first, const v3f &third);
|
2014-01-08 16:47:53 +04:00
|
|
|
|
2018-03-09 00:19:25 +03:00
|
|
|
void setSky(RemotePlayer *player, const video::SColor &bgcolor,
|
2017-04-28 05:06:49 +03:00
|
|
|
const std::string &type, const std::vector<std::string> ¶ms,
|
|
|
|
bool &clouds);
|
2018-03-09 00:19:25 +03:00
|
|
|
void setClouds(RemotePlayer *player, const CloudParams ¶ms);
|
2015-01-12 19:01:41 +03:00
|
|
|
|
2016-10-08 11:38:04 +03:00
|
|
|
bool overrideDayNightRatio(RemotePlayer *player, bool do_override, float brightness);
|
2010-11-27 02:02:21 +03:00
|
|
|
|
2014-01-31 03:24:00 +04:00
|
|
|
/* con::PeerHandler implementation. */
|
2010-11-27 02:02:21 +03:00
|
|
|
void peerAdded(con::Peer *peer);
|
|
|
|
void deletingPeer(con::Peer *peer, bool timeout);
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2017-09-27 20:47:36 +03:00
|
|
|
void DenySudoAccess(session_t peer_id);
|
|
|
|
void DenyAccessVerCompliant(session_t peer_id, u16 proto_ver, AccessDeniedCode reason,
|
2015-07-17 17:40:41 +03:00
|
|
|
const std::string &str_reason = "", bool reconnect = false);
|
2017-09-27 20:47:36 +03:00
|
|
|
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,
|
2014-02-13 23:17:42 +04:00
|
|
|
u8* ser_vers, u16* prot_vers, u8* major, u8* minor, u8* patch,
|
|
|
|
std::string* vers_string);
|
2014-01-26 21:40:25 +04:00
|
|
|
|
2015-07-25 08:43:32 +03:00
|
|
|
void printToConsoleOnly(const std::string &text);
|
|
|
|
|
2018-03-28 18:05:18 +03:00
|
|
|
void SendPlayerHPOrDie(PlayerSAO *player, const PlayerHPChangeReason &reason);
|
2017-01-01 18:13:01 +03:00
|
|
|
void SendPlayerBreath(PlayerSAO *sao);
|
2015-03-04 17:27:53 +03:00
|
|
|
void SendInventory(PlayerSAO* playerSAO);
|
2017-09-27 20:47:36 +03:00
|
|
|
void SendMovePlayer(session_t peer_id);
|
2015-03-04 13:29:34 +03:00
|
|
|
|
2017-03-16 09:53:39 +03:00
|
|
|
virtual bool registerModStorage(ModMetadata *storage);
|
|
|
|
virtual void unregisterModStorage(const std::string &name);
|
2017-02-08 02:15:55 +03:00
|
|
|
|
2017-09-26 01:11:20 +03:00
|
|
|
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);
|
|
|
|
|
2015-01-21 22:32:12 +03:00
|
|
|
// Bind address
|
|
|
|
Address m_bind_addr;
|
|
|
|
|
2015-10-30 09:48:37 +03:00
|
|
|
// Environment mutex (envlock)
|
2017-06-06 17:29:28 +03:00
|
|
|
std::mutex m_env_mutex;
|
2015-10-30 09:48:37 +03:00
|
|
|
|
2014-01-31 03:24:00 +04:00
|
|
|
private:
|
|
|
|
friend class EmergeThread;
|
|
|
|
friend class RemoteClient;
|
2018-06-13 22:58:34 +03:00
|
|
|
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;
|
|
|
|
};
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2017-09-27 20:47:36 +03:00
|
|
|
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,
|
2015-07-17 17:40:41 +03:00
|
|
|
const std::string &custom_reason, bool reconnect = false);
|
2017-09-27 20:47:36 +03:00
|
|
|
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);
|
2018-02-10 23:04:16 +03:00
|
|
|
void SendNodeDef(session_t peer_id, const NodeDefManager *nodedef,
|
|
|
|
u16 protocol_version);
|
2014-01-31 03:24:00 +04:00
|
|
|
|
|
|
|
/* mark blocks not sent for all clients */
|
|
|
|
void SetBlocksNotSent(std::map<v3s16, MapBlock *>& block);
|
2011-04-21 20:35:17 +04:00
|
|
|
|
2015-03-04 13:29:34 +03:00
|
|
|
|
2018-06-13 22:58:34 +03:00
|
|
|
virtual void SendChatMessage(session_t peer_id, const ChatMessage &message);
|
2017-09-27 20:47:36 +03:00
|
|
|
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);
|
2018-03-28 18:04:41 +03:00
|
|
|
void SendPlayerFormspecPrepend(session_t peer_id);
|
2017-09-27 20:47:36 +03:00
|
|
|
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,
|
2017-04-28 05:06:49 +03:00
|
|
|
const std::string &type, const std::vector<std::string> ¶ms,
|
|
|
|
bool &clouds);
|
2018-03-09 00:19:25 +03:00
|
|
|
void SendCloudParams(session_t peer_id, const CloudParams ¶ms);
|
2017-09-27 20:47:36 +03:00
|
|
|
void SendOverrideDayNightRatio(session_t peer_id, bool do_override, float ratio);
|
2017-09-26 01:11:20 +03:00
|
|
|
void broadcastModChannelMessage(const std::string &channel,
|
2017-09-27 20:47:36 +03:00
|
|
|
const std::string &message, session_t from_peer);
|
2015-01-12 19:01:41 +03:00
|
|
|
|
2011-04-06 12:02:39 +04:00
|
|
|
/*
|
|
|
|
Send a node removal/addition event to all clients except ignore_id.
|
|
|
|
Additionally, if far_players!=NULL, players further away than
|
|
|
|
far_d_nodes are ignored and their peer_ids are added to far_players
|
|
|
|
*/
|
2011-05-31 21:02:55 +04:00
|
|
|
// Envlock and conlock should be locked when calling these
|
2011-04-06 12:02:39 +04:00
|
|
|
void sendRemoveNode(v3s16 p, u16 ignore_id=0,
|
2015-03-05 13:18:17 +03:00
|
|
|
std::vector<u16> *far_players=NULL, float far_d_nodes=100);
|
2011-04-06 12:02:39 +04:00
|
|
|
void sendAddNode(v3s16 p, MapNode n, u16 ignore_id=0,
|
2015-03-05 13:18:17 +03:00
|
|
|
std::vector<u16> *far_players=NULL, float far_d_nodes=100,
|
2013-11-23 18:35:49 +04:00
|
|
|
bool remove_metadata=true);
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2011-05-22 18:00:09 +04:00
|
|
|
// Environment and Connection must be locked when called
|
2017-09-27 20:47:36 +03:00
|
|
|
void SendBlockNoLock(session_t peer_id, MapBlock *block, u8 ver, u16 net_proto_version);
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2011-05-31 21:02:55 +04:00
|
|
|
// Sends blocks to clients (locks env and con on its own)
|
2010-11-27 02:02:21 +03:00
|
|
|
void SendBlocks(float dtime);
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2012-03-25 12:50:29 +04:00
|
|
|
void fillMediaCache();
|
2017-09-27 20:47:36 +03:00
|
|
|
void sendMediaAnnouncement(session_t peer_id, const std::string &lang_code);
|
|
|
|
void sendRequestedMedia(session_t peer_id,
|
2015-03-05 13:39:05 +03:00
|
|
|
const std::vector<std::string> &tosend);
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2017-09-27 20:47:36 +03:00
|
|
|
void sendDetachedInventory(const std::string &name, session_t peer_id);
|
|
|
|
void sendDetachedInventories(session_t peer_id);
|
2011-04-21 20:35:17 +04:00
|
|
|
|
2014-01-31 03:24:00 +04:00
|
|
|
// Adds a ParticleSpawner on peer with peer_id (PEER_ID_INEXISTENT == all)
|
2017-09-27 20:47:36 +03:00
|
|
|
void SendAddParticleSpawner(session_t peer_id, u16 protocol_version,
|
2017-01-14 18:48:49 +03:00
|
|
|
u16 amount, float spawntime,
|
2013-01-23 21:32:02 +04:00
|
|
|
v3f minpos, v3f maxpos,
|
|
|
|
v3f minvel, v3f maxvel,
|
|
|
|
v3f minacc, v3f maxacc,
|
|
|
|
float minexptime, float maxexptime,
|
|
|
|
float minsize, float maxsize,
|
2016-05-28 07:08:23 +03:00
|
|
|
bool collisiondetection, bool collision_removal,
|
2016-08-04 23:09:21 +03:00
|
|
|
u16 attached_id,
|
2017-01-14 18:48:49 +03:00
|
|
|
bool vertical, const std::string &texture, u32 id,
|
|
|
|
const struct TileAnimationParams &animation, u8 glow);
|
2013-01-23 21:32:02 +04:00
|
|
|
|
2017-09-27 20:47:36 +03:00
|
|
|
void SendDeleteParticleSpawner(session_t peer_id, u32 id);
|
2013-01-23 21:32:02 +04:00
|
|
|
|
2014-01-31 03:24:00 +04:00
|
|
|
// Spawns particle on peer with peer_id (PEER_ID_INEXISTENT == all)
|
2017-09-27 20:47:36 +03:00
|
|
|
void SendSpawnParticle(session_t peer_id, u16 protocol_version,
|
2013-01-23 21:32:02 +04:00
|
|
|
v3f pos, v3f velocity, v3f acceleration,
|
|
|
|
float expirationtime, float size,
|
2016-05-28 07:08:23 +03:00
|
|
|
bool collisiondetection, bool collision_removal,
|
2017-01-14 18:48:49 +03:00
|
|
|
bool vertical, const std::string &texture,
|
|
|
|
const struct TileAnimationParams &animation, u8 glow);
|
2013-01-23 21:32:02 +04:00
|
|
|
|
2017-09-27 20:47:36 +03:00
|
|
|
u32 SendActiveObjectRemoveAdd(session_t peer_id, const std::string &datas);
|
|
|
|
void SendActiveObjectMessages(session_t peer_id, const std::string &datas,
|
|
|
|
bool reliable = true);
|
2018-06-20 23:36:08 +03:00
|
|
|
void SendCSMRestrictionFlags(session_t peer_id);
|
2017-07-18 22:39:55 +03:00
|
|
|
|
2011-04-21 20:35:17 +04:00
|
|
|
/*
|
|
|
|
Something random
|
|
|
|
*/
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2018-03-28 18:05:18 +03:00
|
|
|
void DiePlayer(session_t peer_id, const PlayerHPChangeReason &reason);
|
2017-09-27 20:47:36 +03:00
|
|
|
void RespawnPlayer(session_t peer_id);
|
|
|
|
void DeleteClient(session_t peer_id, ClientDeletionReason reason);
|
2016-10-08 11:38:04 +03:00
|
|
|
void UpdateCrafting(RemotePlayer *player);
|
2017-11-22 21:25:26 +03:00
|
|
|
bool checkInteractDistance(RemotePlayer *player, const f32 d, const std::string what);
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2015-11-09 08:04:24 +03:00
|
|
|
void handleChatInterfaceEvent(ChatEvent *evt);
|
|
|
|
|
2015-07-25 08:43:32 +03:00
|
|
|
// 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,
|
2017-06-10 14:49:44 +03:00
|
|
|
std::wstring wmessage_input,
|
2015-11-13 03:35:54 +03:00
|
|
|
bool check_shout_priv = false,
|
2016-10-04 19:17:12 +03:00
|
|
|
RemotePlayer *player = NULL);
|
2015-07-25 08:43:32 +03:00
|
|
|
void handleAdminChat(const ChatEventChat *evt);
|
|
|
|
|
2010-11-27 02:02:21 +03:00
|
|
|
// When called, connection mutex should be locked
|
2017-09-27 20:47:36 +03:00
|
|
|
RemoteClient* getClient(session_t peer_id, ClientState state_min = CS_Active);
|
|
|
|
RemoteClient* getClientNoEx(session_t peer_id, ClientState state_min = CS_Active);
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2011-05-31 01:15:43 +04:00
|
|
|
// When called, environment mutex should be locked
|
2017-09-27 20:47:36 +03:00
|
|
|
std::string getPlayerName(session_t peer_id);
|
|
|
|
PlayerSAO *getPlayerSAO(session_t peer_id);
|
2012-03-19 06:04:16 +04:00
|
|
|
|
2011-01-18 01:26:09 +03:00
|
|
|
/*
|
|
|
|
Get a player from memory or creates one.
|
|
|
|
If player is already connected, return NULL
|
2011-11-20 23:16:15 +04:00
|
|
|
Does not verify/modify auth info and password.
|
2011-01-18 01:26:09 +03:00
|
|
|
|
|
|
|
Call with env and con locked.
|
|
|
|
*/
|
2017-09-27 20:47:36 +03:00
|
|
|
PlayerSAO *emergePlayer(const char *name, session_t peer_id, u16 proto_version);
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2010-12-24 18:08:50 +03:00
|
|
|
void handlePeerChanges();
|
2011-05-22 18:00:09 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
Variables
|
|
|
|
*/
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2012-03-10 17:56:24 +04:00
|
|
|
// World directory
|
|
|
|
std::string m_path_world;
|
2012-03-11 16:54:23 +04:00
|
|
|
// Subgame specification
|
|
|
|
SubgameSpec m_gamespec;
|
2012-03-15 17:20:20 +04:00
|
|
|
// If true, do not allow multiple players and hide some multiplayer
|
|
|
|
// functionality
|
|
|
|
bool m_simple_singleplayer_mode;
|
2016-10-04 19:17:12 +03:00
|
|
|
u16 m_max_chatmessage_length;
|
2015-10-15 20:04:15 +03:00
|
|
|
// For "dedicated" server list flag
|
|
|
|
bool m_dedicated;
|
2012-03-10 17:56:24 +04:00
|
|
|
|
2012-03-11 22:45:43 +04:00
|
|
|
// Thread can set; step() will throw as ServerError
|
|
|
|
MutexedVariable<std::string> m_async_fatal_error;
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2011-05-22 18:00:09 +04:00
|
|
|
// Some timers
|
2017-06-18 20:55:15 +03:00
|
|
|
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;
|
2011-06-27 01:27:17 +04:00
|
|
|
IntervalLimiter m_map_timer_and_unload_interval;
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2011-05-22 18:00:09 +04:00
|
|
|
// Environment
|
2017-06-18 20:55:15 +03:00
|
|
|
ServerEnvironment *m_env = nullptr;
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2014-01-31 03:24:00 +04:00
|
|
|
// server connection
|
2017-08-24 09:28:54 +03:00
|
|
|
std::shared_ptr<con::Connection> m_con;
|
2011-05-29 22:11:16 +04:00
|
|
|
|
2013-08-04 09:17:07 +04:00
|
|
|
// Ban checking
|
2017-06-18 20:55:15 +03:00
|
|
|
BanManager *m_banmanager = nullptr;
|
2011-11-11 21:33:17 +04:00
|
|
|
|
2012-07-26 23:06:45 +04:00
|
|
|
// Rollback manager (behind m_env_mutex)
|
2017-06-18 20:55:15 +03:00
|
|
|
IRollbackManager *m_rollback = nullptr;
|
2012-07-26 23:06:45 +04:00
|
|
|
|
2012-11-26 06:16:48 +04:00
|
|
|
// Emerge manager
|
2017-06-18 20:55:15 +03:00
|
|
|
EmergeManager *m_emerge = nullptr;
|
2012-11-26 06:16:48 +04:00
|
|
|
|
2011-11-11 21:33:17 +04:00
|
|
|
// Scripting
|
|
|
|
// Envlock and conlock should be locked when using Lua
|
2017-06-18 20:55:15 +03:00
|
|
|
ServerScripting *m_script = nullptr;
|
2011-11-14 02:19:48 +04:00
|
|
|
|
2012-01-12 09:10:39 +04:00
|
|
|
// Item definition manager
|
|
|
|
IWritableItemDefManager *m_itemdef;
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2011-11-14 23:41:30 +04:00
|
|
|
// Node definition manager
|
2018-02-10 23:04:16 +03:00
|
|
|
NodeDefManager *m_nodedef;
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2011-11-17 04:28:46 +04:00
|
|
|
// Craft definition manager
|
|
|
|
IWritableCraftDefManager *m_craftdef;
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2012-03-23 22:23:03 +04:00
|
|
|
// Event manager
|
|
|
|
EventManager *m_event;
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2011-12-11 18:49:40 +04:00
|
|
|
// Mods
|
2018-03-16 10:41:33 +03:00
|
|
|
std::unique_ptr<ServerModManager> m_modmgr;
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2011-05-22 18:00:09 +04:00
|
|
|
/*
|
|
|
|
Threads
|
|
|
|
*/
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2011-05-22 18:00:09 +04:00
|
|
|
// A buffer for time steps
|
|
|
|
// step() increments and AsyncRunStep() run by m_thread reads it.
|
2017-06-18 20:55:15 +03:00
|
|
|
float m_step_dtime = 0.0f;
|
2017-06-06 17:29:28 +03:00
|
|
|
std::mutex m_step_dtime_mutex;
|
2010-11-27 02:02:21 +03:00
|
|
|
|
2014-01-31 03:24:00 +04:00
|
|
|
// current server step lag counter
|
2014-01-07 02:50:45 +04:00
|
|
|
float m_lag;
|
|
|
|
|
2011-05-22 18:00:09 +04:00
|
|
|
// The server mainly operates in this thread
|
2017-06-18 20:55:15 +03:00
|
|
|
ServerThread *m_thread = nullptr;
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2011-05-22 18:00:09 +04:00
|
|
|
/*
|
|
|
|
Time related stuff
|
|
|
|
*/
|
2010-12-20 15:04:31 +03:00
|
|
|
|
2011-05-22 18:00:09 +04:00
|
|
|
// Timer for sending time of day over network
|
2017-06-18 20:55:15 +03:00
|
|
|
float m_time_of_day_send_timer = 0.0f;
|
2011-05-22 18:00:09 +04:00
|
|
|
// Uptime of server in seconds
|
2011-01-07 20:39:27 +03:00
|
|
|
MutexedVariable<double> m_uptime;
|
2014-01-31 03:24:00 +04:00
|
|
|
/*
|
|
|
|
Client interface
|
|
|
|
*/
|
|
|
|
ClientInterface m_clients;
|
|
|
|
|
2011-05-22 18:00:09 +04:00
|
|
|
/*
|
|
|
|
Peer change queue.
|
|
|
|
Queues stuff from peerAdded() and deletingPeer() to
|
|
|
|
handlePeerChanges()
|
|
|
|
*/
|
2015-03-04 19:48:07 +03:00
|
|
|
std::queue<con::PeerChange> m_peer_change_queue;
|
2010-12-24 18:08:50 +03:00
|
|
|
|
2018-02-19 00:33:42 +03:00
|
|
|
std::unordered_map<session_t, std::string> m_formspec_state_data;
|
|
|
|
|
2011-05-22 18:00:09 +04:00
|
|
|
/*
|
|
|
|
Random stuff
|
|
|
|
*/
|
2012-12-18 22:23:16 +04:00
|
|
|
|
2018-06-13 22:58:34 +03:00
|
|
|
ShutdownState m_shutdown_state;
|
2012-01-12 09:10:39 +04:00
|
|
|
|
2015-07-25 08:43:32 +03:00
|
|
|
ChatInterface *m_admin_chat;
|
|
|
|
std::string m_admin_nick;
|
|
|
|
|
2011-05-22 18:00:09 +04:00
|
|
|
/*
|
|
|
|
Map edit event queue. Automatically receives all map edits.
|
|
|
|
The constructor of this class registers us to receive them through
|
|
|
|
onMapEditEvent
|
|
|
|
|
|
|
|
NOTE: Should these be moved to actually be members of
|
|
|
|
ServerEnvironment?
|
|
|
|
*/
|
|
|
|
|
2011-02-23 03:49:57 +03:00
|
|
|
/*
|
|
|
|
Queue of map edits from the environment for sending to the clients
|
|
|
|
This is behind m_env_mutex
|
|
|
|
*/
|
2015-03-04 19:48:07 +03:00
|
|
|
std::queue<MapEditEvent*> m_unsent_map_edit_queue;
|
2012-03-29 02:22:08 +04:00
|
|
|
/*
|
|
|
|
If a non-empty area, map edit events contained within are left
|
|
|
|
unsent. Done at map generation time to speed up editing of the
|
|
|
|
generated area, as it will be sent anyway.
|
|
|
|
This is behind m_env_mutex
|
|
|
|
*/
|
|
|
|
VoxelArea m_ignore_map_edit_events_area;
|
2011-02-15 17:11:24 +03:00
|
|
|
|
2014-01-31 03:24:00 +04:00
|
|
|
// media files known to server
|
2017-06-04 22:00:04 +03:00
|
|
|
std::unordered_map<std::string, MediaInfo> m_media;
|
2012-03-24 21:01:26 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
Sounds
|
|
|
|
*/
|
2017-06-04 22:00:04 +03:00
|
|
|
std::unordered_map<s32, ServerPlayingSound> m_playing_sounds;
|
2017-06-18 20:55:15 +03:00
|
|
|
s32 m_next_sound_id = 0;
|
2012-07-24 21:57:17 +04:00
|
|
|
|
|
|
|
/*
|
|
|
|
Detached inventories (behind m_env_mutex)
|
|
|
|
*/
|
|
|
|
// key = name
|
|
|
|
std::map<std::string, Inventory*> m_detached_inventories;
|
2016-11-26 19:35:25 +03:00
|
|
|
// value = "" (visible to all players) or player name
|
|
|
|
std::map<std::string, std::string> m_detached_inventories_player;
|
2013-01-23 21:32:02 +04:00
|
|
|
|
2017-06-04 22:00:04 +03:00
|
|
|
std::unordered_map<std::string, ModMetadata *> m_mod_storages;
|
2017-06-18 20:55:15 +03:00
|
|
|
float m_mod_storage_save_timer = 10.0f;
|
2017-07-18 22:39:55 +03:00
|
|
|
|
2018-06-20 23:36:08 +03:00
|
|
|
// CSM restrictions byteflag
|
|
|
|
u64 m_csm_restriction_flags = CSMRestrictionFlags::CSM_RF_NONE;
|
|
|
|
u32 m_csm_restriction_noderange = 8;
|
2017-09-26 01:11:20 +03:00
|
|
|
|
|
|
|
// ModChannel manager
|
|
|
|
std::unique_ptr<ModChannelMgr> m_modchannel_mgr;
|
2010-11-27 02:02:21 +03:00
|
|
|
};
|
|
|
|
|
2011-01-23 18:29:15 +03:00
|
|
|
/*
|
2011-02-15 17:11:24 +03:00
|
|
|
Runs a simple dedicated server loop.
|
|
|
|
|
2015-07-25 00:11:19 +03:00
|
|
|
Shuts down when kill is set to true.
|
2011-01-23 18:29:15 +03:00
|
|
|
*/
|
2015-07-25 00:11:19 +03:00
|
|
|
void dedicated_server_loop(Server &server, bool &kill);
|