10 #include "../stdafx.h"
12 #include "../saveload/saveload.h"
13 #include "../saveload/saveload_filter.h"
14 #include "../command_func.h"
15 #include "../console_func.h"
16 #include "../strings_func.h"
17 #include "../window_func.h"
18 #include "../company_func.h"
19 #include "../company_base.h"
20 #include "../company_gui.h"
21 #include "../company_cmd.h"
22 #include "../core/random_func.hpp"
23 #include "../timer/timer_game_tick.h"
24 #include "../timer/timer_game_calendar.h"
25 #include "../gfx_func.h"
32 #include "../core/backup_type.hpp"
33 #include "../thread.h"
34 #include "../social_integration.h"
36 #include "table/strings.h"
38 #include "../safeguards.h"
44 static const size_t CHUNK = 32 * 1024;
60 for (
auto p : this->blocks) {
74 memcpy(destination->
buf, source, amount);
75 destination->
buf += amount;
86 assert(this->read_bytes == 0);
93 this->blocks.push_back(this->buf = CallocT<uint8_t>(
CHUNK));
94 this->bufe = this->buf +
CHUNK;
99 size_t Read(uint8_t *rbuf,
size_t size)
override
102 size_t ret_size = size = std::min(this->written_bytes - this->read_bytes, size);
103 this->read_bytes += ret_size;
104 const uint8_t *rbufe = rbuf + ret_size;
106 while (rbuf != rbufe) {
107 if (this->buf == this->bufe) {
108 this->buf = *this->block++;
109 this->bufe = this->buf +
CHUNK;
112 size_t to_write = std::min(this->bufe - this->buf, rbufe - rbuf);
113 memcpy(rbuf, this->buf, to_write);
115 this->buf += to_write;
123 this->read_bytes = 0;
125 this->block = this->blocks.data();
126 this->buf = *this->block++;
127 this->bufe = this->buf +
CHUNK;
164 if (this->IsPendingDeletion())
return status;
166 assert(this->
sock != INVALID_SOCKET);
180 this->DeferDeletion();
191 if (this->IsPendingDeletion())
return;
211 default: errorno = NETWORK_ERROR_GENERAL;
break;
279 #ifdef NETWORK_SEND_DOUBLE_SEED
284 ShowNetworkError(STR_NETWORK_ERROR_DESYNC);
286 Debug(net, 0,
"Sync error detected");
331 Debug(net, 9,
"Client::SendJoin()");
333 Debug(net, 9,
"Client::status = JOIN");
335 Debug(net, 9,
"Client::join_status = AUTHORIZING");
340 p->Send_string(GetNetworkRevisionString());
341 p->Send_uint32(_openttd_newgrf_version);
349 Debug(net, 9,
"Client::SendIdentify()");
361 Debug(net, 9,
"Client::SendNewGRFsOk()");
374 Debug(net, 9,
"Client::SendAuthResponse()");
386 Debug(net, 9,
"Client::SendGetMap()");
388 Debug(net, 9,
"Client::status = MAP_WAIT");
399 Debug(net, 9,
"Client::SendMapOk()");
401 Debug(net, 9,
"Client::status = ACTIVE");
412 Debug(net, 9,
"Client::SendAck()");
428 Debug(net, 9,
"Client::SendCommand(): cmd={}", cp.
cmd);
431 my_client->NetworkGameSocketHandler::SendCommand(*p, cp);
440 Debug(net, 9,
"Client::SendChat(): action={}, type={}, dest={}", action, type, dest);
444 p->Send_uint8 (action);
445 p->Send_uint8 (type);
446 p->Send_uint32(dest);
448 p->Send_uint64(data);
457 Debug(net, 9,
"Client::SendError(): errorno={}", errorno);
461 p->Send_uint8(errorno);
472 Debug(net, 9,
"Client::SendSetName()");
476 p->Send_string(name);
486 Debug(net, 9,
"Client::SendQuit()");
501 Debug(net, 9,
"Client::SendRCon()");
504 p->Send_string(pass);
505 p->Send_string(command);
516 Debug(net, 9,
"Client::SendMove(): company={}", company);
519 p->Send_uint8(company);
542 Debug(net, 9,
"Client::Receive_SERVER_FULL()");
552 Debug(net, 9,
"Client::Receive_SERVER_BANNED()");
569 Debug(net, 9,
"Client::Receive_SERVER_CLIENT_INFO(): client_id={}, playas={}",
client_id, playas);
626 static const StringID network_error_strings[] = {
627 STR_NETWORK_ERROR_LOSTCONNECTION,
628 STR_NETWORK_ERROR_LOSTCONNECTION,
629 STR_NETWORK_ERROR_LOSTCONNECTION,
630 STR_NETWORK_ERROR_LOSTCONNECTION,
631 STR_NETWORK_ERROR_LOSTCONNECTION,
632 STR_NETWORK_ERROR_LOSTCONNECTION,
633 STR_NETWORK_ERROR_SERVER_ERROR,
634 STR_NETWORK_ERROR_SERVER_ERROR,
635 STR_NETWORK_ERROR_WRONG_REVISION,
636 STR_NETWORK_ERROR_LOSTCONNECTION,
637 STR_NETWORK_ERROR_WRONG_PASSWORD,
638 STR_NETWORK_ERROR_SERVER_ERROR,
639 STR_NETWORK_ERROR_KICKED,
640 STR_NETWORK_ERROR_CHEATER,
641 STR_NETWORK_ERROR_SERVER_FULL,
642 STR_NETWORK_ERROR_TOO_MANY_COMMANDS,
643 STR_NETWORK_ERROR_TIMEOUT_PASSWORD,
644 STR_NETWORK_ERROR_TIMEOUT_COMPUTER,
645 STR_NETWORK_ERROR_TIMEOUT_MAP,
646 STR_NETWORK_ERROR_TIMEOUT_JOIN,
647 STR_NETWORK_ERROR_INVALID_CLIENT_NAME,
648 STR_NETWORK_ERROR_NOT_ON_ALLOW_LIST,
649 STR_NETWORK_ERROR_SERVER_ERROR,
651 static_assert(
lengthof(network_error_strings) == NETWORK_ERROR_END);
655 Debug(net, 9,
"Client::Receive_SERVER_ERROR(): error={}", error);
657 StringID err = STR_NETWORK_ERROR_LOSTCONNECTION;
658 if (error < (ptrdiff_t)
lengthof(network_error_strings)) err = network_error_strings[error];
680 Debug(net, 9,
"Client::Receive_SERVER_CHECK_NEWGRFS(): grf_count={}", grf_count);
683 for (; grf_count > 0; grf_count--) {
685 DeserializeGRFIdentifier(p, c);
708 virtual void AskUserForPassword(std::shared_ptr<NetworkAuthenticationPasswordRequest> request)
override
713 ShowNetworkNeedPassword(request);
721 Debug(net, 9,
"Client::status = AUTH_GAME");
724 Debug(net, 9,
"Client::Receive_SERVER_AUTH_REQUEST()");
747 Debug(net, 9,
"Client::Receive_SERVER_ENABLE_ENCRYPTION()");
755 Debug(net, 9,
"Client::status = ENCRYPTED");
758 return this->SendIdentify();
764 Debug(net, 9,
"Client::status = AUTHORIZED");
780 Debug(net, 9,
"Client::Receive_SERVER_WAIT()");
783 Debug(net, 9,
"Client::join_status = WAITING");
794 Debug(net, 9,
"Client::status = MAP");
799 this->
savegame = std::make_shared<PacketReader>();
808 Debug(net, 9,
"Client::join_status = DOWNLOADING");
847 Debug(net, 9,
"Client::Receive_SERVER_MAP_DONE()");
849 Debug(net, 9,
"Client::join_status = PROCESSING");
865 this->
last_packet = std::chrono::steady_clock::now();
891 Debug(net, 9,
"Client::join_status = REGISTERING");
893 ShowJoinStatusWindow();
912 #ifdef ENABLE_NETWORK_SYNC_EVERY_FRAME
915 #ifdef NETWORK_SEND_DOUBLE_SEED
922 #ifdef NETWORK_SEND_DOUBLE_SEED
947 #ifdef NETWORK_SEND_DOUBLE_SEED
965 Debug(net, 9,
"Client::Receive_SERVER_COMMAND(): cmd={}, frame={}", cp.
cmd, cp.
frame);
967 if (err !=
nullptr) {
990 Debug(net, 9,
"Client::Receive_SERVER_CHAT(): action={}, client_id={}, self_send={}", action,
client_id, self_send);
998 case NETWORK_ACTION_CHAT_CLIENT:
1000 name = ci_to->client_name;
1005 case NETWORK_ACTION_CHAT_COMPANY: {
1018 name = ci_to->client_name;
1022 if (ci !=
nullptr) {
1037 Debug(net, 9,
"Client::Receive_SERVER_EXTERNAL_CHAT(): source={}", source);
1041 NetworkTextMessage(NETWORK_ACTION_EXTERNAL_CHAT, colour,
false, user, msg, 0, source);
1052 Debug(net, 9,
"Client::Receive_SERVER_ERROR_QUIT(): client_id={}",
client_id);
1055 if (ci !=
nullptr) {
1071 Debug(net, 9,
"Client::Receive_SERVER_QUIT(): client_id={}",
client_id);
1074 if (ci !=
nullptr) {
1075 NetworkTextMessage(NETWORK_ACTION_LEAVE,
CC_DEFAULT,
false, ci->
client_name,
"", STR_NETWORK_MESSAGE_CLIENT_LEAVING);
1078 Debug(net, 1,
"Unknown client ({}) is leaving the game",
client_id);
1093 Debug(net, 9,
"Client::Receive_SERVER_JOIN(): client_id={}",
client_id);
1096 if (ci !=
nullptr) {
1107 Debug(net, 9,
"Client::Receive_SERVER_SHUTDOWN()");
1122 Debug(net, 9,
"Client::Receive_SERVER_NEWGAME()");
1143 Debug(net, 9,
"Client::Receive_SERVER_RCON()");
1163 Debug(net, 9,
"Client::Receive_SERVER_MOVE(): client_id={}, comapny_id={}",
client_id, company_id);
1167 Debug(net, 1,
"Received invalid client index = 0");
1189 _network_server_max_companies = p.
Recv_uint8();
1208 std::chrono::steady_clock::duration lag = std::chrono::steady_clock::now() - this->
last_packet;
1209 if (lag < std::chrono::seconds(5))
return;
1213 if (lag > std::chrono::seconds(20)) {
1219 static std::chrono::steady_clock::duration last_lag = {};
1220 if (std::chrono::duration_cast<std::chrono::seconds>(last_lag) == std::chrono::duration_cast<std::chrono::seconds>(lag))
return;
1223 SetDParam(0, std::chrono::duration_cast<std::chrono::seconds>(lag).count());
1224 ShowErrorMessage(STR_NETWORK_ERROR_CLIENT_GUI_LOST_CONNECTION_CAPTION, STR_NETWORK_ERROR_CLIENT_GUI_LOST_CONNECTION,
WL_INFO);
1236 Debug(net, 9,
"Client::NetworkClient_Connected()");
1272 if (ci->client_playas != cid)
continue;
1273 NetworkTextMessage(NETWORK_ACTION_COMPANY_SPECTATOR,
CC_DEFAULT,
false, ci->client_name);
1289 if (client_name.empty())
return false;
1290 if (client_name[0] ==
' ')
return false;
1337 if (ci ==
nullptr)
return;
1345 std::string temporary_name = client_name;
1379 if (ci->client_playas == cio->
client_playas && ci != cio)
return true;
static uint32_t BSWAP32(uint32_t x)
Perform a 32 bits endianness bitswap on x.
virtual void AskUserForPassword(std::shared_ptr< NetworkAuthenticationPasswordRequest > request) override
Callback to trigger asking the user for the password.
virtual void SendResponse() override
Callback to trigger sending the response for the password request.
Class for handling the client side of the game connection.
NetworkRecvStatus Receive_SERVER_QUIT(Packet &p) override
Notification that a client left the game: uint32_t ID of the client.
static ClientNetworkGameSocketHandler * my_client
This is us!
static NetworkRecvStatus SendQuit()
Tell the server we would like to quit.
NetworkRecvStatus Receive_SERVER_SYNC(Packet &p) override
Sends a sync-check to the client: uint32_t Frame counter.
NetworkRecvStatus Receive_SERVER_ENABLE_ENCRYPTION(Packet &p) override
Indication to the client that authentication is complete and encryption has to be used from here on f...
NetworkRecvStatus Receive_SERVER_MAP_SIZE(Packet &p) override
Sends the size of the map to the client.
static bool Receive()
Check whether we received/can send some data from/to the server and when that's the case handle it ap...
NetworkRecvStatus Receive_SERVER_MAP_DONE(Packet &p) override
Sends that all data of the map are sent to the client:
NetworkRecvStatus Receive_SERVER_CLIENT_INFO(Packet &p) override
Send information about a client: uint32_t ID of the client (always unique on a server.
~ClientNetworkGameSocketHandler()
Clear whatever we assigned.
ServerStatus status
Status of the connection with the server.
NetworkRecvStatus Receive_SERVER_CHECK_NEWGRFS(Packet &p) override
Sends information about all used GRFs to the client: uint8_t Amount of GRFs (the following data is re...
static NetworkRecvStatus SendMove(CompanyID company)
Ask the server to move us.
NetworkRecvStatus Receive_SERVER_WAIT(Packet &p) override
Notification that another client is currently receiving the map: uint8_t Number of clients waiting in...
std::unique_ptr< class NetworkAuthenticationClientHandler > authentication_handler
The handler for the authentication.
std::shared_ptr< struct PacketReader > savegame
Packet reader for reading the savegame.
static bool IsConnected()
Check whether the client is actually connected (and in the game).
NetworkRecvStatus Receive_SERVER_EXTERNAL_CHAT(Packet &p) override
Sends a chat-packet for external source to the client: string Name of the source this message came fr...
uint8_t token
The token we need to send back to the server to prove we're the right client.
static NetworkRecvStatus SendSetName(const std::string &name)
Tell the server that we like to change the name of the client.
friend void NetworkExecuteLocalCommandQueue()
Execute all commands on the local command queue that ought to be executed this frame.
NetworkRecvStatus Receive_SERVER_ERROR_QUIT(Packet &p) override
Inform all clients that one client made an error and thus has quit/been disconnected: uint32_t ID of ...
static NetworkRecvStatus SendNewGRFsOk()
Tell the server we got all the NewGRFs.
static NetworkRecvStatus SendMapOk()
Tell the server we received the complete map.
void CheckConnection()
Check the connection's state, i.e.
NetworkRecvStatus Receive_SERVER_RCON(Packet &p) override
Send the result of an issues RCon command back to the client: uint16_t Colour code.
NetworkRecvStatus Receive_SERVER_BANNED(Packet &p) override
Notification that the client trying to join is banned.
NetworkRecvStatus Receive_SERVER_CONFIG_UPDATE(Packet &p) override
Update the clients knowledge of the max settings: uint8_t Maximum number of companies allowed.
void ClientError(NetworkRecvStatus res)
Handle an error coming from the client side.
NetworkRecvStatus Receive_SERVER_WELCOME(Packet &p) override
The client is joined and ready to receive their map: uint32_t Own client ID.
static NetworkRecvStatus SendAck()
Send an acknowledgement from the server's ticks.
NetworkRecvStatus Receive_SERVER_MAP_BEGIN(Packet &p) override
Sends that the server will begin with sending the map to the client: uint32_t Current frame.
NetworkRecvStatus Receive_SERVER_JOIN(Packet &p) override
A client joined (PACKET_CLIENT_MAP_OK), what usually directly follows is a PACKET_SERVER_CLIENT_INFO:...
@ STATUS_JOIN
We are trying to join a server.
@ STATUS_ENCRYPTED
The game authentication has completed and from here on the connection to the server is encrypted.
@ STATUS_MAP
The client is downloading the map.
@ STATUS_AUTH_GAME
Last action was requesting game (server) password.
@ STATUS_ACTIVE
The client is active within in the game.
@ STATUS_MAP_WAIT
The client is waiting as someone else is downloading the map.
@ STATUS_AUTHORIZED
The client is authorized at the server.
static NetworkRecvStatus SendAuthResponse()
Set the game password as requested.
static NetworkRecvStatus SendRCon(const std::string &password, const std::string &command)
Send a console command.
static bool GameLoop()
Actual game loop for the client.
static void Send()
Send the packets of this socket handler.
NetworkRecvStatus Receive_SERVER_CHAT(Packet &p) override
Sends a chat-packet to the client: uint8_t ID of the action (see NetworkAction).
NetworkRecvStatus Receive_SERVER_MOVE(Packet &p) override
Move a client from one company into another: uint32_t ID of the client.
static NetworkRecvStatus SendCommand(const CommandPacket &cp)
Send a command to the server.
NetworkRecvStatus Receive_SERVER_FRAME(Packet &p) override
Sends the current frame counter to the client: uint32_t Frame counter uint32_t Frame counter max (how...
static NetworkRecvStatus SendChat(NetworkAction action, DestType type, int dest, const std::string &msg, int64_t data)
Send a chat-packet over the network.
NetworkRecvStatus Receive_SERVER_COMMAND(Packet &p) override
Sends a DoCommand to the client: uint8_t ID of the company (0..MAX_COMPANIES-1).
NetworkRecvStatus Receive_SERVER_NEWGAME(Packet &p) override
Let the clients know that the server is loading a new map.
NetworkRecvStatus CloseConnection(NetworkRecvStatus status) override
Close the network connection due to the given status.
static NetworkRecvStatus SendGetMap()
Request the map from the server.
ClientNetworkGameSocketHandler(SOCKET s, const std::string &connection_string)
Create a new socket for the client side of the game connection.
NetworkRecvStatus Receive_SERVER_AUTH_REQUEST(Packet &p) override
Indication to the client that it needs to authenticate: uint8_t The NetworkAuthenticationMethod to us...
NetworkRecvStatus Receive_SERVER_MAP_DATA(Packet &p) override
Sends the data of the map to the client: Contains a part of the map (until max size of packet).
NetworkRecvStatus Receive_SERVER_ERROR(Packet &p) override
The client made an error: uint8_t Error code caused (see NetworkErrorCode).
static NetworkRecvStatus SendError(NetworkErrorCode errorno)
Send an error-packet over the network.
NetworkRecvStatus Receive_SERVER_SHUTDOWN(Packet &p) override
Let the clients know that the server is closing.
static NetworkRecvStatus SendJoin()
Tell the server we would like to join.
NetworkRecvStatus Receive_SERVER_FULL(Packet &p) override
Notification that the server is full.
@ READY_FOR_RESPONSE
We do not have to wait for user input, and can immediately respond to the server.
@ AWAIT_USER_INPUT
We have requested some user input, but must wait on that.
@ INVALID
We have received an invalid request.
static std::unique_ptr< NetworkAuthenticationClientHandler > Create(std::shared_ptr< NetworkAuthenticationPasswordRequestHandler > password_handler, std::string &secret_key, std::string &public_key)
Create a NetworkAuthenticationClientHandler.
Callback interface for client implementations to provide the handling of the password requests.
Base socket handler for all TCP sockets.
NetworkRecvStatus ReceivePackets()
Do the actual receiving of packets.
ClientID client_id
Client identifier.
CommandQueue incoming_queue
The command-queue awaiting handling.
std::chrono::steady_clock::time_point last_packet
Time we received the last frame.
void SetInfo(NetworkClientInfo *info)
Sets the client info for this socket handler.
NetworkClientInfo * GetInfo() const
Gets the client info of this socket handler.
const char * ReceiveCommand(Packet &p, CommandPacket &cp)
Receives a command from the network.
NetworkRecvStatus CloseConnection(bool error=true) override
Functions to help ReceivePacket/SendPacket a bit A socket can make errors.
void MarkClosed()
Mark the connection as closed.
bool HasClientQuit() const
Whether the current client connected to the socket has quit.
std::unique_ptr< class NetworkEncryptionHandler > send_encryption_handler
The handler for encrypting sent packets.
std::unique_ptr< class NetworkEncryptionHandler > receive_encryption_handler
The handler for decrypting received packets.
SOCKET sock
The socket currently connected to.
virtual void SendPacket(std::unique_ptr< Packet > &&packet)
This function puts the packet in the send-queue and it is send as soon as possible.
SendPacketsState SendPackets(bool closing_down=false)
Sends all the buffered packets out for this client.
bool CanSendReceive()
Check whether this socket can send or receive something.
static void EventEnterMultiplayer(uint map_width, uint map_height)
Event: user entered a multiplayer game.
static constexpr TimerGameTick::Ticks DAY_TICKS
1 day is 74 ticks; TimerGameCalendar::date_fract used to be uint16_t and incremented by 885.
static Date date
Current date in days (day counter).
static DateFract date_fract
Fractional part of the day.
TextColour GetDrawStringCompanyColour(CompanyID company)
Get the colour for DrawString-subroutines which matches the colour of the company.
CompanyID _local_company
Company controlled by the human player at this client. Can also be COMPANY_SPECTATOR.
void SetLocalCompany(CompanyID new_company)
Sets the local company and updates the settings that are set on a per-company basis to reflect the co...
CompanyID _current_company
Company currently doing an action.
@ CCA_NEW
Create a new company.
Owner
Enum for all companies/owners.
@ INVALID_COMPANY
An invalid company.
@ COMPANY_SPECTATOR
The client is spectating.
@ COMPANY_NEW_COMPANY
The client wants a new company.
@ CRR_NONE
Dummy reason for actions that don't need one.
static const uint NETWORK_CHAT_LENGTH
The maximum length of a chat message, in bytes including '\0'.
static const uint NETWORK_NAME_LENGTH
The maximum length of the server name and map name, in bytes including '\0'.
static const uint NETWORK_PUBLIC_KEY_LENGTH
The maximum length of the hexadecimal encoded public keys, in bytes including '\0'.
static const uint NETWORK_RCONCOMMAND_LENGTH
The maximum length of a rconsole command, in bytes including '\0'.
void IConsolePrint(TextColour colour_code, const std::string &string)
Handle the printing of text entered into the console or redirected there by any other means.
bool IsValidConsoleColour(TextColour c)
Check whether the given TextColour is valid for console usage.
static const TextColour CC_WARNING
Colour for warning lines.
static const TextColour CC_DEFAULT
Default colour of the console.
NetworkRecvStatus
Status of a network client; reasons why a client has quit.
@ NETWORK_RECV_STATUS_DESYNC
A desync did occur.
@ NETWORK_RECV_STATUS_CLIENT_QUIT
The connection is lost gracefully. Other clients are already informed of this leaving client.
@ NETWORK_RECV_STATUS_SERVER_ERROR
The server told us we made an error.
@ NETWORK_RECV_STATUS_SAVEGAME
Something went wrong (down)loading the savegame.
@ NETWORK_RECV_STATUS_CLOSE_QUERY
Done querying the server.
@ NETWORK_RECV_STATUS_OKAY
Everything is okay.
@ NETWORK_RECV_STATUS_NEWGRF_MISMATCH
We did not have the required NewGRFs.
@ NETWORK_RECV_STATUS_SERVER_FULL
The server is full.
@ NETWORK_RECV_STATUS_MALFORMED_PACKET
We apparently send a malformed packet.
@ NETWORK_RECV_STATUS_SERVER_BANNED
The server has banned us.
#define Debug(category, level, format_string,...)
Ouptut a line of debugging information.
void ClearErrorMessages()
Clear all errors from the queue.
void ShowErrorMessage(StringID summary_msg, int x, int y, CommandCost cc)
Display an error message in a window.
@ WL_ERROR
Errors (eg. saving/loading failed)
@ WL_CRITICAL
Critical errors, the MessageBox is shown in all cases.
@ WL_INFO
Used for DoCommand-like (and some non-fatal AI GUI) errors/information.
@ FT_SAVEGAME
old or new savegame
SaveLoadOperation
Operation performed on the file.
@ SLO_LOAD
File is being loaded.
DetailedFileType
Kinds of files in each AbstractFileType.
@ DFT_GAME_FILE
Save game or scenario file.
Subdirectory
The different kinds of subdirectories OpenTTD uses.
@ NO_DIRECTORY
A path without any base directory.
GameSessionStats _game_session_stats
Statistics about the current session.
SwitchMode _switch_mode
The next mainloop command.
TextColour
Colour of the strings, see _string_colourmap in table/string_colours.h or docs/ottd-colourtext-palett...
static const uint MILLISECONDS_PER_TICK
The number of milliseconds per game tick.
StringID GetNetworkErrorMsg(NetworkErrorCode err)
Retrieve the string id of an internal error number.
uint32_t _frame_counter_server
The frame_counter of the server, if in network-mode.
uint32_t _frame_counter
The current frame.
uint8_t _network_reconnect
Reconnect timeout.
bool _networking
are we in networking mode?
bool _network_server
network-server is active
uint32_t _sync_seed_1
Seed to compare during sync checks.
uint32_t _sync_frame
The frame to perform the sync check.
ClientID _network_own_client_id
Our client identifier.
bool _network_first_time
Whether we have finished joining or not.
uint32_t _frame_counter_max
To where we may go with our clients.
Basic functions/variables used all over the place.
Base core network types and some helper functions to access them.
void NetworkClientSendChat(NetworkAction action, DestType type, int dest, const std::string &msg, int64_t data)
Send a chat message.
void NetworkUpdateClientName(const std::string &client_name)
Send the server our name as callback from the setting.
NetworkJoinInfo _network_join
Information about the game to join to.
bool NetworkIsValidClientName(const std::string_view client_name)
Check whether the given client name is deemed valid for use in network games.
bool NetworkValidateOurClientName()
Convenience method for NetworkValidateClientName on _settings_client.network.client_name.
void ClientNetworkEmergencySave()
Create an emergency savegame when the network connection is lost.
static uint32_t last_ack_frame
Last frame we performed an ack.
bool NetworkMaxCompaniesReached()
Check if max_companies has been reached on the server (local check only).
uint NetworkMaxCompaniesAllowed()
Get the maximum number of companies that are allowed by the server.
void NetworkClient_Connected()
Is called after a client is connected to the server.
void NetworkClientsToSpectators(CompanyID cid)
Move the clients of a company to the spectators.
static uint8_t _network_server_max_companies
Maximum number of companies of the currently joined server.
bool NetworkClientPreferTeamChat(const NetworkClientInfo *cio)
Tell whether the client has team members who they can chat to.
std::string _network_server_name
The current name of the server you are on.
void NetworkClientRequestMove(CompanyID company_id)
Notify the server of this client wanting to be moved to another company.
bool NetworkValidateClientName(std::string &client_name)
Trim the given client name in place, i.e.
void NetworkClientSendRcon(const std::string &password, const std::string &command)
Send a remote console command.
Client part of the network protocol.
void NetworkUpdateClientInfo(ClientID client_id)
Send updated client info of a particular client.
Handling of the list of games.
NetworkJoinStatus _network_join_status
The status of joining.
uint8_t _network_join_waiting
The number of clients waiting in front of us.
uint32_t _network_join_bytes_total
The total number of bytes to download.
uint32_t _network_join_bytes
The number of bytes we already downloaded.
GUIs related to networking.
bool NetworkMakeClientNameUnique(std::string &new_name)
Check whether a name is unique, and otherwise try to make it unique.
DestType
Destination of our chat messages.
NetworkAction
Actions that can be used for NetworkTextMessage.
ClientID
'Unique' identifier to be given to clients
@ CLIENT_ID_SERVER
Servers always have this ID.
NetworkErrorCode
The error codes we send around in the protocols.
const GRFConfig * FindGRFConfig(uint32_t grfid, FindGRFConfigMode mode, const MD5Hash *md5sum, uint32_t desired_version)
Find a NewGRF in the scanned list.
@ FGCM_EXACT
Only find Grfs matching md5sum.
bool SafeLoad(const std::string &filename, SaveLoadOperation fop, DetailedFileType dft, GameMode newgm, Subdirectory subdir, std::shared_ptr< LoadFilter > lf=nullptr)
Load the specified savegame but on error do different things.
void StateGameLoop()
State controlling game loop.
@ SM_MENU
Switch to game intro menu.
GameMode
Mode which defines the state of the game.
Randomizer _random
Random used in the game state calculations.
void DoAutoOrNetsave(FiosNumberedSaveName &counter)
Create an autosave or netsave.
FileToSaveLoad _file_to_saveload
File to save or load in the openttd loop.
ClientSettings _settings_client
The current settings for this game.
void free(const void *ptr)
Version of the standard free that accepts const pointers.
#define lengthof(array)
Return the length of an fixed size array.
std::string FormatArrayAsHex(std::span< const uint8_t > data)
Format a byte array into a continuous hex string.
void StrTrimInPlace(std::string &str)
Trim the spaces from given string in place, i.e.
void SetDParam(size_t n, uint64_t v)
Set a string parameter v at index n in the global string parameter array.
std::string GetString(StringID string)
Resolve the given StringID into a std::string with all the associated DParam lookups and formatting.
void SetDParamStr(size_t n, const char *str)
This function is used to "bind" a C string to a OpenTTD dparam slot.
uint32_t StringID
Numeric value that represents a string, independent of the selected language.
static const StringID INVALID_STRING_ID
Constant representing an invalid string (16bit in case it is used in savegames)
Class to backup a specific variable and restore it later.
void Restore()
Restore the variable.
NetworkSettings network
settings related to the network
GUISettings gui
settings related to the GUI
Everything we need to know about a command to be able to execute it.
uint32_t frame
the frame in which this packet is executed
bool my_cmd
did the command originate from "me"
Commands cmd
command being executed.
void SetMode(FiosType ft)
Set the mode and file type of the file to save or load based on the type of file entry at the file sy...
A savegame name automatically numbered.
Information about GRF, used in the game and (part of it) in savegames.
Basic data to distinguish a GRF.
uint32_t grfid
GRF ID (defined by Action 0x08)
MD5Hash md5sum
MD5 checksum of file to distinguish files with the same GRF ID (eg. newer version of GRF)
bool prefer_teamchat
choose the chat message target with <ENTER>, true=all clients, false=your team
std::chrono::steady_clock::time_point start_time
Time when the current game was started.
std::optional< size_t > savegame_size
Size of the last saved savegame in bytes, or std::nullopt if not saved yet.
Interface for filtering a savegame till it is loaded.
static uint SizeY()
Get the size of the map along the Y.
static debug_inline uint SizeX()
Get the size of the map along the X.
Container for all information known about a client.
static NetworkClientInfo * GetByClientID(ClientID client_id)
Return the CI given it's client-identifier.
CompanyID client_playas
As which company is this client playing (CompanyID)
std::string client_name
Name of the client.
std::string public_key
The public key of the client.
Information required to join a server.
std::string server_password
The password of the server to join.
CompanyID company
The company to join.
std::string client_secret_key
The secret key of the client for authorized key logins.
uint8_t max_companies
maximum amount of companies
std::string client_name
name of the player (as client)
std::string client_public_key
The public key of the client for authorized key logins.
Read some packets, and when do use that data as initial load filter.
size_t Read(uint8_t *rbuf, size_t size) override
Read a given number of bytes from the savegame.
PacketReader()
Initialise everything.
size_t read_bytes
The total number of read bytes.
size_t written_bytes
The total number of bytes we've written.
void AddPacket(Packet &p)
Add a packet to this buffer.
uint8_t * bufe
End of the buffer we write to/read from.
uint8_t ** block
The block we're reading from/writing to.
std::vector< uint8_t * > blocks
Buffer with blocks of allocated memory.
void Reset() override
Reset this filter to read from the beginning of the file.
static ssize_t TransferOutMemCopy(PacketReader *destination, const char *source, size_t amount)
Simple wrapper around fwrite to be able to pass it to Packet's TransferOut.
uint8_t * buf
Buffer we're going to write to/read from.
static const size_t CHUNK
32 KiB chunks of memory.
Internal entity of a packet.
uint16_t Recv_uint16()
Read a 16 bits integer from the packet.
ssize_t TransferOutWithLimit(F transfer_function, size_t limit, D destination, Args &&... args)
Transfer data from the packet to the given function.
uint64_t Recv_uint64()
Read a 64 bits integer from the packet.
bool Recv_bool()
Read a boolean from the packet.
uint32_t Recv_uint32()
Read a 32 bits integer from the packet.
uint8_t Recv_uint8()
Read a 8 bits integer from the packet.
size_t RemainingBytesToTransfer() const
Get the amount of bytes that are still available for the Transfer functions.
bool CanReadFromPacket(size_t bytes_to_read, bool close_connection=false)
Is it safe to read from the packet, i.e.
std::string Recv_string(size_t length, StringValidationSettings settings=SVS_REPLACE_WITH_QUESTION_MARK)
Reads characters (bytes) from the packet until it finds a '\0', or reaches a maximum of length charac...
static size_t GetNumItems()
Returns number of valid items in the pool.
static bool IsValidID(size_t index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
uint32_t state[2]
The state of the randomizer.
@ PACKET_CLIENT_IDENTIFY
Client telling the server the client's name and requested company.
@ PACKET_CLIENT_GETMAP
Client requests the actual map.
@ PACKET_CLIENT_ERROR
A client reports an error to the server.
@ PACKET_CLIENT_JOIN
The client telling the server it wants to join.
@ PACKET_CLIENT_AUTH_RESPONSE
The client responds to the authentication request.
@ PACKET_CLIENT_NEWGRFS_CHECKED
Client acknowledges that it has all required NewGRFs.
@ PACKET_CLIENT_COMMAND
Client executed a command and sends it to the server.
@ PACKET_CLIENT_SET_NAME
A client changes its name.
@ PACKET_CLIENT_ACK
The client tells the server which frame it has executed.
@ PACKET_CLIENT_RCON
Client asks the server to execute some command.
@ PACKET_CLIENT_MAP_OK
Client tells the server that it received the whole map.
@ PACKET_CLIENT_QUIT
A client tells the server it is going to quit.
@ PACKET_CLIENT_MOVE
A client would like to be moved to another company.
@ PACKET_CLIENT_CHAT
Client said something that should be distributed.
void CSleep(int milliseconds)
Sleep on the current thread for a defined time.
void CloseWindowById(WindowClass cls, WindowNumber number, bool force, int data)
Close a window by its class and window number (if it is open).
void InvalidateWindowData(WindowClass cls, WindowNumber number, int data, bool gui_scope)
Mark window data of the window of a given class and specific window number as invalid (in need of re-...
void SetWindowDirty(WindowClass cls, WindowNumber number)
Mark window as dirty (in need of repainting)
@ WN_NETWORK_STATUS_WINDOW_JOIN
Network join status.
@ WC_CLIENT_LIST
Client list; Window numbers:
@ WC_NETWORK_STATUS_WINDOW
Network status window; Window numbers: