Initial public OpenBMH 0.1 source (by Codex)
This commit is contained in:
commit
558fbf166b
613 files changed
+168029
No files matched your search
@@ -0,0 +1,470 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
#include "launch/game_data.hpp"
|
||||
|
||||
#include <algorithm>
|
||||
#include <cctype>
|
||||
#include <cstdio>
|
||||
#include <cstdlib>
|
||||
#include <cstring>
|
||||
#include <fstream>
|
||||
#include <set>
|
||||
#include <system_error>
|
||||
|
||||
#include "formats/binary.hpp"
|
||||
#include "formats/le.hpp"
|
||||
#include "formats/m3d.hpp"
|
||||
#include "formats/textd.hpp"
|
||||
#include "launch/archive.hpp"
|
||||
#include "launch/fltd.hpp"
|
||||
|
||||
namespace fs = std::filesystem;
|
||||
|
||||
namespace bmh::launch {
|
||||
|
||||
namespace {
|
||||
|
||||
std::string upper(std::string s) {
|
||||
for (char& c : s) c = char(std::toupper(static_cast<unsigned char>(c)));
|
||||
return s;
|
||||
}
|
||||
|
||||
// The data files every version has (the German editions and the English one share the
|
||||
// pictures, fonts and sounds; checked against the CD, the nine edition packages and FTL).
|
||||
constexpr int kPictures[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
|
||||
21, 22, 23, 24, 25, 26, 27, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42,
|
||||
43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63,
|
||||
64, 65, 66, 67, 68, 69, 70, 74, 128, 129, 131, 132, 133, 134, 135, 136, 137, 138, 139};
|
||||
constexpr int kBadges[] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 17, 18, 19, 20, 44, 45, 46, 47, 48, 49, 50, 51, 52};
|
||||
|
||||
struct Required {
|
||||
const char* name;
|
||||
uint64_t size; // 0: any size above zero
|
||||
};
|
||||
constexpr Required kCommon[] = {{"M3.DAT", 1408}, {"M3.MEN", 864}, {"M3PC.COL", 768}};
|
||||
|
||||
// Game EXEs by family. The German ones all have 602,527 bytes; the hashes differ between
|
||||
// the editions, so only the size is required.
|
||||
struct Family {
|
||||
GameFamily family;
|
||||
const char* exe;
|
||||
uint64_t exe_size;
|
||||
const char* texts;
|
||||
const char* database;
|
||||
};
|
||||
constexpr Family kFamilies[] = {
|
||||
{GameFamily::german, "BMH.EXE", 602527, "TEXTD.BLK", "M3D.MAN"},
|
||||
{GameFamily::english, "FLTD.EXE", 507925, "TEXTE.BLK", "M3E.MAN"},
|
||||
{GameFamily::disk1994, "M3.EXE", 0, "", "M3PC.MAN"},
|
||||
};
|
||||
|
||||
std::optional<Family> family_of_exe(const std::string& file_name) {
|
||||
const std::string u = upper(file_name);
|
||||
for (const Family& f : kFamilies)
|
||||
if (u == f.exe) return f;
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
// Every game EXE directly in `directory`.
|
||||
std::vector<std::pair<Family, fs::path>> game_exes(const fs::path& directory) {
|
||||
std::vector<std::pair<Family, fs::path>> out;
|
||||
std::error_code ec;
|
||||
for (const auto& e : fs::directory_iterator(directory, ec)) {
|
||||
if (!e.is_regular_file(ec)) continue;
|
||||
if (auto f = family_of_exe(path_to_utf8(e.path().filename()))) out.emplace_back(*f, e.path());
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
void require(GameCheck& c, const fs::path& dir, const std::string& name, uint64_t size, const std::string& shown) {
|
||||
const auto p = find_file(dir, name);
|
||||
if (!p) {
|
||||
c.problems.push_back(shown + " is missing");
|
||||
return;
|
||||
}
|
||||
std::error_code ec;
|
||||
const uint64_t actual = fs::file_size(*p, ec);
|
||||
if (ec || actual == 0) c.problems.push_back(shown + " is empty or unreadable");
|
||||
else if (size != 0 && actual != size)
|
||||
c.problems.push_back(shown + " has " + std::to_string(actual) + " bytes instead of " + std::to_string(size));
|
||||
}
|
||||
|
||||
// The shared picture/font/sound files of the sub directories KB, W, F and S.
|
||||
void require_media(GameCheck& c) {
|
||||
const auto sub = [&](const char* name) -> std::optional<fs::path> {
|
||||
auto p = find_file(c.directory, name);
|
||||
if (!p || !fs::is_directory(*p)) {
|
||||
c.problems.push_back(std::string("the directory ") + name + " is missing");
|
||||
return std::nullopt;
|
||||
}
|
||||
return p;
|
||||
};
|
||||
// (a long list of missing files says less than the count and the first ones)
|
||||
const auto files = [&](const fs::path& dir, const char* shown, const std::vector<std::string>& names) {
|
||||
std::vector<std::string> missing;
|
||||
for (const auto& n : names)
|
||||
if (!find_file(dir, n)) missing.push_back(n);
|
||||
if (missing.empty()) return;
|
||||
std::string text = std::string(shown) + ": " + std::to_string(missing.size()) + " file(s) missing (";
|
||||
for (size_t i = 0; i < missing.size() && i < 5; ++i) text += (i ? ", " : "") + missing[i];
|
||||
c.problems.push_back(text + (missing.size() > 5 ? ", ...)" : ")"));
|
||||
};
|
||||
std::vector<std::string> names;
|
||||
if (auto kb = sub("KB")) {
|
||||
for (int n : kPictures) names.push_back(std::to_string(n) + ".VGA");
|
||||
files(*kb, "KB", names);
|
||||
}
|
||||
names.clear();
|
||||
if (auto w = sub("W")) {
|
||||
for (int n : kBadges) names.push_back(std::to_string(n) + ".VGA");
|
||||
files(*w, "W", names);
|
||||
}
|
||||
if (auto f = sub("F")) files(*f, "F", {"BMH2.FNT", "BMH3.FNT"});
|
||||
if (auto s = sub("S")) files(*s, "S", {"2000", "2001", "2002", "2003"});
|
||||
}
|
||||
|
||||
// A readable title from the text block (ISO 646-DE: the brackets are umlauts).
|
||||
std::string text_title(const std::string& raw) {
|
||||
std::string out;
|
||||
for (unsigned char ch : raw) {
|
||||
switch (ch) {
|
||||
case '[': out += "\xC3\x84"; break;
|
||||
case '\\': out += "\xC3\x96"; break;
|
||||
case ']': out += "\xC3\x9C"; break;
|
||||
case '{': out += "\xC3\xA4"; break;
|
||||
case '|': out += "\xC3\xB6"; break;
|
||||
case '}': out += "\xC3\xBC"; break;
|
||||
case '~': out += "\xC3\x9F"; break;
|
||||
default: out += ch >= 0x20 && ch < 0x7F ? char(ch) : '?';
|
||||
}
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
void check_german(GameCheck& c) {
|
||||
// (a translated English game has BMH.exe in the OpenBMH image format, launch/fltd.hpp)
|
||||
bool image = false;
|
||||
if (const auto exe = find_file(c.directory, "BMH.EXE")) {
|
||||
std::ifstream in(*exe, std::ios::binary);
|
||||
char head[13] = {};
|
||||
in.read(head, sizeof head);
|
||||
image = std::string(head, sizeof head) == "OPENBMH-IMAGE";
|
||||
}
|
||||
require(c, c.directory, "BMH.EXE", image ? 0 : 602527, "BMH.EXE");
|
||||
require(c, c.directory, "TEXTD.BLK", 0, "TEXTD.BLK");
|
||||
require(c, c.directory, "M3D.MAN", 0, "M3D.MAN");
|
||||
for (const Required& r : kCommon) require(c, c.directory, r.name, r.size, r.name);
|
||||
require_media(c);
|
||||
if (!c.problems.empty()) return;
|
||||
// the files must also load: the engine reads tables from the EXE, the texts and the
|
||||
// database of clubs and players
|
||||
try {
|
||||
load_le(*find_file(c.directory, "BMH.EXE"));
|
||||
} catch (const std::exception& e) {
|
||||
c.problems.push_back(std::string("BMH.EXE cannot be read: ") + e.what());
|
||||
}
|
||||
try {
|
||||
const TextDb texts = load_textd(*find_file(c.directory, "TEXTD.BLK"));
|
||||
// the supported rule profile editions greet with their title as the first mailbox message (text 1001);
|
||||
// the CD version has another greeting there
|
||||
c.title = "Bundesliga Manager Hattrick";
|
||||
if (texts.strings.size() > 1001 && texts.strings[1001].rfind("Bundesliga Manager", 0) == 0)
|
||||
c.title = text_title(texts.strings[1001]);
|
||||
} catch (const std::exception& e) {
|
||||
c.problems.push_back(std::string("TEXTD.BLK cannot be read: ") + e.what());
|
||||
}
|
||||
try {
|
||||
load_database(*find_file(c.directory, "M3D.MAN"));
|
||||
} catch (const std::exception& e) {
|
||||
c.problems.push_back(std::string("M3D.MAN cannot be read: ") + e.what());
|
||||
}
|
||||
}
|
||||
|
||||
void check_english(GameCheck& c) {
|
||||
require(c, c.directory, "FLTD.EXE", 507925, "FLTD.EXE");
|
||||
require(c, c.directory, "TEXTE.BLK", 0, "TEXTE.BLK");
|
||||
require(c, c.directory, "M3E.MAN", 0, "M3E.MAN");
|
||||
for (const Required& r : kCommon) require(c, c.directory, r.name, r.size, r.name);
|
||||
require_media(c);
|
||||
c.title = "Football Limited (English)";
|
||||
}
|
||||
|
||||
// A cheap content hash (FNV-1a, 64 bit) that names the cache folder of an archive.
|
||||
std::string content_hash(const fs::path& file) {
|
||||
std::ifstream in(file, std::ios::binary);
|
||||
uint64_t h = 0xcbf29ce484222325ull;
|
||||
char buf[1 << 16];
|
||||
while (in) {
|
||||
in.read(buf, sizeof buf);
|
||||
for (std::streamsize i = 0; i < in.gcount(); ++i) h = (h ^ uint8_t(buf[i])) * 0x100000001b3ull;
|
||||
}
|
||||
char text[17];
|
||||
std::snprintf(text, sizeof text, "%016llx", static_cast<unsigned long long>(h));
|
||||
return text;
|
||||
}
|
||||
|
||||
// Whether an archive file belongs to the game data: the original file kinds, the sounds
|
||||
// (S\2000...) and savegames. Pictures, manuals and other fan extras are left out of the
|
||||
// cache (their long names also overflow the 260 characters of a Windows path).
|
||||
bool is_game_file(const std::string& relative) {
|
||||
const std::string u = upper(relative);
|
||||
const std::string base = u.substr(u.find_last_of('/') + 1);
|
||||
if (u.rfind("S/", 0) == 0 && base.find('.') == std::string::npos) return true; // sounds
|
||||
const size_t dot = base.find_last_of('.');
|
||||
if (dot == std::string::npos) return false;
|
||||
const std::string ext = base.substr(dot + 1);
|
||||
for (const char* e : {"EXE", "BLK", "MAN", "DAT", "MEN", "COL", "VGA", "FNT", "LBM", "EIN", "CFG", "FBM", "WAP"})
|
||||
if (ext == e) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
bool is_archive_name(const std::string& name) {
|
||||
const std::string u = upper(name);
|
||||
for (const char* ext : {".ZIP", ".7Z", ".ARJ", ".RAR", ".LZH", ".TAR", ".GZ"})
|
||||
if (u.size() > std::strlen(ext) && u.compare(u.size() - std::strlen(ext), std::string::npos, ext) == 0) return true;
|
||||
return false;
|
||||
}
|
||||
|
||||
// Unpacks the one game of an archive into the cache (or finds it there).
|
||||
ResolvedGame unpack(const fs::path& file, const fs::path& cache) {
|
||||
ResolvedGame r;
|
||||
const ArchiveFormat format = archive_format(file);
|
||||
if (format == ArchiveFormat::arj) {
|
||||
r.error = "This is an ARJ archive (the installer format of the 1994 floppy disks). OpenBMH cannot read it; "
|
||||
"please unpack the installed game.";
|
||||
return r;
|
||||
}
|
||||
if (format == ArchiveFormat::rar) {
|
||||
r.error = "RAR archives are not supported; please use ZIP or 7z.";
|
||||
return r;
|
||||
}
|
||||
try {
|
||||
Archive archive = Archive::open(file);
|
||||
const auto& entries = archive.entries();
|
||||
// exactly one game EXE; its directory is the game's root in the archive
|
||||
std::vector<size_t> exes;
|
||||
bool nested = false, installer = false;
|
||||
for (size_t i = 0; i < entries.size(); ++i) {
|
||||
if (entries[i].directory) continue;
|
||||
const std::string& n = entries[i].name;
|
||||
const std::string base = n.substr(n.find_last_of('/') + 1);
|
||||
if (family_of_exe(base)) exes.push_back(i);
|
||||
if (is_archive_name(base)) nested = true;
|
||||
if (upper(base) == "INSTALL.EXE") installer = true;
|
||||
}
|
||||
if (exes.empty()) {
|
||||
if (installer) r.error = "The archive holds an installer (INSTALL.EXE), not an installed game.";
|
||||
else if (nested) r.error = "The archive contains further archives (a box with several editions). "
|
||||
"Please choose the archive of one edition.";
|
||||
else r.error = "The archive contains no BMH.EXE or FLTD.EXE.";
|
||||
return r;
|
||||
}
|
||||
if (exes.size() > 1) {
|
||||
r.error = "The archive contains " + std::to_string(exes.size()) +
|
||||
" games. Please use an archive with exactly one game.";
|
||||
return r;
|
||||
}
|
||||
const std::string& exe_name = entries[exes[0]].name;
|
||||
const std::string root = exe_name.substr(0, exe_name.find_last_of('/') + 1); // "" or "dir/.../"
|
||||
|
||||
const fs::path target = cache / content_hash(file);
|
||||
const fs::path marker = target / ".openbmh-unpacked";
|
||||
std::error_code ec;
|
||||
if (!fs::exists(marker, ec)) {
|
||||
const fs::path temp = cache / (content_hash(file) + ".partial");
|
||||
fs::remove_all(temp, ec);
|
||||
fs::create_directories(temp);
|
||||
uint64_t total = 0;
|
||||
for (size_t i = 0; i < entries.size(); ++i) {
|
||||
const ArchiveEntry& e = entries[i];
|
||||
if (e.name.compare(0, root.size(), root) != 0 || e.name.size() == root.size()) continue;
|
||||
const std::string rel = e.name.substr(root.size());
|
||||
// no absolute paths and no way out of the target directory
|
||||
const fs::path relative = path_from_utf8(rel);
|
||||
bool safe = !relative.is_absolute() && !relative.has_root_name();
|
||||
for (const auto& part : relative) safe = safe && part != "..";
|
||||
if (!safe) throw ArchiveError("unsafe path in the archive: " + e.name);
|
||||
if (!e.directory && !is_game_file(rel)) continue;
|
||||
total += e.size;
|
||||
if (total > 256ull * 1024 * 1024) throw ArchiveError("the game in the archive is too large");
|
||||
if (e.directory) {
|
||||
fs::create_directories(temp / relative);
|
||||
continue;
|
||||
}
|
||||
fs::create_directories((temp / relative).parent_path());
|
||||
const std::vector<uint8_t> bytes = archive.read(i);
|
||||
std::ofstream out(temp / relative, std::ios::binary);
|
||||
out.write(reinterpret_cast<const char*>(bytes.data()), std::streamsize(bytes.size()));
|
||||
if (!out) throw ArchiveError("cannot write " + path_to_utf8(temp / relative));
|
||||
}
|
||||
std::ofstream(temp / ".openbmh-unpacked") << path_to_utf8(file) << "\n";
|
||||
fs::remove_all(target, ec);
|
||||
fs::rename(temp, target);
|
||||
}
|
||||
r.check = check_game_directory(target);
|
||||
r.unpacked = true;
|
||||
} catch (const std::exception& e) {
|
||||
r.error = std::string("The archive cannot be used: ") + e.what();
|
||||
}
|
||||
return r;
|
||||
}
|
||||
|
||||
ResolvedGame resolve_game_unchecked(const fs::path& input, const fs::path& cache);
|
||||
|
||||
} // namespace
|
||||
|
||||
std::optional<fs::path> find_file(const fs::path& directory, const std::string& name) {
|
||||
std::error_code ec;
|
||||
const fs::path exact = directory / path_from_utf8(name);
|
||||
if (fs::exists(exact, ec)) return exact;
|
||||
const std::string wanted = upper(name);
|
||||
for (const auto& e : fs::directory_iterator(directory, ec))
|
||||
if (upper(path_to_utf8(e.path().filename())) == wanted) return e.path();
|
||||
return std::nullopt;
|
||||
}
|
||||
|
||||
GameCheck check_game_directory(const fs::path& path) {
|
||||
GameCheck c;
|
||||
std::error_code ec;
|
||||
fs::path dir = fs::is_directory(path, ec) ? path : path.parent_path();
|
||||
auto exes = game_exes(dir);
|
||||
if (exes.empty()) {
|
||||
// an edition folder with the game one level below (e.g. "BMH 2026-27 supported rule profile\BMH")
|
||||
std::vector<fs::path> candidates;
|
||||
for (const auto& e : fs::directory_iterator(dir, ec))
|
||||
if (e.is_directory(ec) && !game_exes(e.path()).empty()) candidates.push_back(e.path());
|
||||
if (candidates.size() == 1) {
|
||||
dir = candidates[0];
|
||||
exes = game_exes(dir);
|
||||
}
|
||||
}
|
||||
c.directory = dir;
|
||||
if (exes.empty()) {
|
||||
c.problems.push_back("no BMH.EXE or FLTD.EXE in " + path_to_utf8(dir));
|
||||
return c;
|
||||
}
|
||||
// a named EXE decides; otherwise the German game before the English one
|
||||
std::sort(exes.begin(), exes.end(), [](const auto& a, const auto& b) { return int(a.first.family) < int(b.first.family); });
|
||||
auto chosen = exes.front();
|
||||
if (!fs::is_directory(path, ec))
|
||||
for (const auto& e : exes)
|
||||
if (upper(path_to_utf8(e.second.filename())) == upper(path_to_utf8(path.filename()))) chosen = e;
|
||||
c.family = chosen.first.family;
|
||||
c.exe = chosen.second;
|
||||
switch (c.family) {
|
||||
case GameFamily::german:
|
||||
check_german(c);
|
||||
c.playable = c.problems.empty();
|
||||
break;
|
||||
case GameFamily::english:
|
||||
check_english(c);
|
||||
// complete English data is translated for the engine when the game is resolved
|
||||
// (resolve_game -> prepare_english_game); the check itself stays on the original
|
||||
break;
|
||||
case GameFamily::disk1994:
|
||||
c.title = "Bundesliga Manager Hattrick (1994 floppy version)";
|
||||
c.unsupported = "The 1994 floppy version (M3.EXE) is not supported; please use the CD version or a later edition.";
|
||||
break;
|
||||
case GameFamily::unknown: break;
|
||||
}
|
||||
return c;
|
||||
}
|
||||
|
||||
ResolvedGame resolve_game(const fs::path& input, const fs::path& cache) {
|
||||
try {
|
||||
ResolvedGame game = resolve_game_unchecked(input, cache);
|
||||
// The English Football Limited runs on the same engine through a German-layout data
|
||||
// directory, built once in the cache (launch/fltd.hpp); its name follows FLTD.EXE.
|
||||
if (game.error.empty() && game.check.family == GameFamily::english && game.check.problems.empty()) {
|
||||
const fs::path prepared = cache / ("en-" + content_hash(game.check.exe));
|
||||
const fs::path marker = prepared / ".openbmh-english";
|
||||
// the version of the translation (launch/fltd.cpp, fltd_map.inc): a cache built
|
||||
// by another version is built again
|
||||
constexpr const char* kTranslation = "english translation 12"; // 12: contract warning ContractExpiryWarningText; 11: statistics windows, graph labels/count classes, streaks and national-badge banks
|
||||
std::string built;
|
||||
{
|
||||
std::ifstream in(marker);
|
||||
std::getline(in, built);
|
||||
}
|
||||
std::error_code ec;
|
||||
if (built != kTranslation) {
|
||||
fs::remove_all(prepared, ec);
|
||||
std::string error;
|
||||
if (!prepare_english_game(game.check.directory, prepared, error)) {
|
||||
game.error = "The English version cannot be prepared: " + error;
|
||||
return game;
|
||||
}
|
||||
std::ofstream(marker) << kTranslation << "\n" << path_to_utf8(game.check.directory) << "\n";
|
||||
}
|
||||
game.check.directory = prepared;
|
||||
game.check.playable = true;
|
||||
game.unpacked = true;
|
||||
}
|
||||
return game;
|
||||
} catch (const std::exception& e) {
|
||||
// (file system errors, names that cannot be converted)
|
||||
ResolvedGame r;
|
||||
r.error = std::string("The game cannot be opened: ") + e.what();
|
||||
return r;
|
||||
}
|
||||
}
|
||||
|
||||
namespace {
|
||||
ResolvedGame resolve_game_unchecked(const fs::path& input, const fs::path& cache) {
|
||||
std::error_code ec;
|
||||
if (!fs::exists(input, ec)) {
|
||||
ResolvedGame r;
|
||||
r.error = "not found: " + path_to_utf8(input);
|
||||
return r;
|
||||
}
|
||||
if (fs::is_directory(input, ec)) return {check_game_directory(input), {}, false};
|
||||
if (family_of_exe(path_to_utf8(input.filename()))) return {check_game_directory(input), {}, false};
|
||||
if (archive_format(input) != ArchiveFormat::none) return unpack(input, cache);
|
||||
ResolvedGame r;
|
||||
r.error = path_to_utf8(input.filename()) + " is neither a game directory, BMH.EXE/FLTD.EXE nor a ZIP/7z archive.";
|
||||
return r;
|
||||
}
|
||||
} // namespace
|
||||
|
||||
fs::path default_cache_directory() {
|
||||
const auto env = [](const char* name) -> std::optional<fs::path> {
|
||||
#ifdef _WIN32
|
||||
// (the wide environment: the profile path may hold characters outside the code page)
|
||||
std::wstring wname(name, name + std::strlen(name));
|
||||
wchar_t* v = nullptr;
|
||||
size_t length = 0;
|
||||
if (_wdupenv_s(&v, &length, wname.c_str()) == 0 && v) {
|
||||
const fs::path value = *v ? fs::path(v) : fs::path();
|
||||
std::free(v);
|
||||
if (!value.empty()) return value;
|
||||
}
|
||||
#else
|
||||
if (const char* v = std::getenv(name); v && *v) return fs::path(v);
|
||||
#endif
|
||||
return std::nullopt;
|
||||
};
|
||||
#if defined(_WIN32)
|
||||
if (auto base = env("LOCALAPPDATA")) return *base / "OpenBMH" / "games";
|
||||
return fs::temp_directory_path() / "OpenBMH" / "games";
|
||||
#elif defined(__APPLE__)
|
||||
if (auto home = env("HOME")) return *home / "Library" / "Application Support" / "OpenBMH" / "games";
|
||||
return fs::temp_directory_path() / "OpenBMH" / "games";
|
||||
#else
|
||||
if (auto data = env("XDG_DATA_HOME")) return *data / "openbmh" / "games";
|
||||
if (auto home = env("HOME")) return *home / ".local" / "share" / "openbmh" / "games";
|
||||
return fs::temp_directory_path() / "openbmh" / "games";
|
||||
#endif
|
||||
}
|
||||
|
||||
std::string describe(const ResolvedGame& game) {
|
||||
if (!game.error.empty()) return game.error;
|
||||
const GameCheck& c = game.check;
|
||||
std::string text;
|
||||
if (!c.title.empty()) text += c.title + "\n";
|
||||
text += path_to_utf8(c.directory) + "\n";
|
||||
for (const auto& p : c.problems) text += "- " + p + "\n";
|
||||
if (!c.unsupported.empty()) text += c.unsupported + "\n";
|
||||
if (c.playable) text += "The game data is complete.\n";
|
||||
return text;
|
||||
}
|
||||
|
||||
} // namespace bmh::launch
|
||||
Reference in new issue
Block a user