int ModApiMainMenu::l_create_world(lua_State *L)
{
const char *name = luaL_checkstring(L, 1);
int gameidx = luaL_checkinteger(L,2) -1;
std::string path = porting::path_user + DIR_DELIM
"worlds" + DIR_DELIM
+ name;
std::vector<SubgameSpec> games = getAvailableGames();
if ((gameidx >= 0) &&
(gameidx < (int) games.size())) {
// Create world if it doesn't exist
if (!loadGameConfAndInitWorld(path, games[gameidx])) {
lua_pushstring(L, "Failed to initialize world");
} else {
lua_pushnil(L);
}
} else {
lua_pushstring(L, "Invalid game index");
}
return 1;
}
static bool get_world_from_cmdline(GameParams *game_params, const Settings &cmd_args)
{
std::string commanded_world = "";
// World name
std::string commanded_worldname = "";
if (cmd_args.exists("worldname"))
commanded_worldname = cmd_args.get("worldname");
// 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) {
dstream << _("Using world specified by --worldname on the "
"command line") << std::endl;
commanded_world = worldspecs[i].path;
found = true;
break;
}
}
if (!found) {
std::string fullpath = porting::path_user + DIR_DELIM + "worlds" DIR_DELIM + commanded_worldname;
game_configure_subgame(game_params, cmd_args);
if (!loadGameConfAndInitWorld(fullpath, game_params->game_spec)) {
dstream << _("World") << " '" << commanded_worldname
<< _("' not available. Available worlds:") << std::endl;
print_worldspecs(worldspecs, dstream);
return false;
} else {
commanded_world = fullpath;
}
}
game_params->world_path = get_clean_world_path(commanded_world);
return commanded_world != "";
}
if (cmd_args.exists("world"))
commanded_world = cmd_args.get("world");
else if (cmd_args.exists("map-dir"))
commanded_world = cmd_args.get("map-dir");
else if (cmd_args.exists("nonopt0")) // First nameless argument
commanded_world = cmd_args.get("nonopt0");
game_params->world_path = get_clean_world_path(commanded_world);
return commanded_world != "";
}
bool ClientLauncher::launch_game(std::string &error_message,
bool reconnect_requested, GameParams &game_params,
const Settings &cmd_args)
{
// Initialize menu data
MainMenuData menudata;
menudata.address = address;
menudata.name = playername;
menudata.port = itos(game_params.socket_port);
menudata.script_data.errormessage = error_message;
menudata.script_data.reconnect_requested = reconnect_requested;
error_message.clear();
if (cmd_args.exists("password"))
menudata.password = cmd_args.get("password");
menudata.enable_public = g_settings->getBool("server_announce");
// If a world was commanded, append and select it
if (game_params.world_path != "") {
worldspec.gameid = getWorldGameId(game_params.world_path, true);
worldspec.name = _("[--world parameter]");
if (worldspec.gameid == "") { // Create new
worldspec.gameid = g_settings->get("default_game");
worldspec.name += " [new]";
}
worldspec.path = game_params.world_path;
}
/* Show the GUI menu
*/
if (!skip_main_menu) {
main_menu(&menudata);
// Skip further loading if there was an exit signal.
if (*porting::signal_handler_killstatus())
return false;
address = menudata.address;
int newport = stoi(menudata.port);
if (newport != 0)
game_params.socket_port = newport;
simple_singleplayer_mode = menudata.simple_singleplayer_mode;
std::vector<WorldSpec> worldspecs = getAvailableWorlds();
if (menudata.selected_world >= 0
&& menudata.selected_world < (int)worldspecs.size()) {
g_settings->set("selected_world_path",
worldspecs[menudata.selected_world].path);
worldspec = worldspecs[menudata.selected_world];
}
} else {
if (address.empty())
simple_singleplayer_mode = 1;
}
if (!menudata.script_data.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 = menudata.script_data.errormessage;
return false;
}
if (menudata.name.empty())
playername = menudata.name = std::string("Guest") + itos(myrand_range(100000, 999999));
else
playername = menudata.name;
password = menudata.password;
g_settings->set("name", playername);
current_playername = playername;
current_password = password;
current_address = address;
current_port = game_params.socket_port;
// If using simple singleplayer mode, override
if (simple_singleplayer_mode) {
//assert(skip_main_menu == false);
current_playername = "singleplayer";
current_password = "";
current_address = "";
current_port = myrand_range(49152, 65535);
} else if (address != "") {
ServerListSpec server;
server["name"] = menudata.servername;
server["address"] = menudata.address;
server["port"] = menudata.port;
server["description"] = menudata.serverdescription;
ServerList::insert(server);
}
infostream << "Selected world: " << worldspec.name
<< " [" << worldspec.path << "]" << std::endl;
if (current_address == "") { // If local game
if (worldspec.path == "") {
error_message = _("No world selected and no address "
"provided. Nothing to do.");
errorstream << error_message << std::endl;
return false;
}
if (!fs::PathExists(worldspec.path)) {
if (!loadGameConfAndInitWorld(worldspec.path, game_params.game_spec)) {
error_message = _("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 = _("Could not find or load game \"")
+ worldspec.gameid + "\"";
errorstream << error_message << std::endl;
return false;
}
if (porting::signal_handler_killstatus())
return true;
if (game_params.game_spec.isValid() &&
game_params.game_spec.id != worldspec.gameid) {
warningstream << "Overriding gamespec from \""
<< worldspec.gameid << "\" to \""
<< game_params.game_spec.id << "\"" << std::endl;
gamespec = game_params.game_spec;
}
if (!gamespec.isValid()) {
error_message = _("Invalid gamespec.");
error_message += " (world.gameid=" + worldspec.gameid + ")";
errorstream << error_message << std::endl;
return false;
}
}
return true;
}
