minetest/src/content/subgames.cpp

337 lines
9.7 KiB
C++
Raw Normal View History

2012-03-11 13:54:23 +01:00
/*
2013-02-24 18:40:43 +01:00
Minetest
2013-02-24 19:38:45 +01:00
Copyright (C) 2013 celeron55, Perttu Ahola <celeron55@gmail.com>
2012-03-11 13:54:23 +01:00
This program is free software; you can redistribute it and/or modify
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
2012-03-11 13:54:23 +01:00
(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 Lesser General Public License for more details.
2012-03-11 13:54:23 +01:00
You should have received a copy of the GNU Lesser General Public License along
2012-03-11 13:54:23 +01:00
with this program; if not, write to the Free Software Foundation, Inc.,
51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
*/
#include "content/subgames.h"
2012-03-11 13:54:23 +01:00
#include "porting.h"
#include "filesys.h"
#include "settings.h"
#include "log.h"
#include "util/strfnd.h"
#include "defaultsettings.h" // for override_default_settings
#include "mapgen/mapgen.h" // for MapgenParams
#include "util/string.h"
#ifndef SERVER
#include "client/tile.h" // getImagePath
#endif
2012-03-11 13:54:23 +01:00
2013-03-21 20:42:23 +01:00
bool getGameMinetestConfig(const std::string &game_path, Settings &conf)
{
std::string conf_path = game_path + DIR_DELIM + "minetest.conf";
return conf.readConfigFile(conf_path.c_str());
}
struct GameFindPath
{
std::string path;
bool user_specific;
GameFindPath(const std::string &path, bool user_specific) :
path(path), user_specific(user_specific)
{
}
};
std::string getSubgamePathEnv()
{
2014-10-28 20:13:14 +01:00
char *subgame_path = getenv("MINETEST_SUBGAME_PATH");
return subgame_path ? std::string(subgame_path) : "";
}
2012-03-11 13:54:23 +01:00
SubgameSpec findSubgame(const std::string &id)
{
if (id.empty())
2012-03-11 13:54:23 +01:00
return SubgameSpec();
2012-03-19 19:44:07 +01:00
std::string share = porting::path_share;
std::string user = porting::path_user;
// Get games install locations
Strfnd search_paths(getSubgamePathEnv());
// Get all possible paths fo game
std::vector<GameFindPath> find_paths;
while (!search_paths.at_end()) {
std::string path = search_paths.next(PATH_DELIM);
find_paths.emplace_back(path + DIR_DELIM + id, false);
find_paths.emplace_back(path + DIR_DELIM + id + "_game", false);
2014-10-28 20:13:14 +01:00
}
find_paths.emplace_back(
user + DIR_DELIM + "games" + DIR_DELIM + id + "_game", true);
find_paths.emplace_back(user + DIR_DELIM + "games" + DIR_DELIM + id, true);
find_paths.emplace_back(
share + DIR_DELIM + "games" + DIR_DELIM + id + "_game", false);
find_paths.emplace_back(share + DIR_DELIM + "games" + DIR_DELIM + id, false);
2012-03-11 13:54:23 +01:00
// Find game directory
std::string game_path;
2012-03-11 13:54:23 +01:00
bool user_game = true; // Game is in user's directory
for (const GameFindPath &find_path : find_paths) {
const std::string &try_path = find_path.path;
if (fs::PathExists(try_path)) {
game_path = try_path;
user_game = find_path.user_specific;
break;
}
2012-03-11 13:54:23 +01:00
}
if (game_path.empty())
2012-03-11 13:54:23 +01:00
return SubgameSpec();
Basic support for configuring which mods to load for each world settings.h: added function to return all keys used in settings, and a function to remove a setting mods.{h,cpp}: added class ModConfiguration that represents a subset of the installed mods. server.{h,cpp}: server does not load add-on mods that are disabled in the world.mt file. mods are disabled by a setting of the form "load_mod_<modname> = false". if no load_mod_<modname> = ... setting is found, the mod is loaded anyways for backwards compatibilty. server also complains to errorstream about mods with unstatisfied dependencies and about mods that are not installed. guiConfigureWorld.{h,cpp}: shows a treeview of installed add-on mods and modpacks with little icons in front of their name indicating their status: a checkmark for enabled mods, a cross for disabled mods, a question mark for "new" mods Mods can be enabled/disabled by a checkbox. Mods also show a list of dependencies and reverse dependencies. double-click on a mod in dependency or reverse dependency listbox selects the corresponding mod. Enabling a mod also enables all its dependencies. Disabling a mod also disables all its reverse dependencies. For modpacks, show buttons to enable/disable all mods (recursively, including their dependencies) in it. Button "Save" saves the current settings to the world.mt file and returns to the main menu. Button "Cancel" returns to main menu without saving. basic keyboard controls (if the proper widget has keyboard focus): up/down: scroll through tree of mods left/right: collaps/expand a modpack space: enable/disable the selected mod
2012-12-08 18:10:54 +01:00
std::string gamemod_path = game_path + DIR_DELIM + "mods";
2012-03-20 00:06:44 +01:00
// Find mod directories
std::set<std::string> mods_paths;
if (!user_game)
mods_paths.insert(share + DIR_DELIM + "mods");
if (user != share || user_game)
mods_paths.insert(user + DIR_DELIM + "mods");
// Get meta
std::string conf_path = game_path + DIR_DELIM + "game.conf";
Settings conf;
conf.readConfigFile(conf_path.c_str());
std::string game_name;
if (conf.exists("name"))
game_name = conf.get("name");
else
2012-03-26 22:02:12 +02:00
game_name = id;
std::string game_author;
if (conf.exists("author"))
game_author = conf.get("author");
2018-05-16 22:52:12 +02:00
int game_release = 0;
if (conf.exists("release"))
game_release = conf.getS32("release");
std::string menuicon_path;
#ifndef SERVER
menuicon_path = getImagePath(
game_path + DIR_DELIM + "menu" + DIR_DELIM + "icon.png");
#endif
return SubgameSpec(id, game_path, gamemod_path, mods_paths, game_name,
2018-05-16 22:52:12 +02:00
menuicon_path, game_author, game_release);
2012-03-11 13:54:23 +01:00
}
SubgameSpec findWorldSubgame(const std::string &world_path)
{
std::string world_gameid = getWorldGameId(world_path, true);
// See if world contains an embedded game; if so, use it.
std::string world_gamepath = world_path + DIR_DELIM + "game";
if (fs::PathExists(world_gamepath)) {
SubgameSpec gamespec;
gamespec.id = world_gameid;
gamespec.path = world_gamepath;
gamespec.gamemods_path = world_gamepath + DIR_DELIM + "mods";
Settings conf;
std::string conf_path = world_gamepath + DIR_DELIM + "game.conf";
conf.readConfigFile(conf_path.c_str());
if (conf.exists("name"))
gamespec.name = conf.get("name");
else
gamespec.name = world_gameid;
return gamespec;
}
return findSubgame(world_gameid);
}
2012-03-11 13:54:23 +01:00
std::set<std::string> getAvailableGameIds()
{
std::set<std::string> gameids;
std::set<std::string> gamespaths;
2012-03-19 19:44:07 +01:00
gamespaths.insert(porting::path_share + DIR_DELIM + "games");
gamespaths.insert(porting::path_user + DIR_DELIM + "games");
Strfnd search_paths(getSubgamePathEnv());
while (!search_paths.at_end())
gamespaths.insert(search_paths.next(PATH_DELIM));
for (const std::string &gamespath : gamespaths) {
std::vector<fs::DirListNode> dirlist = fs::GetDirListing(gamespath);
for (const fs::DirListNode &dln : dirlist) {
if (!dln.dir)
2012-03-11 13:54:23 +01:00
continue;
// If configuration file is not found or broken, ignore game
Settings conf;
std::string conf_path = gamespath + DIR_DELIM + dln.name +
DIR_DELIM + "game.conf";
if (!conf.readConfigFile(conf_path.c_str()))
continue;
// Add it to result
const char *ends[] = {"_game", NULL};
std::string shorter = removeStringEnd(dln.name, ends);
if (!shorter.empty())
gameids.insert(shorter);
else
gameids.insert(dln.name);
2012-03-11 13:54:23 +01:00
}
}
return gameids;
}
std::vector<SubgameSpec> getAvailableGames()
{
std::vector<SubgameSpec> specs;
std::set<std::string> gameids = getAvailableGameIds();
for (const auto &gameid : gameids)
specs.push_back(findSubgame(gameid));
return specs;
}
#define LEGACY_GAMEID "minetest"
bool getWorldExists(const std::string &world_path)
{
return (fs::PathExists(world_path + DIR_DELIM + "map_meta.txt") ||
fs::PathExists(world_path + DIR_DELIM + "world.mt"));
}
std::string getWorldGameId(const std::string &world_path, bool can_be_legacy)
2012-03-11 13:54:23 +01:00
{
std::string conf_path = world_path + DIR_DELIM + "world.mt";
Settings conf;
bool succeeded = conf.readConfigFile(conf_path.c_str());
if (!succeeded) {
if (can_be_legacy) {
// If map_meta.txt exists, it is probably an old minetest world
if (fs::PathExists(world_path + DIR_DELIM + "map_meta.txt"))
return LEGACY_GAMEID;
}
2012-03-11 13:54:23 +01:00
return "";
}
if (!conf.exists("gameid"))
2012-03-11 13:54:23 +01:00
return "";
// The "mesetint" gameid has been discarded
if (conf.get("gameid") == "mesetint")
return "minetest";
2012-03-11 13:54:23 +01:00
return conf.get("gameid");
}
std::string getWorldPathEnv()
{
char *world_path = getenv("MINETEST_WORLD_PATH");
return world_path ? std::string(world_path) : "";
}
std::vector<WorldSpec> getAvailableWorlds()
{
std::vector<WorldSpec> worlds;
std::set<std::string> worldspaths;
Strfnd search_paths(getWorldPathEnv());
while (!search_paths.at_end())
worldspaths.insert(search_paths.next(PATH_DELIM));
2012-03-19 19:44:07 +01:00
worldspaths.insert(porting::path_user + DIR_DELIM + "worlds");
infostream << "Searching worlds..." << std::endl;
for (const std::string &worldspath : worldspaths) {
infostream << " In " << worldspath << ": " << std::endl;
std::vector<fs::DirListNode> dirvector = fs::GetDirListing(worldspath);
for (const fs::DirListNode &dln : dirvector) {
if (!dln.dir)
continue;
std::string fullpath = worldspath + DIR_DELIM + dln.name;
std::string name = dln.name;
// Just allow filling in the gameid always for now
bool can_be_legacy = true;
std::string gameid = getWorldGameId(fullpath, can_be_legacy);
WorldSpec spec(fullpath, name, gameid);
if (!spec.isValid()) {
infostream << "(invalid: " << name << ") ";
} else {
infostream << name << " ";
worlds.push_back(spec);
}
}
infostream << std::endl;
}
// Check old world location
do {
std::string fullpath = porting::path_user + DIR_DELIM + "world";
if (!fs::PathExists(fullpath))
break;
std::string name = "Old World";
std::string gameid = getWorldGameId(fullpath, true);
WorldSpec spec(fullpath, name, gameid);
infostream << "Old world found." << std::endl;
worlds.push_back(spec);
} while (false);
infostream << worlds.size() << " found." << std::endl;
return worlds;
}
bool loadGameConfAndInitWorld(const std::string &path, const SubgameSpec &gamespec)
{
// Override defaults with those provided by the game.
// We clear and reload the defaults because the defaults
// might have been overridden by other subgame config
// files that were loaded before.
g_settings->clearDefaults();
set_default_settings(g_settings);
Settings game_defaults;
getGameMinetestConfig(gamespec.path, game_defaults);
override_default_settings(g_settings, &game_defaults);
infostream << "Initializing world at " << path << std::endl;
fs::CreateAllDirs(path);
// Create world.mt if does not already exist
std::string worldmt_path = path + DIR_DELIM "world.mt";
if (!fs::PathExists(worldmt_path)) {
Settings conf;
conf.set("gameid", gamespec.id);
conf.set("backend", "sqlite3");
conf.set("player_backend", "sqlite3");
conf.setBool("creative_mode", g_settings->getBool("creative_mode"));
conf.setBool("enable_damage", g_settings->getBool("enable_damage"));
if (!conf.updateConfigFile(worldmt_path.c_str()))
return false;
}
// Create map_meta.txt if does not already exist
std::string map_meta_path = path + DIR_DELIM + "map_meta.txt";
if (!fs::PathExists(map_meta_path)) {
verbosestream << "Creating map_meta.txt (" << map_meta_path << ")"
<< std::endl;
fs::CreateAllDirs(path);
std::ostringstream oss(std::ios_base::binary);
Settings conf;
MapgenParams params;
params.readParams(g_settings);
params.writeParams(&conf);
conf.writeLines(oss);
oss << "[end_of_params]\n";
fs::safeWriteToFile(map_meta_path, oss.str());
}
return true;
}