Change error_message from wstring to string

This removes a lot of narrow/wide conversions where a wide string was never used.
This commit is contained in:
ShadowNinja 2015-03-27 20:24:04 -04:00
parent 3d53c90d4b
commit 30075467b8
9 changed files with 129 additions and 149 deletions

@ -119,34 +119,20 @@ Camera::~Camera()
m_wieldmgr->drop(); m_wieldmgr->drop();
} }
bool Camera::successfullyCreated(std::wstring& error_message) bool Camera::successfullyCreated(std::string &error_message)
{ {
if (m_playernode == NULL) if (!m_playernode) {
{ error_message = "Failed to create the player scene node";
error_message = L"Failed to create the player scene node"; } else if (!m_headnode) {
return false; error_message = "Failed to create the head scene node";
} else if (!m_cameranode) {
error_message = "Failed to create the camera scene node";
} else if (!m_wieldmgr) {
error_message = "Failed to create the wielded item scene manager";
} else if (!m_wieldnode) {
error_message = "Failed to create the wielded item scene node";
} }
if (m_headnode == NULL) return error_message.empty();
{
error_message = L"Failed to create the head scene node";
return false;
}
if (m_cameranode == NULL)
{
error_message = L"Failed to create the camera scene node";
return false;
}
if (m_wieldmgr == NULL)
{
error_message = L"Failed to create the wielded item scene manager";
return false;
}
if (m_wieldnode == NULL)
{
error_message = L"Failed to create the wielded item scene node";
return false;
}
return true;
} }
// Returns the fractional part of x // Returns the fractional part of x

@ -110,7 +110,7 @@ public:
} }
// Checks if the constructor was able to create the scene nodes // Checks if the constructor was able to create the scene nodes
bool successfullyCreated(std::wstring& error_message); bool successfullyCreated(std::string &error_message);
// Step the camera: updates the viewing range and view bobbing. // Step the camera: updates the viewing range and view bobbing.
void step(f32 dtime); void step(f32 dtime);

@ -480,7 +480,7 @@ public:
bool accessDenied() bool accessDenied()
{ return m_access_denied; } { return m_access_denied; }
std::wstring accessDeniedReason() std::string accessDeniedReason()
{ return m_access_denied_reason; } { return m_access_denied_reason; }
bool itemdefReceived() bool itemdefReceived()
@ -589,7 +589,7 @@ private:
u64 m_map_seed; u64 m_map_seed;
std::string m_password; std::string m_password;
bool m_access_denied; bool m_access_denied;
std::wstring m_access_denied_reason; std::string m_access_denied_reason;
std::queue<ClientEvent> m_client_event_queue; std::queue<ClientEvent> m_client_event_queue;
bool m_itemdef_received; bool m_itemdef_received;
bool m_nodedef_received; bool m_nodedef_received;

