(by Codex) Fix seller transfer review and fresh-arrival contract flags

This commit is contained in:
Codex committed 2026-11-01 17:57:55 +01:00
1 parent d57b6b5a96
commit 8baf80564a
19 files changed
+461 -28

No files matched your search

+74
View File
@@ -0,0 +1,74 @@
// SPDX-License-Identifier: GPL-3.0-only
#include <array>
#include <cstdint>
#include <iostream>
#include <stdexcept>
#include "formats/executable_layout.hpp"
#include "game/desk_actions.hpp"
#include "game/month.hpp"
#include "game/national.hpp"
#include "game/weekly.hpp"
using namespace bmh;
namespace {
void require(bool value, const char* message) { if (!value) throw std::runtime_error(message); }
GameState fixture() {
GameState g;
g.manager_teams = {0}; g.manager_records.resize(5 * 0xb0c);
g.tactics.resize(5 * 0x840); g.squad_slots.resize(3072, 0xfff);
g.squad_slots[0] = 0x8000;
g.players = {{"Arrival", 70u << 7 | 70u << 14 | 70u, 0, 6u << 21 | 1u}};
g.memory.add_block(layout::EditorList, 44 * 0x58);
for (uint32_t entry = 0; entry < 44; ++entry)
for (uint32_t bid = 0; bid < 4; ++bid)
g.memory.set16(layout::EditorList + entry * 0x58 + bid * 2, 0xffff);
return g;
}
void fresh_arrivals() {
const auto base = fixture();
for (uint8_t inherited : {0x00, 0x20, 0x40, 0x60, 0x80, 0xff}) {
for (uint8_t tenure : {0, 127, 255}) {
auto g = base;
g.tactics[0xb] = inherited; g.tactics[0x11] = tenure;
WatcomRandom actual(713), reference(713);
auto clean = base;
new_board_entry(clean, 0, 0, 0, reference);
new_board_entry(g, 0, 0, 0, actual);
require(g.tactics == clean.tactics, "new arrival inherits no previous contract flags or tenure");
require(actual.calls() == reference.calls() && actual.seed() == reference.seed(), "flag fix consumes no extra RNG");
require(g.tactics[0xc] == 24 && g.tactics[0xb] == 0, "arrival gets ordinary two-year initial term and clean negotiation flags");
g.tactics[0xd] = 105;
const auto demands = contract_demands(g, 0, 0, true, actual);
for (const auto amount : demands)
require(amount != UINT32_MAX && amount > 0, "young arrival can negotiate every supported term immediately");
}
}
auto retired = base;
retired.tactics[0xb] = 0x20; retired.tactics[0xc] = 24; retired.tactics[0xd] = 100;
WatcomRandom rand(713);
for (const auto demand : contract_demands(retired, 0, 0, true, rand))
require(demand == UINT32_MAX, "existing player's genuine retirement decision remains effective");
}
void ordinary_list_guards() {
auto g = fixture();
for (size_t n = 0; n < 40; ++n) g.squad_slots[0xb70 + n] = 1;
WatcomRandom rand(713); MinuteReport report;
const auto full = list_manager_player(g, 0, 0, rand, report);
require(full.status == TransferActionStatus::blocked_by_board && !report.unsupported && rand.calls() == 0,
"full ordinary market refuses without taking reserved entries or RNG");
require(g.squad_slots[0xb70 + 40] == 0xfff, "special offer rows are preserved");
g.squad_slots[0xb70] = 0;
const auto listed = list_manager_player(g, 0, 0, rand, report);
require(listed.status == TransferActionStatus::pending && !report.unsupported && rand.calls() == 0,
"already listed is an explicit inert outcome");
const auto native = g.squad_slots;
const auto rejected = accept_manager_transfer_offer(g, 1, 0, 0, 0, rand, report);
require(rejected.status == TransferActionStatus::invalid_request && g.squad_slots == native && rand.calls() == 0,
"unowned listing cannot be settled through seller action");
}
}
int main() try {
fresh_arrivals(); ordinary_list_guards();
std::cout << "PASS fresh-arrival contract flags, tenure boundaries and ordinary listing guards\n";
return 0;
} catch (const std::exception& error) { std::cerr << error.what() << '\n'; return 1; }
+123
View File
@@ -0,0 +1,123 @@
// SPDX-License-Identifier: GPL-3.0-only
#include <cstdio>
#include <filesystem>
#include <stdexcept>
#include "app/career_session.hpp"
#include "app/window_actions.hpp"
#include "game/save.hpp"
#include "ui/incoming_transfer.hpp"
using namespace bmh;
namespace {
void require(bool ok, const char* message) { if (!ok) throw std::runtime_error(message); }
struct Snapshot {
Bytes native; GameRandom game; WatcomRandom rand; uint64_t revision;
Snapshot(app::CareerSession& s, uint64_t r) : native(save_stream(s.state())), game(s.game()), rand(s.rand()), revision(r) {}
bool same(app::CareerSession& s, uint64_t r) const {
return native == save_stream(s.state()) && revision == r && game.seed() == s.game().seed() &&
game.calls() == s.game().calls() && rand.seed() == s.rand().seed() && rand.calls() == s.rand().calls();
}
};
ui::IncomingTransferDecisionState panel(const GameState& state, const TransferOfferListView& offers) {
ui::IncomingTransferDecisionView view;
view.valid = offers.valid; view.list_entry = offers.list_entry; view.player = offers.player;
view.seller = offers.seller; view.seller_manager = offers.seller_manager; view.viewer_manager = offers.seller_manager;
view.asking_fee = offers.asking_fee; view.asking_monthly_salary = offers.asking_monthly_salary;
for (size_t n = 0; n < 4; ++n) {
const auto& source = offers.offers[n]; auto& row = view.offers[n];
row.bid_index = source.bid_index; row.buyer = source.buyer; row.buyer_manager = source.buyer_manager;
row.present = source.present; row.eligible = source.eligible; row.transaction_supported = source.transaction_supported;
row.fee = source.fee; row.monthly_salary = source.monthly_salary; row.contract_months = source.contract_months;
row.fee_reference = source.fee_reference; row.salary_reference = source.salary_reference;
row.loan = source.loan; row.bonuses = source.bonuses;
}
return ui::incoming_transfer_decision_from_game(state, view);
}
}
int main(int argc, char** argv) try {
if (argc != 3 && argc != 4) return 2;
const std::filesystem::path data = argv[1];
app::CareerSession session(data, 37, argv[2]); uint64_t revision = 1;
const auto base = session.state(); const auto manager = base.memory.u8(layout::ActiveManager);
const auto range = squad_range(base.manager_teams.at(manager));
int entry = -1, player = -1, chosen = -1;
// Produce offers through real listing/bid routines on the supplied career.
// No bidder/amount/term/table bytes are fabricated for this integration test.
for (size_t row = 0; row < range.count && chosen < 0; ++row) {
if ((base.squad_slots[range.first + row] & 0xfff) == 0xfff) continue;
auto listed = base; auto w = session.rand(); auto game = session.game(); MinuteReport listing_report;
const auto listing = list_manager_player(listed, manager, int(row), w, listing_report);
if (listing.status != TransferActionStatus::accepted || listing_report.unsupported) continue;
for (int attempt = 0; attempt < 4 && chosen < 0; ++attempt) {
MinuteReport report;
transfer_bid(listed, 0xb70 + listing.list_entry,
layout::EditorList + uint32_t(listing.list_entry) * 0x58, false, -1, game, w, report);
if (report.unsupported) break;
const auto offers = project_transfer_offer_list(listed, listing.list_entry);
for (const auto& offer : offers.offers) {
if (!offer.present || offer.loan || !offer.eligible) continue;
auto expected = listed; auto expected_rand = w; MinuteReport expected_report;
const auto result = accept_manager_transfer_offer(expected, manager, listing.list_entry,
listing.player, offer.bid_index, expected_rand, expected_report);
if (result.status != TransferActionStatus::accepted || expected_report.unsupported) continue;
session.state() = listed; session.game() = game; session.rand() = w;
chosen = offer.bid_index; entry = listing.list_entry; player = listing.player; break;
}
}
}
require(chosen >= 0, "supplied career produces a natural eligible seller offer");
if (argc == 4) {
std::string save_error;
require(session.save_game(argv[3], 0, false, save_error), "natural offer evidence saves through the session writer");
}
const auto before = Snapshot(session, revision);
ui::TransferMarketRequest request;
request.kind = ui::TransferMarketRequestKind::review_offers;
request.manager_slot = manager; request.runtime_club = session.state().manager_teams[manager];
request.revision = revision; request.bid.manager = manager; request.bid.list_entry = entry;
request.bid.source_slot = 0xb70 + entry; request.bid.player = player;
std::string error; int presentations = 0;
auto choose = [&](const GameState& state, const TransferOfferListView& offers) {
++presentations; ui::IncomingTransferScreen screen(data, panel(state, offers));
require(screen.render().width == 320, "actual incoming modal renders natural offer rows");
const auto selected = screen.click(10, 150 + chosen * 17);
require(selected && *selected == chosen, "actual incoming row input returns its raw bidder identity");
return *selected;
};
auto cancel = [&](const GameState& state, const TransferOfferListView& offers) {
ui::IncomingTransferScreen screen(data, panel(state, offers));
const auto answer = screen.click(200, 100, true);
require(answer && *answer == -1, "actual incoming modal right click cancels early review"); return *answer;
};
const auto canceled = app::TransferActions(session).market(request, {}, revision, error,
app::HumanBuyerMarketEntryPolicy::normal_interactive, {}, cancel);
if (!canceled) std::fprintf(stderr, "early cancel rejected: %s\n", error.c_str());
require(canceled && !canceled->changed && before.same(session, revision), "early cancel preserves complete state and both RNGs");
for (int malformed = 0; malformed < 3; ++malformed) {
auto stale = request;
if (malformed == 0) ++stale.bid.player;
if (malformed == 1) --stale.revision;
if (malformed == 2) ++stale.bid.source_slot;
require(!app::TransferActions(session).market(stale, {}, revision, error,
app::HumanBuyerMarketEntryPolicy::normal_interactive, {}, choose) &&
before.same(session, revision) && presentations == 0, "stale review rejects before presenter and mutation");
}
bool rolled_back = false;
try {
(void)app::TransferActions(session).market(request, {}, revision, error,
app::HumanBuyerMarketEntryPolicy::normal_interactive,
[](const app::TransferActions::MarketDispatch&) { throw std::runtime_error("interrupted acknowledgement"); }, choose);
} catch (const std::runtime_error&) { rolled_back = true; }
require(rolled_back && before.same(session, revision), "interrupted acknowledgement rolls back seller transfer and RNG");
const auto accepted = app::TransferActions(session).market(request, {}, revision, error,
app::HumanBuyerMarketEntryPolicy::normal_interactive, {}, choose);
require(accepted && accepted->changed && accepted->action.status == TransferActionStatus::accepted &&
revision == before.revision + 1 && (session.state().squad_slots.at(size_t(0xb70 + entry)) & 0xfff) == 0xfff,
"qualified natural offer settles exactly once through shared session transaction");
const Snapshot settled(session, revision);
require(!app::TransferActions(session).market(request, {}, revision, error,
app::HumanBuyerMarketEntryPolicy::normal_interactive, {}, choose) && settled.same(session, revision),
"replaying accepted seller request is inert");
std::printf("PASS natural seller offer: player=%d entry=%d raw_bid=%d; real modal cancel/accept, stale guards, acknowledgement rollback\n", player, entry, chosen);
return 0;
} catch (const std::exception& error) { std::fprintf(stderr, "%s\n", error.what()); return 1; }