229 lines
12 KiB
C++
229 lines
12 KiB
C++
// SPDX-License-Identifier: GPL-3.0-only
|
|
#include "app/career_session.hpp"
|
|
#include "app/controller.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 "audio/original.hpp"
|
|
#include <algorithm>
|
|
#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.start_year = 1994;
|
|
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);
|
|
openbmh::audio::OriginalAssets sound;
|
|
for (size_t i = 0; i < 4; ++i)
|
|
sound.containers[i] = read_file(mount.root() / "S" / std::to_string(2000 + i));
|
|
for (size_t i = 0; i < 96; ++i)
|
|
sound.tables.frequencies[i] =
|
|
content->executable.u16(layout::Audio_OriginalAudioAssets_RuntimeField2 + uint32_t(i) * 2);
|
|
for (size_t i = 0; i < 9; ++i)
|
|
sound.tables.operators[i] =
|
|
content->executable.u8(layout::Audio_OriginalAudioAssets_RuntimeField + uint32_t(i) * 16);
|
|
openbmh::audio::OriginalSynth synth;
|
|
std::string sound_error;
|
|
check(synth.load(std::move(sound), 22050, sound_error), sound_error);
|
|
|
|
// 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);
|
|
auto legacy_directory = resolved.check.directory;
|
|
if (!fs::exists(legacy_directory / "BMH.exe")) {
|
|
// The legacy oracle uses fixed filename casing. Only its private test
|
|
// copy needs aliases on case-sensitive filesystems; OBW does not.
|
|
const auto aliases = root / "legacy-case-reference";
|
|
fs::create_directory(aliases);
|
|
for (const char *name : {"BMH.exe", "M3D.MAN", "TEXTD.BLK", "M3.MEN", "M3.DAT"}) {
|
|
const auto source = launch::find_file(legacy_directory, name);
|
|
check(bool(source), "legacy reference file missing");
|
|
fs::copy_file(*source, aliases / name);
|
|
}
|
|
legacy_directory = aliases;
|
|
}
|
|
app::CareerSession old(legacy_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);
|
|
check(initial.desktop.date.year == 1994 && initial.desktop.date.weekday == 2,
|
|
"selected start year changes the year display while retaining the Classic Wednesday epoch");
|
|
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");
|
|
{
|
|
ui::StartupFlow flow(mount.root(), personal);
|
|
check(flow.click(215, 220).request == ui::FlowRequest::submenu_opened,
|
|
"GUI opens native load browser from setup");
|
|
const auto request = flow.send_key("ENTER");
|
|
check(request.request == ui::FlowRequest::file_action && request.file_action.path == save,
|
|
"GUI selects native save from personal directory");
|
|
std::unique_ptr<app::CareerSession> gui_session;
|
|
uint64_t gui_revision = 0;
|
|
openbmh::audio::Playback playback;
|
|
std::optional<uint64_t> audio_session;
|
|
check(app::serve_flow_request(flow, request, gui_session, mount.root(), personal, 999, gui_revision,
|
|
playback, audio_session, false)
|
|
.empty(),
|
|
"GUI controller accepts native save path");
|
|
check(gui_session && flow.screen_name() == "desktop" && gui_revision == 1,
|
|
"GUI controller attaches loaded native desktop: " + flow.state_json());
|
|
const auto save_item =
|
|
std::find_if(flow.desktop()->state().items.begin(), flow.desktop()->state().items.end(),
|
|
[](const ui::DeskItem &item) { return item.kind == 11 && !item.disabled; });
|
|
check(save_item != flow.desktop()->state().items.end(), "native desktop exposes Save");
|
|
const auto serve = [&](const ui::FlowResult &event) {
|
|
check(app::serve_flow_request(flow, event, gui_session, mount.root(), personal, 999, gui_revision,
|
|
playback, audio_session, false)
|
|
.empty(),
|
|
"native GUI file action dispatch");
|
|
};
|
|
serve(flow.click(save_item->x + save_item->width / 2, save_item->y + save_item->height / 2));
|
|
check(flow.screen_name() == "save_load" && flow.text("GUI Roundtrip"),
|
|
"native GUI Save accepts a new filename");
|
|
const auto gui_random = gui_session->rand();
|
|
serve(flow.send_key("ENTER"));
|
|
check(flow.screen_name() == "desktop" && fs::exists(personal / "GUI Roundtrip.obs"),
|
|
"native GUI Save publishes OBS and returns to desktop: " + flow.state_json());
|
|
check(gui_session->rand().seed() == gui_random.seed() &&
|
|
gui_session->rand().calls() == gui_random.calls(),
|
|
"GUI saving preserves random state");
|
|
}
|
|
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;
|
|
}
|