124 lines
8.1 KiB
C++
124 lines
8.1 KiB
C++
// 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; }
|