Files
Dreierpack-Manager/tests/weekly_human_buyer_loan_tests.cpp

195 lines
11 KiB
C++

// SPDX-License-Identifier: GPL-3.0-only
#include "formats/executable_layout.hpp"
#include <cstdio>
#include <filesystem>
#include <stdexcept>
#include <string>
#include "formats/fbm.hpp"
#include "formats/savestate.hpp"
#include "formats/textd.hpp"
#include "game/desk_actions.hpp"
#include "game/save.hpp"
#include "game/transfer_allocator.hpp"
#include "game/weekly.hpp"
using namespace bmh;
namespace {
void check(bool value, const char* why) { if (!value) throw std::runtime_error(why); }
void write32(std::vector<uint8_t>& bytes, size_t at, uint32_t value) {
for (size_t n = 0; n < 4; ++n) bytes.at(at + n) = uint8_t(value >> (n * 8));
}
uint32_t read32(const std::vector<uint8_t>& bytes, size_t at) {
uint32_t value = 0;
for (size_t n = 0; n < 4; ++n) value |= uint32_t(bytes.at(at + n)) << (n * 8);
return value;
}
uint32_t expected_market_fee(const GameState& g, int buyer_manager, int player, uint32_t fee) {
const size_t rec = size_t(buyer_manager) * 0xb0c;
const uint8_t subsidy = g.manager_records.at(rec + 0x170);
const int position = int(g.players.at(size_t(player)).w364 & 3);
if (fee > read32(g.manager_records, rec + 0x314) || subsidy == 0 || (subsidy & 3) != position)
return fee;
int league = g.manager_records.at(rec + 0x210);
if (league > 2) --league;
const uint32_t threshold = (((uint32_t(subsidy) >> 2) & 7u) * 50000u + 150000u) * uint32_t(4 - league);
if (fee >= threshold) return fee;
const uint32_t discount = (((uint32_t(subsidy) >> 5) + 3u) * fee * 10u) / 100u;
return fee - discount;
}
bool contains(const GameState& g, int team, int player) {
const auto range = squad_range(team);
for (size_t n = 0; n < range.count; ++n)
if ((g.squad_slots.at(range.first + n) & 0x0fff) == player) return true;
return false;
}
struct WeekCase { GameState game; int entry = -1; int player = -1; };
WeekCase make_week_case(const TextDb& texts, const GameState& original, bool full_buyer = false, bool loan = true) {
auto g = original;
WatcomRandom listing_w(37);
MinuteReport listing_report;
const auto listed = list_manager_player(g, 0, 5, listing_w, listing_report);
check(listed.status == TransferActionStatus::accepted && !listing_report.unsupported,
"build ordinary human-seller week-list entry through source listing primitive");
const int buyer = g.manager_teams.at(1);
if (full_buyer) {
const auto range = squad_range(buyer);
for (size_t n = 0; n < range.count; ++n)
if (g.squad_slots.at(range.first + n) == 0x0fff)
g.squad_slots.at(range.first + n) = 0xffff;
}
const uint32_t list = ::bmh::layout::EditorList + uint32_t(listed.list_entry) * 0x58;
g.memory.set16(list, uint16_t(buyer));
g.memory.set32(list + 0x1c, 250000);
g.memory.set32(list + 0x0c, 70000);
g.memory.set8(list + 0x34, loan ? 0x8c : 12); // 12-month loan or ordinary 12-month purchase
for (uint32_t n = 0; n < 7; ++n) g.memory.set8(list + 0x38 + n, uint8_t(n + 3));
g.memory.set8(list + 0x56, 1); // accepted and settled on this week's countdown
g.memory.set8(::bmh::layout::ActiveManager, 1); // current owner is the human buyer
g.level = 1;
write32(g.manager_records, 0xb0c + 0x314, 10000000);
write32(g.manager_records, 0xb0c + 0x31c, 0);
g.transfer_offer_selector = [](const GameState&, const TransferOfferListView& view) {
return view.offers[0].present ? 0 : -1;
};
g.texts = &texts;
return {std::move(g), listed.list_entry, listed.player};
}
void run_case(const TextDb& texts, const GameState& original, TransferAllocatorContext gate,
bool full_buyer = false) {
auto prepared = make_week_case(texts, original, full_buyer);
auto& g = prepared.game;
const int entry = prepared.entry;
const int player = prepared.player;
const uint32_t starting_balance = read32(g.manager_records, 0xb0c + 0x314);
const uint32_t offer = ::bmh::layout::EditorList + uint32_t(entry) * 0x58;
GameRandom game(73);
WatcomRandom rand(0x13579);
MinuteReport report;
transfer_list_countdown(g, game, rand, report, false, gate);
check(!report.unsupported, "general legacy routine path reaches shared loan settlement");
bool in_buyer = false;
const int buyer = g.manager_teams.at(1);
const auto buyer_range = squad_range(buyer);
for (size_t n = 0; n < buyer_range.count; ++n)
if ((g.squad_slots.at(buyer_range.first + n) & 0x0fff) == player) in_buyer = true;
if (gate == TransferAllocatorContext::zero) {
int loan = -1;
for (int n = 0; n < 200; ++n)
if (g.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField + uint32_t(n) * 4) != 0 &&
int(g.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField + uint32_t(n) * 4) & 0x0fff) == player) { loan = n; break; }
check(in_buyer && loan >= 0 && g.memory.u8(::bmh::layout::ClubPlayerDetail_InvalidArgument_RuntimeField + uint32_t(loan)) == 12,
"zero allocator books buyer board and loan return record");
} else {
bool ledger_written = false;
for (int n = 0; n < 200; ++n)
if (g.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField + uint32_t(n) * 4) != 0 &&
int(g.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField + uint32_t(n) * 4) & 0x0fff) == player) ledger_written = true;
check(!in_buyer && !ledger_written && contains(g, g.manager_teams.at(0), player),
"blocked allocator charges before allocation but leaves seller squad and loan ledger untouched");
if (full_buyer)
check(read32(g.manager_records, 0xb0c + 0x314) < starting_balance,
"full human buyer is charged before the Source allocator-block result");
}
check(g.squad_slots.at(0xb70 + size_t(entry)) == 0x0fff && g.memory.u16(offer) == 0xffff,
"weekly countdown completes and clears accepted list entry");
}
void run_ordinary_case(const TextDb& texts, const GameState& original, TransferAllocatorContext gate,
bool full_buyer = false) {
auto prepared = make_week_case(texts, original, full_buyer, false);
auto& g = prepared.game;
const int entry = prepared.entry;
const int player = prepared.player;
const size_t buyer_record = 0xb0c;
const size_t seller_record = 0;
const uint32_t buyer_start = read32(g.manager_records, buyer_record + 0x314);
const uint32_t seller_start = read32(g.manager_records, seller_record + 0x314);
const uint32_t buyer_transfer_sum = read32(g.manager_records, buyer_record + 0x330);
const uint32_t seller_transfer_sum = read32(g.manager_records, seller_record + 0x330);
const uint32_t offer = ::bmh::layout::EditorList + uint32_t(entry) * 0x58;
const uint32_t expected_fee = expected_market_fee(g, 1, player, g.memory.u32(offer + 0x1c));
GameRandom game(73);
WatcomRandom rand(0x13579);
MinuteReport report;
transfer_list_countdown(g, game, rand, report, false, gate);
check(!report.unsupported, "ordinary human-buyer purchase reaches shared legacy routine/legacy routine settlement");
const int buyer = g.manager_teams.at(1);
const auto buyer_range = squad_range(buyer);
size_t buyer_row = buyer_range.count;
for (size_t n = 0; n < buyer_range.count; ++n)
if ((g.squad_slots.at(buyer_range.first + n) & 0x0fff) == player) buyer_row = n;
const bool in_buyer = buyer_row < buyer_range.count;
const size_t board = size_t(1) * 0x840 + buyer_row * 0x58;
bool loan_written = false;
for (int n = 0; n < 200; ++n)
if (g.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField + uint32_t(n) * 4) != 0 &&
int(g.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField + uint32_t(n) * 4) & 0x0fff) == player) loan_written = true;
if (gate == TransferAllocatorContext::zero) {
check(in_buyer, "zero allocator moves ordinary purchase into buyer squad");
check(!loan_written, "ordinary purchase does not write loan return ledger");
check(g.tactics.at(board + 0x0c) == 12, "ordinary purchase stores its contract term on buyer board");
check(uint32_t(buyer_start - read32(g.manager_records, buyer_record + 0x314)) == expected_fee &&
uint32_t(read32(g.manager_records, seller_record + 0x314) - seller_start) == expected_fee,
"successful purchase books exactly one source-adjusted buyer debit and seller credit");
check(uint32_t(read32(g.manager_records, buyer_record + 0x330) - buyer_transfer_sum) == expected_fee &&
uint32_t(seller_transfer_sum - read32(g.manager_records, seller_record + 0x330)) == expected_fee,
"successful purchase updates each transfer total exactly once");
} else {
check(!in_buyer && !loan_written && contains(g, g.manager_teams.at(0), player),
"blocked allocator leaves ordinary purchase ownership and loan ledger unchanged");
check(uint32_t(buyer_start - read32(g.manager_records, buyer_record + 0x314)) == expected_fee &&
uint32_t(read32(g.manager_records, seller_record + 0x314) - seller_start) == expected_fee,
"blocked allocation retains exactly one source-adjusted buyer debit and seller credit");
check(uint32_t(read32(g.manager_records, buyer_record + 0x330) - buyer_transfer_sum) == expected_fee &&
uint32_t(seller_transfer_sum - read32(g.manager_records, seller_record + 0x330)) == expected_fee,
"blocked allocation updates each transfer total exactly once");
}
check(g.squad_slots.at(0xb70 + size_t(entry)) == 0x0fff &&
g.memory.u16(::bmh::layout::EditorList + uint32_t(entry) * 0x58) == 0xffff,
"weekly countdown completes and clears settled ordinary purchase");
}
}
int main(int argc, char** argv) try {
check(argc == 3, "usage: weekly_human_buyer_loan_tests DATA_DIR 2PNWK001.FBM");
if (!*argv[1]) { std::puts("weekly human buyer loan: skipped (Original data not configured)"); return 77; }
auto texts = load_textd(std::filesystem::path(argv[1]) / "TEXTD.BLK");
const auto fbm = load_savegame(argv[2]);
auto original = GameState::from_save(SaveState(fbm.stream)); original.texts = &texts;
check(original.manager_teams.size() == 2 && original.manager_teams[0] == 1 &&
original.manager_teams[1] == 54, "genuine 2PNWK001 human manager identities");
run_case(texts, original, TransferAllocatorContext::zero);
run_case(texts, original, TransferAllocatorContext::blocked);
run_case(texts, original, TransferAllocatorContext::blocked, true);
run_ordinary_case(texts, original, TransferAllocatorContext::zero);
run_ordinary_case(texts, original, TransferAllocatorContext::blocked);
run_ordinary_case(texts, original, TransferAllocatorContext::blocked, true);
std::puts("PASS ordinary weekly human-buyer purchases and loans with zero/blocked allocator context");
return 0;
} catch (const std::exception& e) {
std::fprintf(stderr, "weekly_human_buyer_loan_tests: %s\n", e.what()); return 1;
}