Build 0.2 native launcher and portable Classic runtime (by Codex)

This commit is contained in:
Codex committed 2026-10-18 11:28:51 +02:00
1 parent 3a021fc160
commit 2552528176
84 files changed
+5004 -197

No files matched your search

+140
View File
@@ -0,0 +1,140 @@
// SPDX-License-Identifier: GPL-3.0-only
#include "content/package.hpp"
#include "content/save.hpp"
#include "launch/mods.hpp"
#include "formats/content.hpp"
#include "formats/native_state.hpp"
#include "formats/vga.hpp"
#include <chrono>
#include <iostream>
using namespace bmh;
namespace fs = std::filesystem;
void check(bool value, const char *message) {
if (!value)
throw std::runtime_error(message);
}
template <class F> void rejects(F f, const char *message) {
bool failed = false;
try {
f();
} catch (const std::exception &) {
failed = true;
}
check(failed, message);
}
int main() try {
check(content::sha256("") == "e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855",
"SHA256 empty vector");
check(content::sha256("abc") == "ba7816bf8f01cfea414140de5dae2223b00361a396177a9cb410ff61f20015ad",
"SHA256 short vector");
check(content::sha256(std::string(1000000, 'a')) ==
"cdc76e5c9914fb9281a1c7e284d73e67f1809a48a497200e046d39ccc7112cd0",
"SHA256 multi-block vector");
const auto root = fs::temp_directory_path() /
("openbmh-native-test-" +
std::to_string(std::chrono::steady_clock::now().time_since_epoch().count()));
fs::create_directories(root);
struct Cleanup {
fs::path p;
~Cleanup() {
std::error_code ec;
fs::remove_all(p, ec);
}
} cleanup{root};
auto classic = std::make_shared<content::Classic>();
classic->images.emplace("kb/7", Image(2, 2, 19));
classic->audio["2000"] = {1, 2, 3};
classic->desktops = {4, 5};
classic->palette.argb[9] = 0xffabcdef;
{
content::Mount mount(root / "content.obw", classic);
check(!fs::exists(mount.root()), "mounted contents need no materialized legacy files");
check(load_vga(mount.root() / "KB/7.VGA").pixels == Bytes(4, 19),
"indexed OBW image reaches existing renderer");
check(read_file(mount.root() / "S/2000") == Bytes({1, 2, 3}),
"audio bank comes from immutable store");
check(read_file(mount.root() / "M3.MEN") == Bytes({4, 5}),
"startup input comes from immutable store");
check(load_palette(mount.root() / "M3PC.COL").argb[9] == 0xffabcdef,
"palette keeps exact imported RGB8");
rejects([&] { load_vga(mount.root() / "KB/999.VGA"); },
"missing content must not fall through to disk");
rejects([&] { content::Mount duplicate(mount.root(), classic); },
"duplicate mounts must not replace live contents");
}
check(!content::find(root / "content.obw/KB/7.VGA"), "mount lifetime is bounded");
GameState state;
state.date = 99;
state.season_start = 12;
state.display_start_year = 1994;
state.squad_slots = {0x8fff, 42};
state.manager_teams = {-1, 12};
state.manager_records = {1, 2, 3};
state.player_names = {0, 0xff};
state.memory.add_block(0x1000, 4);
state.memory.set32(0x1000, 0xff123456);
state.players.push_back({std::string("A\xff", 2), 0xdeadbeef, 0x12345678, 0xffffffff});
state.autosave_month = 4;
state.list_toggle = 1;
state.sportschau_homes[9] = 41;
state.reality.initialized = true;
state.reality.grid.place(0, 5, 7, 0);
state.reality.cue_actors[3] = 19;
const auto encoded = encode_native_state(state);
const auto restored = decode_native_state(cli::parse_json(cli::dump_json(encoded)));
check(cli::dump_json(encoded) == cli::dump_json(encode_native_state(restored)),
"all native fields round-trip without host padding/pointers");
check(restored.reality == state.reality, "Reality residues survive exactly");
auto damaged = encoded;
damaged.object()->at("schema") = "classic-state@99.0";
rejects([&] { decode_native_state(damaged); }, "unsupported checkpoint schema rejected");
TurnDriver driver;
driver.referees = {1, 0x81};
driver.next_event_id = UINT64_MAX;
TurnDriver copy;
content::restore_driver(copy, content::driver_checkpoint(driver));
check(copy.next_event_id == UINT64_MAX && copy.referees == driver.referees,
"driver counters and referees round-trip");
WatcomRandom random(7);
random.rand();
WatcomRandom continued;
continued.restore(random.seed(), random.calls());
check(continued.rand() == random.rand() && continued.calls() == random.calls(),
"Watcom stream resumes including counter");
content::Documents docs{{"manifest.json", "{}"}, {"assets/test.pixels", std::string("a\0b", 3)}};
const auto archive = root / "sample.obs";
content::write_archive(docs, archive);
check(content::read_archive(archive) == docs, "binary native archive round-trip");
rejects([&] { content::write_archive({{"../outside", "x"}}, root / "unsafe.obs"); },
"archive traversal rejected");
rejects([&] { content::write_archive({}, archive); }, "existing saves require explicit overwrite");
check(content::read_archive(archive) == docs, "rejected overwrite retains existing save");
content::write_archive({{"new", "value"}}, archive, true);
check(content::read_archive(archive).contains("new"), "atomic replacement publishes complete archive");
content::save_preferences(root / "test.obsettings", "settings", Bytes(180, 0x82), false);
check(content::load_preferences(root / "test.obsettings", "settings", 180) == Bytes(180, 0x82),
"native settings retain availability bits");
rejects([&] { content::load_preferences(root / "test.obsettings", "layout", 180); },
"preferences kinds cannot be confused");
launch::ModLibrary library(root);
check(library.list().empty(), "first launch has no implicit installation");
for (const char *name : {"../escape", "CON", "lpt1.txt", "trailing.", "bad/name", ""})
rejects([&] { launch::ModLibrary::validate_name(name); }, "portable mod name validation");
fs::create_directories(root / "mods/BMH-classic");
auto entries = library.list();
check(entries.size() == 1 && !entries[0].error.empty(), "damaged mods remain visible with error");
rejects([&] { library.rename(entries[0], "bmh-CLASSIC"); }, "case-insensitive duplicate name rejected");
library.rename(entries[0], "Renamed");
entries = library.list();
check(entries[0].name == "Renamed", "rename changes directory name");
entries[0].content_id = std::string(64, 'a');
const auto personal = library.user_directory(entries[0]);
content::write_atomic(personal / "keep.obs", "saved", false);
library.remove(entries[0]);
check(library.list().empty() && fs::exists(personal / "keep.obs"), "delete retains personal saves");
std::cout << "native content, checkpoints and portable mod lifecycle passed\n";
return 0;
} catch (const std::exception &e) {
std::cerr << e.what() << '\n';
return 1;
}
+158
View File
@@ -0,0 +1,158 @@
// SPDX-License-Identifier: GPL-3.0-only
#include "app/career_session.hpp"
#include "content/save.hpp"
#include "launch/mods.hpp"
#include "launch/game_data.hpp"
#include "ui/setup.hpp"
#include "ui/sportschau.hpp"
#include "game/save.hpp"
#include <chrono>
#include <iostream>
using namespace bmh;
namespace fs = std::filesystem;
void check(bool value, const std::string &text) {
if (!value)
throw std::runtime_error(text);
}
int main(int argc, char **argv) try {
if (argc < 2)
return 77;
const auto root = fs::temp_directory_path() /
("openbmh-native-career-" +
std::to_string(std::chrono::steady_clock::now().time_since_epoch().count()));
fs::create_directories(root);
struct Cleanup {
fs::path p;
~Cleanup() {
std::error_code ec;
fs::remove_all(p, ec);
}
} cleanup{root};
launch::ModLibrary library(root);
launch::AddMod request;
request.source = argv[1];
request.name = "Test Classic";
request.migrate = false;
const auto result = library.add(request, {});
const auto package = result.mod.directory / "content.obw";
auto content = content::open(package);
content::Mount mount(package, content);
// Exercise renderers through aliases while the mod contains only content.obw.
check(ui::SetupScreen(mount.root()).render().pixels.size() == 320 * 240, "OBW-only setup renderer");
(void)ui::SportschauIntro(mount.root()).render_frame(0);
const auto resolved = launch::resolve_game(request.source, root / "legacy-test-cache");
check(resolved.error.empty(), resolved.error);
app::CareerSession old(resolved.check.directory, 12345);
app::CareerSession session(mount.root(), 12345);
check(save_stream(old.state()) == save_stream(session.state()) &&
old.rand().seed() == session.rand().seed() && old.game().seed() == session.game().seed(),
"OBW bootstrap matches legacy state and RNG");
ui::SetupOptions options;
options.managers = 1;
ui::ManagerChoice manager;
manager.slot = 0;
manager.master_club = 0;
manager.start_league = 0;
manager.strength = 1;
manager.portrait = 0;
manager.name = "Native QA";
std::string error;
check(session.confirm_manager(options, manager, error), error);
const auto personal = library.user_directory(result.mod);
session.configure_autosave_directory(personal);
session.state().memory.set8(layout::Desk_EnterDesk_RuntimeField, 1);
ui::CareerInitializationResult initial;
check(session.finish(initial, error), error);
const auto before = cli::dump_json(encode_native_state(session.state()));
const auto random = session.rand();
const auto game = session.game();
const auto save = library.user_directory(result.mod) / "QA.obs";
check(session.save_game(save, 0, false, error), error);
check(session.rand().seed() == random.seed() && session.rand().calls() == random.calls() &&
session.game().seed() == game.seed() && session.game().calls() == game.calls(),
"native saving is RNG-neutral");
app::CareerSession loaded(mount.root(), 999, save);
check(cli::dump_json(encode_native_state(loaded.state())) == before, "native career state round-trip");
check(loaded.rand().seed() == random.seed() && loaded.rand().calls() == random.calls() &&
loaded.game().seed() == game.seed() && loaded.game().calls() == game.calls(),
"both RNG states and counters restored");
check(cli::dump_json(content::driver_checkpoint(session.manager_join_checkpoint().driver)) ==
cli::dump_json(content::driver_checkpoint(loaded.manager_join_checkpoint().driver)),
"native turn cursor round-trip");
session.state().memory.set8(layout::Desk_EnterDesk_RuntimeField, 1);
loaded.state().memory.set8(layout::Desk_EnterDesk_RuntimeField, 1);
session.state().autosave_month = 0;
loaded.state().autosave_month = 0;
uint64_t first_revision = 1, second_revision = 1;
for (int step = 0; step < 8; ++step) {
const auto first_desk = session.desktop_projection(first_revision),
second_desk = loaded.desktop_projection(second_revision);
ui::DeskRequest first_request;
first_request.kind = ui::DeskRequestKind::advance_turn;
first_request.manager_slot = first_desk.manager_slot;
first_request.revision = first_revision;
auto second_request = first_request;
second_request.manager_slot = second_desk.manager_slot;
second_request.revision = second_revision;
std::string first_error, second_error;
const auto first = session.dispatch_kickoff(first_request, first_revision, first_error);
const auto second = loaded.dispatch_kickoff(second_request, second_revision, second_error);
check(first.kind == second.kind && first_error == second_error,
"native continuation has identical outcome");
check(cli::dump_json(encode_native_state(session.state())) ==
cli::dump_json(encode_native_state(loaded.state())),
"native continuation preserves every game-state field");
check(session.rand().seed() == loaded.rand().seed() &&
session.rand().calls() == loaded.rand().calls() &&
session.game().seed() == loaded.game().seed() &&
session.game().calls() == loaded.game().calls(),
"native continuation preserves both random streams");
if (first.kind == TurnDeskKind::Failed || first.kind == TurnDeskKind::WaitingAtDesk)
break;
if (step == 0) {
const auto autosave_error = session.take_autosave_error();
check(fs::exists(personal / "AUTOSAVE.obs"), "native autosave at stable desk: " + autosave_error);
app::CareerSession autosaved(mount.root(), 0, personal / "AUTOSAVE.obs");
check(cli::dump_json(encode_native_state(autosaved.state())) ==
cli::dump_json(encode_native_state(session.state())),
"autosave matches completed desk, including runtime flags");
}
check(session.save_game(save, first.manager_slot, true, error), error);
auto fresh = std::make_unique<app::CareerSession>(mount.root(), 0, save);
check(cli::dump_json(content::driver_checkpoint(session.manager_join_checkpoint().driver)) ==
cli::dump_json(content::driver_checkpoint(fresh->manager_join_checkpoint().driver)),
"prepared match groups and previous results survive saving");
}
// Original save migration must not require the original installation afterwards.
auto old_save = make_savegame(session.state(), session.rand());
write_savegame(root / "legacy.FBM", old_save);
app::CareerSession migrated(mount.root(), 4321, root / "legacy.FBM", true);
check(migrated.save_game(root / "migrated.obs", 0, false, error), error);
app::CareerSession continued(mount.root(), 1, root / "migrated.obs");
check(continued.state().players.size() == session.state().players.size(),
"legacy save migrates to native continuation");
if (argc > 2) {
app::CareerSession original(mount.root(), 0x12345678, argv[2], true);
check(original.save_game(root / "original-import.obs",
original.state().memory.u8(layout::ActiveManager), false, error),
error);
app::CareerSession resumed(mount.root(), 0, root / "original-import.obs");
check(cli::dump_json(encode_native_state(original.state())) ==
cli::dump_json(encode_native_state(resumed.state())),
"original edition save migration round-trip");
}
auto changed = content->documents;
changed["assets/classic/images/kb/29.pixels"][0] ^= 1;
bool rejected = false;
try {
content::verify(changed);
} catch (const std::exception &) {
rejected = true;
}
check(rejected, "modified Classic assets rejected");
std::cout << "OBW-only GUI/bootstrap, career/RNG round-trip and migration passed\n";
return 0;
} catch (const std::exception &e) {
std::cerr << e.what() << '\n';
return 1;
}
+18
View File
@@ -1,6 +1,7 @@
// SPDX-License-Identifier: GPL-3.0-only
#include "import/obw.hpp"
#include "import/classic.hpp"
#include "content/package.hpp"
#include "import/assets.hpp"
#include "formats/executable_layout.hpp"
#include "launch/archive.hpp"
@@ -283,6 +284,23 @@ int main() {
const auto classic_zip = root / "classic.obw";
obw::write(classic, classic_zip, false);
check(obw::read(classic_zip) == classic, "binary Classic ZIP round trip");
auto sealed=classic;
const auto identity=content::seal(sealed);
const auto runtime_zip=root/"runtime.obw";
content::write_archive(sealed,runtime_zip);
const auto runtime=content::open(runtime_zip);
check(runtime->content_id==identity&&runtime->database.squad_list==db.squad_list,
"sealed native runtime reconstructs typed database without the source codec");
auto changed_title=sealed;
auto changed_manifest=cli::parse_json(changed_title.at("manifest.json"));
(*changed_manifest.object())["generator"]="new importer version";
(*changed_manifest.object())["title"]=J::Object{{"default","Renamed title"}};
changed_title["manifest.json"]=cli::dump_json(changed_manifest)+"\n";
obw::refresh_classic_inventory(changed_title);
check(content::seal(changed_title)==identity,"reimport identity ignores presentation title and generator version");
auto edited=sealed;edited.at("x-classic/desktop-seed.bin")[0]^=1;
obw::refresh_classic_inventory(edited);
rejects([&]{content::verify(edited);},"refreshing old CRC inventory cannot bypass the Classic seal");
auto damaged = classic;
damaged.at("x-classic/desktop-seed.bin")[0] ^= 1;
rejects([&] { obw::validate(damaged); }, "inventory catches binary corruption");
+1 -1
View File
@@ -22,7 +22,7 @@ class PackageAllowlistTests(unittest.TestCase):
with tempfile.TemporaryDirectory() as directory:
root = Path(directory)
# Empty authored placeholders test names/structure, not executable behavior.
for name in ['openbmh_play', 'openbmh_cli', 'openbmh_import', 'README.md', 'LICENSE',
for name in ['OpenBMH', 'openbmh_cli', 'openbmh_import', 'README.md', 'LICENSE',
'THIRD_PARTY_NOTICES.md', 'ACKNOWLEDGEMENTS.md', 'CONTRIBUTING.md']:
(root / name).write_text('synthetic')
notes = root / 'docs/release/0.1/RELEASE_NOTES.md'