@ -156,7 +156,7 @@ bool ClientLauncher::run(GameParams &game_params, const Settings &cmd_args)
// If an error occurs, this is set to something by menu(). // If an error occurs, this is set to something by menu().
// It is then displayed before the menu shows on the next call to menu() // It is then displayed before the menu shows on the next call to menu()
std::wstring error_message = L""; std::string error_message;
bool first_loop = true; bool first_loop = true;
@ -184,7 +184,7 @@ bool ClientLauncher::run(GameParams &game_params, const Settings &cmd_args)
*/ */
guiroot = guienv->addStaticText(L"", core::rect<s32>(0, 0, 10000, 10000)); guiroot = guienv->addStaticText(L"", core::rect<s32>(0, 0, 10000, 10000));
bool game_has_run = launch_game(&error_message, game_params, cmd_args); bool game_has_run = launch_game(error_message, game_params, cmd_args);
// If skip_main_menu, we only want to startup once // If skip_main_menu, we only want to startup once
if (skip_main_menu && !first_loop) if (skip_main_menu && !first_loop)
@ -207,7 +207,7 @@ bool ClientLauncher::run(GameParams &game_params, const Settings &cmd_args)
} }
if (current_playername.length() > PLAYERNAME_SIZE-1) { if (current_playername.length() > PLAYERNAME_SIZE-1) {
error_message = wgettext("Player name too long."); error_message = gettext("Player name too long.");
playername = current_playername.substr(0, PLAYERNAME_SIZE-1); playername = current_playername.substr(0, PLAYERNAME_SIZE-1);
g_settings->set("name", playername); g_settings->set("name", playername);
continue; continue;
@ -245,25 +245,24 @@ bool ClientLauncher::run(GameParams &game_params, const Settings &cmd_args)
} //try } //try
catch (con::PeerNotFoundException &e) { catch (con::PeerNotFoundException &e) {
error_message = wgettext("Connection error (timed out?)"); error_message = gettext("Connection error (timed out?)");
errorstream << wide_to_narrow(error_message) << std::endl; errorstream << error_message << std::endl;
} }
#ifdef NDEBUG #ifdef NDEBUG
catch (std::exception &e) { catch (std::exception &e) {
std::string narrow_message = "Some exception: \""; std::string error_message = "Some exception: \"";
narrow_message += e.what(); error_message += e.what();
narrow_message += "\""; error_message += "\"";
errorstream << narrow_message << std::endl; errorstream << error_message << std::endl;
error_message = narrow_to_wide(narrow_message);
} }
#endif #endif
// If no main menu, show error and exit // If no main menu, show error and exit
if (skip_main_menu) { if (skip_main_menu) {
if (error_message != L"") { if (!error_message.empty()) {
verbosestream << "error_message = " verbosestream << "error_message = "
<< wide_to_narrow(error_message) << std::endl; << error_message << std::endl;
retval = false; retval = false;
} }
break; break;
@ -312,7 +311,7 @@ bool ClientLauncher::init_engine(int log_level)
return device != NULL; return device != NULL;
} }
bool ClientLauncher::launch_game(std::wstring *error_message, bool ClientLauncher::launch_game(std::string &error_message,
GameParams &game_params, const Settings &cmd_args) GameParams &game_params, const Settings &cmd_args)
{ {
// Initialize menu data // Initialize menu data
@ -320,9 +319,9 @@ bool ClientLauncher::launch_game(std::wstring *error_message,
menudata.address = address; menudata.address = address;
menudata.name = playername; menudata.name = playername;
menudata.port = itos(game_params.socket_port); menudata.port = itos(game_params.socket_port);
menudata.errormessage = wide_to_narrow(*error_message); menudata.errormessage = error_message;
*error_message = L""; error_message.clear();
if (cmd_args.exists("password")) if (cmd_args.exists("password"))
menudata.password = cmd_args.get("password"); menudata.password = cmd_args.get("password");
@ -367,11 +366,11 @@ bool ClientLauncher::launch_game(std::wstring *error_message,
} }
} }
if (menudata.errormessage != "") { if (!menudata.errormessage.empty()) {
/* The calling function will pass this back into this function upon the /* The calling function will pass this back into this function upon the
* next iteration (if any) causing it to be displayed by the GUI * next iteration (if any) causing it to be displayed by the GUI
*/ */
*error_message = narrow_to_wide(menudata.errormessage); error_message = menudata.errormessage;
return false; return false;
} }
@ -410,25 +409,25 @@ bool ClientLauncher::launch_game(std::wstring *error_message,
if (current_address == "") { // If local game if (current_address == "") { // If local game
if (worldspec.path == "") { if (worldspec.path == "") {
*error_message = wgettext("No world selected and no address " error_message = gettext("No world selected and no address "
"provided. Nothing to do."); "provided. Nothing to do.");
errorstream << wide_to_narrow(*error_message) << std::endl; errorstream << error_message << std::endl;
return false; return false;
} }
if (!fs::PathExists(worldspec.path)) { if (!fs::PathExists(worldspec.path)) {
*error_message = wgettext("Provided world path doesn't exist: ") error_message = gettext("Provided world path doesn't exist: ")
+ narrow_to_wide(worldspec.path); + worldspec.path;
errorstream << wide_to_narrow(*error_message) << std::endl; errorstream << error_message << std::endl;
return false; return false;
} }
// Load gamespec for required game // Load gamespec for required game
gamespec = findWorldSubgame(worldspec.path); gamespec = findWorldSubgame(worldspec.path);
if (!gamespec.isValid() && !game_params.game_spec.isValid()) { if (!gamespec.isValid() && !game_params.game_spec.isValid()) {
*error_message = wgettext("Could not find or load game \"") error_message = gettext("Could not find or load game \"")
+ narrow_to_wide(worldspec.gameid) + L"\""; + worldspec.gameid + "\"";
errorstream << wide_to_narrow(*error_message) << std::endl; errorstream << error_message << std::endl;
return false; return false;
} }
@ -444,10 +443,9 @@ bool ClientLauncher::launch_game(std::wstring *error_message,
} }
if (!gamespec.isValid()) { if (!gamespec.isValid()) {
*error_message = wgettext("Invalid gamespec."); error_message = gettext("Invalid gamespec.");
*error_message += L" (world_gameid=" error_message += " (world.gameid=" + worldspec.gameid + ")";
+ narrow_to_wide(worldspec.gameid) + L")"; errorstream << error_message << std::endl;
errorstream << wide_to_narrow(*error_message) << std::endl;
return false; return false;
} }
} }

