#include "serialization.h" // for SER_FMT_VER_INVALID
#include "network/networkpacket.h"
#include "network/networkprotocol.h"
+#include "network/address.h"
#include "porting.h"
#include <list>
{
CSE_Hello,
CSE_AuthAccept,
- CSE_InitLegacy,
CSE_GotInit2,
CSE_SetDenied,
CSE_SetDefinitionsSent,
*/
struct PrioritySortedBlockTransfer
{
- PrioritySortedBlockTransfer(float a_priority, const v3s16 &a_pos, u16 a_peer_id)
+ PrioritySortedBlockTransfer(float a_priority, const v3s16 &a_pos, session_t a_peer_id)
{
priority = a_priority;
pos = a_pos;
}
float priority;
v3s16 pos;
- u16 peer_id;
+ session_t peer_id;
};
class RemoteClient
// NOTE: If client is made allowed to exist while peer doesn't,
// this has to be set to 0 when there is no peer.
// Also, the client must be moved to some other container.
- u16 peer_id = PEER_ID_INEXISTENT;
+ session_t peer_id = PEER_ID_INEXISTENT;
// The serialization version to use with the client
u8 serialization_version = SER_FMT_VER_INVALID;
//
bool isMechAllowed(AuthMechanism mech)
{ return allowed_auth_mechs & mech; }
- RemoteClient() = default;
+ RemoteClient();
~RemoteClient() = default;
/*
u32 getSendingCount() const { return m_blocks_sending.size(); }
+ bool isBlockSent(v3s16 p) const
+ {
+ return m_blocks_sent.find(p) != m_blocks_sent.end();
+ }
+
// Increments timeouts and removes timed-out blocks from list
// NOTE: This doesn't fix the server-not-sending-block bug
// because it is related to emerging, not sending.
u8 getMajor() const { return m_version_major; }
u8 getMinor() const { return m_version_minor; }
u8 getPatch() const { return m_version_patch; }
+ const std::string &getFullVer() const { return m_full_version; }
+
+ void setLangCode(const std::string &code) { m_lang_code = code; }
+ const std::string &getLangCode() const { return m_lang_code; }
+
+ void setCachedAddress(const Address &addr) { m_addr = addr; }
+ const Address &getAddress() const { return m_addr; }
+
private:
// Version is stored in here after INIT before INIT2
u8 m_pending_serialization_version = SER_FMT_VER_INVALID;
/* current state of client */
ClientState m_state = CS_Created;
+ // Cached here so retrieval doesn't have to go to connection API
+ Address m_addr;
+
+ // Client sent language code
+ std::string m_lang_code;
+
/*
Blocks that have been sent to client.
- These don't have to be sent again.
std::set<v3s16> m_blocks_sent;
s16 m_nearest_unsent_d = 0;
v3s16 m_last_center;
- float m_nearest_unsent_reset_timer = 0.0f;
+ v3f m_last_camera_dir;
+
+ const u16 m_max_simul_sends;
+ const float m_min_time_from_building;
+ const s16 m_max_send_distance;
+ const s16 m_block_optimize_distance;
+ const s16 m_max_gen_distance;
+ const bool m_occ_cull;
/*
Blocks that are currently on the line.
std::map<v3s16, float> m_blocks_sending;
/*
- Blocks that have been modified since last sending them.
- These blocks will not be marked as sent, even if the
- client reports it has received them to account for blocks
- that are being modified while on the line.
+ Blocks that have been modified since blocks were
+ sent to the client last (getNextBlocks()).
+ This is used to reset the unsent distance, so that
+ modified blocks are resent to the client.
List of block positions.
*/
/*
client information
- */
+ */
u8 m_version_major = 0;
u8 m_version_minor = 0;
u8 m_version_patch = 0;
void step(float dtime);
/* get list of active client id's */
- std::vector<u16> getClientIDs(ClientState min_state=CS_Active);
+ std::vector<session_t> getClientIDs(ClientState min_state=CS_Active);
+
+ /* mark block as not sent to active client sessions */
+ void markBlockposAsNotSent(const v3s16 &pos);
/* verify is server user limit was reached */
bool isUserLimitReached();
const std::vector<std::string> &getPlayerNames() const { return m_clients_names; }
/* send message to client */
- void send(u16 peer_id, u8 channelnum, NetworkPacket* pkt, bool reliable);
+ void send(session_t peer_id, u8 channelnum, NetworkPacket *pkt, bool reliable);
/* send to all clients */
void sendToAll(NetworkPacket *pkt);
void sendToAllCompat(NetworkPacket *pkt, NetworkPacket *legacypkt, u16 min_proto_ver);
/* delete a client */
- void DeleteClient(u16 peer_id);
+ void DeleteClient(session_t peer_id);
/* create client */
- void CreateClient(u16 peer_id);
+ void CreateClient(session_t peer_id);
/* get a client by peer_id */
- RemoteClient* getClientNoEx(u16 peer_id, ClientState state_min=CS_Active);
+ RemoteClient *getClientNoEx(session_t peer_id, ClientState state_min = CS_Active);
/* get client by peer_id (make sure you have list lock before!*/
- RemoteClient* lockedGetClientNoEx(u16 peer_id, ClientState state_min=CS_Active);
+ RemoteClient *lockedGetClientNoEx(session_t peer_id, ClientState state_min = CS_Active);
/* get state of client by id*/
- ClientState getClientState(u16 peer_id);
+ ClientState getClientState(session_t peer_id);
/* set client playername */
- void setPlayerName(u16 peer_id,std::string name);
+ void setPlayerName(session_t peer_id, const std::string &name);
/* get protocol version of client */
- u16 getProtocolVersion(u16 peer_id);
+ u16 getProtocolVersion(session_t peer_id);
/* set client version */
- void setClientVersion(u16 peer_id, u8 major, u8 minor, u8 patch, std::string full);
+ void setClientVersion(session_t peer_id, u8 major, u8 minor, u8 patch,
+ const std::string &full);
/* event to update client state */
- void event(u16 peer_id, ClientStateEvent event);
+ void event(session_t peer_id, ClientStateEvent event);
/* Set environment. Do not call this function if environment is already set */
void setEnv(ServerEnvironment *env)
// Connection
std::shared_ptr<con::Connection> m_con;
- std::mutex m_clients_mutex;
+ std::recursive_mutex m_clients_mutex;
// Connected clients (behind the con mutex)
RemoteClientMap m_clients;
std::vector<std::string> m_clients_names; //for announcing masterserver
projects / dragonfireclient.git / blobdiff