mirrors
/
OpenRCT2
mirror of https://github.com/OpenRCT2/OpenRCT2.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Fix #2802 - extract hardcoded network-related strings 

I extracted all of the hardcoded network-related strings. In addition to that, I also refactored the way last_disconnect_reason was being accessed/modified.
This commit is contained in:
Martin Černáč 2016-02-18 14:52:02 +01:00
parent b13af3c8f5
commit 361d30c6f5
4 changed files with 120 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
data/language/english_uk.txt
View File

@ -4046,6 +4046,22 @@ STR_5738 :Closed, {COMMA16} people still on ride
STR_5739 :{WINDOW_COLOUR_2}Customers on ride: {BLACK}{COMMA16}
STR_5740 :Never-ending marketing campaigns
STR_5741 :{SMALLFONT}{BLACK}Marketing campaigns never end
STR_5742 :Authenticating...
STR_5743 :Connecting...
STR_5744 :Resolving...
STR_5745 :Network desync detected
STR_5746 :Disconnected
STR_5747 :Kicked
STR_5748 :Get out of the server!
STR_5749 :Connection Closed
STR_5750 :No Data
STR_5751 :has disconnected
STR_5752 :Bad Player Name
STR_5753 :Incorrect Software Version
STR_5754 :Bad Password
STR_5755 :Server Full
STR_5756 :has joined the game
STR_5757 :Downloading map
#############

17
src/localisation/string_ids.h
View File

@ -2347,6 +2347,23 @@ enum {
STR_CHEAT_NEVERENDING_MARKETING = 5740,
STR_CHEAT_TIP_NEVERENDING_MARKETING = 5741,
STR_MULTIPLAYER_RESOLVING = 5742,
STR_MULTIPLAYER_CONNECTING = 5743,
STR_MULTIPLAYER_AUTHENTICATING = 5744,
STR_MULTIPLAYER_DESYNC = 5745,
STR_MULTIPLAYER_DISCONNECTED = 5746,
STR_MULTIPLAYER_KICKED = 5747,
STR_MULTIPLAYER_DISCONNECT_MSG = 5748,
STR_MULTIPLAYER_CONNECTION_CLOSED = 5749,
STR_MULTIPLAYER_NO_DATA = 5750,
STR_MULTIPLAYER_HAS_DISCONNECTED = 5751,
STR_MULTIPLAYER_BAD_PLAYER_NAME = 5752,
STR_MULTIPLAYER_INCORRECT_SOFTWARE_VERSION = 5753,
STR_MULTIPLAYER_BAD_PASSWORD = 5754,
STR_MULTIPLAYER_SERVER_FULL = 5755,
STR_MULTIPLAYER_HAS_JOINED_THE_GAME = 5756,
STR_MULTIPLAYER_DOWNLOADING_MAP = 5757,
// Have to include resource strings (from scenarios and objects) for the time being now that language is partially working
STR_COUNT = 32768
};

107
src/network/network.cpp
View File

