183 lines
12 KiB
C++
183 lines
12 KiB
C++
// SPDX-License-Identifier: GPL-3.0-only
|
|
#include "formats/executable_layout.hpp"
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <iostream>
|
|
#include <stdexcept>
|
|
|
|
#include "app/career_session.hpp"
|
|
#include "game/save.hpp"
|
|
|
|
using namespace bmh;
|
|
namespace {
|
|
void check(bool ok, const char* why) { if (!ok) throw std::runtime_error(why); }
|
|
|
|
struct Snapshot {
|
|
Bytes native;
|
|
uint32_t game_seed, rand_seed;
|
|
uint64_t game_calls, rand_calls, revision;
|
|
Snapshot(app::CareerSession& session, uint64_t rev)
|
|
: native(save_stream(session.state())), game_seed(session.game().seed()),
|
|
rand_seed(session.rand().seed()), game_calls(session.game().calls()),
|
|
rand_calls(session.rand().calls()), revision(rev) {}
|
|
bool random_unchanged(app::CareerSession& session) const {
|
|
return game_seed == session.game().seed() && rand_seed == session.rand().seed() &&
|
|
game_calls == session.game().calls() && rand_calls == session.rand().calls();
|
|
}
|
|
bool unchanged(app::CareerSession& session, uint64_t rev) const {
|
|
return native == save_stream(session.state()) && random_unchanged(session) && revision == rev;
|
|
}
|
|
};
|
|
|
|
ui::SettingsWriteRequest write_for(const ui::SettingsState& state, uint8_t column) {
|
|
return {state.manager_slot, state.revision, state.cells, 0, column, ui::SettingsEdit::toggle_binary};
|
|
}
|
|
|
|
void rejected(app::CareerSession& session, ui::SettingsWriteRequest request, uint64_t& revision) {
|
|
const Snapshot before(session, revision);
|
|
std::string error;
|
|
check(!session.dispatch_settings(request, revision, error) && !error.empty(),
|
|
"unavailable or stale sound action is rejected with a reason");
|
|
check(before.unchanged(session, revision), "rejected sound action preserves Native, both RNGs and revision");
|
|
}
|
|
|
|
void toggle(app::CareerSession& session, const std::filesystem::path& data,
|
|
uint8_t column, uint64_t& revision) {
|
|
const auto state = session.settings_projection(int(session.state().memory.u8(::bmh::layout::ActiveManager)), revision);
|
|
const Snapshot before(session, revision);
|
|
ui::SettingsScreen screen(data, state);
|
|
check(screen.click(70 + column * 24, 27) && screen.pending(), "real A6/A7 UI click creates a request");
|
|
check(before.unchanged(session, revision), "projection, rendering and input do not write Native");
|
|
auto expected = session.state();
|
|
const uint32_t address = ::bmh::layout::LeaguePresentationOptionsUnsigned + column;
|
|
expected.memory.set8(address, uint8_t((expected.memory.u8(address) & 0x7f) ^ 1));
|
|
std::string error;
|
|
check(session.dispatch_settings(*screen.pending(), revision, error), "supported sound UI request toggles");
|
|
check(save_stream(session.state()) == save_stream(expected) && revision == before.revision + 1 &&
|
|
before.random_unchanged(session), "deliberate sound toggle writes only the addressed Native byte and one revision");
|
|
screen.acknowledge(session.settings_projection(state.manager_slot, revision));
|
|
check(!screen.pending() && screen.state().cells[size_t(column)] == expected.memory.u8(address),
|
|
"UI acknowledgement displays the actual committed sound value");
|
|
}
|
|
}
|
|
|
|
int main(int argc, char** argv) try {
|
|
check(argc == 3, "usage: sound_settings_app_tests <data> <genuine two-manager FBM>");
|
|
const std::filesystem::path data(argv[1]);
|
|
app::CareerSession session(data, 8128, argv[2]);
|
|
check(session.state().manager_teams == std::vector<int>({1, 54}), "unchanged genuine two-manager Native fixture");
|
|
uint64_t revision = 17;
|
|
const int manager = session.state().memory.u8(::bmh::layout::ActiveManager);
|
|
const Snapshot native_input(session, revision);
|
|
const auto headless = session.settings_projection(manager, revision);
|
|
check(!headless.audio_config_known && headless.display_cells, "headless Session retains unknown capability state");
|
|
for (uint8_t column : {uint8_t(5), uint8_t(6)}) {
|
|
check(headless.cells[column] == session.state().memory.u8(::bmh::layout::LeaguePresentationOptionsUnsigned + column) &&
|
|
(*headless.display_cells)[column] == headless.cells[column],
|
|
"headless projection preserves saved A6/A7 value and lock bits exactly");
|
|
rejected(session, write_for(headless, column), revision);
|
|
}
|
|
check(native_input.unchanged(session, revision), "unknown sound projection and rejected toggles preserve entire genuine Native");
|
|
for (uint8_t value : {uint8_t(0), uint8_t(1), uint8_t(0x80), uint8_t(0x81)}) {
|
|
session.state().memory.set8(::bmh::layout::Audio_OriginalAudioOptions_ExecutableField, value);
|
|
session.state().memory.set8(::bmh::layout::Audio_OriginalAudioOptions_ExecutableField2, value);
|
|
const Snapshot before(session, revision);
|
|
const auto unknown = session.settings_projection(manager, revision);
|
|
check(!unknown.audio_config_known && (*unknown.display_cells)[5] == value &&
|
|
(*unknown.display_cells)[6] == value, "unknown host preserves both locked and unlocked saved sound bytes");
|
|
rejected(session, write_for(unknown, 5), revision);
|
|
rejected(session, write_for(unknown, 6), revision);
|
|
check(before.unchanged(session, revision), "unknown host cannot toggle even an unlocked zero/one sound cell");
|
|
}
|
|
|
|
// Explicit controlled byte variants exercise portable capabilities over old
|
|
// SOUND.CFG locks. These are regression controls, not natural career saves.
|
|
for (bool music : {false, true}) for (bool effects : {false, true}) {
|
|
session.state().memory.set8(::bmh::layout::Audio_OriginalAudioOptions_ExecutableField, 0x80);
|
|
session.state().memory.set8(::bmh::layout::Audio_OriginalAudioOptions_ExecutableField2, 0x81);
|
|
const Snapshot before(session, revision);
|
|
session.configure_sound_capabilities(music, effects);
|
|
const auto state = session.settings_projection(manager, revision);
|
|
ui::SettingsScreen screen(data, state);
|
|
(void)screen.render();
|
|
check(state.audio_config_known && state.display_cells && state.cells[5] == 0x80 && state.cells[6] == 0x81,
|
|
"known capability projection retains raw old lock bytes");
|
|
check((*state.display_cells)[5] == (music ? 0 : 0x80) &&
|
|
(*state.display_cells)[6] == (effects ? 1 : 0x81),
|
|
"independent runtime music/effects capabilities determine A6/A7 display locks");
|
|
check(before.unchanged(session, revision), "configuring capabilities and projecting/rendering writes no Native or RNG state");
|
|
for (uint8_t column : {uint8_t(5), uint8_t(6)}) {
|
|
if (column == 5 ? music : effects) {
|
|
toggle(session, data, column, revision);
|
|
toggle(session, data, column, revision);
|
|
check(session.state().memory.u8(::bmh::layout::LeaguePresentationOptionsUnsigned + column) == (column == 5 ? 0 : 1),
|
|
"two deliberate toggles restore logical value and clear only stale sound lock");
|
|
} else {
|
|
rejected(session, write_for(session.settings_projection(manager, revision), column), revision);
|
|
check(session.state().memory.u8(::bmh::layout::LeaguePresentationOptionsUnsigned + column) == (column == 5 ? 0x80 : 0x81),
|
|
"unsupported sound channel preserves saved lock and logical value");
|
|
}
|
|
}
|
|
}
|
|
|
|
session.configure_sound_capabilities(true, true);
|
|
for (uint8_t invalid : {uint8_t(2), uint8_t(0x82), uint8_t(0x40), uint8_t(0xc1)}) {
|
|
for (uint8_t column : {uint8_t(5), uint8_t(6)}) {
|
|
session.state().memory.set8(::bmh::layout::LeaguePresentationOptionsUnsigned + column, invalid);
|
|
rejected(session, write_for(session.settings_projection(manager, revision), column), revision);
|
|
}
|
|
}
|
|
session.state().memory.set8(::bmh::layout::Audio_OriginalAudioOptions_ExecutableField, 0);
|
|
session.state().memory.set8(::bmh::layout::Audio_OriginalAudioOptions_ExecutableField2, 1);
|
|
const auto state = session.settings_projection(manager, revision);
|
|
auto bad = write_for(state, 5); --bad.revision; rejected(session, bad, revision);
|
|
bad = write_for(state, 5); bad.manager_slot = (manager + 1) % 2; rejected(session, bad, revision);
|
|
bad = write_for(state, 5); bad.expected_raw[6] ^= 1; rejected(session, bad, revision);
|
|
bad = write_for(state, 5); bad.operation = ui::SettingsEdit::increment; rejected(session, bad, revision);
|
|
const auto stale = write_for(state, 6);
|
|
toggle(session, data, 5, revision);
|
|
rejected(session, stale, revision);
|
|
|
|
// Check the normal owned desktop menu, whose write/ACK projection must also
|
|
// carry the configured host capabilities through both sound toggles.
|
|
const auto desk = session.desktop_projection(revision);
|
|
const auto item = std::find_if(desk.items.begin(), desk.items.end(),
|
|
[](const auto& i) { return i.kind == 19 && !i.disabled; });
|
|
check(item != desk.items.end(), "genuine manager desk exposes the settings menu");
|
|
std::string error;
|
|
const Snapshot before_open(session, revision);
|
|
const std::array<uint8_t, 2> saved_sound{session.state().memory.u8(::bmh::layout::Audio_OriginalAudioOptions_ExecutableField), session.state().memory.u8(::bmh::layout::Audio_OriginalAudioOptions_ExecutableField2)};
|
|
auto opened = session.open_desk_settings(ui::DeskRequest{ui::DeskRequestKind::open_menu,
|
|
desk.manager_slot, item->id, 19, -1, revision}, revision, error);
|
|
check(opened && opened->state.audio_config_known &&
|
|
session.state().memory.u8(::bmh::layout::Audio_OriginalAudioOptions_ExecutableField) == saved_sound[0] && session.state().memory.u8(::bmh::layout::Audio_OriginalAudioOptions_ExecutableField2) == saved_sound[1] &&
|
|
before_open.random_unchanged(session), "desktop settings entry retains capabilities without rewriting sound bytes or drawing RNG");
|
|
for (uint8_t column : {uint8_t(4), uint8_t(5), uint8_t(6)}) {
|
|
const Snapshot before(session, revision);
|
|
ui::SettingsScreen screen(data, opened->state);
|
|
check(screen.click(70 + column * 24, 27) && screen.pending(), "owned menu sound click creates request");
|
|
auto expected = session.state();
|
|
expected.memory.set8(::bmh::layout::LeaguePresentationOptionsUnsigned + column, uint8_t((expected.memory.u8(::bmh::layout::LeaguePresentationOptionsUnsigned + column) & 0x7f) ^ 1));
|
|
auto changed = session.dispatch_desk_settings(app::CareerSession::DeskSettingsAction{
|
|
app::CareerSession::DeskSettingsWrite{opened->owner.sequence, *screen.pending()}}, revision, error);
|
|
check(changed && !changed->closed && changed->state.audio_config_known &&
|
|
save_stream(session.state()) == save_stream(expected) && revision == before.revision + 1 &&
|
|
before.random_unchanged(session), "owned desktop sound toggle changes only its Native byte and revision");
|
|
screen.acknowledge(changed->state);
|
|
opened->owner = changed->owner;
|
|
opened->state = changed->state;
|
|
}
|
|
const Snapshot before_close(session, revision);
|
|
const std::array<uint8_t, 2> changed_sound{session.state().memory.u8(::bmh::layout::Audio_OriginalAudioOptions_ExecutableField), session.state().memory.u8(::bmh::layout::Audio_OriginalAudioOptions_ExecutableField2)};
|
|
auto closed = session.dispatch_desk_settings(app::CareerSession::DeskSettingsAction{
|
|
app::CareerSession::DeskSettingsClose{opened->owner}}, revision, error);
|
|
check(closed && closed->closed && closed->state.audio_config_known &&
|
|
session.state().memory.u8(::bmh::layout::Audio_OriginalAudioOptions_ExecutableField) == changed_sound[0] && session.state().memory.u8(::bmh::layout::Audio_OriginalAudioOptions_ExecutableField2) == changed_sound[1] &&
|
|
before_close.random_unchanged(session), "normal settings close retains capabilities without additional sound writes or RNG draws");
|
|
std::cout << "Sound settings Session/UI tests passed\n";
|
|
return 0;
|
|
} catch (const std::exception& error) {
|
|
std::cerr << "sound_settings_app_tests: " << error.what() << '\n';
|
|
return 1;
|
|
}
|