Prepare release packages / build (push) Blocked by required conditions
Build without game data / build (linux-x64, ubuntu-24.04) (push) Waiting to run
Build without game data / build (macos-arm64, macos-14) (push) Waiting to run
Build without game data / build (windows-x64, windows-2022) (push) Waiting to run
475 lines
32 KiB
C++
475 lines
32 KiB
C++
// SPDX-License-Identifier: GPL-3.0-only
|
|
#include "formats/executable_layout.hpp"
|
|
#include "ui/advertising.hpp"
|
|
#include "ui/source_notice_test_helpers.hpp"
|
|
|
|
#include <array>
|
|
#include <filesystem>
|
|
#include <functional>
|
|
#include <iostream>
|
|
#include <stdexcept>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include "app/career_session.hpp"
|
|
#include "formats/textd.hpp"
|
|
#include "game/messages.hpp"
|
|
#include "game/state.hpp"
|
|
#include "ui/manager.hpp"
|
|
#include "ui/setup.hpp"
|
|
|
|
using namespace bmh;
|
|
using namespace bmh::ui;
|
|
|
|
namespace {
|
|
void check(bool ok, const char* message) {
|
|
if (!ok) throw std::runtime_error(message);
|
|
}
|
|
void rejected(const std::function<void()>& action) {
|
|
try { action(); } catch (const FormatError&) { return; }
|
|
throw std::runtime_error("expected invalid advertising projection rejection");
|
|
}
|
|
void put32(std::vector<uint8_t>& bytes, size_t at, uint32_t value) {
|
|
for (int i = 0; i < 4; ++i) bytes.at(at + size_t(i)) = uint8_t(value >> (8 * i));
|
|
}
|
|
void set_contract(GameState& game, int slot, uint32_t amount, uint8_t months,
|
|
uint8_t flags, uint8_t sponsor) {
|
|
const size_t at = 0xa34 + size_t(slot) * 0xc;
|
|
put32(game.manager_records, at, amount);
|
|
game.manager_records.at(at + 5) = months;
|
|
game.manager_records.at(at + 6) = flags;
|
|
game.manager_records.at(at + 7) = sponsor;
|
|
}
|
|
void set_offer(GameState& game, int group, int raw_slot, uint32_t amount,
|
|
uint8_t bundle, uint8_t months, uint8_t sponsor) {
|
|
const size_t at = 0x8cc + size_t(group) * 0x78 + size_t(raw_slot) * 0x0c;
|
|
put32(game.manager_records, at, amount);
|
|
game.manager_records.at(at + 4) = bundle;
|
|
game.manager_records.at(at + 5) = months;
|
|
game.manager_records.at(at + 7) = sponsor;
|
|
}
|
|
}
|
|
|
|
int main(int argc, char** argv) {
|
|
try {
|
|
if (argc != 2) throw std::runtime_error("usage: ui_advertising_tests <BMH data>");
|
|
const std::filesystem::path data(argv[1]);
|
|
app::CareerSession session(data, 9941);
|
|
SetupOptions options;
|
|
ManagerChoice choice;
|
|
choice.name = "SIM";
|
|
choice.master_club = 0;
|
|
choice.strength = 2;
|
|
std::string error;
|
|
check(session.confirm_manager(options, choice, error), "engine manager setup failed");
|
|
CareerInitializationResult initialized;
|
|
check(session.finish(initialized, error), "engine career initialization failed");
|
|
GameState game = session.state();
|
|
check(game.manager_records.size() >= 0xb0c && game.manager_teams.size() == 1,
|
|
"initialized manager record is available");
|
|
|
|
set_contract(game, 0, 25000, 12, 0, 0);
|
|
set_contract(game, 1, 8000, 7, 0x80, 1);
|
|
set_contract(game, 14, 5000, 10, 0x03, 2);
|
|
set_contract(game, 15, 12000, 11, 0x80, 3);
|
|
const auto records_before = game.manager_records;
|
|
const auto state = advertising_from_game(game, 0);
|
|
check(state.boards.size() == 14 && state.boards[0].record_slot == 0 &&
|
|
state.boards[0].monthly_amount == 25000 && state.boards[0].sponsor_id == 0 &&
|
|
state.boards[0].amount_text == original_to_utf8(format_number(game, 25000, 0x108)),
|
|
"the source ordering keeps regular active board deals ahead of options");
|
|
check(state.boards[1].record_slot == 1 && state.boards[1].option_marker &&
|
|
state.boards[1].months_remaining == 7,
|
|
"board contract flags and remaining months are projected without reinterpretation");
|
|
check(state.shirt.record_slot == 14 && state.shirt.monthly_amount == 5000 &&
|
|
state.shirt.extension_months == 3 && state.television.record_slot == 15 &&
|
|
state.television.monthly_amount == 12000,
|
|
"shirt and TV contract groups use the two source-supported extra surface records");
|
|
check(state.boards[0].sponsor_name == original_to_utf8(message_text(game, ::bmh::layout::Advertising_FormatError_ExecutableField3)) &&
|
|
state.television.sponsor_name == original_to_utf8(message_text(game, ::bmh::layout::Advertising_FormatError_ExecutableField3 + 13 * 4)),
|
|
"sponsor labels resolve through the matching TEXTD pointer table");
|
|
check(game.manager_records == records_before,
|
|
"projection reads advertising fields without changing the game record");
|
|
check(state.finance_preview.balance == state.finance_preview.income - state.finance_preview.expenses,
|
|
"the owned financial preview follows the exact Original income-minus-expenses relationship");
|
|
check(state.finance_preview.income_text == original_to_utf8(
|
|
format_number(game, state.finance_preview.income, 0x88) + " EU.") &&
|
|
state.finance_preview.expenses_text == original_to_utf8(
|
|
format_number(game, state.finance_preview.expenses, 0x88) + " EU.") &&
|
|
state.finance_preview.balance_text == original_to_utf8(
|
|
format_number(game, state.finance_preview.balance, 0x88) + " EU."),
|
|
"finance display strings use the Original 0x188 formatter and format field suffix");
|
|
|
|
// Controlled source fixture: zero all finance/ownership inputs, leave the
|
|
// 14 always-charged facility costs, and one 1,234 EU advertising contract.
|
|
GameState finance_fixture = game;
|
|
const size_t rec = 0;
|
|
for (int i = 0; i < 6; ++i) finance_fixture.manager_records[size_t(i)] = 0;
|
|
for (int i = 0x3c; i < 0x44; ++i) finance_fixture.manager_records[size_t(i)] = 0;
|
|
for (int i = 0; i < 16; ++i) put32(finance_fixture.manager_records, 0xa34 + size_t(i) * 0xc, 0);
|
|
put32(finance_fixture.manager_records, rec + 0x314, 0);
|
|
put32(finance_fixture.manager_records, rec + 0x318, 0);
|
|
put32(finance_fixture.manager_records, rec + 0x31c, 0);
|
|
put32(finance_fixture.manager_records, rec + 0x854, 0);
|
|
put32(finance_fixture.manager_records, rec + 0x858, 0);
|
|
put32(finance_fixture.manager_records, rec + 0x880, 0);
|
|
finance_fixture.manager_records.at(rec + 0x179) = 0;
|
|
put32(finance_fixture.manager_records, rec + 0x290, uint32_t(game.manager_teams[0]));
|
|
set_contract(finance_fixture, 0, 1234, 1, 0, 0);
|
|
for (size_t slot = 0; slot < 24; ++slot)
|
|
finance_fixture.tactics[slot * 0x58 + 0x3d] = 0xff;
|
|
finance_fixture.memory.set8(::bmh::layout::ManagerCount, 1);
|
|
for (int i = 0; i < 6; ++i) {
|
|
finance_fixture.memory.set32(::bmh::layout::FundBlock + uint32_t(i) * 0x1c, 0);
|
|
finance_fixture.memory.set16(::bmh::layout::Advertising_OriginalShareAdjustment_RuntimeField + uint32_t(i) * 0x1c, 0);
|
|
finance_fixture.memory.set32(::bmh::layout::Spending + uint32_t(i) * 4, 0);
|
|
}
|
|
for (uint32_t at = ::bmh::layout::Loans; at < ::bmh::layout::FixtureAdvertisingWorkspaceEnd; ++at)
|
|
if (finance_fixture.memory.has(at)) finance_fixture.memory.set8(at, 0);
|
|
const auto finance_record_before = finance_fixture.manager_records;
|
|
const auto finance_tactics_before = finance_fixture.tactics;
|
|
auto finance_memory = [](const GameState& value) {
|
|
std::vector<uint8_t> bytes;
|
|
for (const auto [first, last] : {std::pair<uint32_t,uint32_t>{::bmh::layout::FundBlock,::bmh::layout::FixtureAdvertisingRatingsEnd},
|
|
{::bmh::layout::Spending,::bmh::layout::FixtureAdvertisingCountersEnd}, {::bmh::layout::Loans,::bmh::layout::FixtureAdvertisingWorkspaceEnd}})
|
|
for (uint32_t address = first; address < last; ++address)
|
|
if (value.memory.has(address)) bytes.push_back(value.memory.u8(address));
|
|
return bytes;
|
|
};
|
|
const auto finance_memory_before = finance_memory(finance_fixture);
|
|
const auto preview = advertising_from_game(finance_fixture, 0).finance_preview;
|
|
check(preview.income == 1234 && preview.expenses == 43400 && preview.balance == -42166,
|
|
"a controlled fixture matches Original contract income, fixed facility costs, and negative balance");
|
|
check(finance_fixture.manager_records == finance_record_before &&
|
|
finance_fixture.tactics == finance_tactics_before && finance_fixture.date == game.date &&
|
|
finance_memory(finance_fixture) == finance_memory_before,
|
|
"the financial projection is readonly across records, board, date, and source cost/share blocks");
|
|
GameState shares_fixture = finance_fixture;
|
|
shares_fixture.memory.set32(::bmh::layout::FundBlock, 10000);
|
|
shares_fixture.memory.set16(::bmh::layout::Advertising_OriginalShareAdjustment_RuntimeField, 2);
|
|
check(advertising_from_game(shares_fixture, 0).finance_preview.income == 1264,
|
|
"share income uses the saved share count and the Original 1.5-EU unit factor");
|
|
GameState multi_share_fixture = finance_fixture;
|
|
multi_share_fixture.memory.set32(::bmh::layout::FundBlock, 10000);
|
|
multi_share_fixture.memory.set16(::bmh::layout::Advertising_OriginalShareAdjustment_RuntimeField, 2); // 15 EU * 2
|
|
multi_share_fixture.memory.set32(::bmh::layout::FundBlock + 0x1c, 20000);
|
|
multi_share_fixture.memory.set16(::bmh::layout::Advertising_OriginalShareAdjustment_RuntimeField + 0x1c, 3); // 36 EU * 3
|
|
multi_share_fixture.memory.set32(::bmh::layout::FundBlock + 5 * 0x1c, 10000);
|
|
multi_share_fixture.memory.set16(::bmh::layout::Advertising_OriginalShareAdjustment_RuntimeField + 5 * 0x1c, 2); // 30 EU * 2
|
|
check(advertising_from_game(multi_share_fixture, 0).finance_preview.income == 1432,
|
|
"all six legacy routine rows use their 0x1c-byte record stride");
|
|
GameState interest_fixture = shares_fixture;
|
|
interest_fixture.date = 0; // July; source day table factor 31.
|
|
put32(interest_fixture.manager_records, 0x314, 3650000);
|
|
check(advertising_from_game(interest_fixture, 0).finance_preview.income == 4364,
|
|
"the Original param-0 balance interest is projected with the current month-length factor");
|
|
GameState cap_fixture = finance_fixture;
|
|
cap_fixture.memory.set32(::bmh::layout::Spending + 4, 99);
|
|
cap_fixture.memory.set32(::bmh::layout::Spending, 111);
|
|
cap_fixture.memory.set32(::bmh::layout::Spending + 8, 222);
|
|
check(advertising_from_game(cap_fixture, 0).finance_preview.expenses == 43832,
|
|
"all three youth budgets enter the monthly finance preview");
|
|
put32(cap_fixture.manager_records, 0x880, 1500000);
|
|
const auto no_cap_preview = advertising_from_game(cap_fixture, 0).finance_preview;
|
|
check(no_cap_preview.expenses == 43832,
|
|
"ordinary monthly youth budgets continue after the former academy threshold");
|
|
GameState ignored_cost_fixture = finance_fixture;
|
|
ignored_cost_fixture.memory.set32(::bmh::layout::Spending, 111);
|
|
ignored_cost_fixture.memory.set32(::bmh::layout::Spending + 8, 222);
|
|
check(advertising_from_game(ignored_cost_fixture, 0).finance_preview.expenses == 43733,
|
|
"the youngest and oldest youth budgets both enter expenses");
|
|
GameState loan_fixture = finance_fixture;
|
|
loan_fixture.memory.set32(::bmh::layout::Loans + 8, 100);
|
|
const auto loan_preview = advertising_from_game(loan_fixture, 0).finance_preview;
|
|
check(loan_preview.expenses == 43500,
|
|
"the Original preview adds the outstanding-share repayment to expenses");
|
|
GameState min_loan_fixture = finance_fixture;
|
|
min_loan_fixture.memory.set32(::bmh::layout::Loans + 8, 0x80000000u);
|
|
check(advertising_from_game(min_loan_fixture, 0).finance_preview.expenses == 0,
|
|
"share repayment negation wraps definedly at INT_MIN before the Original zero clamp");
|
|
GameState min_finance_fixture = finance_fixture;
|
|
put32(min_finance_fixture.manager_records, 0x314, 0x80000000u);
|
|
put32(min_finance_fixture.manager_records, 0x318, 0x80000000u);
|
|
put32(min_finance_fixture.manager_records, 0x31c, 0x80000000u);
|
|
(void)advertising_from_game(min_finance_fixture, 0);
|
|
const auto preview_json = advertising_state_json(advertising_from_game(finance_fixture, 0));
|
|
check(preview_json.find("\"finance_preview\":{\"income\":1234,\"expenses\":43400,\"balance\":-42166") != std::string::npos &&
|
|
preview_json.find("\"income_text\":") != std::string::npos,
|
|
"the owned UI report exposes original preview totals without creating actions");
|
|
GameState invalid_manager_count = finance_fixture;
|
|
invalid_manager_count.memory.set8(::bmh::layout::ManagerCount, 5);
|
|
rejected([&] { (void)advertising_from_game(invalid_manager_count, 0); });
|
|
|
|
// Independent wrap example: 1234 * INT_MAX wraps to -1234, then /2.
|
|
GameState currency_fixture = finance_fixture;
|
|
currency_fixture.memory.add_block(::bmh::layout::CurrencyMultiplier, 8);
|
|
currency_fixture.memory.set32(::bmh::layout::CurrencyMultiplier, 0x7fffffffu);
|
|
currency_fixture.memory.set32(::bmh::layout::CurrencyDivisor, 2);
|
|
put32(currency_fixture.manager_records, 0x854, 4);
|
|
const auto currency_state = advertising_from_game(currency_fixture, 0);
|
|
check(currency_state.finance_preview.income_text ==
|
|
original_to_utf8(format_number(currency_fixture, -617, 0x88) + " EU.") &&
|
|
currency_state.boards[0].amount_text ==
|
|
original_to_utf8(format_number(currency_fixture, -617, 0x08) + " EU") &&
|
|
currency_state.auxiliary_text[1] ==
|
|
original_to_utf8(format_number(currency_fixture, -2, 0x81) + " EU."),
|
|
"currency conversion preserves Original signed wrap in totals, contracts and spending bars");
|
|
currency_fixture.memory.set32(::bmh::layout::CurrencyDivisor, 0);
|
|
rejected([&] { (void)advertising_from_game(currency_fixture, 0); });
|
|
currency_fixture.memory.set32(::bmh::layout::CurrencyMultiplier, 0x80000000u);
|
|
currency_fixture.memory.set32(::bmh::layout::CurrencyDivisor, 0xffffffffu);
|
|
set_contract(currency_fixture, 0, 1235, 1, 0, 0);
|
|
rejected([&] { (void)advertising_from_game(currency_fixture, 0); });
|
|
|
|
GameState tied = game;
|
|
for (int slot = 0; slot < 14; ++slot)
|
|
set_contract(tied, slot, 25000, 12, 0, uint8_t(slot % 10));
|
|
const auto tied_records = tied.manager_records;
|
|
const auto tied_state = advertising_from_game(tied, 0);
|
|
constexpr std::array<int, 14> source_tie_order{9, 7, 8, 12, 13, 10, 11,
|
|
2, 0, 1, 5, 6, 3, 4};
|
|
for (size_t i = 0; i < source_tie_order.size(); ++i)
|
|
check(tied_state.boards[i].record_slot == source_tie_order[i],
|
|
"equal keys follow the Original midpoint-partition swap order");
|
|
check(tied.manager_records == tied_records,
|
|
"Original ordering rearranges only the owned projection, not manager records");
|
|
|
|
auto invalid_manager = [&] { (void)advertising_from_game(game, -1); };
|
|
rejected(invalid_manager);
|
|
GameState invalid = game;
|
|
invalid.manager_records[0xa34 + 7] = 0xff;
|
|
rejected([&] { (void)advertising_from_game(invalid, 0); });
|
|
|
|
AdvertisingScreen screen(data, state);
|
|
auto duplicate = state;
|
|
duplicate.boards[1].record_slot = duplicate.boards[0].record_slot;
|
|
rejected([&] { AdvertisingScreen invalid(data, duplicate); });
|
|
auto corrupt = state;
|
|
corrupt.shirt.sponsor_id = 10;
|
|
rejected([&] { AdvertisingScreen invalid(data, corrupt); });
|
|
corrupt = state;
|
|
corrupt.television.record_slot = 14;
|
|
rejected([&] { AdvertisingScreen invalid(data, corrupt); });
|
|
auto invalid_text = state;
|
|
invalid_text.finance_labels[0] = std::string(1, char(0xff));
|
|
rejected([&] { AdvertisingScreen bad(data, invalid_text); });
|
|
invalid_text = state;
|
|
invalid_text.finance_preview.income_text = std::string(1, char(0xff));
|
|
rejected([&] { AdvertisingScreen bad(data, invalid_text); });
|
|
invalid_text = state;
|
|
invalid_text.auxiliary_text[1] = std::string(1, char(0xff));
|
|
rejected([&] { AdvertisingScreen bad(data, invalid_text); });
|
|
const auto first = screen.render();
|
|
check(first.width == 320 && first.height == 240 && first.pixels == screen.render().pixels,
|
|
"original-asset advertising view renders deterministically at native resolution");
|
|
const auto exe = load_le(asset_path(data, "BMH.exe"));
|
|
const auto art = load_vga(asset_path(data / "KB", "4.VGA"));
|
|
const auto logos = load_vga(asset_path(data / "KB", "34.VGA"));
|
|
auto pixel = [](const Image& image, int x, int y) { return image.pixels[size_t(y) * image.width + x]; };
|
|
check(pixel(first, 0, 19) == pixel(art, 0, 0x90),
|
|
"the upper sponsor-board strip is cropped from KB/4 at legacy routine coordinates");
|
|
auto plain_state = state;
|
|
plain_state.decorated_background = false;
|
|
AdvertisingScreen plain(data, plain_state);
|
|
const auto plain_image = plain.render();
|
|
check(pixel(plain_image, 0, 4) == 0x44 && pixel(plain_image, 1, 5) == 0x39 &&
|
|
pixel(plain_image, 0, 228) == 0x44 && pixel(plain_image, 1, 229) == 0x39 &&
|
|
pixel(plain_image, 319, 239) == 0,
|
|
"plain_background uses the Original plain header/footer instead of KB129");
|
|
for (int y = 0; y < 22; ++y)
|
|
for (int x = 0; x < 32; ++x)
|
|
check(pixel(first, exe.u16(::bmh::layout::Advertising_Click_RuntimeField3) + x, exe.u16(::bmh::layout::Advertising_Click_RuntimeField4) + y) ==
|
|
pixel(logos, x, y),
|
|
"active board logos use the original KB/34 partner sprite and hitbox coordinates");
|
|
check(screen.click(exe.u16(::bmh::layout::Advertising_Click_RuntimeField3) + 1, exe.u16(::bmh::layout::Advertising_Click_RuntimeField4) + 1) &&
|
|
screen.selected_contract() == 0,
|
|
"a board click selects a local read-only details panel");
|
|
const auto selected_json = screen.state_json();
|
|
check(selected_json.find("\"selected_contract\":0") != std::string::npos &&
|
|
selected_json.find(state.club_name) != std::string::npos,
|
|
"owned screen state retains selection and UTF-8 club text");
|
|
check(!screen.click(319, 239) && screen.selected_contract() == 0,
|
|
"unsupported areas do not create an action request or clear the local selection");
|
|
if (screen.offer_open()) {
|
|
check(screen.key("ESC") && !screen.close_requested() && !screen.offer_open() &&
|
|
screen.key("ESC") && screen.close_requested() && !screen.key("LEFT"),
|
|
"ESC closes an existing offer browser before the screen");
|
|
} else {
|
|
check(screen.key("ESC") && screen.close_requested() && !screen.key("LEFT"),
|
|
"without a saved offer, ESC closes the contract details directly");
|
|
}
|
|
|
|
// Existing saved offer pool: raw slot 5 is the highest amount, but an
|
|
// empty lower raw slot remains an explicit stop when paging backward.
|
|
GameState offer_game = game;
|
|
for (size_t i = 0; i < 10 * 0x0c; ++i) offer_game.manager_records[0x8cc + i] = 0;
|
|
set_offer(offer_game, 0, 0, 8000, 1, 24, 1);
|
|
set_offer(offer_game, 0, 5, 10904, 1, 24, 2);
|
|
const auto offer_records_before = offer_game.manager_records;
|
|
const auto offer_state = advertising_from_game(offer_game, 0, 41);
|
|
check(offer_state.offers[0].offers.size() == 10 &&
|
|
offer_state.offers[0].offers[5].present &&
|
|
offer_state.offers[0].offers[5].monthly_amount == 10904 &&
|
|
offer_state.offers[0].offers[5].can_accept,
|
|
"the owned view projects a saved raw-pool offer without generating one");
|
|
check(offer_game.manager_records == offer_records_before,
|
|
"offer projection leaves manager contracts and raw pool bytes unchanged");
|
|
AdvertisingScreen offers(data, offer_state, 0x200000001ULL);
|
|
const bool opened = offers.open_offers(0);
|
|
check(opened && offers.offer_open() && offers.selected_offer() == 5,
|
|
"opening the source offer browser selects the highest saved raw offer");
|
|
check(offers.click(140, 164) && offers.selected_offer() == 4 &&
|
|
!offers.click(190, 195) && !offers.pending(),
|
|
"an empty raw slot cannot create an acceptance request");
|
|
check(offers.click(140, 164) && offers.selected_offer() == 3,
|
|
"raw-slot browsing steps across empty rows without skipping them");
|
|
check(offers.click(140, 180) && offers.selected_offer() == 4 &&
|
|
offers.click(140, 180) && offers.selected_offer() == 5,
|
|
"the opposite source control returns through the same raw slots");
|
|
for (int i = 0; i < 5; ++i) check(offers.click(140, 164), "page raw slot toward zero");
|
|
check(offers.selected_offer() == 0 && !offers.click(140, 164) && offers.selected_offer() == 0,
|
|
"raw-slot navigation does not underflow below slot zero");
|
|
for (int i = 0; i < 5; ++i) check(offers.click(140, 180), "restore selected raw slot");
|
|
check(offers.selected_offer() == 5, "selected raw slot is restored before submission");
|
|
check(offers.click(190, 195) && offers.pending().has_value(),
|
|
"accept creates a request envelope rather than mutating GameState");
|
|
const auto request = *offers.pending();
|
|
check(request.request_id == 0x200000001ULL && request.manager_slot == 0 &&
|
|
request.runtime_club == offer_state.runtime_team_id && request.revision == 41 &&
|
|
request.offer.manager == 0 && request.offer.display_slot == 0 &&
|
|
request.offer.contract_slot == offer_state.offers[0].contract_slot &&
|
|
request.offer.raw_slot == 5 &&
|
|
request.offer.expected_contract == offer_state.offers[0].contract_bytes &&
|
|
request.offer.expected_offer == offer_state.offers[0].offers[5].bytes,
|
|
"request binds manager, revision, visible/physical row, raw slot and full byte identities");
|
|
check(offer_game.manager_records == offer_records_before && !offers.click(190, 195),
|
|
"pending request cannot be replayed by clicking and has no engine-side write");
|
|
check(offers.reject_action("veraltete Ansicht") && !offers.pending() &&
|
|
offers.state_json().find("veraltete Ansicht") != std::string::npos,
|
|
"controller rejection clears the pending request and exposes owned feedback");
|
|
check(offers.click(110, 195) && !offers.offer_open() && offers.key("ESC") &&
|
|
offers.close_requested(),
|
|
"cancel closes the offer browser first; a second ESC closes the screen");
|
|
|
|
// The three source spending controls open the original calculator. All
|
|
// editing remains local; only J/Enter on a changed value creates a
|
|
// manager/revision-bound request for the app controller.
|
|
GameState spending_game = game;
|
|
put32(spending_game.manager_records, 0x850, 0);
|
|
put32(spending_game.manager_records, 0x854, 10000);
|
|
put32(spending_game.manager_records, 0x858, 15000);
|
|
spending_game.manager_records.at(0x287) = 0;
|
|
const auto spending_records = spending_game.manager_records;
|
|
const auto spending_state = advertising_from_game(spending_game, 0, 73);
|
|
check(spending_state.spending[0].target_slot == 16 && spending_state.spending[0].available &&
|
|
spending_state.spending[0].maximum_amount == 350000 &&
|
|
spending_state.spending[1].target_slot == 17 && spending_state.spending[1].current_amount == 10000 &&
|
|
spending_state.spending[1].maximum_amount == 35000 &&
|
|
spending_state.spending[2].current_amount == 15000,
|
|
"the three read-only spend projections use the source record values and limits");
|
|
check(spending_state.notification_ack_label == original_to_utf8(message_text(spending_game, ::bmh::layout::Advertising_FormatError_TextPointer17)),
|
|
"the Original manager modal button label resolves from its actual EXE text pointer");
|
|
AdvertisingScreen merchandise(data, spending_state, 0x300000001ULL);
|
|
const int merchandise_x = exe.u16(::bmh::layout::Advertising_Click_RuntimeField3 + 16 * 2) + 1;
|
|
const int merchandise_y = exe.u16(::bmh::layout::Advertising_Click_RuntimeField4 + 16 * 2) + 1;
|
|
check(merchandise.click(merchandise_x, merchandise_y) && merchandise.spending_calculator_open() &&
|
|
merchandise.selected_spending_slot() == 16 && merchandise.spending_input() == 0,
|
|
"the original merchandise hitbox opens its calculator with the saved value");
|
|
const auto calculator_art = load_vga(asset_path(data / "KB", "6.VGA"));
|
|
const auto calculator_image = merchandise.render();
|
|
check(calculator_image.pixels[size_t(55) * 320 + 103] == calculator_art.pixels[0],
|
|
"the calculator opens over the original advertising screen using KB/6 at source coordinates");
|
|
check(merchandise.text("200000") && merchandise.spending_input() == 200000 &&
|
|
merchandise.key("ENTER") && merchandise.pending().has_value(),
|
|
"calculator text entry and Enter create one merchandise request");
|
|
const auto spend_request = *merchandise.pending();
|
|
check(spend_request.kind == AdvertisingActionKind::set_spending &&
|
|
spend_request.request_id == 0x300000001ULL && spend_request.manager_slot == 0 &&
|
|
spend_request.runtime_club == spending_state.runtime_team_id && spend_request.revision == 73 &&
|
|
spend_request.spending.manager == 0 && spend_request.spending.target_slot == 16 &&
|
|
spend_request.spending.amount == 200000 && spend_request.spending.expected_amount == 0 &&
|
|
spend_request.spending.expected_delivery_weeks == 0,
|
|
"merchandise request carries manager, revision, target, chosen amount and stale guards");
|
|
check(spending_game.manager_records == spending_records &&
|
|
!merchandise.text("1") && !merchandise.key("ESC") &&
|
|
!merchandise.click(merchandise_x, merchandise_y),
|
|
"editing/request display is read-only and a pending request cannot be changed or replayed");
|
|
check(merchandise.reject_action("veraltete Ansicht") && !merchandise.pending() &&
|
|
!merchandise.spending_calculator_open(),
|
|
"a controller rejection clears the request and dismisses the calculator");
|
|
|
|
AdvertisingScreen clamped_input(data, spending_state);
|
|
check(clamped_input.click(merchandise_x, merchandise_y) && clamped_input.text("9999999") &&
|
|
clamped_input.spending_input() == 350000 && clamped_input.key("SPACE") &&
|
|
clamped_input.spending_input() == 0 && clamped_input.key("ESC") && !clamped_input.pending(),
|
|
"typed digits clamp at the source maximum and SPACE clears the calculator without booking");
|
|
|
|
AdvertisingScreen unchanged_budget(data, spending_state, 0x300000010ULL);
|
|
const int budget_x = exe.u16(::bmh::layout::Advertising_Click_RuntimeField3 + 17 * 2) + 1;
|
|
const int budget_y = exe.u16(::bmh::layout::Advertising_Click_RuntimeField4 + 17 * 2) + 1;
|
|
check(unchanged_budget.click(budget_x, budget_y) && unchanged_budget.spending_calculator_open() &&
|
|
unchanged_budget.spending_input() == 10000 && unchanged_budget.key("J") &&
|
|
!unchanged_budget.pending() && !unchanged_budget.spending_calculator_open(),
|
|
"accepting an unchanged monthly budget closes locally without an engine request");
|
|
|
|
AdvertisingScreen preset_budget(data, spending_state, 0x300000018ULL);
|
|
const int preset0_x = 103 + exe.u16(::bmh::layout::Advertising_Click_RuntimeField + 15 * 2);
|
|
const int preset0_y = 55 + exe.u8(::bmh::layout::Advertising_Click_RuntimeField2 + 15);
|
|
check(preset_budget.click(budget_x, budget_y) &&
|
|
preset_budget.click(preset0_x + 2, preset0_y + 2) &&
|
|
preset_budget.spending_input() == 5000 && preset_budget.key("J") &&
|
|
preset_budget.pending() && preset_budget.pending()->spending.amount == 5000 &&
|
|
preset_budget.pending()->spending.expected_amount == 10000,
|
|
"the first monthly-budget preset uses the original executable hitbox and value");
|
|
|
|
AdvertisingScreen clear_budget(data, spending_state, 0x300000020ULL);
|
|
check(clear_budget.click(budget_x, budget_y) && clear_budget.key("C") &&
|
|
clear_budget.spending_input() == 0 && clear_budget.key("J") && clear_budget.pending() &&
|
|
clear_budget.pending()->spending.target_slot == 17 && clear_budget.pending()->spending.amount == 0 &&
|
|
clear_budget.pending()->spending.expected_amount == 10000,
|
|
"clearing a monthly budget creates a request bound to the previous amount");
|
|
|
|
AdvertisingScreen empty_merchandise(data, spending_state, 0x300000030ULL);
|
|
check(empty_merchandise.click(merchandise_x, merchandise_y) && empty_merchandise.key("C") &&
|
|
empty_merchandise.key("J") && !empty_merchandise.pending() &&
|
|
!empty_merchandise.spending_calculator_open(),
|
|
"zero merchandise spending is a local no-op and does not ask the engine to purchase");
|
|
|
|
GameState delivery_pending = spending_game;
|
|
delivery_pending.manager_records.at(0x287) = 3;
|
|
const auto blocked_state = advertising_from_game(delivery_pending, 0, 74);
|
|
check(!blocked_state.spending[0].available && blocked_state.spending[0].delivery_weeks == 3,
|
|
"a saved delivery countdown makes the merchandise target unavailable");
|
|
AdvertisingScreen blocked_merchandise(data, blocked_state);
|
|
check(blocked_merchandise.click(merchandise_x, merchandise_y) &&
|
|
blocked_merchandise.notification_open() && !blocked_merchandise.spending_calculator_open() &&
|
|
blocked_merchandise.state_json().find(blocked_state.spending_blocked_text) != std::string::npos &&
|
|
blocked_merchandise.click(10, 10) && !blocked_merchandise.notification_open() &&
|
|
!blocked_merchandise.close_requested(),
|
|
"a blocked delivery shows the owned source warning and dismisses without closing the desk");
|
|
AdvertisingScreen timed_merchandise(data,blocked_state);
|
|
check(timed_merchandise.click(merchandise_x,merchandise_y)&&timed_merchandise.timed_notice_open(),
|
|
"delivery warning uses Source timed mode");
|
|
bmh::ui::test::expect_notice_symbols(timed_merchandise.render(),load_vga(asset_path(data/"KB","0.VGA")));
|
|
check(timed_merchandise.expire_timed_notice()&&!timed_merchandise.notification_open()&&
|
|
!timed_merchandise.pending()&&!timed_merchandise.close_requested(),"timed delivery notice expires locally");
|
|
GameState malformed_budget = spending_game;
|
|
put32(malformed_budget.manager_records, 0x854, 36000);
|
|
const auto malformed_budget_state = advertising_from_game(malformed_budget, 0, 75);
|
|
AdvertisingScreen invalid_budget(data, malformed_budget_state);
|
|
check(malformed_budget_state.spending[1].available &&
|
|
malformed_budget_state.spending[1].current_amount == 36000,
|
|
"a legacy monthly value above the new maximum remains available to the source calculator");
|
|
check(invalid_budget.click(budget_x, budget_y) && invalid_budget.spending_calculator_open() &&
|
|
invalid_budget.spending_input() == 35000 && invalid_budget.key("J") &&
|
|
invalid_budget.pending() && invalid_budget.pending()->spending.amount == 35000 &&
|
|
invalid_budget.pending()->spending.expected_amount == 36000,
|
|
"the calculator's maximum clamps a legacy value and binds its old value in the request");
|
|
std::cout << "Advertising projection, request binding and source offer navigation passed.\n";
|
|
return 0;
|
|
} catch (const std::exception& e) {
|
|
std::cerr << e.what() << '\n';
|
|
return 1;
|
|
}
|
|
}
|