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) 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
|
|
|
|
2017-01-08 12:49:47 +03:00
|
|
|
#include "clientenvironment.h"
|
2012-06-17 05:00:31 +04:00
|
|
|
#include "irrlichttypes_extrabloated.h"
|
2010-11-27 02:02:21 +03:00
|
|
|
#include <ostream>
|
2013-08-11 06:09:45 +04:00
|
|
|
#include <map>
|
2012-03-13 21:56:12 +04:00
|
|
|
#include <set>
|
|
|
|
#include <vector>
|
2017-06-04 22:00:04 +03:00
|
|
|
#include <unordered_set>
|
2011-02-21 01:45:14 +03:00
|
|
|
#include "clientobject.h"
|
2011-11-14 02:19:48 +04:00
|
|
|
#include "gamedef.h"
|
2011-12-06 17:21:56 +04:00
|
|
|
#include "inventorymanager.h"
|
2012-03-31 17:23:26 +04:00
|
|
|
#include "localplayer.h"
|
2018-01-20 16:09:58 +03:00
|
|
|
#include "client/hud.h"
|
2012-12-31 22:33:36 +04:00
|
|
|
#include "particles.h"
|
2017-01-11 11:03:07 +03:00
|
|
|
#include "mapnode.h"
|
2017-01-14 18:48:49 +03:00
|
|
|
#include "tileanimation.h"
|
2017-04-15 10:55:52 +03:00
|
|
|
#include "mesh_generator_thread.h"
|
2017-08-24 09:28:54 +03:00
|
|
|
#include "network/address.h"
|
|
|
|
#include "network/peerhandler.h"
|
2017-06-30 21:14:39 +03:00
|
|
|
#include <fstream>
|
2010-11-27 02:02:21 +03:00
|
|
|
|
2017-07-15 10:28:10 +03:00
|
|
|
#define CLIENT_CHAT_MESSAGE_LIMIT_PER_10S 10.0f
|
|
|
|
|
2017-08-28 21:02:23 +03:00
|
|
|
struct ClientEvent;
|
2011-06-26 03:34:36 +04:00
|
|
|
struct MeshMakeData;
|
2017-07-16 11:47:31 +03:00
|
|
|
struct ChatMessage;
|
2012-03-13 21:56:12 +04:00
|
|
|
class MapBlockMesh;
|
2011-11-15 23:00:39 +04:00
|
|
|
class IWritableTextureSource;
|
2012-03-19 05:59:12 +04:00
|
|
|
class IWritableShaderSource;
|
2012-01-12 09:10:39 +04:00
|
|
|
class IWritableItemDefManager;
|
2018-03-24 17:45:25 +03:00
|
|
|
class ISoundManager;
|
2018-02-10 23:04:16 +03:00
|
|
|
class NodeDefManager;
|
2011-11-17 04:28:46 +04:00
|
|
|
//class IWritableCraftDefManager;
|
Rewrite client media download and support hash-based remote download
Move most of the media-related code in client.cpp into a new class
ClientMediaDownloader (clientmedia.cpp, clientmedia.h). Among other
things, this class does the following things:
- Download [remote_server][sha1] instead of [remote_server][name]. This
is to support servers that provide the same file name with different
contents.
- Initially fetch [remote_server]index.mth. This file should follow the
Minetest Hashset format (currently version 1) and contain a list of SHA1
hashes that exist on the server.
- The list of needed SHA1s is uploaded (via HTTP POST) when index.mth is
requested, so servers can optionally narrow down the list to the needs
of the client.
- If index.mth is missing (HTTP response code 404), we enter compat mode,
fetching [remote_server][name] as before this commit.
- remote_server can now contain multiple servers, separated by commas.
The downloader code attempts to split requests between the different
servers, as permitted by each server's index.mth. If one server claims
to have a file but actually doesn't (or something fails), we ask a
different server that also claims to have it.
- As before, when none of the remote servers provide a particular
file, we download it via the conventional method, i.e. using
the minetest protocol: TOSERVER_REQUEST_MEDIA / TOCLIENT_MEDIA.
- Bugfix: Every downloaded file's SHA1 is now verified against the SHA1
announced by the minetest server (before loading it and inserting it
into the file cache).
- Bugfix: Only send TOSERVER_RECEIVED_MEDIA when we actually have all
media. This should fix #863.
2013-08-29 07:22:18 +04:00
|
|
|
class ClientMediaDownloader;
|
2012-03-16 02:25:18 +04:00
|
|
|
struct MapDrawControl;
|
2017-09-26 01:11:20 +03:00
|
|
|
class ModChannelMgr;
|
2012-03-23 22:23:03 +04:00
|
|
|
class MtEventManager;
|
Rewrite client media download and support hash-based remote download
Move most of the media-related code in client.cpp into a new class
ClientMediaDownloader (clientmedia.cpp, clientmedia.h). Among other
things, this class does the following things:
- Download [remote_server][sha1] instead of [remote_server][name]. This
is to support servers that provide the same file name with different
contents.
- Initially fetch [remote_server]index.mth. This file should follow the
Minetest Hashset format (currently version 1) and contain a list of SHA1
hashes that exist on the server.
- The list of needed SHA1s is uploaded (via HTTP POST) when index.mth is
requested, so servers can optionally narrow down the list to the needs
of the client.
- If index.mth is missing (HTTP response code 404), we enter compat mode,
fetching [remote_server][name] as before this commit.
- remote_server can now contain multiple servers, separated by commas.
The downloader code attempts to split requests between the different
servers, as permitted by each server's index.mth. If one server claims
to have a file but actually doesn't (or something fails), we ask a
different server that also claims to have it.
- As before, when none of the remote servers provide a particular
file, we download it via the conventional method, i.e. using
the minetest protocol: TOSERVER_REQUEST_MEDIA / TOCLIENT_MEDIA.
- Bugfix: Every downloaded file's SHA1 is now verified against the SHA1
announced by the minetest server (before loading it and inserting it
into the file cache).
- Bugfix: Only send TOSERVER_RECEIVED_MEDIA when we actually have all
media. This should fix #863.
2013-08-29 07:22:18 +04:00
|
|
|
struct PointedThing;
|
2017-04-23 15:35:08 +03:00
|
|
|
class MapDatabase;
|
2017-03-16 12:34:54 +03:00
|
|
|
class Minimap;
|
2015-06-22 05:34:56 +03:00
|
|
|
struct MinimapMapblock;
|
2016-02-15 16:01:01 +03:00
|
|
|
class Camera;
|
2017-01-09 22:39:22 +03:00
|
|
|
class NetworkPacket;
|
2017-08-24 09:28:54 +03:00
|
|
|
namespace con {
|
|
|
|
class Connection;
|
|
|
|
}
|
2010-11-27 02:02:21 +03:00
|
|
|
|
2014-02-13 23:17:42 +04:00
|
|
|
enum LocalClientState {
|
|
|
|
LC_Created,
|
|
|
|
LC_Init,
|
|
|
|
LC_Ready
|
|
|
|
};
|
|
|
|
|
2013-08-11 06:09:45 +04:00
|
|
|
/*
|
|
|
|
Packet counter
|
|
|
|
*/
|
|
|
|
|
|
|
|
class PacketCounter
|
|
|
|
{
|
|
|
|
public:
|
2017-08-16 09:53:52 +03:00
|
|
|
PacketCounter() = default;
|
2013-08-11 06:09:45 +04:00
|
|
|
|
|
|
|
void add(u16 command)
|
|
|
|
{
|
2020-04-08 21:13:23 +03:00
|
|
|
auto n = m_packets.find(command);
|
|
|
|
if (n == m_packets.end())
|
2013-08-11 06:09:45 +04:00
|
|
|
m_packets[command] = 1;
|
|
|
|
else
|
|
|
|
n->second++;
|
|
|
|
}
|
|
|
|
|
|
|
|
void clear()
|
|
|
|
{
|
2020-04-08 21:13:23 +03:00
|
|
|
m_packets.clear();
|
2013-08-11 06:09:45 +04:00
|
|
|
}
|
|
|
|
|
2020-04-08 21:13:23 +03:00
|
|
|
void print(std::ostream &o) const;
|
2013-08-11 06:09:45 +04:00
|
|
|
|
|
|
|
private:
|
|
|
|
// command, count
|
|
|
|
std::map<u16, u16> m_packets;
|
|
|
|
};
|
|
|
|
|
2017-01-21 17:02:08 +03:00
|
|
|
class ClientScripting;
|
2018-01-03 16:28:55 +03:00
|
|
|
class GameUI;
|
2017-01-21 17:02:08 +03:00
|
|
|
|
2011-11-14 02:19:48 +04:00
|
|
|
class Client : public con::PeerHandler, public InventoryManager, public IGameDef
|
2010-11-27 02:02:21 +03:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
/*
|
2011-04-04 03:05:12 +04:00
|
|
|
NOTE: Nothing is thread-safe here.
|
2010-11-27 02:02:21 +03:00
|
|
|
*/
|
2011-04-04 03:05:12 +04:00
|
|
|
|
2010-12-19 20:11:05 +03:00
|
|
|
Client(
|
|
|
|
const char *playername,
|
2017-04-19 01:36:30 +03:00
|
|
|
const std::string &password,
|
2017-04-19 16:16:54 +03:00
|
|
|
const std::string &address_name,
|
2011-11-14 02:19:48 +04:00
|
|
|
MapDrawControl &control,
|
2011-11-14 23:41:30 +04:00
|
|
|
IWritableTextureSource *tsrc,
|
2012-03-19 05:59:12 +04:00
|
|
|
IWritableShaderSource *shsrc,
|
2012-01-12 09:10:39 +04:00
|
|
|
IWritableItemDefManager *itemdef,
|
2018-02-10 23:04:16 +03:00
|
|
|
NodeDefManager *nodedef,
|
2012-03-23 22:23:03 +04:00
|
|
|
ISoundManager *sound,
|
2013-06-23 11:31:22 +04:00
|
|
|
MtEventManager *event,
|
2017-03-19 15:18:52 +03:00
|
|
|
bool ipv6,
|
2018-01-03 16:28:55 +03:00
|
|
|
GameUI *game_ui
|
2011-11-14 02:19:48 +04:00
|
|
|
);
|
2015-01-19 07:29:19 +03:00
|
|
|
|
2010-11-27 02:02:21 +03:00
|
|
|
~Client();
|
2017-06-10 14:49:15 +03:00
|
|
|
DISABLE_CLASS_COPY(Client);
|
2014-01-06 15:45:42 +04:00
|
|
|
|
2017-06-30 21:14:39 +03:00
|
|
|
// Load local mods into memory
|
|
|
|
void scanModSubfolder(const std::string &mod_name, const std::string &mod_path,
|
|
|
|
std::string mod_subpath);
|
|
|
|
inline void scanModIntoMemory(const std::string &mod_name, const std::string &mod_path)
|
|
|
|
{
|
|
|
|
scanModSubfolder(mod_name, mod_path, "");
|
|
|
|
}
|
|
|
|
|
2014-01-06 15:45:42 +04:00
|
|
|
/*
|
|
|
|
request all threads managed by client to be stopped
|
|
|
|
*/
|
|
|
|
void Stop();
|
|
|
|
|
|
|
|
|
|
|
|
bool isShutdown();
|
2015-01-30 17:33:23 +03:00
|
|
|
|
2010-11-27 02:02:21 +03:00
|
|
|
/*
|
|
|
|
The name of the local player should already be set when
|
|
|
|
calling this, as it is sent in the initialization.
|
|
|
|
*/
|
2017-04-19 16:16:54 +03:00
|
|
|
void connect(Address address, bool is_local_server);
|
2014-02-13 23:17:42 +04:00
|
|
|
|
2010-11-27 02:02:21 +03:00
|
|
|
/*
|
|
|
|
Stuff that references the environment is valid only as
|
|
|
|
long as this is not called. (eg. Players)
|
|
|
|
If this throws a PeerNotFoundException, the connection has
|
|
|
|
timed out.
|
|
|
|
*/
|
|
|
|
void step(float dtime);
|
|
|
|
|
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_Hello(NetworkPacket* pkt);
|
|
|
|
void handleCommand_AuthAccept(NetworkPacket* pkt);
|
2015-04-12 05:49:13 +03:00
|
|
|
void handleCommand_AcceptSudoMode(NetworkPacket* pkt);
|
|
|
|
void handleCommand_DenySudoMode(NetworkPacket* pkt);
|
2015-03-13 16:14:48 +03:00
|
|
|
void handleCommand_AccessDenied(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_RemoveNode(NetworkPacket* pkt);
|
|
|
|
void handleCommand_AddNode(NetworkPacket* pkt);
|
2018-12-04 22:37:48 +03:00
|
|
|
void handleCommand_NodemetaChanged(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_BlockData(NetworkPacket* pkt);
|
|
|
|
void handleCommand_Inventory(NetworkPacket* pkt);
|
|
|
|
void handleCommand_TimeOfDay(NetworkPacket* pkt);
|
2017-07-16 11:47:31 +03:00
|
|
|
void handleCommand_ChatMessage(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_ActiveObjectRemoveAdd(NetworkPacket* pkt);
|
|
|
|
void handleCommand_ActiveObjectMessages(NetworkPacket* pkt);
|
|
|
|
void handleCommand_Movement(NetworkPacket* pkt);
|
2018-07-15 03:26:30 +03:00
|
|
|
void handleCommand_Fov(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_HP(NetworkPacket* pkt);
|
|
|
|
void handleCommand_Breath(NetworkPacket* pkt);
|
|
|
|
void handleCommand_MovePlayer(NetworkPacket* pkt);
|
|
|
|
void handleCommand_DeathScreen(NetworkPacket* pkt);
|
|
|
|
void handleCommand_AnnounceMedia(NetworkPacket* pkt);
|
|
|
|
void handleCommand_Media(NetworkPacket* pkt);
|
|
|
|
void handleCommand_NodeDef(NetworkPacket* pkt);
|
|
|
|
void handleCommand_ItemDef(NetworkPacket* pkt);
|
|
|
|
void handleCommand_PlaySound(NetworkPacket* pkt);
|
|
|
|
void handleCommand_StopSound(NetworkPacket* pkt);
|
2016-07-10 08:08:26 +03:00
|
|
|
void handleCommand_FadeSound(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_Privileges(NetworkPacket* pkt);
|
|
|
|
void handleCommand_InventoryFormSpec(NetworkPacket* pkt);
|
|
|
|
void handleCommand_DetachedInventory(NetworkPacket* pkt);
|
|
|
|
void handleCommand_ShowFormSpec(NetworkPacket* pkt);
|
|
|
|
void handleCommand_SpawnParticle(NetworkPacket* pkt);
|
|
|
|
void handleCommand_AddParticleSpawner(NetworkPacket* pkt);
|
2015-03-13 16:14:48 +03:00
|
|
|
void handleCommand_DeleteParticleSpawner(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_HudAdd(NetworkPacket* pkt);
|
|
|
|
void handleCommand_HudRemove(NetworkPacket* pkt);
|
|
|
|
void handleCommand_HudChange(NetworkPacket* pkt);
|
|
|
|
void handleCommand_HudSetFlags(NetworkPacket* pkt);
|
|
|
|
void handleCommand_HudSetParam(NetworkPacket* pkt);
|
|
|
|
void handleCommand_HudSetSky(NetworkPacket* pkt);
|
2019-08-21 23:47:45 +03:00
|
|
|
void handleCommand_HudSetSun(NetworkPacket* pkt);
|
|
|
|
void handleCommand_HudSetMoon(NetworkPacket* pkt);
|
|
|
|
void handleCommand_HudSetStars(NetworkPacket* pkt);
|
2017-03-17 12:39:47 +03:00
|
|
|
void handleCommand_CloudParams(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_OverrideDayNightRatio(NetworkPacket* pkt);
|
|
|
|
void handleCommand_LocalPlayerAnimations(NetworkPacket* pkt);
|
|
|
|
void handleCommand_EyeOffset(NetworkPacket* pkt);
|
2017-06-08 16:30:09 +03:00
|
|
|
void handleCommand_UpdatePlayerList(NetworkPacket* pkt);
|
2017-09-26 01:11:20 +03:00
|
|
|
void handleCommand_ModChannelMsg(NetworkPacket *pkt);
|
|
|
|
void handleCommand_ModChannelSignal(NetworkPacket *pkt);
|
2018-03-28 18:04:41 +03:00
|
|
|
void handleCommand_SrpBytesSandB(NetworkPacket *pkt);
|
|
|
|
void handleCommand_FormspecPrepend(NetworkPacket *pkt);
|
2018-06-20 23:36:08 +03:00
|
|
|
void handleCommand_CSMRestrictionFlags(NetworkPacket *pkt);
|
2019-07-16 15:00:42 +03:00
|
|
|
void handleCommand_PlayerSpeed(NetworkPacket *pkt);
|
2015-01-12 19:01:41 +03:00
|
|
|
|
2015-03-31 11:35:51 +03:00
|
|
|
void ProcessData(NetworkPacket *pkt);
|
2015-01-12 19:01:41 +03:00
|
|
|
|
[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 Send(NetworkPacket* pkt);
|
2010-11-27 02:02:21 +03:00
|
|
|
|
2019-08-04 07:53:59 +03:00
|
|
|
void interact(InteractAction action, const PointedThing &pointed);
|
2010-11-27 02:02:21 +03:00
|
|
|
|
2012-06-01 21:51:15 +04:00
|
|
|
void sendNodemetaFields(v3s16 p, const std::string &formname,
|
2015-05-19 09:24:14 +03:00
|
|
|
const StringMap &fields);
|
2012-07-22 18:10:58 +04:00
|
|
|
void sendInventoryFields(const std::string &formname,
|
2015-05-19 09:24:14 +03:00
|
|
|
const StringMap &fields);
|
2010-12-22 17:30:23 +03:00
|
|
|
void sendInventoryAction(InventoryAction *a);
|
2010-12-23 23:35:53 +03:00
|
|
|
void sendChatMessage(const std::wstring &message);
|
2017-07-15 10:28:10 +03:00
|
|
|
void clearOutChatQueue();
|
2015-04-17 07:10:30 +03:00
|
|
|
void sendChangePassword(const std::string &oldpassword,
|
2015-05-19 09:24:14 +03:00
|
|
|
const std::string &newpassword);
|
2019-02-11 02:03:26 +03:00
|
|
|
void sendDamage(u16 damage);
|
2011-10-15 15:46:59 +04:00
|
|
|
void sendRespawn();
|
2014-02-13 23:17:42 +04:00
|
|
|
void sendReady();
|
2012-03-16 01:54:10 +04:00
|
|
|
|
2017-01-09 22:39:22 +03:00
|
|
|
ClientEnvironment& getEnv() { return m_env; }
|
|
|
|
ITextureSource *tsrc() { return getTextureSource(); }
|
|
|
|
ISoundManager *sound() { return getSoundManager(); }
|
2017-01-27 09:41:10 +03:00
|
|
|
static const std::string &getBuiltinLuaPath();
|
|
|
|
static const std::string &getClientModsLuaPath();
|
2017-01-21 17:02:08 +03:00
|
|
|
|
2018-03-29 14:30:18 +03:00
|
|
|
const std::vector<ModSpec> &getMods() const override;
|
|
|
|
const ModSpec* getModSpec(const std::string &modname) const override;
|
2015-01-19 07:29:19 +03:00
|
|
|
|
2012-03-16 01:54:10 +04:00
|
|
|
// Causes urgent mesh updates (unlike Map::add/removeNodeWithEvent)
|
2010-12-23 23:35:53 +03:00
|
|
|
void removeNode(v3s16 p);
|
2017-07-18 22:39:55 +03:00
|
|
|
|
2019-11-09 00:57:03 +03:00
|
|
|
// helpers to enforce CSM restrictions
|
|
|
|
MapNode CSMGetNode(v3s16 p, bool *is_valid_position);
|
|
|
|
int CSMClampRadius(v3s16 pos, int radius);
|
2019-11-09 02:22:42 +03:00
|
|
|
v3s16 CSMClampPos(v3s16 pos);
|
2019-11-09 00:57:03 +03:00
|
|
|
|
2013-11-23 18:35:49 +04:00
|
|
|
void addNode(v3s16 p, MapNode n, bool remove_metadata = true);
|
2015-01-19 07:29:19 +03:00
|
|
|
|
2010-11-27 02:02:21 +03:00
|
|
|
void setPlayerControl(PlayerControl &control);
|
2011-08-10 20:31:44 +04:00
|
|
|
|
2010-11-27 02:02:21 +03:00
|
|
|
// Returns true if the inventory of the local player has been
|
|
|
|
// updated from the server. If it is true, it is set to false.
|
2019-08-24 20:07:38 +03:00
|
|
|
bool updateWieldedItem();
|
2015-01-19 07:29:19 +03:00
|
|
|
|
2011-12-06 17:21:56 +04:00
|
|
|
/* InventoryManager interface */
|
2018-03-29 14:30:18 +03:00
|
|
|
Inventory* getInventory(const InventoryLocation &loc) override;
|
|
|
|
void inventoryAction(InventoryAction *a) override;
|
2011-04-04 16:13:19 +04:00
|
|
|
|
2019-08-07 20:16:31 +03:00
|
|
|
// Send the item number 'item' as player item to the server
|
|
|
|
void setPlayerItem(u16 item);
|
|
|
|
|
2016-10-09 00:13:38 +03:00
|
|
|
const std::list<std::string> &getConnectedPlayerNames()
|
|
|
|
{
|
|
|
|
return m_env.getPlayerNames();
|
|
|
|
}
|
2011-12-03 12:01:14 +04:00
|
|
|
|
2012-03-13 21:56:12 +04:00
|
|
|
float getAnimationTime();
|
|
|
|
|
|
|
|
int getCrackLevel();
|
2017-04-15 10:55:52 +03:00
|
|
|
v3s16 getCrackPos();
|
2012-03-13 21:56:12 +04:00
|
|
|
void setCrack(int level, v3s16 pos);
|
|
|
|
|
2011-04-21 20:35:17 +04:00
|
|
|
u16 getHP();
|
|
|
|
|
2016-10-05 10:03:55 +03:00
|
|
|
bool checkPrivilege(const std::string &priv) const
|
2012-03-31 17:23:26 +04:00
|
|
|
{ return (m_privileges.count(priv) != 0); }
|
2010-12-23 23:35:53 +03:00
|
|
|
|
2017-06-07 10:09:06 +03:00
|
|
|
const std::unordered_set<std::string> &getPrivilegeList() const
|
|
|
|
{ return m_privileges; }
|
|
|
|
|
2011-12-03 12:01:14 +04:00
|
|
|
bool getChatMessage(std::wstring &message);
|
|
|
|
void typeChatMessage(const std::wstring& message);
|
2010-12-23 23:35:53 +03:00
|
|
|
|
2011-02-28 03:01:40 +03:00
|
|
|
u64 getMapSeed(){ return m_map_seed; }
|
|
|
|
|
2012-03-13 21:56:12 +04:00
|
|
|
void addUpdateMeshTask(v3s16 blockpos, bool ack_to_server=false, bool urgent=false);
|
2011-04-04 03:05:12 +04:00
|
|
|
// Including blocks at appropriate edges
|
2012-03-13 21:56:12 +04:00
|
|
|
void addUpdateMeshTaskWithEdge(v3s16 blockpos, bool ack_to_server=false, bool urgent=false);
|
|
|
|
void addUpdateMeshTaskForNode(v3s16 nodepos, bool ack_to_server=false, bool urgent=false);
|
2015-01-19 07:29:19 +03:00
|
|
|
|
2014-04-06 17:12:04 +04:00
|
|
|
void updateCameraOffset(v3s16 camera_offset)
|
|
|
|
{ m_mesh_update_thread.m_camera_offset = camera_offset; }
|
2011-04-04 03:05:12 +04:00
|
|
|
|
2017-04-29 18:25:25 +03:00
|
|
|
bool hasClientEvents() const { return !m_client_event_queue.empty(); }
|
|
|
|
// Get event from queue. If queue is empty, it triggers an assertion failure.
|
2017-08-28 21:02:23 +03:00
|
|
|
ClientEvent * getClientEvent();
|
2015-01-19 07:29:19 +03:00
|
|
|
|
2017-01-22 13:17:41 +03:00
|
|
|
bool accessDenied() const { return m_access_denied; }
|
2011-05-20 23:28:03 +04:00
|
|
|
|
2017-01-22 13:17:41 +03:00
|
|
|
bool reconnectRequested() const { return m_access_denied_reconnect; }
|
2015-07-17 17:40:41 +03:00
|
|
|
|
2017-01-22 13:17:41 +03:00
|
|
|
void setFatalError(const std::string &reason)
|
|
|
|
{
|
|
|
|
m_access_denied = true;
|
|
|
|
m_access_denied_reason = reason;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Renaming accessDeniedReason to better name could be good as it's used to
|
|
|
|
// disconnect client when CSM failed.
|
|
|
|
const std::string &accessDeniedReason() const { return m_access_denied_reason; }
|
2011-11-16 01:58:56 +04:00
|
|
|
|
2019-09-13 09:04:06 +03:00
|
|
|
const bool itemdefReceived() const
|
2012-01-12 09:10:39 +04:00
|
|
|
{ return m_itemdef_received; }
|
2019-09-13 09:04:06 +03:00
|
|
|
const bool nodedefReceived() const
|
2011-11-16 01:58:56 +04:00
|
|
|
{ return m_nodedef_received; }
|
2019-09-13 09:04:06 +03:00
|
|
|
const bool mediaReceived() const
|
2017-06-17 20:11:28 +03:00
|
|
|
{ return !m_media_downloader; }
|
2019-08-25 03:54:21 +03:00
|
|
|
const bool activeObjectsReceived() const
|
|
|
|
{ return m_activeobjects_received; }
|
Rewrite client media download and support hash-based remote download
Move most of the media-related code in client.cpp into a new class
ClientMediaDownloader (clientmedia.cpp, clientmedia.h). Among other
things, this class does the following things:
- Download [remote_server][sha1] instead of [remote_server][name]. This
is to support servers that provide the same file name with different
contents.
- Initially fetch [remote_server]index.mth. This file should follow the
Minetest Hashset format (currently version 1) and contain a list of SHA1
hashes that exist on the server.
- The list of needed SHA1s is uploaded (via HTTP POST) when index.mth is
requested, so servers can optionally narrow down the list to the needs
of the client.
- If index.mth is missing (HTTP response code 404), we enter compat mode,
fetching [remote_server][name] as before this commit.
- remote_server can now contain multiple servers, separated by commas.
The downloader code attempts to split requests between the different
servers, as permitted by each server's index.mth. If one server claims
to have a file but actually doesn't (or something fails), we ask a
different server that also claims to have it.
- As before, when none of the remote servers provide a particular
file, we download it via the conventional method, i.e. using
the minetest protocol: TOSERVER_REQUEST_MEDIA / TOCLIENT_MEDIA.
- Bugfix: Every downloaded file's SHA1 is now verified against the SHA1
announced by the minetest server (before loading it and inserting it
into the file cache).
- Bugfix: Only send TOSERVER_RECEIVED_MEDIA when we actually have all
media. This should fix #863.
2013-08-29 07:22:18 +04:00
|
|
|
|
2019-02-11 02:03:26 +03:00
|
|
|
u16 getProtoVersion()
|
2015-06-20 13:55:48 +03:00
|
|
|
{ return m_proto_ver; }
|
|
|
|
|
2017-08-24 09:28:54 +03:00
|
|
|
bool connectedToServer();
|
2018-01-13 14:07:16 +03:00
|
|
|
void confirmRegistration();
|
|
|
|
bool m_is_registration_confirmation_state = false;
|
|
|
|
bool m_simple_singleplayer_mode;
|
2016-08-22 05:27:44 +03:00
|
|
|
|
Rewrite client media download and support hash-based remote download
Move most of the media-related code in client.cpp into a new class
ClientMediaDownloader (clientmedia.cpp, clientmedia.h). Among other
things, this class does the following things:
- Download [remote_server][sha1] instead of [remote_server][name]. This
is to support servers that provide the same file name with different
contents.
- Initially fetch [remote_server]index.mth. This file should follow the
Minetest Hashset format (currently version 1) and contain a list of SHA1
hashes that exist on the server.
- The list of needed SHA1s is uploaded (via HTTP POST) when index.mth is
requested, so servers can optionally narrow down the list to the needs
of the client.
- If index.mth is missing (HTTP response code 404), we enter compat mode,
fetching [remote_server][name] as before this commit.
- remote_server can now contain multiple servers, separated by commas.
The downloader code attempts to split requests between the different
servers, as permitted by each server's index.mth. If one server claims
to have a file but actually doesn't (or something fails), we ask a
different server that also claims to have it.
- As before, when none of the remote servers provide a particular
file, we download it via the conventional method, i.e. using
the minetest protocol: TOSERVER_REQUEST_MEDIA / TOCLIENT_MEDIA.
- Bugfix: Every downloaded file's SHA1 is now verified against the SHA1
announced by the minetest server (before loading it and inserting it
into the file cache).
- Bugfix: Only send TOSERVER_RECEIVED_MEDIA when we actually have all
media. This should fix #863.
2013-08-29 07:22:18 +04:00
|
|
|
float mediaReceiveProgress();
|
|
|
|
|
2017-06-26 21:11:17 +03:00
|
|
|
void afterContentReceived();
|
2012-01-12 09:10:39 +04:00
|
|
|
|
2017-03-16 12:34:54 +03:00
|
|
|
float getRTT();
|
|
|
|
float getCurRate();
|
2011-10-17 18:18:50 +04:00
|
|
|
|
2017-03-16 12:34:54 +03:00
|
|
|
Minimap* getMinimap() { return m_minimap; }
|
|
|
|
void setCamera(Camera* camera) { m_camera = camera; }
|
2016-02-15 16:01:01 +03:00
|
|
|
|
2017-05-20 09:15:56 +03:00
|
|
|
Camera* getCamera () { return m_camera; }
|
2016-02-15 16:01:01 +03:00
|
|
|
|
2017-03-16 12:34:54 +03:00
|
|
|
bool shouldShowMinimap() const;
|
2015-09-01 04:07:02 +03:00
|
|
|
|
2011-11-14 02:19:48 +04:00
|
|
|
// IGameDef interface
|
2018-03-29 14:30:18 +03:00
|
|
|
IItemDefManager* getItemDefManager() override;
|
|
|
|
const NodeDefManager* getNodeDefManager() override;
|
|
|
|
ICraftDefManager* getCraftDefManager() override;
|
2017-01-09 22:39:22 +03:00
|
|
|
ITextureSource* getTextureSource();
|
2020-02-16 22:37:28 +03:00
|
|
|
virtual IWritableShaderSource* getShaderSource();
|
2018-03-29 14:30:18 +03:00
|
|
|
u16 allocateUnknownNodeId(const std::string &name) override;
|
2012-03-23 14:05:17 +04:00
|
|
|
virtual ISoundManager* getSoundManager();
|
2018-03-30 19:32:52 +03:00
|
|
|
MtEventManager* getEventManager();
|
2015-01-05 20:34:59 +03:00
|
|
|
virtual ParticleManager* getParticleManager();
|
2017-01-09 22:39:22 +03:00
|
|
|
bool checkLocalPrivilege(const std::string &priv)
|
2012-03-31 17:23:26 +04:00
|
|
|
{ return checkPrivilege(priv); }
|
2017-12-05 09:25:09 +03:00
|
|
|
virtual scene::IAnimatedMesh* getMesh(const std::string &filename, bool cache = false);
|
2019-11-09 17:11:21 +03:00
|
|
|
const std::string* getModFile(std::string filename);
|
2011-11-14 02:19:48 +04:00
|
|
|
|
2018-03-29 14:30:18 +03:00
|
|
|
std::string getModStoragePath() const override;
|
|
|
|
bool registerModStorage(ModMetadata *meta) override;
|
|
|
|
void unregisterModStorage(const std::string &name) override;
|
2017-03-16 09:53:39 +03:00
|
|
|
|
Rewrite client media download and support hash-based remote download
Move most of the media-related code in client.cpp into a new class
ClientMediaDownloader (clientmedia.cpp, clientmedia.h). Among other
things, this class does the following things:
- Download [remote_server][sha1] instead of [remote_server][name]. This
is to support servers that provide the same file name with different
contents.
- Initially fetch [remote_server]index.mth. This file should follow the
Minetest Hashset format (currently version 1) and contain a list of SHA1
hashes that exist on the server.
- The list of needed SHA1s is uploaded (via HTTP POST) when index.mth is
requested, so servers can optionally narrow down the list to the needs
of the client.
- If index.mth is missing (HTTP response code 404), we enter compat mode,
fetching [remote_server][name] as before this commit.
- remote_server can now contain multiple servers, separated by commas.
The downloader code attempts to split requests between the different
servers, as permitted by each server's index.mth. If one server claims
to have a file but actually doesn't (or something fails), we ask a
different server that also claims to have it.
- As before, when none of the remote servers provide a particular
file, we download it via the conventional method, i.e. using
the minetest protocol: TOSERVER_REQUEST_MEDIA / TOCLIENT_MEDIA.
- Bugfix: Every downloaded file's SHA1 is now verified against the SHA1
announced by the minetest server (before loading it and inserting it
into the file cache).
- Bugfix: Only send TOSERVER_RECEIVED_MEDIA when we actually have all
media. This should fix #863.
2013-08-29 07:22:18 +04:00
|
|
|
// The following set of functions is used by ClientMediaDownloader
|
2012-03-25 15:47:51 +04:00
|
|
|
// Insert a media file appropriately into the appropriate manager
|
|
|
|
bool loadMedia(const std::string &data, const std::string &filename);
|
Rewrite client media download and support hash-based remote download
Move most of the media-related code in client.cpp into a new class
ClientMediaDownloader (clientmedia.cpp, clientmedia.h). Among other
things, this class does the following things:
- Download [remote_server][sha1] instead of [remote_server][name]. This
is to support servers that provide the same file name with different
contents.
- Initially fetch [remote_server]index.mth. This file should follow the
Minetest Hashset format (currently version 1) and contain a list of SHA1
hashes that exist on the server.
- The list of needed SHA1s is uploaded (via HTTP POST) when index.mth is
requested, so servers can optionally narrow down the list to the needs
of the client.
- If index.mth is missing (HTTP response code 404), we enter compat mode,
fetching [remote_server][name] as before this commit.
- remote_server can now contain multiple servers, separated by commas.
The downloader code attempts to split requests between the different
servers, as permitted by each server's index.mth. If one server claims
to have a file but actually doesn't (or something fails), we ask a
different server that also claims to have it.
- As before, when none of the remote servers provide a particular
file, we download it via the conventional method, i.e. using
the minetest protocol: TOSERVER_REQUEST_MEDIA / TOCLIENT_MEDIA.
- Bugfix: Every downloaded file's SHA1 is now verified against the SHA1
announced by the minetest server (before loading it and inserting it
into the file cache).
- Bugfix: Only send TOSERVER_RECEIVED_MEDIA when we actually have all
media. This should fix #863.
2013-08-29 07:22:18 +04:00
|
|
|
// Send a request for conventional media transfer
|
2015-03-05 12:43:08 +03:00
|
|
|
void request_media(const std::vector<std::string> &file_requests);
|
2012-12-14 15:30:17 +04:00
|
|
|
|
2014-02-13 23:17:42 +04:00
|
|
|
LocalClientState getState() { return m_state; }
|
|
|
|
|
2017-06-19 01:00:55 +03:00
|
|
|
void makeScreenshot();
|
2014-09-21 04:23:55 +04:00
|
|
|
|
2017-07-16 11:47:31 +03:00
|
|
|
inline void pushToChatQueue(ChatMessage *cec)
|
2017-01-22 00:44:37 +03:00
|
|
|
{
|
2017-07-16 11:47:31 +03:00
|
|
|
m_chat_queue.push(cec);
|
2017-01-22 00:44:37 +03:00
|
|
|
}
|
|
|
|
|
2017-01-22 02:20:55 +03:00
|
|
|
ClientScripting *getScript() { return m_script; }
|
2018-11-24 13:41:11 +03:00
|
|
|
const bool modsLoaded() const { return m_mods_loaded; }
|
2017-01-22 02:20:55 +03:00
|
|
|
|
2017-08-28 21:02:23 +03:00
|
|
|
void pushToEventQueue(ClientEvent *event);
|
2017-01-24 19:26:15 +03:00
|
|
|
|
2017-08-16 09:53:52 +03:00
|
|
|
void showMinimap(bool show = true);
|
2017-03-19 15:18:52 +03:00
|
|
|
|
2017-08-24 09:28:54 +03:00
|
|
|
const Address getServerAddress();
|
2017-04-19 16:16:54 +03:00
|
|
|
|
|
|
|
const std::string &getAddressName() const
|
|
|
|
{
|
|
|
|
return m_address_name;
|
|
|
|
}
|
|
|
|
|
2019-11-09 13:00:19 +03:00
|
|
|
inline u64 getCSMRestrictionFlags() const
|
|
|
|
{
|
|
|
|
return m_csm_restriction_flags;
|
|
|
|
}
|
|
|
|
|
2018-06-20 23:36:08 +03:00
|
|
|
inline bool checkCSMRestrictionFlag(CSMRestrictionFlags flag) const
|
2017-07-18 22:39:55 +03:00
|
|
|
{
|
2018-06-20 23:36:08 +03:00
|
|
|
return m_csm_restriction_flags & flag;
|
2017-07-18 22:39:55 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
u32 getCSMNodeRangeLimit() const
|
|
|
|
{
|
2018-06-20 23:36:08 +03:00
|
|
|
return m_csm_restriction_noderange;
|
2017-07-18 22:39:55 +03:00
|
|
|
}
|
|
|
|
|
2018-01-26 18:05:47 +03:00
|
|
|
inline std::unordered_map<u32, u32> &getHUDTranslationMap()
|
|
|
|
{
|
|
|
|
return m_hud_server_to_client;
|
|
|
|
}
|
|
|
|
|
2018-03-29 14:30:18 +03:00
|
|
|
bool joinModChannel(const std::string &channel) override;
|
|
|
|
bool leaveModChannel(const std::string &channel) override;
|
|
|
|
bool sendModChannelMessage(const std::string &channel,
|
|
|
|
const std::string &message) override;
|
|
|
|
ModChannel *getModChannel(const std::string &channel) override;
|
2017-09-26 01:11:20 +03:00
|
|
|
|
2018-03-28 18:04:41 +03:00
|
|
|
const std::string &getFormspecPrepend() const
|
|
|
|
{
|
|
|
|
return m_env.getLocalPlayer()->formspec_prepend;
|
|
|
|
}
|
Rewrite client media download and support hash-based remote download
Move most of the media-related code in client.cpp into a new class
ClientMediaDownloader (clientmedia.cpp, clientmedia.h). Among other
things, this class does the following things:
- Download [remote_server][sha1] instead of [remote_server][name]. This
is to support servers that provide the same file name with different
contents.
- Initially fetch [remote_server]index.mth. This file should follow the
Minetest Hashset format (currently version 1) and contain a list of SHA1
hashes that exist on the server.
- The list of needed SHA1s is uploaded (via HTTP POST) when index.mth is
requested, so servers can optionally narrow down the list to the needs
of the client.
- If index.mth is missing (HTTP response code 404), we enter compat mode,
fetching [remote_server][name] as before this commit.
- remote_server can now contain multiple servers, separated by commas.
The downloader code attempts to split requests between the different
servers, as permitted by each server's index.mth. If one server claims
to have a file but actually doesn't (or something fails), we ask a
different server that also claims to have it.
- As before, when none of the remote servers provide a particular
file, we download it via the conventional method, i.e. using
the minetest protocol: TOSERVER_REQUEST_MEDIA / TOCLIENT_MEDIA.
- Bugfix: Every downloaded file's SHA1 is now verified against the SHA1
announced by the minetest server (before loading it and inserting it
into the file cache).
- Bugfix: Only send TOSERVER_RECEIVED_MEDIA when we actually have all
media. This should fix #863.
2013-08-29 07:22:18 +04:00
|
|
|
private:
|
2017-12-11 19:33:44 +03:00
|
|
|
void loadMods();
|
|
|
|
bool checkBuiltinIntegrity();
|
2012-12-14 15:30:17 +04:00
|
|
|
|
2010-11-27 02:02:21 +03:00
|
|
|
// Virtual methods from con::PeerHandler
|
2018-03-29 14:30:18 +03:00
|
|
|
void peerAdded(con::Peer *peer) override;
|
|
|
|
void deletingPeer(con::Peer *peer, bool timeout) override;
|
2015-01-19 07:29:19 +03:00
|
|
|
|
2015-01-30 17:33:23 +03:00
|
|
|
void initLocalMapSaving(const Address &address,
|
|
|
|
const std::string &hostname,
|
|
|
|
bool is_local_server);
|
|
|
|
|
2010-11-27 02:02:21 +03:00
|
|
|
void ReceiveAll();
|
2015-01-19 07:29:19 +03:00
|
|
|
|
2010-11-27 02:02:21 +03:00
|
|
|
void sendPlayerPos();
|
2015-01-19 07:29:19 +03:00
|
|
|
|
2015-04-12 05:49:13 +03:00
|
|
|
void deleteAuthData();
|
|
|
|
// helper method shared with clientpackethandler
|
|
|
|
static AuthMechanism choseAuthMech(const u32 mechs);
|
|
|
|
|
|
|
|
void sendInit(const std::string &playerName);
|
2018-01-13 14:07:16 +03:00
|
|
|
void promptConfirmRegistration(AuthMechanism chosen_auth_mechanism);
|
2015-04-12 05:49:13 +03:00
|
|
|
void startAuth(AuthMechanism chosen_auth_mechanism);
|
2015-03-16 14:39:27 +03:00
|
|
|
void sendDeletedBlocks(std::vector<v3s16> &blocks);
|
2019-08-07 11:31:12 +03:00
|
|
|
void sendGotBlocks(const std::vector<v3s16> &blocks);
|
2015-03-16 14:39:27 +03:00
|
|
|
void sendRemovedSounds(std::vector<s32> &soundList);
|
|
|
|
|
2015-04-12 05:49:13 +03:00
|
|
|
// Helper function
|
|
|
|
inline std::string getPlayerName()
|
|
|
|
{ return m_env.getLocalPlayer()->getName(); }
|
|
|
|
|
2017-07-15 10:28:10 +03:00
|
|
|
bool canSendChatMessage() const;
|
|
|
|
|
2017-06-16 12:25:52 +03:00
|
|
|
float m_packetcounter_timer = 0.0f;
|
|
|
|
float m_connection_reinit_timer = 0.1f;
|
|
|
|
float m_avg_rtt_timer = 0.0f;
|
|
|
|
float m_playerpos_send_timer = 0.0f;
|
2011-06-27 01:27:17 +04:00
|
|
|
IntervalLimiter m_map_timer_and_unload_interval;
|
2010-12-19 17:51:45 +03:00
|
|
|
|
2011-11-14 23:41:30 +04:00
|
|
|
IWritableTextureSource *m_tsrc;
|
2012-03-19 05:59:12 +04:00
|
|
|
IWritableShaderSource *m_shsrc;
|
2012-01-12 09:10:39 +04:00
|
|
|
IWritableItemDefManager *m_itemdef;
|
2018-02-10 23:04:16 +03:00
|
|
|
NodeDefManager *m_nodedef;
|
2012-03-23 17:29:30 +04:00
|
|
|
ISoundManager *m_sound;
|
2012-03-23 22:23:03 +04:00
|
|
|
MtEventManager *m_event;
|
|
|
|
|
2015-01-05 20:34:59 +03:00
|
|
|
|
2011-04-04 03:05:12 +04:00
|
|
|
MeshUpdateThread m_mesh_update_thread;
|
2011-02-21 01:45:14 +03:00
|
|
|
ClientEnvironment m_env;
|
2015-01-05 20:34:59 +03:00
|
|
|
ParticleManager m_particle_manager;
|
2017-08-24 09:28:54 +03:00
|
|
|
std::unique_ptr<con::Connection> m_con;
|
2017-04-19 16:16:54 +03:00
|
|
|
std::string m_address_name;
|
2017-06-16 12:25:52 +03:00
|
|
|
Camera *m_camera = nullptr;
|
|
|
|
Minimap *m_minimap = nullptr;
|
|
|
|
bool m_minimap_disabled_by_server = false;
|
2010-11-27 02:02:21 +03:00
|
|
|
// Server serialization version
|
|
|
|
u8 m_server_ser_ver;
|
2015-07-05 22:05:07 +03:00
|
|
|
|
2015-04-12 05:49:13 +03:00
|
|
|
// Used version of the protocol with server
|
2015-07-05 22:05:07 +03:00
|
|
|
// Values smaller than 25 only mean they are smaller than 25,
|
|
|
|
// and aren't accurate. We simply just don't know, because
|
|
|
|
// the server didn't send the version back then.
|
|
|
|
// If 0, server init hasn't been received yet.
|
2019-02-11 02:03:26 +03:00
|
|
|
u16 m_proto_ver = 0;
|
2015-07-05 22:05:07 +03:00
|
|
|
|
2019-08-24 20:07:38 +03:00
|
|
|
bool m_update_wielded_item = false;
|
2017-06-16 12:25:52 +03:00
|
|
|
Inventory *m_inventory_from_server = nullptr;
|
|
|
|
float m_inventory_from_server_age = 0.0f;
|
2010-11-27 18:18:34 +03:00
|
|
|
PacketCounter m_packetcounter;
|
2012-03-13 21:56:12 +04:00
|
|
|
// Block mesh animation parameters
|
2017-06-16 12:25:52 +03:00
|
|
|
float m_animation_time = 0.0f;
|
|
|
|
int m_crack_level = -1;
|
2012-03-13 21:56:12 +04:00
|
|
|
v3s16 m_crack_pos;
|
2010-12-19 17:51:45 +03:00
|
|
|
// 0 <= m_daynight_i < DAYNIGHT_CACHE_COUNT
|
|
|
|
//s32 m_daynight_i;
|
|
|
|
//u32 m_daynight_ratio;
|
2017-07-15 10:28:10 +03:00
|
|
|
std::queue<std::wstring> m_out_chat_queue;
|
|
|
|
u32 m_last_chat_message_sent;
|
|
|
|
float m_chat_message_allowance = 5.0f;
|
2017-07-16 11:47:31 +03:00
|
|
|
std::queue<ChatMessage *> m_chat_queue;
|
2015-04-12 05:49:13 +03:00
|
|
|
|
|
|
|
// The authentication methods we can use to enter sudo mode (=change password)
|
|
|
|
u32 m_sudo_auth_methods;
|
|
|
|
|
2011-02-28 03:01:40 +03:00
|
|
|
// The seed returned by the server in TOCLIENT_INIT is stored here
|
2017-06-16 12:25:52 +03:00
|
|
|
u64 m_map_seed = 0;
|
2015-04-12 05:49:13 +03:00
|
|
|
|
|
|
|
// Auth data
|
|
|
|
std::string m_playername;
|
2011-05-20 23:28:03 +04:00
|
|
|
std::string m_password;
|
2015-04-12 05:49:13 +03:00
|
|
|
// If set, this will be sent (and cleared) upon a TOCLIENT_ACCEPT_SUDO_MODE
|
|
|
|
std::string m_new_password;
|
|
|
|
// Usable by auth mechanisms.
|
|
|
|
AuthMechanism m_chosen_auth_mech;
|
2017-06-16 12:25:52 +03:00
|
|
|
void *m_auth_data = nullptr;
|
2015-04-12 05:49:13 +03:00
|
|
|
|
|
|
|
|
2017-06-16 12:25:52 +03:00
|
|
|
bool m_access_denied = false;
|
|
|
|
bool m_access_denied_reconnect = false;
|
|
|
|
std::string m_access_denied_reason = "";
|
2017-08-28 21:02:23 +03:00
|
|
|
std::queue<ClientEvent *> m_client_event_queue;
|
2017-06-16 12:25:52 +03:00
|
|
|
bool m_itemdef_received = false;
|
|
|
|
bool m_nodedef_received = false;
|
2019-08-25 03:54:21 +03:00
|
|
|
bool m_activeobjects_received = false;
|
2017-12-11 19:33:44 +03:00
|
|
|
bool m_mods_loaded = false;
|
Rewrite client media download and support hash-based remote download
Move most of the media-related code in client.cpp into a new class
ClientMediaDownloader (clientmedia.cpp, clientmedia.h). Among other
things, this class does the following things:
- Download [remote_server][sha1] instead of [remote_server][name]. This
is to support servers that provide the same file name with different
contents.
- Initially fetch [remote_server]index.mth. This file should follow the
Minetest Hashset format (currently version 1) and contain a list of SHA1
hashes that exist on the server.
- The list of needed SHA1s is uploaded (via HTTP POST) when index.mth is
requested, so servers can optionally narrow down the list to the needs
of the client.
- If index.mth is missing (HTTP response code 404), we enter compat mode,
fetching [remote_server][name] as before this commit.
- remote_server can now contain multiple servers, separated by commas.
The downloader code attempts to split requests between the different
servers, as permitted by each server's index.mth. If one server claims
to have a file but actually doesn't (or something fails), we ask a
different server that also claims to have it.
- As before, when none of the remote servers provide a particular
file, we download it via the conventional method, i.e. using
the minetest protocol: TOSERVER_REQUEST_MEDIA / TOCLIENT_MEDIA.
- Bugfix: Every downloaded file's SHA1 is now verified against the SHA1
announced by the minetest server (before loading it and inserting it
into the file cache).
- Bugfix: Only send TOSERVER_RECEIVED_MEDIA when we actually have all
media. This should fix #863.
2013-08-29 07:22:18 +04:00
|
|
|
ClientMediaDownloader *m_media_downloader;
|
2012-03-16 18:34:30 +04:00
|
|
|
|
|
|
|
// time_of_day speed approximation for old protocol
|
2017-06-16 12:25:52 +03:00
|
|
|
bool m_time_of_day_set = false;
|
|
|
|
float m_last_time_of_day_f = -1.0f;
|
|
|
|
float m_time_of_day_update_timer = 0.0f;
|
2012-03-24 21:01:26 +04:00
|
|
|
|
2012-11-27 00:31:21 +04:00
|
|
|
// An interval for generally sending object positions and stuff
|
2017-06-16 12:25:52 +03:00
|
|
|
float m_recommended_send_interval = 0.1f;
|
2012-11-27 00:31:21 +04:00
|
|
|
|
2012-03-24 21:01:26 +04:00
|
|
|
// Sounds
|
2017-06-16 12:25:52 +03:00
|
|
|
float m_removed_sounds_check_timer = 0.0f;
|
2012-03-24 21:01:26 +04:00
|
|
|
// Mapping from server sound ids to our sound ids
|
2017-06-04 22:00:04 +03:00
|
|
|
std::unordered_map<s32, int> m_sounds_server_to_client;
|
2012-03-24 21:01:26 +04:00
|
|
|
// And the other way!
|
2017-06-04 22:00:04 +03:00
|
|
|
std::unordered_map<int, s32> m_sounds_client_to_server;
|
2020-01-25 23:19:29 +03:00
|
|
|
// Relation of client id to object id
|
2017-06-04 22:00:04 +03:00
|
|
|
std::unordered_map<int, u16> m_sounds_to_objects;
|
2010-11-27 02:02:21 +03:00
|
|
|
|
2019-02-26 10:53:53 +03:00
|
|
|
// Map server hud ids to client hud ids
|
2018-01-20 16:09:58 +03:00
|
|
|
std::unordered_map<u32, u32> m_hud_server_to_client;
|
|
|
|
|
2012-03-31 17:23:26 +04:00
|
|
|
// Privileges
|
2017-06-04 22:00:04 +03:00
|
|
|
std::unordered_set<std::string> m_privileges;
|
2012-07-24 21:57:17 +04:00
|
|
|
|
|
|
|
// Detached inventories
|
|
|
|
// key = name
|
2017-06-04 22:00:04 +03:00
|
|
|
std::unordered_map<std::string, Inventory*> m_detached_inventories;
|
2014-01-06 15:24:06 +04:00
|
|
|
|
|
|
|
// Storage for mesh data for creating multiple instances of the same mesh
|
2015-05-19 09:24:14 +03:00
|
|
|
StringMap m_mesh_data;
|
2014-02-13 23:17:42 +04:00
|
|
|
|
|
|
|
// own state
|
|
|
|
LocalClientState m_state;
|
2014-10-09 16:02:02 +04:00
|
|
|
|
2018-01-03 16:28:55 +03:00
|
|
|
GameUI *m_game_ui;
|
|
|
|
|
2014-10-09 16:02:02 +04:00
|
|
|
// Used for saving server map to disk client-side
|
2017-06-16 12:25:52 +03:00
|
|
|
MapDatabase *m_localdb = nullptr;
|
2014-11-16 23:31:57 +03:00
|
|
|
IntervalLimiter m_localdb_save_interval;
|
|
|
|
u16 m_cache_save_interval;
|
2014-12-06 17:37:37 +03:00
|
|
|
|
2019-11-08 22:01:47 +03:00
|
|
|
// Client modding
|
2017-06-16 12:25:52 +03:00
|
|
|
ClientScripting *m_script = nullptr;
|
2017-03-13 17:55:30 +03:00
|
|
|
bool m_modding_enabled;
|
2017-06-04 22:00:04 +03:00
|
|
|
std::unordered_map<std::string, ModMetadata *> m_mod_storages;
|
2017-06-16 12:25:52 +03:00
|
|
|
float m_mod_storage_save_timer = 10.0f;
|
2017-06-30 21:14:39 +03:00
|
|
|
std::vector<ModSpec> m_mods;
|
2019-11-08 22:01:47 +03:00
|
|
|
StringMap m_mod_vfs;
|
2017-01-21 17:02:08 +03:00
|
|
|
|
2017-06-16 12:25:52 +03:00
|
|
|
bool m_shutdown = false;
|
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
|
|
|
|
|
|
|
std::unique_ptr<ModChannelMgr> m_modchannel_mgr;
|
2012-03-31 17:23:26 +04:00
|
|
|
};
|