@ -92,7 +92,7 @@ protected:
void init_args(GameParams &game_params, const Settings &cmd_args); void init_args(GameParams &game_params, const Settings &cmd_args);
bool init_engine(int log_level); bool init_engine(int log_level);
bool launch_game(std::wstring *error_message, GameParams &game_params, bool launch_game(std::string &error_message, GameParams &game_params,
const Settings &cmd_args); const Settings &cmd_args);
void main_menu(MainMenuData *menudata); void main_menu(MainMenuData *menudata);

@ -1423,7 +1423,7 @@ public:
// If address is "", local server is used and address is updated // If address is "", local server is used and address is updated
std::string *address, std::string *address,
u16 port, u16 port,
std::wstring *error_message, std::string &error_message,
ChatBackend *chat_backend, ChatBackend *chat_backend,
const SubgameSpec &gamespec, // Used for local game const SubgameSpec &gamespec, // Used for local game
bool simple_singleplayer_mode); bool simple_singleplayer_mode);
@ -1445,9 +1445,8 @@ protected:
// Client creation // Client creation
bool createClient(const std::string &playername, bool createClient(const std::string &playername,
const std::string &password, std::string *address, u16 port, const std::string &password, std::string *address, u16 port);
std::wstring *error_message); bool initGui();
bool initGui(std::wstring *error_message);
// Client connection // Client connection
bool connectToServer(const std::string &playername, bool connectToServer(const std::string &playername,
@ -1575,7 +1574,7 @@ private:
video::IVideoDriver *driver; video::IVideoDriver *driver;
scene::ISceneManager *smgr; scene::ISceneManager *smgr;
bool *kill; bool *kill;
std::wstring *error_message; std::string *error_message;
IGameDef *gamedef; // Convenience (same as *client) IGameDef *gamedef; // Convenience (same as *client)
scene::ISceneNode *skybox; scene::ISceneNode *skybox;
@ -1692,7 +1691,7 @@ bool Game::startup(bool *kill,
const std::string &password, const std::string &password,
std::string *address, // can change if simple_singleplayer_mode std::string *address, // can change if simple_singleplayer_mode
u16 port, u16 port,
std::wstring *error_message, std::string &error_message,
ChatBackend *chat_backend, ChatBackend *chat_backend,
const SubgameSpec &gamespec, const SubgameSpec &gamespec,
bool simple_singleplayer_mode) bool simple_singleplayer_mode)
@ -1700,7 +1699,7 @@ bool Game::startup(bool *kill,
// "cache" // "cache"
this->device = device; this->device = device;
this->kill = kill; this->kill = kill;
this->error_message = error_message; this->error_message = &error_message;
this->random_input = random_input; this->random_input = random_input;
this->input = input; this->input = input;
this->chat_backend = chat_backend; this->chat_backend = chat_backend;
@ -1714,7 +1713,7 @@ bool Game::startup(bool *kill,
if (!init(map_dir, address, port, gamespec)) if (!init(map_dir, address, port, gamespec))
return false; return false;
if (!createClient(playername, password, address, port, error_message)) if (!createClient(playername, password, address, port))
return false; return false;
return true; return true;
@ -1934,10 +1933,10 @@ bool Game::createSingleplayerServer(const std::string map_dir,
} }
if (bind_addr.isIPv6() && !g_settings->getBool("enable_ipv6")) { if (bind_addr.isIPv6() && !g_settings->getBool("enable_ipv6")) {
*error_message = L"Unable to listen on " + *error_message = "Unable to listen on " +
narrow_to_wide(bind_addr.serializeString()) + bind_addr.serializeString() +
L" because IPv6 is disabled"; " because IPv6 is disabled";
errorstream << wide_to_narrow(*error_message) << std::endl; errorstream << *error_message << std::endl;
return false; return false;
} }
@ -1950,8 +1949,7 @@ bool Game::createSingleplayerServer(const std::string map_dir,
} }
bool Game::createClient(const std::string &playername, bool Game::createClient(const std::string &playername,
const std::string &password, std::string *address, u16 port, const std::string &password, std::string *address, u16 port)
std::wstring *error_message)
{ {
showOverlayMessage(wgettext("Creating client..."), 0, 10); showOverlayMessage(wgettext("Creating client..."), 0, 10);
@ -1966,19 +1964,19 @@ bool Game::createClient(const std::string &playername,
return false; return false;
if (!could_connect) { if (!could_connect) {
if (*error_message == L"" && !connect_aborted) { if (error_message->empty() && !connect_aborted) {
// Should not happen if error messages are set properly // Should not happen if error messages are set properly
*error_message = L"Connection failed for unknown reason"; *error_message = "Connection failed for unknown reason";
errorstream << wide_to_narrow(*error_message) << std::endl; errorstream << *error_message << std::endl;
} }
return false; return false;
} }
if (!getServerContent(&connect_aborted)) { if (!getServerContent(&connect_aborted)) {
if (*error_message == L"" && !connect_aborted) { if (error_message->empty() && !connect_aborted) {
// Should not happen if error messages are set properly // Should not happen if error messages are set properly
*error_message = L"Connection failed for unknown reason"; *error_message = "Connection failed for unknown reason";
errorstream << wide_to_narrow(*error_message) << std::endl; errorstream << *error_message << std::endl;
} }
return false; return false;
} }
@ -1997,9 +1995,8 @@ bool Game::createClient(const std::string &playername,
if (m_cache_enable_clouds) { if (m_cache_enable_clouds) {
clouds = new Clouds(smgr->getRootSceneNode(), smgr, -1, time(0)); clouds = new Clouds(smgr->getRootSceneNode(), smgr, -1, time(0));
if (!clouds) { if (!clouds) {
*error_message = L"Memory allocation error"; *error_message = "Memory allocation error (clouds)";
*error_message += narrow_to_wide(" (clouds)"); errorstream << *error_message << std::endl;
errorstream << wide_to_narrow(*error_message) << std::endl;
return false; return false;
} }
} }
@ -2012,9 +2009,8 @@ bool Game::createClient(const std::string &playername,
local_inventory = new Inventory(itemdef_manager); local_inventory = new Inventory(itemdef_manager);
if (!(sky && local_inventory)) { if (!(sky && local_inventory)) {
*error_message = L"Memory allocation error"; *error_message = "Memory allocation error (sky or local inventory)";
*error_message += narrow_to_wide(" (sky or local inventory)"); errorstream << *error_message << std::endl;
errorstream << wide_to_narrow(*error_message) << std::endl;
return false; return false;
} }
@ -2028,7 +2024,7 @@ bool Game::createClient(const std::string &playername,
crack_animation_length = 5; crack_animation_length = 5;
} }
if (!initGui(error_message)) if (!initGui())
return false; return false;
/* Set window caption /* Set window caption
@ -2046,15 +2042,15 @@ bool Game::createClient(const std::string &playername,
hud = new Hud(driver, smgr, guienv, gamedef, player, local_inventory); hud = new Hud(driver, smgr, guienv, gamedef, player, local_inventory);
if (!hud) { if (!hud) {
*error_message = L"Memory error: could not create HUD"; *error_message = "Memory error: could not create HUD";
errorstream << wide_to_narrow(*error_message) << std::endl; errorstream << *error_message << std::endl;
return false; return false;
} }
return true; return true;
} }
bool Game::initGui(std::wstring *error_message) bool Game::initGui()
{ {
// First line of debug text // First line of debug text
guitext = guienv->addStaticText( guitext = guienv->addStaticText(
@ -2095,8 +2091,8 @@ bool Game::initGui(std::wstring *error_message)
gui_chat_console = new GUIChatConsole(guienv, guienv->getRootGUIElement(), gui_chat_console = new GUIChatConsole(guienv, guienv->getRootGUIElement(),
-1, chat_backend, client); -1, chat_backend, client);
if (!gui_chat_console) { if (!gui_chat_console) {
*error_message = L"Could not allocate memory for chat console"; *error_message = "Could not allocate memory for chat console";
errorstream << wide_to_narrow(*error_message) << std::endl; errorstream << *error_message << std::endl;
return false; return false;
} }
@ -2146,16 +2142,16 @@ bool Game::connectToServer(const std::string &playername,
local_server_mode = true; local_server_mode = true;
} }
} catch (ResolveError &e) { } catch (ResolveError &e) {
*error_message = L"Couldn't resolve address: " + narrow_to_wide(e.what()); *error_message = std::string("Couldn't resolve address: ") + e.what();
errorstream << wide_to_narrow(*error_message) << std::endl; errorstream << *error_message << std::endl;
return false; return false;
} }
if (connect_address.isIPv6() && !g_settings->getBool("enable_ipv6")) { if (connect_address.isIPv6() && !g_settings->getBool("enable_ipv6")) {
*error_message = L"Unable to connect to " + *error_message = "Unable to connect to " +
narrow_to_wide(connect_address.serializeString()) + connect_address.serializeString() +
L" because IPv6 is disabled"; " because IPv6 is disabled";
errorstream << wide_to_narrow(*error_message) << std::endl; errorstream << *error_message << std::endl;
return false; return false;
} }
@ -2205,9 +2201,9 @@ bool Game::connectToServer(const std::string &playername,
// Break conditions // Break conditions
if (client->accessDenied()) { if (client->accessDenied()) {
*error_message = L"Access denied. Reason: " *error_message = "Access denied. Reason: "
+ client->accessDeniedReason(); + client->accessDeniedReason();
errorstream << wide_to_narrow(*error_message) << std::endl; errorstream << *error_message << std::endl;
break; break;
} }
@ -2253,16 +2249,12 @@ bool Game::getServerContent(bool *aborted)
} }
// Error conditions // Error conditions
if (client->accessDenied()) { if (!checkConnection())
*error_message = L"Access denied. Reason: "
+ client->accessDeniedReason();
errorstream << wide_to_narrow(*error_message) << std::endl;
return false; return false;
}
if (client->getState() < LC_Init) { if (client->getState() < LC_Init) {
*error_message = L"Client disconnected"; *error_message = "Client disconnected";
errorstream << wide_to_narrow(*error_message) << std::endl; errorstream << *error_message << std::endl;
return false; return false;
} }
@ -2336,9 +2328,9 @@ inline void Game::updateInteractTimers(GameRunData *runData, f32 dtime)
inline bool Game::checkConnection() inline bool Game::checkConnection()
{ {
if (client->accessDenied()) { if (client->accessDenied()) {
*error_message = L"Access denied. Reason: " *error_message = "Access denied. Reason: "
+ client->accessDeniedReason(); + client->accessDeniedReason();
errorstream << wide_to_narrow(*error_message) << std::endl; errorstream << *error_message << std::endl;
return false; return false;
} }
@ -4219,7 +4211,7 @@ void the_game(bool *kill,
const std::string &address, // If empty local server is created const std::string &address, // If empty local server is created
u16 port, u16 port,
std::wstring &error_message, std::string &error_message,
ChatBackend &chat_backend, ChatBackend &chat_backend,
const SubgameSpec &gamespec, // Used for local game const SubgameSpec &gamespec, // Used for local game
bool simple_singleplayer_mode) bool simple_singleplayer_mode)
@ -4235,24 +4227,24 @@ void the_game(bool *kill,
try { try {
if (game.startup(kill, random_input, input, device, map_dir, if (game.startup(kill, random_input, input, device, map_dir,
playername, password, &server_address, port, playername, password, &server_address, port,
&error_message, &chat_backend, gamespec, error_message, &chat_backend, gamespec,
simple_singleplayer_mode)) { simple_singleplayer_mode)) {
game.run(); game.run();
game.shutdown(); game.shutdown();
} }
} catch (SerializationError &e) { } catch (SerializationError &e) {
error_message = L"A serialization error occurred:\n" error_message = std::string("A serialization error occurred:\n")
+ narrow_to_wide(e.what()) + L"\n\nThe server is probably " + e.what() + "\n\nThe server is probably "
L" running a different version of " PROJECT_NAME "."; " running a different version of " PROJECT_NAME ".";
errorstream << wide_to_narrow(error_message) << std::endl; errorstream << error_message << std::endl;
} catch (ServerError &e) { } catch (ServerError &e) {
error_message = narrow_to_wide(e.what()); error_message = e.what();
errorstream << "ServerError: " << e.what() << std::endl; errorstream << "ServerError: " << error_message << std::endl;
} catch (ModError &e) { } catch (ModError &e) {
errorstream << "ModError: " << e.what() << std::endl; error_message = e.what() + strgettext("\nCheck debug.txt for details.");
error_message = narrow_to_wide(e.what()) + wstrgettext("\nCheck debug.txt for details."); errorstream << "ModError: " << error_message << std::endl;
} }
} }

@ -145,7 +145,7 @@ void the_game(bool *kill,
const std::string &password, const std::string &password,
const std::string &address, // If "", local server is used const std::string &address, // If "", local server is used
u16 port, u16 port,
std::wstring &error_message, std::string &error_message,
ChatBackend &chat_backend, ChatBackend &chat_backend,
const SubgameSpec &gamespec, // Used for local game const SubgameSpec &gamespec, // Used for local game
bool simple_singleplayer_mode); bool simple_singleplayer_mode);

@ -140,7 +140,7 @@ void Client::handleCommand_AccessDenied(NetworkPacket* pkt)
// to be processed even if the serialisation format has // to be processed even if the serialisation format has
// not been agreed yet, the same as TOCLIENT_INIT. // not been agreed yet, the same as TOCLIENT_INIT.
m_access_denied = true; m_access_denied = true;
m_access_denied_reason = L"Unknown"; m_access_denied_reason = "Unknown";
if (pkt->getCommand() == TOCLIENT_ACCESS_DENIED) { if (pkt->getCommand() == TOCLIENT_ACCESS_DENIED) {
if (pkt->getSize() < 1) if (pkt->getSize() < 1)
@ -149,7 +149,9 @@ void Client::handleCommand_AccessDenied(NetworkPacket* pkt)
u8 denyCode = SERVER_ACCESSDENIED_UNEXPECTED_DATA; u8 denyCode = SERVER_ACCESSDENIED_UNEXPECTED_DATA;
*pkt >> denyCode; *pkt >> denyCode;
if (denyCode == SERVER_ACCESSDENIED_CUSTOM_STRING) { if (denyCode == SERVER_ACCESSDENIED_CUSTOM_STRING) {
*pkt >> m_access_denied_reason; std::wstring wide_reason;
*pkt >> wide_reason;
m_access_denied_reason = wide_to_narrow(wide_reason);
} }
else if (denyCode < SERVER_ACCESSDENIED_MAX) { else if (denyCode < SERVER_ACCESSDENIED_MAX) {
m_access_denied_reason = accessDeniedStrings[denyCode]; m_access_denied_reason = accessDeniedStrings[denyCode];
@ -159,7 +161,9 @@ void Client::handleCommand_AccessDenied(NetworkPacket* pkt)
// for compat with old clients // for compat with old clients
else { else {
if (pkt->getSize() >= 2) { if (pkt->getSize() >= 2) {
*pkt >> m_access_denied_reason; std::wstring wide_reason;
*pkt >> wide_reason;
m_access_denied_reason = wide_to_narrow(wide_reason);
} }
} }
} }

@ -861,36 +861,36 @@ enum ToServerCommand
}; };
enum AccessDeniedCode { enum AccessDeniedCode {
SERVER_ACCESSDENIED_WRONG_PASSWORD = 0, SERVER_ACCESSDENIED_WRONG_PASSWORD,
SERVER_ACCESSDENIED_UNEXPECTED_DATA = 1, SERVER_ACCESSDENIED_UNEXPECTED_DATA,
SERVER_ACCESSDENIED_SINGLEPLAYER = 2, SERVER_ACCESSDENIED_SINGLEPLAYER,
SERVER_ACCESSDENIED_WRONG_VERSION = 3, SERVER_ACCESSDENIED_WRONG_VERSION,
SERVER_ACCESSDENIED_WRONG_CHARS_IN_NAME = 4, SERVER_ACCESSDENIED_WRONG_CHARS_IN_NAME,
SERVER_ACCESSDENIED_WRONG_NAME = 5, SERVER_ACCESSDENIED_WRONG_NAME,
SERVER_ACCESSDENIED_TOO_MANY_USERS = 6, SERVER_ACCESSDENIED_TOO_MANY_USERS,
SERVER_ACCESSDENIED_EMPTY_PASSWORD = 7, SERVER_ACCESSDENIED_EMPTY_PASSWORD,
SERVER_ACCESSDENIED_ALREADY_CONNECTED = 8, SERVER_ACCESSDENIED_ALREADY_CONNECTED,
SERVER_ACCESSDENIED_SERVER_FAIL = 9, SERVER_ACCESSDENIED_SERVER_FAIL,
SERVER_ACCESSDENIED_CUSTOM_STRING = 10, SERVER_ACCESSDENIED_CUSTOM_STRING,
SERVER_ACCESSDENIED_MAX = 11, SERVER_ACCESSDENIED_MAX,
}; };
enum NetProtoCompressionMode { enum NetProtoCompressionMode {
NETPROTO_COMPRESSION_ZLIB = 0, NETPROTO_COMPRESSION_ZLIB = 0,
}; };
const static std::wstring accessDeniedStrings[SERVER_ACCESSDENIED_MAX] = { const static std::string accessDeniedStrings[SERVER_ACCESSDENIED_MAX] = {
L"Invalid password", "Invalid password",
L"Your client sent something server didn't expect. Try reconnecting or updating your client", "Your client sent something the server didn't expect. Try reconnecting or updating your client",
L"The server is running in simple singleplayer mode. You cannot connect.", "The server is running in simple singleplayer mode. You cannot connect.",
L"Your client's version is not supported.\nPlease contact server administrator.", "Your client's version is not supported.\nPlease contact server administrator.",
L"Name contains unallowed characters", "Player name contains disallowed characters.",
L"Name is not allowed", "Player name not allowed.",
L"Too many users.", "Too many users.",
L"Empty passwords are disallowed. Set a password and try again.", "Empty passwords are disallowed. Set a password and try again.",
L"Another client is connected with this name. If your client closed unexpectedly, try again in a minute.", "Another client is connected with this name. If your client closed unexpectedly, try again in a minute.",
L"Server authenticator failed. Maybe the servers has some problems." "Server authention failed. This is likely a server error."
L"", "",
}; };
#endif #endif