This removes a lot of narrow/wide conversions where a wide string was never used.
m_wieldmgr->drop();
}
-bool Camera::successfullyCreated(std::wstring& error_message)
+bool Camera::successfullyCreated(std::string &error_message)
{
- if (m_playernode == NULL)
- {
- error_message = L"Failed to create the player scene node";
- return false;
- }
- if (m_headnode == NULL)
- {
- 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;
+ if (!m_playernode) {
+ error_message = "Failed to create the player scene node";
+ } else if (!m_headnode) {
+ 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";
}
- return true;
+ return error_message.empty();
}
// Returns the fractional part of x
}
// 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.
void step(f32 dtime);
bool accessDenied()
{ return m_access_denied; }
- std::wstring accessDeniedReason()
+ std::string accessDeniedReason()
{ return m_access_denied_reason; }
bool itemdefReceived()
u64 m_map_seed;
std::string m_password;
bool m_access_denied;
- std::wstring m_access_denied_reason;
+ std::string m_access_denied_reason;
std::queue<ClientEvent> m_client_event_queue;
bool m_itemdef_received;
bool m_nodedef_received;
// 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()
- std::wstring error_message = L"";
+ std::string error_message;
bool first_loop = true;
*/
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 && !first_loop)
}
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);
g_settings->set("name", playername);
continue;
} //try
catch (con::PeerNotFoundException &e) {
- error_message = wgettext("Connection error (timed out?)");
- errorstream << wide_to_narrow(error_message) << std::endl;
+ error_message = gettext("Connection error (timed out?)");
+ errorstream << error_message << std::endl;
}
#ifdef NDEBUG
catch (std::exception &e) {
- std::string narrow_message = "Some exception: \"";
- narrow_message += e.what();
- narrow_message += "\"";
- errorstream << narrow_message << std::endl;
- error_message = narrow_to_wide(narrow_message);
+ std::string error_message = "Some exception: \"";
+ error_message += e.what();
+ error_message += "\"";
+ errorstream << error_message << std::endl;
}
#endif
// If no main menu, show error and exit
if (skip_main_menu) {
- if (error_message != L"") {
+ if (!error_message.empty()) {
verbosestream << "error_message = "
- << wide_to_narrow(error_message) << std::endl;
+ << error_message << std::endl;
retval = false;
}
break;
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)
{
// Initialize menu data
menudata.address = address;
menudata.name = playername;
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"))
menudata.password = cmd_args.get("password");
}
}
- if (menudata.errormessage != "") {
+ if (!menudata.errormessage.empty()) {
/* The calling function will pass this back into this function upon the
* 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;
}
if (current_address == "") { // If local game
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.");
- errorstream << wide_to_narrow(*error_message) << std::endl;
+ errorstream << error_message << std::endl;
return false;
}
if (!fs::PathExists(worldspec.path)) {
- *error_message = wgettext("Provided world path doesn't exist: ")
- + narrow_to_wide(worldspec.path);
- errorstream << wide_to_narrow(*error_message) << std::endl;
+ error_message = gettext("Provided world path doesn't exist: ")
+ + worldspec.path;
+ errorstream << error_message << std::endl;
return false;
}
// Load gamespec for required game
gamespec = findWorldSubgame(worldspec.path);
if (!gamespec.isValid() && !game_params.game_spec.isValid()) {
- *error_message = wgettext("Could not find or load game \"")
- + narrow_to_wide(worldspec.gameid) + L"\"";
- errorstream << wide_to_narrow(*error_message) << std::endl;
+ error_message = gettext("Could not find or load game \"")
+ + worldspec.gameid + "\"";
+ errorstream << error_message << std::endl;
return false;
}
}
if (!gamespec.isValid()) {
- *error_message = wgettext("Invalid gamespec.");
- *error_message += L" (world_gameid="
- + narrow_to_wide(worldspec.gameid) + L")";
- errorstream << wide_to_narrow(*error_message) << std::endl;
+ error_message = gettext("Invalid gamespec.");
+ error_message += " (world.gameid=" + worldspec.gameid + ")";
+ errorstream << error_message << std::endl;
return false;
}
}
void init_args(GameParams &game_params, const Settings &cmd_args);
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);
void main_menu(MainMenuData *menudata);
// If address is "", local server is used and address is updated
std::string *address,
u16 port,
- std::wstring *error_message,
+ std::string &error_message,
ChatBackend *chat_backend,
const SubgameSpec &gamespec, // Used for local game
bool simple_singleplayer_mode);
// Client creation
bool createClient(const std::string &playername,
- const std::string &password, std::string *address, u16 port,
- std::wstring *error_message);
- bool initGui(std::wstring *error_message);
+ const std::string &password, std::string *address, u16 port);
+ bool initGui();
// Client connection
bool connectToServer(const std::string &playername,
video::IVideoDriver *driver;
scene::ISceneManager *smgr;
bool *kill;
- std::wstring *error_message;
+ std::string *error_message;
IGameDef *gamedef; // Convenience (same as *client)
scene::ISceneNode *skybox;
const std::string &password,
std::string *address, // can change if simple_singleplayer_mode
u16 port,
- std::wstring *error_message,
+ std::string &error_message,
ChatBackend *chat_backend,
const SubgameSpec &gamespec,
bool simple_singleplayer_mode)
// "cache"
this->device = device;
this->kill = kill;
- this->error_message = error_message;
+ this->error_message = &error_message;
this->random_input = random_input;
this->input = input;
this->chat_backend = chat_backend;
if (!init(map_dir, address, port, gamespec))
return false;
- if (!createClient(playername, password, address, port, error_message))
+ if (!createClient(playername, password, address, port))
return false;
return true;
}
if (bind_addr.isIPv6() && !g_settings->getBool("enable_ipv6")) {
- *error_message = L"Unable to listen on " +
- narrow_to_wide(bind_addr.serializeString()) +
- L" because IPv6 is disabled";
- errorstream << wide_to_narrow(*error_message) << std::endl;
+ *error_message = "Unable to listen on " +
+ bind_addr.serializeString() +
+ " because IPv6 is disabled";
+ errorstream << *error_message << std::endl;
return false;
}
}
bool Game::createClient(const std::string &playername,
- const std::string &password, std::string *address, u16 port,
- std::wstring *error_message)
+ const std::string &password, std::string *address, u16 port)
{
showOverlayMessage(wgettext("Creating client..."), 0, 10);
return false;
if (!could_connect) {
- if (*error_message == L"" && !connect_aborted) {
+ if (error_message->empty() && !connect_aborted) {
// Should not happen if error messages are set properly
- *error_message = L"Connection failed for unknown reason";
- errorstream << wide_to_narrow(*error_message) << std::endl;
+ *error_message = "Connection failed for unknown reason";
+ errorstream << *error_message << std::endl;
}
return false;
}
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
- *error_message = L"Connection failed for unknown reason";
- errorstream << wide_to_narrow(*error_message) << std::endl;
+ *error_message = "Connection failed for unknown reason";
+ errorstream << *error_message << std::endl;
}
return false;
}
if (m_cache_enable_clouds) {
clouds = new Clouds(smgr->getRootSceneNode(), smgr, -1, time(0));
if (!clouds) {
- *error_message = L"Memory allocation error";
- *error_message += narrow_to_wide(" (clouds)");
- errorstream << wide_to_narrow(*error_message) << std::endl;
+ *error_message = "Memory allocation error (clouds)";
+ errorstream << *error_message << std::endl;
return false;
}
}
local_inventory = new Inventory(itemdef_manager);
if (!(sky && local_inventory)) {
- *error_message = L"Memory allocation error";
- *error_message += narrow_to_wide(" (sky or local inventory)");
- errorstream << wide_to_narrow(*error_message) << std::endl;
+ *error_message = "Memory allocation error (sky or local inventory)";
+ errorstream << *error_message << std::endl;
return false;
}
crack_animation_length = 5;
}
- if (!initGui(error_message))
+ if (!initGui())
return false;
/* Set window caption
hud = new Hud(driver, smgr, guienv, gamedef, player, local_inventory);
if (!hud) {
- *error_message = L"Memory error: could not create HUD";
- errorstream << wide_to_narrow(*error_message) << std::endl;
+ *error_message = "Memory error: could not create HUD";
+ errorstream << *error_message << std::endl;
return false;
}
return true;
}
-bool Game::initGui(std::wstring *error_message)
+bool Game::initGui()
{
// First line of debug text
guitext = guienv->addStaticText(
gui_chat_console = new GUIChatConsole(guienv, guienv->getRootGUIElement(),
-1, chat_backend, client);
if (!gui_chat_console) {
- *error_message = L"Could not allocate memory for chat console";
- errorstream << wide_to_narrow(*error_message) << std::endl;
+ *error_message = "Could not allocate memory for chat console";
+ errorstream << *error_message << std::endl;
return false;
}
local_server_mode = true;
}
} catch (ResolveError &e) {
- *error_message = L"Couldn't resolve address: " + narrow_to_wide(e.what());
- errorstream << wide_to_narrow(*error_message) << std::endl;
+ *error_message = std::string("Couldn't resolve address: ") + e.what();
+ errorstream << *error_message << std::endl;
return false;
}
if (connect_address.isIPv6() && !g_settings->getBool("enable_ipv6")) {
- *error_message = L"Unable to connect to " +
- narrow_to_wide(connect_address.serializeString()) +
- L" because IPv6 is disabled";
- errorstream << wide_to_narrow(*error_message) << std::endl;
+ *error_message = "Unable to connect to " +
+ connect_address.serializeString() +
+ " because IPv6 is disabled";
+ errorstream << *error_message << std::endl;
return false;
}
// Break conditions
if (client->accessDenied()) {
- *error_message = L"Access denied. Reason: "
+ *error_message = "Access denied. Reason: "
+ client->accessDeniedReason();
- errorstream << wide_to_narrow(*error_message) << std::endl;
+ errorstream << *error_message << std::endl;
break;
}
}
// Error conditions
- if (client->accessDenied()) {
- *error_message = L"Access denied. Reason: "
- + client->accessDeniedReason();
- errorstream << wide_to_narrow(*error_message) << std::endl;
+ if (!checkConnection())
return false;
- }
if (client->getState() < LC_Init) {
- *error_message = L"Client disconnected";
- errorstream << wide_to_narrow(*error_message) << std::endl;
+ *error_message = "Client disconnected";
+ errorstream << *error_message << std::endl;
return false;
}
inline bool Game::checkConnection()
{
if (client->accessDenied()) {
- *error_message = L"Access denied. Reason: "
+ *error_message = "Access denied. Reason: "
+ client->accessDeniedReason();
- errorstream << wide_to_narrow(*error_message) << std::endl;
+ errorstream << *error_message << std::endl;
return false;
}
const std::string &address, // If empty local server is created
u16 port,
- std::wstring &error_message,
+ std::string &error_message,
ChatBackend &chat_backend,
const SubgameSpec &gamespec, // Used for local game
bool simple_singleplayer_mode)
try {
if (game.startup(kill, random_input, input, device, map_dir,
- playername, password, &server_address, port,
- &error_message, &chat_backend, gamespec,
- simple_singleplayer_mode)) {
-
+ playername, password, &server_address, port,
+ error_message, &chat_backend, gamespec,
+ simple_singleplayer_mode)) {
game.run();
game.shutdown();
}
} catch (SerializationError &e) {
- error_message = L"A serialization error occurred:\n"
- + narrow_to_wide(e.what()) + L"\n\nThe server is probably "
- L" running a different version of " PROJECT_NAME ".";
- errorstream << wide_to_narrow(error_message) << std::endl;
+ error_message = std::string("A serialization error occurred:\n")
+ + e.what() + "\n\nThe server is probably "
+ " running a different version of " PROJECT_NAME ".";
+ errorstream << error_message << std::endl;
} catch (ServerError &e) {
- error_message = narrow_to_wide(e.what());
- errorstream << "ServerError: " << e.what() << std::endl;
+ error_message = e.what();
+ errorstream << "ServerError: " << error_message << std::endl;
} catch (ModError &e) {
- errorstream << "ModError: " << e.what() << std::endl;
- error_message = narrow_to_wide(e.what()) + wstrgettext("\nCheck debug.txt for details.");
+ error_message = e.what() + strgettext("\nCheck debug.txt for details.");
+ errorstream << "ModError: " << error_message << std::endl;
}
}
+
const std::string &password,
const std::string &address, // If "", local server is used
u16 port,
- std::wstring &error_message,
+ std::string &error_message,
ChatBackend &chat_backend,
const SubgameSpec &gamespec, // Used for local game
bool simple_singleplayer_mode);
// to be processed even if the serialisation format has
// not been agreed yet, the same as TOCLIENT_INIT.
m_access_denied = true;
- m_access_denied_reason = L"Unknown";
+ m_access_denied_reason = "Unknown";
if (pkt->getCommand() == TOCLIENT_ACCESS_DENIED) {
if (pkt->getSize() < 1)
u8 denyCode = SERVER_ACCESSDENIED_UNEXPECTED_DATA;
*pkt >> denyCode;
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) {
m_access_denied_reason = accessDeniedStrings[denyCode];
// for compat with old clients
else {
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);
}
}
}
};
enum AccessDeniedCode {
- SERVER_ACCESSDENIED_WRONG_PASSWORD = 0,
- SERVER_ACCESSDENIED_UNEXPECTED_DATA = 1,
- SERVER_ACCESSDENIED_SINGLEPLAYER = 2,
- SERVER_ACCESSDENIED_WRONG_VERSION = 3,
- SERVER_ACCESSDENIED_WRONG_CHARS_IN_NAME = 4,
- SERVER_ACCESSDENIED_WRONG_NAME = 5,
- SERVER_ACCESSDENIED_TOO_MANY_USERS = 6,
- SERVER_ACCESSDENIED_EMPTY_PASSWORD = 7,
- SERVER_ACCESSDENIED_ALREADY_CONNECTED = 8,
- SERVER_ACCESSDENIED_SERVER_FAIL = 9,
- SERVER_ACCESSDENIED_CUSTOM_STRING = 10,
- SERVER_ACCESSDENIED_MAX = 11,
+ SERVER_ACCESSDENIED_WRONG_PASSWORD,
+ SERVER_ACCESSDENIED_UNEXPECTED_DATA,
+ SERVER_ACCESSDENIED_SINGLEPLAYER,
+ SERVER_ACCESSDENIED_WRONG_VERSION,
+ SERVER_ACCESSDENIED_WRONG_CHARS_IN_NAME,
+ SERVER_ACCESSDENIED_WRONG_NAME,
+ SERVER_ACCESSDENIED_TOO_MANY_USERS,
+ SERVER_ACCESSDENIED_EMPTY_PASSWORD,
+ SERVER_ACCESSDENIED_ALREADY_CONNECTED,
+ SERVER_ACCESSDENIED_SERVER_FAIL,
+ SERVER_ACCESSDENIED_CUSTOM_STRING,
+ SERVER_ACCESSDENIED_MAX,
};
enum NetProtoCompressionMode {
NETPROTO_COMPRESSION_ZLIB = 0,
};
-const static std::wstring accessDeniedStrings[SERVER_ACCESSDENIED_MAX] = {
- L"Invalid password",
- L"Your client sent something server didn't expect. Try reconnecting or updating your client",
- L"The server is running in simple singleplayer mode. You cannot connect.",
- L"Your client's version is not supported.\nPlease contact server administrator.",
- L"Name contains unallowed characters",
- L"Name is not allowed",
- L"Too many users.",
- L"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.",
- L"Server authenticator failed. Maybe the servers has some problems."
- L"",
+const static std::string accessDeniedStrings[SERVER_ACCESSDENIED_MAX] = {
+ "Invalid password",
+ "Your client sent something the server didn't expect. Try reconnecting or updating your client",
+ "The server is running in simple singleplayer mode. You cannot connect.",
+ "Your client's version is not supported.\nPlease contact server administrator.",
+ "Player name contains disallowed characters.",
+ "Player name not allowed.",
+ "Too many users.",
+ "Empty passwords are disallowed. Set a password and try again.",
+ "Another client is connected with this name. If your client closed unexpectedly, try again in a minute.",
+ "Server authention failed. This is likely a server error."
+ "",
};
#endif
projects / oweals / minetest.git / commitdiff