Copyright (C) 2010-2011 celeron55, Perttu Ahola <celeron55@gmail.com>
This program is free software; you can redistribute it and/or modify
-it under the terms of the GNU General Public License as published by
-the Free Software Foundation; either version 2 of the License, or
+it under the terms of the GNU Lesser General Public License as published by
+the Free Software Foundation; either version 2.1 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
-GNU General Public License for more details.
+GNU Lesser General Public License for more details.
-You should have received a copy of the GNU General Public License along
+You should have received a copy of the GNU Lesser General Public License along
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include <iostream>
#include <fstream>
#include <locale.h>
-#include "common_irrlicht.h"
+#include "irrlichttypes_extrabloated.h"
#include "debug.h"
#include "test.h"
#include "server.h"
#include "profiler.h"
#include "log.h"
#include "mods.h"
-#include "utility_string.h"
+#if USE_FREETYPE
+#include "xCGUITTFont.h"
+#endif
+#include "util/string.h"
#include "subgame.h"
#include "quicktune.h"
+#include "serverlist.h"
/*
Settings.
log_register_thread("main");
- // Set locale. This is for forcing '.' as the decimal point.
- std::locale::global(std::locale("C"));
- // This enables printing all characters in bitmap font
- setlocale(LC_CTYPE, "en_US");
+ // This enables internatonal characters input
+ if( setlocale(LC_ALL, "") == NULL )
+ {
+ fprintf( stderr, "%s: warning: could not set default locale\n", argv[0] );
+ }
+ // Set locale. This is for forcing '.' as the decimal point.
+ try {
+ std::locale::global(std::locale(std::locale(""), "C", std::locale::numeric));
+ setlocale(LC_NUMERIC, "C");
+ } catch (const std::exception& ex) {
+ errorstream<<"Could not set numeric locale to C"<<std::endl;
+ }
/*
Parse command line
*/
// List all allowed options
core::map<std::string, ValueSpec> allowed_options;
allowed_options.insert("help", ValueSpec(VALUETYPE_FLAG,
- "Show allowed options"));
+ _("Show allowed options")));
allowed_options.insert("config", ValueSpec(VALUETYPE_STRING,
- "Load configuration from specified file"));
+ _("Load configuration from specified file")));
allowed_options.insert("port", ValueSpec(VALUETYPE_STRING,
- "Set network port (UDP)"));
+ _("Set network port (UDP)")));
allowed_options.insert("disable-unittests", ValueSpec(VALUETYPE_FLAG,
- "Disable unit tests"));
+ _("Disable unit tests")));
allowed_options.insert("enable-unittests", ValueSpec(VALUETYPE_FLAG,
- "Enable unit tests"));
+ _("Enable unit tests")));
allowed_options.insert("map-dir", ValueSpec(VALUETYPE_STRING,
- "Same as --world (deprecated)"));
+ _("Same as --world (deprecated)")));
allowed_options.insert("world", ValueSpec(VALUETYPE_STRING,
- "Set world path (implies local game)"));
+ _("Set world path (implies local game) ('list' lists all)")));
allowed_options.insert("worldname", ValueSpec(VALUETYPE_STRING,
- "Set world by name (implies local game)"));
+ _("Set world by name (implies local game)")));
allowed_options.insert("info", ValueSpec(VALUETYPE_FLAG,
- "Print more information to console"));
+ _("Print more information to console")));
allowed_options.insert("verbose", ValueSpec(VALUETYPE_FLAG,
- "Print even more information to console"));
+ _("Print even more information to console")));
allowed_options.insert("trace", ValueSpec(VALUETYPE_FLAG,
- "Print enormous amounts of information to log and console"));
+ _("Print enormous amounts of information to log and console")));
allowed_options.insert("logfile", ValueSpec(VALUETYPE_STRING,
- "Set logfile path ('' = no logging)"));
+ _("Set logfile path ('' = no logging)")));
allowed_options.insert("gameid", ValueSpec(VALUETYPE_STRING,
- "Set gameid (\"--gameid list\" prints available ones)"));
+ _("Set gameid (\"--gameid list\" prints available ones)")));
#ifndef SERVER
allowed_options.insert("speedtests", ValueSpec(VALUETYPE_FLAG,
- "Run speed tests"));
+ _("Run speed tests")));
allowed_options.insert("address", ValueSpec(VALUETYPE_STRING,
- "Address to connect to. ('' = local game)"));
+ _("Address to connect to. ('' = local game)")));
allowed_options.insert("random-input", ValueSpec(VALUETYPE_FLAG,
- "Enable random user input, for testing"));
+ _("Enable random user input, for testing")));
allowed_options.insert("server", ValueSpec(VALUETYPE_FLAG,
- "Run dedicated server"));
+ _("Run dedicated server")));
allowed_options.insert("name", ValueSpec(VALUETYPE_STRING,
- "Set player name"));
+ _("Set player name")));
allowed_options.insert("password", ValueSpec(VALUETYPE_STRING,
- "Set password"));
+ _("Set password")));
allowed_options.insert("go", ValueSpec(VALUETYPE_FLAG,
- "Disable main menu"));
+ _("Disable main menu")));
#endif
Settings cmd_args;
if(ret == false || cmd_args.getFlag("help") || cmd_args.exists("nonopt1"))
{
- dstream<<"Allowed options:"<<std::endl;
+ dstream<<_("Allowed options:")<<std::endl;
for(core::map<std::string, ValueSpec>::Iterator
i = allowed_options.getIterator();
i.atEnd() == false; i++)
if(i.getNode()->getValue().type == VALUETYPE_FLAG)
{}
else
- os1<<" <value>";
+ os1<<_(" <value>");
dstream<<padStringRight(os1.str(), 24);
if(i.getNode()->getValue().help != NULL)
// If trace is enabled, enable logging of certain things
if(cmd_args.getFlag("trace")){
- dstream<<"Enabling trace level debug output"<<std::endl;
- dout_con_ptr = &verbosestream;
- socket_enable_debug_output = true;
+ dstream<<_("Enabling trace level debug output")<<std::endl;
+ log_trace_level_enabled = true;
+ dout_con_ptr = &verbosestream; // this is somewhat old crap
+ socket_enable_debug_output = true; // socket doesn't use log.h
}
// In certain cases, output info level on stderr
if(cmd_args.getFlag("info") || cmd_args.getFlag("verbose") ||
// Create user data directory
fs::CreateDir(porting::path_user);
- init_gettext((porting::path_share+DIR_DELIM+".."+DIR_DELIM+"locale").c_str());
+ init_gettext((porting::path_share + DIR_DELIM + "locale").c_str());
// Initialize debug streams
-#ifdef RUN_IN_PLACE
+#define DEBUGFILE "debug.txt"
+#if RUN_IN_PLACE
std::string logfile = DEBUGFILE;
#else
std::string logfile = porting::path_user+DIR_DELIM+DEBUGFILE;
return 0;
}
+ // List worlds if requested
+ if(cmd_args.exists("world") && cmd_args.get("world") == "list"){
+ dstream<<_("Available worlds:")<<std::endl;
+ std::vector<WorldSpec> worldspecs = getAvailableWorlds();
+ print_worldspecs(worldspecs, dstream);
+ return 0;
+ }
+
// Print startup message
infostream<<PROJECT_NAME<<
- " with SER_FMT_VER_HIGHEST="<<(int)SER_FMT_VER_HIGHEST
+ " "<<_("with")<<" SER_FMT_VER_HIGHEST="<<(int)SER_FMT_VER_HIGHEST
<<", "<<BUILD_INFO
<<std::endl;
// Legacy configuration file location
filenames.push_back(porting::path_user +
DIR_DELIM + ".." + DIR_DELIM + "minetest.conf");
-#ifdef RUN_IN_PLACE
+#if RUN_IN_PLACE
// Try also from a lower level (to aid having the same configuration
// for many RUN_IN_PLACE installs)
filenames.push_back(porting::path_user +
if(commanded_world.size() > worldmt.size() &&
commanded_world.substr(commanded_world.size()-worldmt.size())
== worldmt){
- dstream<<"Supplied world.mt file - stripping it off."<<std::endl;
+ dstream<<_("Supplied world.mt file - stripping it off.")<<std::endl;
commanded_world = commanded_world.substr(
0, commanded_world.size()-worldmt.size());
}
}
+ // If a world name was specified, convert it to a path
+ if(commanded_worldname != ""){
+ // Get information about available worlds
+ std::vector<WorldSpec> worldspecs = getAvailableWorlds();
+ bool found = false;
+ for(u32 i=0; i<worldspecs.size(); i++){
+ std::string name = worldspecs[i].name;
+ if(name == commanded_worldname){
+ if(commanded_world != ""){
+ dstream<<_("--worldname takes precedence over previously "
+ "selected world.")<<std::endl;
+ }
+ commanded_world = worldspecs[i].path;
+ found = true;
+ break;
+ }
+ }
+ if(!found){
+ dstream<<_("World")<<" '"<<commanded_worldname<<_("' not "
+ "available. Available worlds:")<<std::endl;
+ print_worldspecs(worldspecs, dstream);
+ return 1;
+ }
+ }
+
// Gamespec
SubgameSpec commanded_gamespec;
if(cmd_args.exists("gameid")){
#else
bool run_dedicated_server = cmd_args.getFlag("server");
#endif
+ g_settings->set("server_dedicated", run_dedicated_server ? "true" : "false");
if(run_dedicated_server)
{
DSTACK("Dedicated server branch");
// World directory
std::string world_path;
- verbosestream<<"Determining world path"<<std::endl;
+ verbosestream<<_("Determining world path")<<std::endl;
bool is_legacy_world = false;
// If a world was commanded, use it
if(commanded_world != ""){
infostream<<"Using commanded world path ["<<world_path<<"]"
<<std::endl;
}
- // If a world name was specified, select it
- else if(commanded_worldname != ""){
- // Get information about available worlds
- std::vector<WorldSpec> worldspecs = getAvailableWorlds();
- world_path = "";
- for(u32 i=0; i<worldspecs.size(); i++){
- std::string name = worldspecs[i].name;
- if(name == commanded_worldname){
- world_path = worldspecs[i].path;
- break;
- }
- }
- if(world_path == ""){
- dstream<<"World '"<<commanded_worldname<<"' not "
- <<"available. Available worlds:"<<std::endl;
- print_worldspecs(worldspecs, dstream);
- return 1;
- }
- }
// No world was specified; try to select it automatically
else
{
}
}
if(world_path == ""){
- dstream<<"World '"<<commanded_worldname<<"' not "
- <<"available. Available worlds:"<<std::endl;
+ dstream<<_("World")<<" '"<<commanded_worldname<<"' "<<_("not "
+ "available. Available worlds:")<<std::endl;
print_worldspecs(worldspecs, dstream);
return 1;
}
// If there is only a single world, use it
if(worldspecs.size() == 1){
world_path = worldspecs[0].path;
- dstream<<"Automatically selecting world at ["
+ dstream<<_("Automatically selecting world at")<<" ["
<<world_path<<"]"<<std::endl;
// If there are multiple worlds, list them
} else if(worldspecs.size() > 1){
- dstream<<"Multiple worlds are available."<<std::endl;
- dstream<<"Please select one using --worldname <name>"
- <<" or --world <path>"<<std::endl;
+ dstream<<_("Multiple worlds are available.")<<std::endl;
+ dstream<<_("Please select one using --worldname <name>"
+ " or --world <path>")<<std::endl;
print_worldspecs(worldspecs, dstream);
return 1;
// If there are no worlds, automatically create a new one
errorstream<<"No world path specified or found."<<std::endl;
return 1;
}
- verbosestream<<"Using world path ["<<world_path<<"]"<<std::endl;
+ verbosestream<<_("Using world path")<<" ["<<world_path<<"]"<<std::endl;
- // We need a gameid.
- std::string gameid;
- verbosestream<<"Determining gameid"<<std::endl;
+ // We need a gamespec.
+ SubgameSpec gamespec;
+ verbosestream<<_("Determining gameid/gamespec")<<std::endl;
// If world doesn't exist
if(!getWorldExists(world_path))
{
// Try to take gamespec from command line
if(commanded_gamespec.isValid()){
- gameid = commanded_gamespec.id;
- infostream<<"Using commanded gameid ["<<gameid<<"]"<<std::endl;
+ gamespec = commanded_gamespec;
+ infostream<<"Using commanded gameid ["<<gamespec.id<<"]"<<std::endl;
}
// Otherwise we will be using "minetest"
else{
- gameid = g_settings->get("default_game");
- infostream<<"Using default gameid ["<<gameid<<"]"<<std::endl;
+ gamespec = findSubgame(g_settings->get("default_game"));
+ infostream<<"Using default gameid ["<<gamespec.id<<"]"<<std::endl;
}
}
- // If world exists
+ // World exists
else
{
- // Otherwise read from the world
std::string world_gameid = getWorldGameId(world_path, is_legacy_world);
- gameid = world_gameid;
- if(commanded_gamespec.isValid() &&
- commanded_gamespec.id != world_gameid){
- gameid = commanded_gamespec.id;
- errorstream<<"WARNING: Using commanded gameid ["<<gameid<<"]"
- <<" instead of world gameid ["<<world_gameid
- <<"]"<<std::endl;
+ // If commanded to use a gameid, do so
+ if(commanded_gamespec.isValid()){
+ gamespec = commanded_gamespec;
+ if(commanded_gamespec.id != world_gameid){
+ errorstream<<"WARNING: Using commanded gameid ["
+ <<gamespec.id<<"]"<<" instead of world gameid ["
+ <<world_gameid<<"]"<<std::endl;
+ }
} else{
- infostream<<"Using world gameid ["<<gameid<<"]"<<std::endl;
+ // If world contains an embedded game, use it;
+ // Otherwise find world from local system.
+ gamespec = findWorldSubgame(world_path);
+ infostream<<"Using world gameid ["<<gamespec.id<<"]"<<std::endl;
}
}
- verbosestream<<"Finding subgame ["<<gameid<<"]"<<std::endl;
- SubgameSpec gamespec = findSubgame(gameid);
if(!gamespec.isValid()){
- errorstream<<"Subgame ["<<gameid<<"] could not be found."
+ errorstream<<"Subgame ["<<gamespec.id<<"] could not be found."
<<std::endl;
return 1;
}
- verbosestream<<"Using gameid ["<<gamespec.id<<"]"<<std::endl;
+ verbosestream<<_("Using gameid")<<" ["<<gamespec.id<<"]"<<std::endl;
// Create server
Server server(world_path, configpath, gamespec, false);
address = "";
else if(cmd_args.exists("address"))
address = cmd_args.get("address");
- else if(cmd_args.exists("world"))
- address = "";
std::string playername = g_settings->get("name");
if(cmd_args.exists("name"))
video::IVideoDriver* driver = device->getVideoDriver();
- // Disable mipmaps (because some of them look ugly)
- driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, false);
-
/*
This changes the minimum allowed number of vertices in a VBO.
Default is 500.
guienv = device->getGUIEnvironment();
gui::IGUISkin* skin = guienv->getSkin();
+ #if USE_FREETYPE
+ std::string font_path = g_settings->get("font_path");
+ u16 font_size = g_settings->getU16("font_size");
+ gui::IGUIFont *font = gui::CGUITTFont::createTTFont(guienv, font_path.c_str(), font_size);
+ #else
gui::IGUIFont* font = guienv->getFont(getTexturePath("fontlucida.png").c_str());
+ #endif
if(font)
skin->setFont(font);
else
skin->setColor(gui::EGDC_3D_SHADOW, video::SColor(255,0,0,0));
skin->setColor(gui::EGDC_HIGH_LIGHT, video::SColor(255,70,100,50));
skin->setColor(gui::EGDC_HIGH_LIGHT_TEXT, video::SColor(255,255,255,255));
-
+
+#if (IRRLICHT_VERSION_MAJOR >= 1 && IRRLICHT_VERSION_MINOR >= 8) || IRRLICHT_VERSION_MAJOR >= 2
+ // Irrlicht 1.8 input colours
+ skin->setColor(gui::EGDC_EDITABLE, video::SColor(255,128,128,128));
+ skin->setColor(gui::EGDC_FOCUSED_EDITABLE, video::SColor(255,96,134,49));
+#endif
+
/*
GUI stuff
*/
while(device->run() && kill == false)
{
// Set the window caption
- device->setWindowCaption(L"Minetest [Main Menu]");
+ device->setWindowCaption((std::wstring(L"Minetest [")+wgettext("Main Menu")+L"]").c_str());
// This is used for catching disconnects
try
menudata.smooth_lighting = g_settings->getBool("smooth_lighting");
menudata.clouds_3d = g_settings->getBool("enable_3d_clouds");
menudata.opaque_water = g_settings->getBool("opaque_water");
+ menudata.mip_map = g_settings->getBool("mip_map");
+ menudata.anisotropic_filter = g_settings->getBool("anisotropic_filter");
+ menudata.bilinear_filter = g_settings->getBool("bilinear_filter");
+ menudata.trilinear_filter = g_settings->getBool("trilinear_filter");
+ menudata.enable_shaders = g_settings->getS32("enable_shaders");
+ menudata.preload_item_visuals = g_settings->getBool("preload_item_visuals");
+ menudata.enable_particles = g_settings->getBool("enable_particles");
+ driver->setTextureCreationFlag(video::ETCF_CREATE_MIP_MAPS, menudata.mip_map);
menudata.creative_mode = g_settings->getBool("creative_mode");
menudata.enable_damage = g_settings->getBool("enable_damage");
// Default to selecting nothing
// If a world was commanded, append and select it
if(commanded_world != ""){
std::string gameid = getWorldGameId(commanded_world, true);
- std::string name = "[--world parameter]";
+ std::string name = _("[--world parameter]");
if(gameid == ""){
gameid = g_settings->get("default_game");
name += " [new]";
g_settings->set("smooth_lighting", itos(menudata.smooth_lighting));
g_settings->set("enable_3d_clouds", itos(menudata.clouds_3d));
g_settings->set("opaque_water", itos(menudata.opaque_water));
+
+ g_settings->set("mip_map", itos(menudata.mip_map));
+ g_settings->set("anisotropic_filter", itos(menudata.anisotropic_filter));
+ g_settings->set("bilinear_filter", itos(menudata.bilinear_filter));
+ g_settings->set("trilinear_filter", itos(menudata.trilinear_filter));
+
+ g_settings->setS32("enable_shaders", menudata.enable_shaders);
+ g_settings->set("preload_item_visuals", itos(menudata.preload_item_visuals));
+ g_settings->set("enable_particles", itos(menudata.enable_particles));
+
g_settings->set("creative_mode", itos(menudata.creative_mode));
g_settings->set("enable_damage", itos(menudata.enable_damage));
+ g_settings->set("server_announce", itos(menudata.enable_public));
g_settings->set("name", playername);
g_settings->set("address", address);
g_settings->set("port", itos(port));
if(menudata.selected_world != -1)
g_settings->set("selected_world_path",
worldspecs[menudata.selected_world].path);
-
+
// Break out of menu-game loop to shut down cleanly
if(device->run() == false || kill == true)
break;
current_address = "";
current_port = 30011;
}
+ else if (address != "")
+ {
+ ServerListSpec server;
+ server["name"] = menudata.servername;
+ server["address"] = wide_to_narrow(menudata.address);
+ server["port"] = wide_to_narrow(menudata.port);
+ server["description"] = menudata.serverdescription;
+ ServerList::insert(server);
+ }
// Set world path to selected one
if(menudata.selected_world != -1){
+ wide_to_narrow(menudata.create_world_name);
// Create world if it doesn't exist
if(!initializeWorld(path, menudata.create_world_gameid)){
- error_message = L"Failed to initialize world";
+ error_message = wgettext("Failed to initialize world");
errorstream<<wide_to_narrow(error_message)<<std::endl;
continue;
}
if(current_address == "")
{
if(menudata.selected_world == -1){
- error_message = L"No world selected and no address "
- L"provided. Nothing to do.";
+ error_message = wgettext("No world selected and no address "
+ "provided. Nothing to do.");
errorstream<<wide_to_narrow(error_message)<<std::endl;
continue;
}
// Load gamespec for required game
- gamespec = findSubgame(worldspec.gameid);
+ gamespec = findWorldSubgame(worldspec.path);
if(!gamespec.isValid() && !commanded_gamespec.isValid()){
- error_message = L"Could not find or load game \""
+ error_message = wgettext("Could not find or load game \"")
+ narrow_to_wide(worldspec.gameid) + L"\"";
errorstream<<wide_to_narrow(error_message)<<std::endl;
continue;
}
if(!gamespec.isValid()){
- error_message = L"Invalid gamespec. (world_gameid="
+ error_message = wgettext("Invalid gamespec.");
+ error_message += L" (world_gameid="
+narrow_to_wide(worldspec.gameid)+L")";
errorstream<<wide_to_narrow(error_message)<<std::endl;
continue;
} //try
catch(con::PeerNotFoundException &e)
{
- error_message = L"Connection error (timed out?)";
+ error_message = wgettext("Connection error (timed out?)");
errorstream<<wide_to_narrow(error_message)<<std::endl;
}
catch(ServerError &e)
catch(ModError &e)
{
errorstream<<e.what()<<std::endl;
- error_message = narrow_to_wide(e.what()) + L"\nCheck debug.txt for details.";
+ error_message = narrow_to_wide(e.what()) + wgettext("\nCheck debug.txt for details.");
}
#ifdef NDEBUG
catch(std::exception &e)
{
- std::string narrow_message = "Some exception, what()=\"";
+ std::string narrow_message = "Some exception: \"";
narrow_message += e.what();
narrow_message += "\"";
errorstream<<narrow_message<<std::endl;
projects / oweals / minetest.git / blobdiff