@ -324,6 +324,10 @@ NetworkConnection::~NetworkConnection()
if (socket != INVALID_SOCKET) {
closesocket(socket);
}
if (last_disconnect_reason) {
delete[] last_disconnect_reason;
}
}
int NetworkConnection::ReadPacket()
@ -442,6 +446,35 @@ bool NetworkConnection::ReceivedPacketRecently()
return true;
}
const char* NetworkConnection::getLastDisconnectReason() const
{
return this->last_disconnect_reason;
}
void NetworkConnection::setLastDisconnectReason(const char *src)
{
if (src == nullptr) {
if (last_disconnect_reason) {
delete[] last_disconnect_reason;
last_disconnect_reason = NULL;
}
return;
}
if (!last_disconnect_reason) {
last_disconnect_reason = new char[NETWORK_DISCONNECT_REASON_BUFFER_SIZE];
}
strncpy(last_disconnect_reason, src, NETWORK_DISCONNECT_REASON_BUFFER_SIZE - 1);
}
void NetworkConnection::setLastDisconnectReason(const rct_string_id string_id)
{
char buffer[NETWORK_DISCONNECT_REASON_BUFFER_SIZE];
format_string(buffer, string_id, 0);
setLastDisconnectReason(buffer);
}
NetworkAddress::NetworkAddress()
{
ss = std::make_shared<sockaddr_storage>();
@ -579,7 +612,8 @@ void Network::Close()
mode = NETWORK_MODE_NONE;
status = NETWORK_STATUS_NONE;
server_connection.authstatus = NETWORK_AUTH_NONE;
server_connection.last_disconnect_reason = NULL;
server_connection.setLastDisconnectReason(nullptr);
client_connection_list.clear();
game_command_queue.clear();
@ -609,7 +643,9 @@ bool Network::BeginClient(const char* host, unsigned short port)
server_address.Resolve(host, port);
status = NETWORK_STATUS_RESOLVING;
window_network_status_open("Resolving...");
char str_resolving[256];
format_string(str_resolving, STR_MULTIPLAYER_RESOLVING, 0);
window_network_status_open(str_resolving);
mode = NETWORK_MODE_CLIENT;
@ -796,7 +832,9 @@ void Network::UpdateClient()
}
if (connect(server_connection.socket, (sockaddr *)&(*server_address.ss), (*server_address.ss_len)) == SOCKET_ERROR && (LAST_SOCKET_ERROR() == EINPROGRESS || LAST_SOCKET_ERROR() == EWOULDBLOCK)){
window_network_status_open("Connecting...");
char str_connecting[256];
format_string(str_connecting, STR_MULTIPLAYER_CONNECTING, 0);
window_network_status_open(str_connecting);
server_connect_time = SDL_GetTicks();
status = NETWORK_STATUS_CONNECTING;
} else {
@ -847,21 +885,25 @@ void Network::UpdateClient()
status = NETWORK_STATUS_CONNECTED;
server_connection.ResetLastPacketTime();
Client_Send_AUTH(gConfigNetwork.player_name, "");
window_network_status_open("Authenticating...");
char str_authenticating[256];
format_string(str_authenticating, STR_MULTIPLAYER_AUTHENTICATING, 0);
window_network_status_open(str_authenticating);
}
}
}break;
case NETWORK_STATUS_CONNECTED:
if (!ProcessConnection(server_connection)) {
std::string errormsg = "Disconnected";
if (server_connection.last_disconnect_reason) {
errormsg += ": ";
errormsg += server_connection.last_disconnect_reason;
char str_disconnected[256];
format_string(str_disconnected, STR_MULTIPLAYER_DISCONNECTED, 0);
if (server_connection.getLastDisconnectReason()) {
strcat(str_disconnected, ": ");
strcat(str_disconnected, server_connection.getLastDisconnectReason());
}
if (server_connection.authstatus == NETWORK_AUTH_REQUIREPASSWORD) { // Do not show disconnect message window when password window closed/canceled
window_network_status_close();
} else {
window_network_status_open(errormsg.c_str());
window_network_status_open(str_disconnected);
}
Close();
}
@ -870,7 +912,9 @@ void Network::UpdateClient()
// Check synchronisation
if (!_desynchronised && !CheckSRAND(RCT2_GLOBAL(RCT2_ADDRESS_CURRENT_TICKS, uint32), RCT2_GLOBAL(RCT2_ADDRESS_SCENARIO_SRAND_0, uint32))) {
_desynchronised = true;
window_network_status_open("Network desync detected");
char str_desync[256];
format_string(str_desync, STR_MULTIPLAYER_DESYNC, 0);
window_network_status_open(str_desync);
if (!gConfigNetwork.stay_connected) {
Close();
}
@ -971,8 +1015,10 @@ void Network::KickPlayer(int playerId)
for(auto it = client_connection_list.begin(); it != client_connection_list.end(); it++) {
if ((*it)->player->id == playerId) {
// Disconnect the client gracefully
(*it)->last_disconnect_reason = "Kicked";
Server_Send_SETDISCONNECTMSG(*(*it), "Get out of the server!");
(*it)->setLastDisconnectReason(STR_MULTIPLAYER_KICKED);
char str_disconnect_msg[256];
format_string(str_disconnect_msg, STR_MULTIPLAYER_DISCONNECT_MSG, 0);
Server_Send_SETDISCONNECTMSG(*(*it), str_disconnect_msg);
shutdown((*it)->socket, SHUT_RD);
(*it)->SendQueuedPackets();
break;
@ -1457,8 +1503,8 @@ bool Network::ProcessConnection(NetworkConnection& connection)
switch(packetStatus) {
case NETWORK_READPACKET_DISCONNECTED:
// closed connection or network error
if (!connection.last_disconnect_reason) {
connection.last_disconnect_reason = "Connection Closed";
if (!connection.getLastDisconnectReason()) {
connection.setLastDisconnectReason(STR_MULTIPLAYER_CONNECTION_CLOSED);
}
return false;
break;
@ -1476,8 +1522,8 @@ bool Network::ProcessConnection(NetworkConnection& connection)
} while (packetStatus == NETWORK_READPACKET_MORE_DATA || packetStatus == NETWORK_READPACKET_SUCCESS);
connection.SendQueuedPackets();
if (!connection.ReceivedPacketRecently()) {
if (!connection.last_disconnect_reason) {
connection.last_disconnect_reason = "No Data";
if (!connection.getLastDisconnectReason()) {
connection.setLastDisconnectReason(STR_MULTIPLAYER_NO_DATA);
}
return false;
}
@ -1548,10 +1594,14 @@ void Network::RemoveClient(std::unique_ptr<NetworkConnection>& connection)
lineCh = utf8_write_codepoint(lineCh, FORMAT_RED);
char reasonstr[100];
reasonstr[0] = 0;
if (connection->last_disconnect_reason && strlen(connection->last_disconnect_reason) < sizeof(reasonstr)) {
sprintf(reasonstr, " (%s)", connection->last_disconnect_reason);
if (connection->getLastDisconnectReason() && strlen(connection->getLastDisconnectReason()) < sizeof(reasonstr)) {
sprintf(reasonstr, " (%s)", connection->getLastDisconnectReason());
}
sprintf(lineCh, "%s has disconnected%s", connection_player->name, reasonstr);
char str_has_disconnected[256];
format_string(str_has_disconnected, STR_MULTIPLAYER_HAS_DISCONNECTED, 0);
sprintf(lineCh, "%s %s%s", connection_player->name, str_has_disconnected, reasonstr);
chat_history_add(text);
gNetwork.Server_Send_CHAT(text);
}
@ -1604,19 +1654,19 @@ void Network::Client_Handle_AUTH(NetworkConnection& connection, NetworkPacket& p
packet >> (uint32&)connection.authstatus >> (uint8&)player_id;
switch(connection.authstatus) {
case NETWORK_AUTH_BADNAME:
connection.last_disconnect_reason = "Bad Player Name";
connection.setLastDisconnectReason(STR_MULTIPLAYER_BAD_PLAYER_NAME);
shutdown(connection.socket, SHUT_RDWR);
break;
case NETWORK_AUTH_BADVERSION:
connection.last_disconnect_reason = "Incorrect Software Version";
connection.setLastDisconnectReason(STR_MULTIPLAYER_INCORRECT_SOFTWARE_VERSION);
shutdown(connection.socket, SHUT_RDWR);
break;
case NETWORK_AUTH_BADPASSWORD:
connection.last_disconnect_reason = "Bad Password";
connection.setLastDisconnectReason(STR_MULTIPLAYER_BAD_PASSWORD);
shutdown(connection.socket, SHUT_RDWR);
break;
case NETWORK_AUTH_FULL:
connection.last_disconnect_reason = "Server Full";
connection.setLastDisconnectReason(STR_MULTIPLAYER_SERVER_FULL);
shutdown(connection.socket, SHUT_RDWR);
break;
case NETWORK_AUTH_REQUIREPASSWORD:
@ -1655,7 +1705,9 @@ void Network::Server_Handle_AUTH(NetworkConnection& connection, NetworkPacket& p
char* lineCh = text;
lineCh = utf8_write_codepoint(lineCh, FORMAT_OUTLINE);
lineCh = utf8_write_codepoint(lineCh, FORMAT_GREEN);
sprintf(lineCh, "%s has joined the game", player->name);
char str_has_joined_the_game[256];
format_string(str_has_joined_the_game, STR_MULTIPLAYER_HAS_JOINED_THE_GAME, 0);
sprintf(lineCh, "%s %s", player->name, str_has_joined_the_game);
chat_history_add(text);
Server_Send_MAP(&connection);
gNetwork.Server_Send_CHAT(text);
@ -1678,8 +1730,9 @@ void Network::Client_Handle_MAP(NetworkConnection& connection, NetworkPacket& pa
if (offset + chunksize > chunk_buffer.size()) {
chunk_buffer.resize(offset + chunksize);
}
char status[256];
sprintf(status, "Downloading map ... (%u / %u)", (offset + chunksize) / 1000, size / 1000);
char status[256], str_downloading_map[256];
format_string(str_downloading_map, STR_MULTIPLAYER_DOWNLOADING_MAP, 0);
sprintf(status, "%s ... (%u / %u)", str_downloading_map, (offset + chunksize) / 1000, size / 1000);
window_network_status_open(status);
memcpy(&chunk_buffer[offset], (void*)packet.Read(chunksize), chunksize);
if (offset + chunksize == size) {
@ -1884,7 +1937,7 @@ void Network::Client_Handle_SETDISCONNECTMSG(NetworkConnection& connection, Netw
const char* disconnectmsg = packet.ReadString();
if (disconnectmsg) {
msg = disconnectmsg;
connection.last_disconnect_reason = msg.c_str();
connection.setLastDisconnectReason(msg.c_str());
}
}

8
src/network/network.h
View File

@ -71,6 +71,8 @@ extern "C" {
#define NETWORK_STREAM_VERSION "2"
#define NETWORK_STREAM_ID OPENRCT2_VERSION "-" NETWORK_STREAM_VERSION
#define NETWORK_DISCONNECT_REASON_BUFFER_SIZE 256
#ifdef __WINDOWS__
#include <winsock2.h>
#include <ws2tcpip.h>
@ -240,14 +242,18 @@ public:
void ResetLastPacketTime();
bool ReceivedPacketRecently();
const char *getLastDisconnectReason() const;
void setLastDisconnectReason(const char *src);
void setLastDisconnectReason(const rct_string_id string_id);
SOCKET socket;
NetworkPacket inboundpacket;
int authstatus;
NetworkPlayer* player;
uint32 ping_time;
const char* last_disconnect_reason;
private:
char* last_disconnect_reason;
bool SendPacket(NetworkPacket& packet);
std::list<std::unique_ptr<NetworkPacket>> outboundpackets;
uint32 last_packet_time;