12#include "../core/string_consumer.hpp"
13#include "../strings_func.h"
14#include "../command_func.h"
15#include "../timer/timer_game_tick.h"
16#include "../timer/timer_game_economy.h"
29#include "../console_func.h"
30#include "../3rdparty/md5/md5.h"
31#include "../core/random_func.hpp"
32#include "../window_func.h"
33#include "../company_func.h"
34#include "../company_base.h"
35#include "../landscape_type.h"
37#include "../core/pool_func.hpp"
38#include "../gfx_func.h"
40#include "../misc_cmd.h"
41#include "../core/string_builder.hpp"
42#ifdef DEBUG_DUMP_COMMANDS
43# include "../fileio_func.h"
47#include "table/strings.h"
49#include "../safeguards.h"
51#ifdef DEBUG_DUMP_COMMANDS
57bool _ddc_fastforward =
true;
84#ifdef NETWORK_SEND_DOUBLE_SEED
93extern std::string
GenerateUid(std::string_view subject);
101 return !NetworkClientSocket::Iterate().empty();
121 if (ci->client_id ==
client_id)
return ci;
157 if (cs->client_id ==
client_id)
return cs;
170static auto FindKey(
auto *authorized_keys, std::string_view authorized_key)
172 return std::ranges::find_if(*authorized_keys, [authorized_key](
auto &value) {
return StrEqualsIgnoreCase(value, authorized_key); });
170static auto FindKey(
auto *authorized_keys, std::string_view authorized_key) {
…}
182 return FindKey(
this, key) != this->end();
192 if (key.empty())
return false;
194 auto iter =
FindKey(
this, key);
195 if (iter != this->end())
return false;
197 this->emplace_back(key);
208 auto iter =
FindKey(
this, key);
209 if (iter == this->end())
return false;
216uint8_t NetworkSpectatorCount()
246 case NETWORK_ACTION_SERVER_MESSAGE:
248 builder +=
GetString(STR_NETWORK_SERVER_MESSAGE, str);
251 case NETWORK_ACTION_COMPANY_SPECTATOR:
253 builder +=
GetString(STR_NETWORK_MESSAGE_CLIENT_COMPANY_SPECTATE, name);
255 case NETWORK_ACTION_COMPANY_JOIN:
257 builder +=
GetString(STR_NETWORK_MESSAGE_CLIENT_COMPANY_JOIN, name, str);
259 case NETWORK_ACTION_COMPANY_NEW:
261 builder +=
GetString(STR_NETWORK_MESSAGE_CLIENT_COMPANY_NEW, name, std::move(data));
263 case NETWORK_ACTION_JOIN:
266 GetString(STR_NETWORK_MESSAGE_CLIENT_JOINED_ID, name, std::move(data)) :
267 GetString(STR_NETWORK_MESSAGE_CLIENT_JOINED, name);
269 case NETWORK_ACTION_LEAVE: builder +=
GetString(STR_NETWORK_MESSAGE_CLIENT_LEFT, name, std::move(data));
break;
270 case NETWORK_ACTION_NAME_CHANGE: builder +=
GetString(STR_NETWORK_MESSAGE_NAME_CHANGE, name, str);
break;
271 case NETWORK_ACTION_GIVE_MONEY: builder +=
GetString(STR_NETWORK_MESSAGE_GIVE_MONEY, name, std::move(data), str);
break;
272 case NETWORK_ACTION_KICKED: builder +=
GetString(STR_NETWORK_MESSAGE_KICKED, name, str);
break;
273 case NETWORK_ACTION_CHAT_COMPANY: builder +=
GetString(self_send ? STR_NETWORK_CHAT_TO_COMPANY : STR_NETWORK_CHAT_COMPANY, name, str);
break;
274 case NETWORK_ACTION_CHAT_CLIENT: builder +=
GetString(self_send ? STR_NETWORK_CHAT_TO_CLIENT : STR_NETWORK_CHAT_CLIENT, name, str);
break;
275 case NETWORK_ACTION_EXTERNAL_CHAT: builder +=
GetString(STR_NETWORK_CHAT_EXTERNAL, std::move(data), name, str);
break;
276 default: builder +=
GetString(STR_NETWORK_CHAT_ALL, name, str);
break;
285uint NetworkCalculateLag(
const NetworkClientSocket *cs)
287 int lag = cs->last_frame_server - cs->last_frame;
300void ShowNetworkError(
StringID error_string)
315 static const StringID network_error_strings[] = {
316 STR_NETWORK_ERROR_CLIENT_GENERAL,
317 STR_NETWORK_ERROR_CLIENT_DESYNC,
318 STR_NETWORK_ERROR_CLIENT_SAVEGAME,
319 STR_NETWORK_ERROR_CLIENT_CONNECTION_LOST,
320 STR_NETWORK_ERROR_CLIENT_PROTOCOL_ERROR,
321 STR_NETWORK_ERROR_CLIENT_NEWGRF_MISMATCH,
322 STR_NETWORK_ERROR_CLIENT_NOT_AUTHORIZED,
323 STR_NETWORK_ERROR_CLIENT_NOT_EXPECTED,
324 STR_NETWORK_ERROR_CLIENT_WRONG_REVISION,
325 STR_NETWORK_ERROR_CLIENT_NAME_IN_USE,
326 STR_NETWORK_ERROR_CLIENT_WRONG_PASSWORD,
327 STR_NETWORK_ERROR_CLIENT_COMPANY_MISMATCH,
328 STR_NETWORK_ERROR_CLIENT_KICKED,
329 STR_NETWORK_ERROR_CLIENT_CHEATER,
330 STR_NETWORK_ERROR_CLIENT_SERVER_FULL,
331 STR_NETWORK_ERROR_CLIENT_TOO_MANY_COMMANDS,
332 STR_NETWORK_ERROR_CLIENT_TIMEOUT_PASSWORD,
333 STR_NETWORK_ERROR_CLIENT_TIMEOUT_COMPUTER,
334 STR_NETWORK_ERROR_CLIENT_TIMEOUT_MAP,
335 STR_NETWORK_ERROR_CLIENT_TIMEOUT_JOIN,
336 STR_NETWORK_ERROR_CLIENT_INVALID_CLIENT_NAME,
337 STR_NETWORK_ERROR_CLIENT_NOT_ON_ALLOW_LIST,
338 STR_NETWORK_ERROR_CLIENT_NO_AUTHENTICATION_METHOD_AVAILABLE,
340 static_assert(
lengthof(network_error_strings) == NETWORK_ERROR_END);
342 if (err >= (ptrdiff_t)
lengthof(network_error_strings)) err = NETWORK_ERROR_GENERAL;
344 return network_error_strings[err];
356 switch (changed_mode) {
364 if (!paused && !changed)
return;
368 std::array<StringParameter, 5> params{};
369 auto it = params.begin();
375 str =
GetStringWithArgs(STR_NETWORK_SERVER_MESSAGE_GAME_STILL_PAUSED_1 + std::distance(params.begin(), it) - 1, {params.begin(), it});
378 switch (changed_mode) {
379 case PauseMode::Normal: reason = STR_NETWORK_SERVER_MESSAGE_GAME_REASON_MANUAL;
break;
380 case PauseMode::Join: reason = STR_NETWORK_SERVER_MESSAGE_GAME_REASON_CONNECTING_CLIENTS;
break;
384 default: NOT_REACHED();
386 str =
GetString(paused ? STR_NETWORK_SERVER_MESSAGE_GAME_PAUSED : STR_NETWORK_SERVER_MESSAGE_GAME_UNPAUSED, reason);
389 NetworkTextMessage(NETWORK_ACTION_SERVER_MESSAGE,
CC_DEFAULT,
false,
"", str);
423 for (
const NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
424 if (cs->status != NetworkClientSocket::STATUS_ACTIVE)
continue;
451 for (
const NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
452 if (cs->status >= NetworkClientSocket::STATUS_AUTHORIZED && cs->status < NetworkClientSocket::STATUS_ACTIVE)
return true;
478 std::string_view ip = connection_string;
479 if (company_id ==
nullptr)
return ip;
481 size_t offset = ip.find_last_of(
'#');
482 if (offset != std::string::npos) {
483 std::string_view company_string = ip.substr(offset + 1);
484 ip = ip.substr(0, offset);
486 uint8_t company_value;
487 auto [_, err] = std::from_chars(company_string.data(), company_string.data() + company_string.size(), company_value);
488 if (err == std::errc()) {
490 if (company_value > MAX_COMPANIES || company_value == 0) {
494 *company_id = (
CompanyID)(company_value - 1);
524 size_t port_offset = ip.find_last_of(
':');
525 size_t ipv6_close = ip.find_last_of(
']');
526 if (port_offset != std::string::npos && (ipv6_close == std::string::npos || ipv6_close < port_offset)) {
527 std::string_view port_string = ip.substr(port_offset + 1);
528 ip = ip.substr(0, port_offset);
529 std::from_chars(port_string.data(), port_string.data() + port_string.size(), port);
542 uint16_t port = default_port;
544 return fmt::format(
"{}:{}", ip, port);
557 uint16_t port = default_port;
598 as->CloseConnection(
true);
602 for (NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
617 NetworkGameSocketHandler::ProcessDeferredDeletions();
630static void NetworkInitialize(
bool close_admins =
true)
643 std::string connection_string;
650 Debug(net, 9,
"Query::OnFailure(): connection_string={}", this->connection_string);
661 Debug(net, 9,
"Query::OnConnect(): connection_string={}", this->connection_string);
675 Debug(net, 9,
"NetworkQueryServer(): connection_string={}", connection_string);
681 TCPConnecter::Create<TCPQueryConnecter>(connection_string);
695 if (connection_string.empty())
return nullptr;
708 if (manually) item->
manually =
true;
709 if (never_expire) item->
version = INT32_MAX;
722 addresses->emplace_back(iter, port);
726 if (addresses->empty()) {
727 addresses->emplace_back(
"", port);
734void NetworkRebuildHostList()
746 std::string connection_string;
753 Debug(net, 9,
"Client::OnFailure(): connection_string={}", this->connection_string);
755 ShowNetworkError(STR_NETWORK_ERROR_NOCONNECTION);
760 Debug(net, 9,
"Client::OnConnect(): connection_string={}", this->connection_string);
788 Debug(net, 9,
"NetworkClientConnectGame(): connection_string={}", connection_string);
800 if (_game_mode == GM_MENU) {
825 Debug(net, 9,
"status = CONNECTING");
827 ShowJoinStatusWindow();
832static void NetworkInitGameInfo()
834 FillStaticNetworkServerGameInfo();
862 if (!server_name.empty())
return true;
876 static const std::string fallback_client_name =
"Unnamed Client";
879 Debug(net, 1,
"No \"client_name\" has been set, using \"{}\" instead. Please set this now using the \"name <new name>\" command", fallback_client_name);
883 static const std::string fallback_server_name =
"Unnamed Server";
886 Debug(net, 1,
"No \"server_name\" has been set, using \"{}\" instead. Please set this now using the \"server_name <new name>\" command", fallback_server_name);
891bool NetworkServerStart()
903 NetworkInitialize(
false);
905 Debug(net, 5,
"Starting listeners for clients");
910 Debug(net, 5,
"Starting listeners for admins");
915 Debug(net, 5,
"Starting listeners for incoming server queries");
928 NetworkInitGameInfo();
958 if (c !=
nullptr && ci !=
nullptr) {
980 for (NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
1003 for (NetworkClientSocket *cs : NetworkClientSocket::Iterate()) {
1033 case SERVER_GAME_TYPE_LOCAL:
1037 case SERVER_GAME_TYPE_INVITE_ONLY:
1038 case SERVER_GAME_TYPE_PUBLIC:
1060 NetworkGameSocketHandler::ProcessDeferredDeletions();
1065static void NetworkSend()
1073 NetworkGameSocketHandler::ProcessDeferredDeletions();
1088 NetworkGameSocketHandler::ProcessDeferredDeletions();
1095void NetworkGameLoop()
1112#ifdef DEBUG_DUMP_COMMANDS
1116 static uint32_t next_date_fract;
1118 static bool check_sync_state =
false;
1119 static uint32_t sync_state[2];
1120 if (!f.has_value() && next_date == 0) {
1121 Debug(desync, 0,
"Cannot open commands.log");
1125 while (f.has_value() && !feof(*f)) {
1127 if (cp !=
nullptr) {
1133 if (check_sync_state) {
1137 Debug(desync, 0,
"Sync check: {:08x}; {:02x}; mismatch expected {{{:08x}, {:08x}}}, got {{{:08x}, {:08x}}}",
1141 check_sync_state =
false;
1147 Debug(desync, 0,
"Skipping to next command at {:08x}:{:02x}", next_date, next_date_fract);
1148 if (cp !=
nullptr) {
1152 check_sync_state =
false;
1155 if (cp !=
nullptr || check_sync_state)
break;
1158 if (fgets(buff,
lengthof(buff), *f) ==
nullptr)
break;
1162 if (consumer.ReadCharIf(
'[')) {
1164 consumer.SkipCharIf(
' ');
1167 if (consumer.ReadIf(
"cmd: ")
1168#ifdef DEBUG_FAILED_DUMP_COMMANDS
1169 || consumer.ReadIf(
"cmdf: ")
1174 bool valid = consumer.ReadIf(
"; ");
1175 next_date_fract = consumer.ReadIntegerBase<uint32_t>(16);
1176 valid &= consumer.ReadIf(
"; ");
1177 cp->
company =
static_cast<CompanyID>(consumer.ReadIntegerBase<uint16_t>(16));
1178 valid &= consumer.ReadIf(
"; ");
1179 cp->
cmd =
static_cast<Commands>(consumer.ReadIntegerBase<uint32_t>(16));
1180 valid &= consumer.ReadIf(
"; ");
1181 cp->
err_msg = consumer.ReadIntegerBase<uint32_t>(16);
1182 valid &= consumer.ReadIf(
"; ");
1188 for (
size_t i = 0; i + 1 < args.size(); i += 2) {
1190 std::from_chars(args.data() + i, args.data() + i + 2, e, 16);
1191 cp->
data.push_back(e);
1193 }
else if (consumer.ReadIf(
"join: ")) {
1196 bool valid = consumer.ReadIf(
"; ");
1197 next_date_fract = consumer.ReadIntegerBase<uint32_t>(16);
1199 Debug(desync, 0,
"Injecting pause for join at {:08x}:{:02x}; please join when paused", next_date, next_date_fract);
1204 _ddc_fastforward =
false;
1205 }
else if (consumer.ReadIf(
"sync: ")) {
1207 bool valid = consumer.ReadIf(
"; ");
1208 next_date_fract = consumer.ReadIntegerBase<uint32_t>(16);
1209 valid &= consumer.ReadIf(
"; ");
1210 sync_state[0] = consumer.ReadIntegerBase<uint32_t>(16);
1211 valid &= consumer.ReadIf(
"; ");
1212 sync_state[1] = consumer.ReadIntegerBase<uint32_t>(16);
1214 check_sync_state =
true;
1215 }
else if (consumer.ReadIf(
"msg: ") || consumer.ReadIf(
"client: ") ||
1216 consumer.ReadIf(
"load: ") || consumer.ReadIf(
"save: ") ||
1217 consumer.ReadIf(
"warning: ")) {
1219#ifndef DEBUG_FAILED_DUMP_COMMANDS
1220 }
else if (consumer.ReadIf(
"cmdf: ")) {
1229 if (f.has_value() && feof(*f)) {
1230 Debug(desync, 0,
"End of commands.log");
1243 bool send_frame =
false;
1259#ifdef NETWORK_SEND_DOUBLE_SEED
1288 Debug(net, 3,
"Starting network");
1294 _network_game_info = {};
1296 NetworkInitialize();
1298 Debug(net, 3,
"Network online, multiplayer available");
1310 Debug(net, 3,
"Shutting down network");
1317#ifdef __EMSCRIPTEN__
1320void CDECL em_openttd_add_server(
const char *connection_string)
std::vector< NetworkAddress > NetworkAddressList
Type for a list of addresses.
constexpr bool Test(Tvalue_type value) const
Test if the value-th bit is set.
constexpr bool None() const
Test if none of the values are set.
constexpr Timpl & Set()
Set all bits.
constexpr bool Any(const Timpl &other) const
Test if any of the given values are set.
void SendReceive()
Check whether we received/can send some data from/to the content server and when that's the case hand...
void Register()
Register our server to receive our invite code.
void SendReceive()
Check whether we received/can send some data from/to the Game Coordinator server and when that's the ...
void CloseAllConnections()
Close all pending connection tokens.
NetworkRecvStatus CloseConnection(bool error=true) override
This will put this socket handler in a close state.
Class for handling the client side of the game connection.
static ClientNetworkGameSocketHandler * my_client
This is us!
static NetworkRecvStatus SendQuit()
Tell the server we would like to quit.
static bool Receive()
Check whether we received/can send some data from/to the server and when that's the case handle it ap...
static bool GameLoop()
Actual game loop for the client.
static void Send()
Send the packets of this socket handler.
NetworkRecvStatus CloseConnection(NetworkRecvStatus status) override
Close the network connection due to the given status.
Endian-aware buffer adapter that always writes values in little endian order.
Wrapper for (un)resolved network addresses; there's no reason to transform a numeric IP to a string a...
static void EnsureValidSecretKeyAndUpdatePublicKey(std::string &secret_key, std::string &public_key)
Ensures that the given secret key is valid, and when not overwrite it with a valid secret key.
bool Contains(std::string_view key) const
Check whether the given key is contains in these authorized keys.
bool Add(std::string_view key)
Add the given key to the authorized keys, when it is not already contained.
bool Remove(std::string_view key)
Remove the given key from the authorized keys, when it is exists.
ClientID client_id
Client identifier.
static void HTTPReceive()
Do the receiving for all HTTP connections.
static void SendReceive()
Check if any query needs to send or receive.
static void QueryServer(SOCKET s, std::string_view connection_string)
Start to query a server based on an open socket.
std::string connection_string
The connection string for this ServerAddress.
static ServerAddress Parse(std::string_view connection_string, uint16_t default_port, CompanyID *company_id=nullptr)
Convert a string containing either "hostname", "hostname:port" or invite code to a ServerAddress,...
Class for handling the server side of the game connection.
static void Send()
Send the packets for the server sockets.
static void WelcomeAll()
Send a Welcome packet to all connected admins.
static Pool::IterateWrapperFiltered< ServerNetworkAdminSocketHandler, ServerNetworkAdminSocketHandlerFilter > IterateActive(size_t from=0)
Returns an iterable ensemble of all active admin sockets.
Class for handling the server side of the game connection.
static ServerNetworkGameSocketHandler * GetByClientID(ClientID client_id)
Return the client state given it's client-identifier.
static void Send()
Send the packets for the server sockets.
static void AcceptConnection(SOCKET s, const NetworkAddress &address)
Handle the accepting of a connection to the server.
NetworkAddress client_address
IP-address of the client (so they can be banned)
Compose data into a growing std::string.
Parse data from a string / buffer.
void SkipUntilChar(char c, SeparatorUsage sep)
Skip data until the first occurrence of 8-bit char 'c'.
@ SKIP_ONE_SEPARATOR
Read and discard one separator, do not include it in the result.
static constexpr size_type npos
Special value for "end of data".
Non blocking connection create to actually connect to servers.
void OnConnect(SOCKET s) override
Callback when the connection succeeded.
void OnFailure() override
Callback for when the connection attempt failed.
static void CheckCallbacks()
Check whether we need to call the callback, i.e.
static void KillAll()
Kill all connection attempts.
static bool Receive()
Handle the receiving of packets.
static bool Listen(uint16_t port)
Listen on a particular port.
static void CloseListeners()
Close the sockets we're listening on.
Non blocking connection to query servers for their game info.
void OnConnect(SOCKET s) override
Callback when the connection succeeded.
void OnFailure() override
Callback for when the connection attempt failed.
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.
std::string_view GetCommandName(Commands cmd)
This function mask the parameter with CMD_ID_MASK and returns the name which belongs to the given com...
void NetworkSendCommand(Commands cmd, StringID err_message, CommandCallback *callback, CompanyID company, const CommandDataBuffer &cmd_data)
Prepare a DoCommand to be send over the network.
Commands
List of commands.
@ CMD_PAUSE
pause the game
CompanyID GetFirstPlayableCompanyID()
Get the index of the first available company.
CompanyID _current_company
Company currently doing an action.
static constexpr CompanyID COMPANY_SPECTATOR
The client is spectating.
static constexpr CompanyID COMPANY_NEW_COMPANY
The client wants a new company.
static const uint16_t NETWORK_DEFAULT_PORT
The default port of the game server (TCP & UDP)
void IConsoleCmdExec(std::string_view command_string, const uint recurse_count)
Execute a given command passed to us.
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.
static const TextColour CC_DEFAULT
Default colour of the console.
void NetworkCoreShutdown()
Shuts down the network core (as that is needed for some platforms.
bool NetworkCoreInitialize()
Initializes the network core (as that is needed for some platforms.
@ NETWORK_RECV_STATUS_CLIENT_QUIT
The connection is lost gracefully. Other clients are already informed of this leaving client.
#define Debug(category, level, format_string,...)
Output a line of debugging information.
@ WL_ERROR
Errors (eg. saving/loading failed)
@ WL_CRITICAL
Critical errors, the MessageBox is shown in all cases.
void ShowErrorMessage(EncodedString &&summary_msg, int x, int y, CommandCost &cc)
Display an error message in a window.
std::optional< FileHandle > FioFOpenFile(std::string_view filename, std::string_view mode, Subdirectory subdir, size_t *filesize)
Opens a OpenTTD file somewhere in a personal or global directory.
@ SAVE_DIR
Base directory for all savegames.
PauseModes _pause_mode
The current pause mode.
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...
void NetworkFindBroadcastIPs(NetworkAddressList *broadcast)
Find the IPv4 broadcast addresses; IPv6 uses a completely different strategy for broadcasting.
Resolving of hostnames/IPs.
void NetworkHTTPInitialize()
Initialize the HTTP socket handler.
void NetworkHTTPUninitialize()
Uninitialize the HTTP socket handler.
uint32_t _last_sync_frame
Used in the server to store the last time a sync packet was sent to clients.
NetworkAddress ParseConnectionString(std::string_view connection_string, uint16_t default_port)
Convert a string containing either "hostname" or "hostname:ip" to a NetworkAddress.
void NetworkStartUp()
This tries to launch the network for a given OS.
bool _is_network_server
Does this client wants to be a network-server?
NetworkClientInfoPool _networkclientinfo_pool("NetworkClientInfo")
Make sure both pools have the same size.
void NetworkHandlePauseChange(PauseModes prev_mode, PauseMode changed_mode)
Handle the pause mode change so we send the right messages to the chat.
static uint NetworkCountActiveClients()
Counts the number of active clients connected.
StringList _network_host_list
The servers we know.
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.
static void CheckPauseOnJoin()
Check whether we should pause on join.
NetworkAddressList _broadcast_list
List of broadcast addresses.
void NetworkClientJoinGame()
Actually perform the joining to the server.
static bool NetworkHasJoiningClient()
Checks whether there is a joining client.
static auto FindKey(auto *authorized_keys, std::string_view authorized_key)
Simple helper to find the location of the given authorized key in the authorized keys.
ClientID _redirect_console_to_client
If not invalid, redirect the console output to a client.
static void CheckClientAndServerName()
Check whether the client and server name are set, for a dedicated server and if not set them to some ...
void NetworkOnGameStart()
Perform tasks when the server is started.
uint32_t _frame_counter
The current frame.
bool _network_available
is network mode available?
uint8_t _network_reconnect
Reconnect timeout.
bool _networking
are we in networking mode?
void NetworkQueryServer(std::string_view connection_string)
Query a server to fetch the game-info.
static void InitializeNetworkPools(bool close_admins=true)
Resets the pools used for network clients, and the admin pool if needed.
StringList _network_ban_list
The banned clients.
bool _network_dedicated
are we a dedicated server?
bool HasClients()
Return whether there is any client connected or trying to connect at all.
static bool NetworkReceive()
Receives something from the network.
void NetworkDisconnect(bool close_admins)
We want to disconnect from the host/clients.
bool _network_server
network-server is active
std::string GenerateUid(std::string_view subject)
Generate an unique ID.
uint32_t _sync_seed_1
Seed to compare during sync checks.
NetworkGame * NetworkAddServer(std::string_view connection_string, bool manually, bool never_expire)
Validates an address entered as a string and adds the server to the list.
uint32_t _sync_frame
The frame to perform the sync check.
void NetworkBackgroundLoop()
We have to do some (simple) background stuff that runs normally, even when we are not in multiplayer.
StringList _network_bind_list
The addresses to bind on.
std::string NormalizeConnectionString(std::string_view connection_string, uint16_t default_port)
Normalize a connection string.
bool NetworkClientConnectGame(std::string_view connection_string, CompanyID default_company, const std::string &join_server_password)
Join a client to the server at with the given connection string.
static void CheckMinActiveClients()
Check if the minimum number of active clients has been reached and pause or unpause the game as appro...
ClientID _network_own_client_id
Our client identifier.
std::string_view ParseCompanyFromConnectionString(std::string_view connection_string, CompanyID *company_id)
Parse the company part ("#company" postfix) of a connecting string.
static void CheckPauseHelper(bool pause, PauseMode pm)
Helper function for the pause checkers.
bool _network_first_time
Whether we have finished joining or not.
void NetworkShutDown()
This shuts the network down.
uint8_t _network_clients_connected
The amount of clients connected.
void GetBindAddresses(NetworkAddressList *addresses, uint16_t port)
Get the addresses to bind to.
std::string_view ParseFullConnectionString(std::string_view connection_string, uint16_t &port, CompanyID *company_id)
Converts a string to ip/port/company Format: IP:port::company.
void NetworkUpdateServerGameType()
The setting server_game_type was updated; possibly we need to take some action.
bool NetworkCanJoinCompany(CompanyID company_id)
Returns whether the given company can be joined by this client.
void NetworkClose(bool close_admins)
Close current connections.
uint32_t _frame_counter_max
To where we may go with our clients.
bool NetworkValidateServerName(std::string &server_name)
Trim the given server name in place, i.e.
Server part of the admin network protocol.
Base core network types and some helper functions to access them.
void CDECL NetworkAddChatMessage(TextColour colour, uint duration, const std::string &message)
Add a text message to the 'chat window' to be shown.
NetworkJoinInfo _network_join
Information about the game to join to.
bool NetworkValidateOurClientName()
Convenience method for NetworkValidateClientName on _settings_client.network.client_name.
void NetworkClient_Connected()
Is called after a client is connected to the server.
Client part of the network protocol.
void NetworkFreeLocalCommandQueue()
Free the local command queues.
void NetworkExecuteLocalCommandQueue()
Execute all commands on the local command queue that ought to be executed this frame.
void NetworkDistributeCommands()
Distribute the commands of ourself and the clients.
ClientNetworkContentSocketHandler _network_content_client
The client we use to connect to the server.
Part of the network protocol handling content distribution.
ClientNetworkCoordinatorSocketHandler _network_coordinator_client
The connection to the Game Coordinator.
Part of the network protocol handling Game Coordinator requests.
void NetworkServerNewCompany(const Company *company, NetworkClientInfo *ci)
Perform all the server specific administration of a new company.
void NetworkServerUpdateGameInfo()
Update the server's NetworkServerGameInfo due to changes in settings.
NetworkGame * NetworkGameListAddItem(std::string_view connection_string)
Add a new item to the linked gamelist.
std::vector< std::unique_ptr< NetworkGame > > _network_game_list
Game list of this client.
Handling of the list of games.
@ NGLS_OFFLINE
Server is offline (or cannot be queried).
NetworkJoinStatus _network_join_status
The status of joining.
void UpdateNetworkGameWindow()
Update the network new window because a new server is found on the network.
GUIs related to networking.
Query part of the network protocol.
void ChangeNetworkRestartTime(bool reset)
Reset the automatic network restart time interval.
void NetworkServer_Tick(bool send_frame)
This is called every tick if this is a _network_server.
Server part of the network protocol.
@ DESTTYPE_CLIENT
Send message/notice to only a certain client (Private)
NetworkErrorCode
The error codes we send around in the protocols.
NetworkAction
Actions that can be used for NetworkTextMessage.
ClientID
'Unique' identifier to be given to clients
@ CLIENT_ID_SERVER
Servers always have this ID.
void NetworkUDPClose()
Close all UDP related stuff.
void NetworkUDPInitialize()
Initialize the whole UDP bit.
void NetworkUDPServerListen()
Start the listening of the UDP server component.
void NetworkBackgroundUDPLoop()
Receive the UDP packets.
Sending and receiving UDP messages.
void ClearGRFConfigList(GRFConfigList &config)
Clear a GRF Config list, freeing all nodes.
void StateGameLoop()
State controlling game loop.
PauseMode
Modes of pausing we've got.
@ LinkGraph
A game paused due to the link graph schedule lagging.
@ Error
A game paused because a (critical) error.
@ GameScript
A game paused by a game script.
@ ActiveClients
A game paused for 'min_active_clients'.
@ Normal
A game normally paused.
@ Join
A game paused for 'pause_on_join'.
@ SM_JOIN_GAME
Join a network game.
@ SM_MENU
Switch to game intro menu.
#define INSTANTIATE_POOL_METHODS(name)
Force instantiation of pool methods so we don't get linker errors.
@ NetworkClient
Network client pools.
@ NetworkAdmin
Network admin pool.
Randomizer _random
Random used in the game state calculations.
ClientSettings _settings_client
The current settings for this game.
#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.
bool StrEqualsIgnoreCase(std::string_view str1, std::string_view str2)
Compares two string( view)s for equality, while ignoring the case of the characters.
void StrTrimInPlace(std::string &str)
Trim the spaces from given string in place, i.e.
static const char32_t CHAR_TD_LRM
The next character acts like a left-to-right character.
static const char32_t CHAR_TD_RLM
The next character acts like a right-to-left character.
std::vector< std::string > StringList
Type for a list of strings.
void GetStringWithArgs(StringBuilder &builder, StringID string, StringParameters &args, uint case_index, bool game_script)
Get a parsed string with most special stringcodes replaced by the string parameters.
EncodedString GetEncodedString(StringID str)
Encode a string with no parameters into an encoded string.
std::string GetString(StringID string)
Resolve the given StringID into a std::string with formatting but no parameters.
TextDirection _current_text_dir
Text direction of the currently selected language.
uint32_t StringID
Numeric value that represents a string, independent of the selected language.
@ TD_LTR
Text is written left-to-right by default.
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.
StringID err_msg
string ID of error message to use.
CommandDataBuffer data
command parameters.
CompanyID company
company that is executing the command
Commands cmd
command being executed.
Defines the traits of a command.
NetworkAuthorizedKeys allow_list
Public keys of clients that are allowed to join this company.
StringID name_1
Name of the company if the user did not change it.
std::string name
Name of the company if the user changed it.
uint16_t network_chat_timeout
timeout of chat messages in seconds
Container for all information known about a client.
static NetworkClientInfo * GetByClientID(ClientID client_id)
Return the CI given it's client-identifier.
~NetworkClientInfo()
Basically a client is leaving us right now.
bool CanJoinCompany(CompanyID company_id) const
Returns whether the given company can be joined by this client.
CompanyID client_playas
As which company is this client playing (CompanyID)
ClientID client_id
Client identifier (same as ClientState->client_id)
std::string client_name
Name of the client.
std::string public_key
The public key of the client.
Structure with information shown in the game list (GUI)
bool refreshing
Whether this server is being queried.
int version
Used to see which servers are no longer available on the Game Coordinator and can be removed.
NetworkGameInfo info
The game information of this server.
bool manually
True if the server was added manually.
NetworkGameStatus status
Stats of the server.
std::string connection_string
The address of the server to join.
std::string server_password
The password of the server to join.
CompanyID company
The company to join.
GRFConfigList grfconfig
List of NewGRF files used.
std::string server_name
Server name.
uint8_t clients_on
Current count of clients on server.
std::string client_secret_key
The secret key of the client for authorized key logins.
std::string client_name
name of the player (as client)
ServerGameType server_game_type
Server type: local / public / invite-only.
std::string client_public_key
The public key of the client for authorized key logins.
uint8_t frame_freq
how often do we send commands to the clients
uint8_t min_active_clients
minimum amount of active clients to unpause the game
uint16_t server_port
port the server listens on
std::string last_joined
Last joined server.
std::string server_name
name of the server
uint16_t server_admin_port
port the server listens on for the admin network
bool pause_on_join
pause the game when people join
static void Clean(PoolTypes)
Clean all pools of given type.
static Pool::IterateWrapper< Titem > Iterate(size_t from=0)
Returns an iterable ensemble of all valid Titem.
Tindex index
Index of this pool item.
static bool CanAllocateItem(size_t n=1)
Helper functions so we can use PoolItem::Function() instead of _poolitem_pool.Function()
static bool IsValidID(auto index)
Tests whether given index can be used to get valid (non-nullptr) Titem.
static Titem * GetIfValid(auto index)
Returns Titem with given index.
Base class for all pools.
static constexpr size_t MAX_SIZE
Make template parameter accessible from outside.
uint32_t state[2]
The state of the randomizer.
The data required to format and validate a single parameter of a string.
Templated helper to make a type-safe 'typedef' representing a single POD value.
Basic functions to receive and send UDP packets.
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-...
@ WN_NETWORK_STATUS_WINDOW_JOIN
Network join status.
@ WC_SEND_NETWORK_MSG
Chatbox; Window numbers:
@ WC_CLIENT_LIST
Client list; Window numbers:
@ WC_NETWORK_STATUS_WINDOW
Network status window; Window numbers: