(by Codex) Fix seller transfer review and fresh-arrival contract flags
This commit is contained in:
1 parent
d57b6b5a96
commit
8baf80564a
19 files changed
+461
-28
No files matched your search
@@ -1165,3 +1165,12 @@ bmh_add_data_test(NAME desktop_feedback_tests COMMAND desktop_feedback_tests "${
|
||||
add_executable(daily_interest_unit_tests tests/daily_interest_unit_tests.cpp)
|
||||
target_link_libraries(daily_interest_unit_tests PRIVATE bmhcore)
|
||||
add_test(NAME daily_interest_unit_tests COMMAND daily_interest_unit_tests)
|
||||
add_executable(transfer_seller_actions_tests tests/transfer_seller_actions_tests.cpp)
|
||||
target_link_libraries(transfer_seller_actions_tests PRIVATE bmhcore)
|
||||
add_test(NAME transfer_seller_actions_tests COMMAND transfer_seller_actions_tests)
|
||||
|
||||
add_executable(transfer_seller_app_tests tests/transfer_seller_app_tests.cpp ${BMH_APP_SESSION_SDL_SOURCE})
|
||||
target_link_libraries(transfer_seller_app_tests PRIVATE bmhui openbmh_audio ${BMH_SDL_TARGET})
|
||||
set(BMH_TEST_TRANSFER_SELLER_APP_SAVE "" CACHE FILEPATH "External career for seller-offer integration; not distributed")
|
||||
bmh_add_data_test(NAME transfer_seller_app_tests REQUIRED_OPTIONS BMH_TEST_TRANSFER_SELLER_APP_SAVE
|
||||
COMMAND transfer_seller_app_tests "${BMH_DATA}" "${BMH_TEST_TRANSFER_SELLER_APP_SAVE}")
|
||||
@@ -139,6 +139,8 @@ This index includes registered and reserved names. `ListOptions` and `Help` from
|
||||
| `SetSquadSheet` | sheet:enum(A,B) | Set Squad Sheet. See current Help for behaviour and bounds. |
|
||||
| `SetMarketVisible` | on:bool | Set Market Visible. See current Help for behaviour and bounds. |
|
||||
| `ShowPlayer` | player:Player | Show Player. See current Help for behaviour and bounds. |
|
||||
| `ShowOffers` | player:Player | existing bids for an owned listing; raw bid slots 0..3 |
|
||||
| `AcceptOffer` | player:Player, bid:int(0..3) | accept an existing bid before weekly expiry |
|
||||
| `SellPlayer` | player:Player | VER-KAUFEN: put an own player on the list |
|
||||
| `LoanOutPlayer` | player:Player, months:int(12\|24) | VER-LEIHEN: offer an own player for loan |
|
||||
| `BuyPlayer` | player:Player | VER-KAUFEN on a market player: the offer editor |
|
||||
|
||||
@@ -76,3 +76,25 @@ preview uses the same calculation. Original rates, division order and random
|
||||
consumption remain unchanged. Account balances and accumulated statistics retain
|
||||
the native 32-bit save representation; this change does not add unlimited account
|
||||
balances or change the original high-cash deduction policy.
|
||||
OpenBMH deviates from the original: the legacy transfer market allows an owned
|
||||
listing to open incoming offers before its weekly expiry. Select the player and
|
||||
use the sale action (or Enter). Cancel keeps the listing and offers unchanged;
|
||||
acceptance uses the existing buyer eligibility, player salary qualification and
|
||||
transaction rules. Human-buyer loans still require their separate consent and
|
||||
allocator context and are unavailable in this early review. Viewing/canceling
|
||||
consumes no RNG. The weekly auction remains unchanged.
|
||||
|
||||
The transfer overview processes one selected player per action and renders action
|
||||
feedback in its footer. A cleared unsuccessful listing can be listed again
|
||||
immediately; there is no additional cooldown. The manager listing action refuses a full ordinary market
|
||||
without allocating a reserved special-offer row. These are explicit
|
||||
application outcomes instead of the Original's destructive overflow/dialog paths.
|
||||
|
||||
OpenBMH deviates from the original: a newly initialized squad board entry clears
|
||||
retirement, refused-negotiation and month-processing flags left by its previous
|
||||
occupant. The Original leaves that byte intact when reusing the row, so purchases
|
||||
and academy arrivals can inherit a refusal to renew. Existing players' genuine
|
||||
retirement/refusal flags remain effective. The initial academy contract remains
|
||||
two years; a young arrival can immediately negotiate any supported renewal term.
|
||||
This corrects the reused-row mechanism; it does not establish a fixed 200–300
|
||||
season threshold or repair ambiguous refusal flags in existing saved careers.
|
||||
@@ -3985,7 +3985,8 @@ std::optional<CareerSession::TransferMarketPreviewDispatch> CareerSession::previ
|
||||
|
||||
std::optional<TransferActionResult> CareerSession::dispatch_transfer_market(
|
||||
const ui::TransferMarketRequest& request, const HumanBuyerSaleHooks& presenters,
|
||||
uint64_t& revision, std::string& error) {
|
||||
uint64_t& revision, std::string& error,
|
||||
const std::function<int(const GameState&, const TransferOfferListView&)>& review) {
|
||||
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
|
||||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return std::nullopt; }
|
||||
error.clear();
|
||||
@@ -3998,7 +3999,18 @@ std::optional<TransferActionResult> CareerSession::dispatch_transfer_market(
|
||||
error = "transfer market: stale or nested request";
|
||||
return std::nullopt;
|
||||
}
|
||||
if (request.kind == ui::TransferMarketRequestKind::submit_bid) {
|
||||
if (request.kind == ui::TransferMarketRequestKind::review_offers) {
|
||||
if (!review || request.bid.manager != request.manager_slot || request.bid.list_entry < 0 ||
|
||||
request.bid.list_entry >= 40 || request.bid.source_slot != 0xb70 + request.bid.list_entry ||
|
||||
request.squad_row != -1 || !request.selected_players.empty()) {
|
||||
error = "transfer market: invalid offer review"; return std::nullopt;
|
||||
}
|
||||
const auto view = project_transfer_offer_list(g_, request.bid.list_entry);
|
||||
if (!view.valid || view.player != request.bid.player || view.seller != request.runtime_club ||
|
||||
view.seller_manager != request.manager_slot) {
|
||||
error = "transfer market: stale seller listing"; return std::nullopt;
|
||||
}
|
||||
} else if (request.kind == ui::TransferMarketRequestKind::submit_bid) {
|
||||
if (request.bid.manager != request.manager_slot || request.squad_row != -1 ||
|
||||
request.expected_player != -1 ||
|
||||
std::any_of(request.bid.bonuses.begin(), request.bid.bonuses.end(),
|
||||
@@ -4064,7 +4076,21 @@ std::optional<TransferActionResult> CareerSession::dispatch_transfer_market(
|
||||
try {
|
||||
const auto before = save_stream(g_);
|
||||
TransferActionResult result;
|
||||
if (request.kind == ui::TransferMarketRequestKind::list_player)
|
||||
if (request.kind == ui::TransferMarketRequestKind::review_offers) {
|
||||
const auto view = project_transfer_offer_list(next_state, request.bid.list_entry);
|
||||
const int selected = view.offer_count ? review(next_state, view) : -1;
|
||||
result.player = view.player; result.list_entry = view.list_entry;
|
||||
result.status = TransferActionStatus::pending;
|
||||
if (selected != -1) {
|
||||
auto allocator = TransferAllocatorContext::unsupported;
|
||||
if (turn_driver_.transfer_allocator_context == PendingOfferAllocatorGate::zero)
|
||||
allocator = TransferAllocatorContext::zero;
|
||||
else if (turn_driver_.transfer_allocator_context == PendingOfferAllocatorGate::blocked)
|
||||
allocator = TransferAllocatorContext::blocked;
|
||||
result = accept_manager_transfer_offer(next_state, request.manager_slot,
|
||||
view.list_entry, view.player, selected, next_rand, report, allocator);
|
||||
}
|
||||
} else if (request.kind == ui::TransferMarketRequestKind::list_player)
|
||||
result = list_manager_player(next_state, request.manager_slot, request.squad_row, next_rand, report);
|
||||
else
|
||||
result = submit_transfer_bid_source_human_buyer(next_state, request.bid, next_rand, hooks, report);
|
||||
|
||||
@@ -175,7 +175,8 @@ public:
|
||||
// result with valid dependent projections becomes the live state.
|
||||
std::optional<TransferActionResult> dispatch_transfer_market(
|
||||
const ui::TransferMarketRequest&, const HumanBuyerSaleHooks&,
|
||||
uint64_t& revision, std::string& error);
|
||||
uint64_t& revision, std::string& error,
|
||||
const std::function<int(const GameState&, const TransferOfferListView&)>& review = {});
|
||||
|
||||
struct TransferMarketPreviewDispatch {
|
||||
ui::PreparationState preparation;
|
||||
|
||||
+19
-7
@@ -370,9 +370,11 @@ std::string transfer_status_message(TransferActionStatus status, ui::TransferMar
|
||||
case TransferActionStatus::accepted:
|
||||
return kind == ui::TransferMarketRequestKind::list_player
|
||||
? "Der Spieler steht jetzt auf der Transferliste." : "Der Spieler hat das Angebot angenommen.";
|
||||
case TransferActionStatus::pending: return "Der Spieler entscheidet sich nächste Woche.";
|
||||
case TransferActionStatus::pending: return kind == ui::TransferMarketRequestKind::list_player
|
||||
? "Der Spieler steht bereits auf der Transferliste." : "Der Spieler entscheidet sich nächste Woche.";
|
||||
case TransferActionStatus::offer_too_low: return "Das Angebot ist zu niedrig.";
|
||||
case TransferActionStatus::blocked_by_board: return "Der Vorstand genehmigt diesen Transfer nicht.";
|
||||
case TransferActionStatus::blocked_by_board: return kind == ui::TransferMarketRequestKind::list_player
|
||||
? "Transferliste voll oder Spieler nicht verfügbar." : "Der Vorstand genehmigt diesen Transfer nicht.";
|
||||
case TransferActionStatus::insufficient_funds: return "Das Geld reicht für diesen Transfer nicht aus.";
|
||||
case TransferActionStatus::no_squad_room: return "Im Kader ist kein Platz für diesen Spieler.";
|
||||
case TransferActionStatus::rejected: return "Der Spieler hat das Angebot abgelehnt.";
|
||||
@@ -384,7 +386,8 @@ void serve_transfer_action(ui::StartupFlow& flow, CareerSession& session,
|
||||
const ui::TransferMarketRequest& request, uint64_t& revision,
|
||||
const HumanBuyerSaleHooks& presenters,
|
||||
HumanBuyerMarketEntryPolicy entry_policy,
|
||||
const CareerSession::PoachPlayerSelector& poach_selector, const PoachNoticePresenter& poach_notice) {
|
||||
const CareerSession::PoachPlayerSelector& poach_selector, const PoachNoticePresenter& poach_notice,
|
||||
const TransferOfferPresenter& review) {
|
||||
const auto* pending = flow.pending_transfer_market();
|
||||
// JSON covers every offer field except its redundant nested manager identity.
|
||||
// Check that identity too, before an engine helper can consume a random draw.
|
||||
@@ -473,13 +476,22 @@ void serve_transfer_action(ui::StartupFlow& flow, CareerSession& session,
|
||||
const auto outcome = TransferActions(session).market(request, hooks, revision, error, entry_policy,
|
||||
[&](const TransferActions::MarketDispatch& applied) {
|
||||
// Preserve the Source caller's existing notice/ACK sequence.
|
||||
const bool source_finished = entry_policy == HumanBuyerMarketEntryPolicy::normal_interactive &&
|
||||
(source_notice_presented || applied.action.status == TransferActionStatus::pending);
|
||||
const bool source_finished = request.kind != ui::TransferMarketRequestKind::review_offers &&
|
||||
entry_policy == HumanBuyerMarketEntryPolicy::normal_interactive &&
|
||||
(source_notice_presented || (request.kind == ui::TransferMarketRequestKind::submit_bid &&
|
||||
applied.action.status == TransferActionStatus::pending));
|
||||
auto notice = source_finished ? std::string{} : transfer_status_message(applied.action.status, request.kind);
|
||||
if (request.kind == ui::TransferMarketRequestKind::review_offers) {
|
||||
notice = applied.action.status == TransferActionStatus::accepted
|
||||
? "Das Angebot wurde angenommen."
|
||||
: applied.action.status == TransferActionStatus::pending
|
||||
? "Spieler bleibt auf der Transferliste."
|
||||
: "Angebot abgelehnt; Transferliste unverändert.";
|
||||
}
|
||||
if (!applied.changed && source_finished) flow.acknowledge_unchanged_transfer_market();
|
||||
else if (!applied.changed) flow.reject_preparation_action(std::move(notice));
|
||||
else flow.acknowledge_preparation(session.preparation_projection(revision), std::move(notice));
|
||||
});
|
||||
}, review);
|
||||
if (!outcome) throw FormatError(error);
|
||||
} catch (const std::exception&) {
|
||||
flow.reject_preparation_action("Diese Transferaktion konnte nicht übernommen werden.");
|
||||
@@ -1533,7 +1545,7 @@ std::string serve_flow_request(ui::StartupFlow& flow, const ui::FlowResult& resu
|
||||
} else if (result.request == ui::FlowRequest::submenu_action && session &&
|
||||
std::holds_alternative<ui::TransferMarketRequest>(result.submenu_action)) {
|
||||
serve_transfer_action(flow, *session, std::get<ui::TransferMarketRequest>(result.submenu_action), revision,
|
||||
market_sale_presenter, market_entry_policy, poach_player_selector, poach_notice_presenter);
|
||||
market_sale_presenter, market_entry_policy, poach_player_selector, poach_notice_presenter, transfer_presenter);
|
||||
} else if (result.request == ui::FlowRequest::submenu_action && session &&
|
||||
std::holds_alternative<ui::OutgoingTransferRequest>(result.submenu_action)) {
|
||||
serve_transfer_offer(flow, *session, std::get<ui::OutgoingTransferRequest>(result.submenu_action), revision,
|
||||
|
||||
@@ -108,12 +108,13 @@ bool TransferActions::apply(uint64_t& revision, const std::function<bool()>& act
|
||||
std::optional<TransferActions::MarketDispatch> TransferActions::market(
|
||||
const ui::TransferMarketRequest& request, const HumanBuyerSaleHooks& hooks,
|
||||
uint64_t& revision, std::string& error, HumanBuyerMarketEntryPolicy policy,
|
||||
const MarketAccept& acknowledge) {
|
||||
const MarketAccept& acknowledge,
|
||||
const std::function<int(const GameState&, const TransferOfferListView&)>& review) {
|
||||
std::optional<MarketDispatch> result;
|
||||
apply(revision, [&] {
|
||||
const auto old_revision = revision;
|
||||
if (policy == HumanBuyerMarketEntryPolicy::normal_interactive) {
|
||||
const auto action = session_.dispatch_transfer_market(request, hooks, revision, error);
|
||||
const auto action = session_.dispatch_transfer_market(request, hooks, revision, error, review);
|
||||
if (!action) return false;
|
||||
result = MarketDispatch{*action, revision != old_revision};
|
||||
} else {
|
||||
@@ -174,7 +175,8 @@ std::string TransferActions::rejection(const ui::TransferMarketRequest& request,
|
||||
return "Dieser Spieler gehört nicht mehr zur gewählten Kaderposition.";
|
||||
} else if (request.kind != ui::TransferMarketRequestKind::open_offer &&
|
||||
request.kind != ui::TransferMarketRequestKind::preview_quote &&
|
||||
request.kind != ui::TransferMarketRequestKind::open_poach)
|
||||
request.kind != ui::TransferMarketRequestKind::open_poach &&
|
||||
request.kind != ui::TransferMarketRequestKind::review_offers)
|
||||
return "Diese Transferaktion ist nicht verfügbar.";
|
||||
return {};
|
||||
}
|
||||
|
||||
@@ -38,7 +38,8 @@ public:
|
||||
std::optional<MarketDispatch> market(const ui::TransferMarketRequest&, const HumanBuyerSaleHooks&,
|
||||
uint64_t& revision, std::string& error,
|
||||
HumanBuyerMarketEntryPolicy = HumanBuyerMarketEntryPolicy::normal_interactive,
|
||||
const MarketAccept& = {});
|
||||
const MarketAccept& = {},
|
||||
const std::function<int(const GameState&, const TransferOfferListView&)>& review = {});
|
||||
std::optional<CareerSession::TransferOfferEditorDispatch> open_offer(const ui::TransferMarketRequest&,
|
||||
uint64_t& revision, std::string& error, const OfferAccept& = {});
|
||||
std::optional<CareerSession::TransferMarketPreviewDispatch> preview(const ui::TransferMarketRequest&,
|
||||
|
||||
@@ -160,6 +160,8 @@ void Console::register_transfer_commands() {
|
||||
require_engine(false, "transfer", error);
|
||||
}
|
||||
flush_notices();
|
||||
if (outcome->action.status != TransferActionStatus::accepted)
|
||||
fail("E_RULE", "Der Spieler konnte nicht auf die Transferliste gesetzt werden.");
|
||||
emit('+', utf8(item.name) + (loan
|
||||
? " steht auf der Transferliste; der Entleiher wählt 12 oder 24 Monate im Angebot"
|
||||
: " is on the transfer list"));
|
||||
@@ -175,6 +177,42 @@ void Console::register_transfer_commands() {
|
||||
list_player(v.text("player"), true);
|
||||
});
|
||||
|
||||
add({"Transfer", "ShowOffers", {player}, "incoming offers for an own listed player", false},
|
||||
[this, market_item](const Values& v) {
|
||||
const auto item = market_item(v.text("player"));
|
||||
if (!item.own_listing) fail("E_RULE", "the listing belongs to another club");
|
||||
const auto offers = project_transfer_offer_list(session_->state(), item.list_entry);
|
||||
std::vector<std::vector<std::string>> rows;
|
||||
for (const auto& offer : offers.offers) {
|
||||
if (!offer.present) continue;
|
||||
rows.push_back({std::to_string(offer.bid_index), utf8(session_->state().club_name(offer.buyer)),
|
||||
money(offer.fee), money(offer.monthly_salary), std::to_string(offer.contract_months),
|
||||
offer.loan ? "loan" : "sale",
|
||||
offer.eligible && offer.loan_permitted && offer.transaction_supported ? "yes" : "no"});
|
||||
}
|
||||
emit_table({"Bid", "Club", "Fee", "Monthly salary", "Months", "Type", "Available"}, rows);
|
||||
if (rows.empty()) emit('i', "Noch keine Angebote für diesen Spieler.");
|
||||
});
|
||||
add({"Transfer", "AcceptOffer", {player, integer("bid", 0, 3)}, "accept an existing bid before weekly expiry", true},
|
||||
[this, market, market_item, hooks, flush_notices](const Values& v) {
|
||||
const auto observed = market();
|
||||
const auto item = market_item(v.text("player"));
|
||||
if (!item.own_listing) fail("E_RULE", "the listing belongs to another club");
|
||||
auto request = app::TransferActions::opening(observed, item, false);
|
||||
request.kind = ui::TransferMarketRequestKind::review_offers;
|
||||
request.selected_players.clear();
|
||||
const int bid = int(v.integer("bid"));
|
||||
std::string error;
|
||||
const auto outcome = app::TransferActions(*session_).market(request, hooks(), revision_, error,
|
||||
app::HumanBuyerMarketEntryPolicy::normal_interactive, {},
|
||||
[bid](const GameState&, const TransferOfferListView&) { return bid; });
|
||||
if (!outcome) require_engine(false, "transfer", error);
|
||||
flush_notices();
|
||||
if (outcome->action.status != TransferActionStatus::accepted)
|
||||
fail("E_RULE", "Dieses Angebot kann nicht angenommen werden; die Transferliste bleibt unverändert.");
|
||||
emit('+', "Das Angebot wurde angenommen.");
|
||||
});
|
||||
|
||||
// --- Transfer.Negotiate: the offer editor (06-verein 5.2) -----------------------------
|
||||
auto show_offer = [this] {
|
||||
if (!offer_editor_) fail("E_INTERNAL", "no offer editor");
|
||||
|
||||
@@ -538,6 +538,13 @@ TransferActionResult list_manager_player(GameState& g, int manager, int squad_ro
|
||||
out.status = TransferActionStatus::invalid_player;
|
||||
return out;
|
||||
}
|
||||
bool free_entry = false;
|
||||
for (size_t entry = 0; entry < 40; ++entry) {
|
||||
const int listed = g.squad_slots.at(0xb70 + entry) & 0xfff;
|
||||
if (listed == player) { out.status = TransferActionStatus::pending; out.player = player; out.list_entry = int(entry); return out; }
|
||||
free_entry = free_entry || listed == 0xfff;
|
||||
}
|
||||
if (!free_entry) { out.status = TransferActionStatus::blocked_by_board; return out; }
|
||||
if (!list_transfer_player(g, slot, rand, report)) {
|
||||
out.status = report.unsupported ? TransferActionStatus::invalid_request : TransferActionStatus::blocked_by_board;
|
||||
return out;
|
||||
|
||||
@@ -1,5 +1,6 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
#pragma once
|
||||
#include "game/transfer_allocator.hpp"
|
||||
// OpenBMH deviates from the original: supports designated set-piece records and the supported transfer-editor rules.
|
||||
// Actions a human manager can take at his desk that change the game state and draw random
|
||||
// numbers (BMH.exe V2.24 + supported rule profile patch). The screens themselves belong to the UI; these
|
||||
@@ -272,6 +273,12 @@ struct TransferOfferEditorSubmitResult {
|
||||
TransferOfferEditorSubmitResult submit_transfer_offer_editor_source(GameState&,
|
||||
const TransferOfferEditorState&,WatcomRandom&,const HumanBuyerSaleHooks&,MinuteReport&);
|
||||
|
||||
// OpenBMH deviates from the original: a seller may accept an existing bid before expiry.
|
||||
// The caller stages state/RNG; cancellation is handled before invoking this action.
|
||||
TransferActionResult accept_manager_transfer_offer(GameState&, int manager, int list_entry,
|
||||
int expected_player, int bid_index, WatcomRandom&, MinuteReport&,
|
||||
TransferAllocatorContext = TransferAllocatorContext::unsupported);
|
||||
|
||||
// Submit a manager bid on an existing list entry. A full-value fee and salary meeting
|
||||
// the demand complete an immediate agreement; lower viable offers persist for weekly review.
|
||||
TransferActionResult submit_transfer_bid(GameState& g, const TransferBidRequest& request, WatcomRandom& rand);
|
||||
|
||||
@@ -74,6 +74,9 @@ void new_board_entry(GameState& g, int manager, int index, int slot, WatcomRando
|
||||
uint8_t* e = &g.tactics.at(size_t(manager) * kBoard + size_t(index) * kBoardSlot);
|
||||
std::memset(e + 7, 0, 3);
|
||||
std::memset(e + 0x19, 0, 0x24);
|
||||
// OpenBMH deviates from the original: a new arrival must not inherit the
|
||||
// previous occupant's retirement/refusal/month-processing flags.
|
||||
e[0xb] = 0;
|
||||
e[10] = 2;
|
||||
for (int k = 0; k < 4; k++) e[2 + k] = index < 2 ? 1 : uint8_t(rand.range(2, 0x27));
|
||||
e[0x3f] = 0xff;
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
// SPDX-License-Identifier: GPL-3.0-only
|
||||
#include "formats/executable_layout.hpp"
|
||||
#include "game/weekly.hpp"
|
||||
#include "game/desk_actions.hpp"
|
||||
#include "game/pending_offer.hpp"
|
||||
#include "game/human_buyer_sale.hpp"
|
||||
#include "game/transfer_bid.hpp"
|
||||
@@ -1637,6 +1638,7 @@ static TransferOfferListView project_transfer_offer_list_impl(const GameState& g
|
||||
view.player = player;
|
||||
view.seller = g.memory.u16(list + 8) & 0x7fff;
|
||||
view.seller_manager = g.manager_of(view.seller);
|
||||
offer_bases(g.memory, list, -1, view.asking_fee, view.asking_monthly_salary);
|
||||
for (int bid = 0; bid < 4; ++bid) view.offers[size_t(bid)].bid_index = bid;
|
||||
if (view.seller_manager >= 0 && g.memory.has(::bmh::layout::DeskActions_Unsupported_RuntimeField + uint32_t(view.seller_manager)))
|
||||
view.seller_loan_count = g.memory.u8(::bmh::layout::DeskActions_Unsupported_RuntimeField + uint32_t(view.seller_manager));
|
||||
@@ -2621,6 +2623,47 @@ PendingOfferResult process_national_nomination_pending_after_desk(GameState& g,
|
||||
return process_natural_pending_offers_after_desk(g,request,game,rand,hooks,report);
|
||||
}
|
||||
|
||||
TransferActionResult accept_manager_transfer_offer(GameState& g, int manager, int entry,
|
||||
int expected_player, int bid, WatcomRandom& rand, MinuteReport& report, TransferAllocatorContext allocator) {
|
||||
TransferActionResult result;
|
||||
const auto view = project_transfer_offer_list(g, entry);
|
||||
if (!view.valid || manager < 0 || view.seller_manager != manager ||
|
||||
view.player != expected_player || bid < 0 || bid >= 4) return result;
|
||||
const auto& offer = view.offers[size_t(bid)];
|
||||
if (!offer.present) return result;
|
||||
if (!offer.affordable) { result.status = TransferActionStatus::insufficient_funds; return result; }
|
||||
if (!offer.has_squad_room) { result.status = TransferActionStatus::no_squad_room; return result; }
|
||||
if (!offer.passes_foreign_limit || !offer.loan_permitted) {
|
||||
result.status = TransferActionStatus::blocked_by_board; return result;
|
||||
}
|
||||
if (!offer.transaction_supported) { result.status = TransferActionStatus::unsupported; return result; }
|
||||
const uint32_t list = kTransferList + uint32_t(entry) * kListEntry;
|
||||
auto staged = g;
|
||||
auto staged_rand = rand;
|
||||
const uint32_t salary_at = list + 0x0c + uint32_t(bid) * 4;
|
||||
const auto salary = staged.memory.u32(salary_at);
|
||||
staged.memory.set32(salary_at, (salary * 10u) >> 3);
|
||||
uint32_t fee_pct = 0, salary_pct = 0;
|
||||
const bool rated = evaluate_bid(staged, list, bid, fee_pct, salary_pct, staged_rand, report);
|
||||
staged.memory.set32(salary_at, salary);
|
||||
if (!rated || report.unsupported) { result.status = TransferActionStatus::unsupported; return result; }
|
||||
if (!salary_pct) { result.status = TransferActionStatus::rejected; return result; }
|
||||
if (!accept_transfer_bid_immediately(staged, entry, bid, staged_rand, report,
|
||||
allocator) || report.unsupported) {
|
||||
result.status = TransferActionStatus::unsupported; return result;
|
||||
}
|
||||
const auto buyer_range = squad_range(offer.buyer);
|
||||
const bool moved = std::any_of(staged.squad_slots.begin() + buyer_range.first,
|
||||
staged.squad_slots.begin() + buyer_range.first + buyer_range.count,
|
||||
[&](uint16_t slot) { return (slot & 0xfff) == expected_player; });
|
||||
if (!moved) { result.status = TransferActionStatus::unsupported; return result; }
|
||||
g = std::move(staged); rand = staged_rand;
|
||||
result.status = TransferActionStatus::accepted;
|
||||
result.player = expected_player; result.list_entry = entry;
|
||||
result.fee = int32_t(offer.fee); result.annual_salary = int32_t(offer.monthly_salary);
|
||||
return result;
|
||||
}
|
||||
|
||||
bool accept_transfer_bid_immediately(GameState& g, int entry, int bid, WatcomRandom& rand,
|
||||
MinuteReport& report, TransferAllocatorContext allocator) {
|
||||
if (entry < 0 || entry >= 40 || bid < 0 || bid >= 4) return false;
|
||||
|
||||
@@ -461,7 +461,10 @@ Image IncomingTransferScreen::render_at_elapsed(uint64_t elapsed_ms) const {
|
||||
std::string(text_at(texts_, ::bmh::layout::IncomingTransfer_RenderAtElapsed_TextPointer14)) + source_number(state_.quoted_years, 1, false) +
|
||||
std::string(text_at(texts_, ::bmh::layout::Contracts_Out_ExecutableField15)) + (state_.quoted_years == 1 ? "" : exe_.cstring(::bmh::layout::Fltd_Layout_TextPointer3)) +
|
||||
exe_.cstring(::bmh::layout::IncomingTransfer_RenderAtElapsed_TextPointer);
|
||||
centered(0, 319, 32, quote, 0x6a);
|
||||
// Early listing review has no newly rolled quote. Explain its input instead
|
||||
// of presenting a fabricated zero-year, zero-price valuation.
|
||||
centered(0, 319, 32, state_.quoted_years ? quote :
|
||||
"Angebot anklicken. Rechtsklick: zurueck.", 0x6a);
|
||||
shadow_text(7, 123, std::string(text_at(texts_, ::bmh::layout::IncomingTransfer_RenderAtElapsed_TextPointer10)) +
|
||||
source_money(state_.asking_fee, 7, state_.currency_numerator, state_.currency_denominator), 0x6a);
|
||||
shadow_text(170, 123, std::string(text_at(texts_, ::bmh::layout::IncomingTransfer_RenderAtElapsed_TextPointer11)) +
|
||||
|
||||
+40
-11
@@ -282,7 +282,8 @@ std::string transfer_market_request_json(const TransferMarketRequest& r) {
|
||||
r.kind == TransferMarketRequestKind::list_player ? "list_player" :
|
||||
r.kind == TransferMarketRequestKind::open_offer ? "open_offer" :
|
||||
r.kind == TransferMarketRequestKind::preview_quote ? "preview_quote" :
|
||||
r.kind == TransferMarketRequestKind::open_poach ? "open_poach" : "none";
|
||||
r.kind == TransferMarketRequestKind::open_poach ? "open_poach" :
|
||||
r.kind == TransferMarketRequestKind::review_offers ? "review_offers" : "none";
|
||||
std::ostringstream out;
|
||||
out << "{\"kind\":\"" << kind << "\",\"manager_slot\":" << r.manager_slot
|
||||
<< ",\"runtime_club\":" << r.runtime_club << ",\"revision\":" << r.revision
|
||||
@@ -520,6 +521,16 @@ Image TransferMarketScreen::render() const {
|
||||
sprite_font_.draw(out,SpriteFont::centered_title_x(sprite_font_.text_width(title)),13,title);
|
||||
sprite_font_.draw(out,5,235,original_to_utf8(state_.club_name));
|
||||
draw_market_overview(out);
|
||||
if (!feedback_.empty()) {
|
||||
rect(out, 1, 227, 318, 12, 0x39);
|
||||
auto line = feedback_;
|
||||
while (!line.empty() && sprite_font_.text_width(line) > 310) {
|
||||
size_t at = line.size() - 1;
|
||||
while (at > 0 && (uint8_t(line[at]) & 0xc0) == 0x80) --at;
|
||||
line.resize(at);
|
||||
}
|
||||
sprite_font_.draw(out, 5, 235, line);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
@@ -553,13 +564,17 @@ TransferMarketRequest TransferMarketScreen::make_bid() {
|
||||
TransferMarketRequest TransferMarketScreen::make_listing(bool loan) {
|
||||
if (pending_ || !selected_squad_) return {};
|
||||
const auto& item = state_.squad.at(size_t(*selected_squad_));
|
||||
if (item.already_listed) { feedback_ = "Spieler steht bereits auf der Liste"; return {}; }
|
||||
if (item.already_listed) {
|
||||
const auto listing = std::find_if(state_.items.begin(), state_.items.end(),
|
||||
[&](const auto& row) { return row.player == item.player && row.own_listing; });
|
||||
if (listing != state_.items.end()) return make_review(*listing);
|
||||
feedback_ = "Spieler steht bereits auf der Liste"; return {};
|
||||
}
|
||||
TransferMarketRequest request;
|
||||
request.kind = TransferMarketRequestKind::list_player;request.offer_is_loan=loan;
|
||||
request.manager_slot = state_.manager_slot; request.runtime_club = state_.runtime_club; request.revision = state_.revision;
|
||||
request.squad_row = item.row; request.expected_player = item.player;
|
||||
for(size_t n=0;n<state_.squad.size();++n) {if(std::find(marked_squad_.begin(),marked_squad_.end(),int(n))==marked_squad_.end())continue;const auto& marked=state_.squad[n];request.selected_players.push_back({-1,state_.roster.squad_start_offset+marked.row,marked.player,state_.runtime_club,marked.row});}
|
||||
if(request.selected_players.empty())request.selected_players.push_back({-1,state_.roster.squad_start_offset+item.row,item.player,state_.runtime_club,item.row});
|
||||
request.selected_players.push_back({-1,state_.roster.squad_start_offset+item.row,item.player,state_.runtime_club,item.row});
|
||||
pending_ = request; feedback_.clear();
|
||||
return request;
|
||||
}
|
||||
@@ -589,18 +604,27 @@ TransferMarketRequest TransferMarketScreen::make_preview(bool purchase) {
|
||||
}
|
||||
pending_=request;preview_.reset();return request;
|
||||
}
|
||||
TransferMarketRequest TransferMarketScreen::make_review(const TransferMarketItem& item) {
|
||||
if (pending_) return {};
|
||||
if (item.offers == 0) { feedback_ = "Noch keine Angebote für diesen Spieler."; return {}; }
|
||||
TransferMarketRequest request;
|
||||
request.kind = TransferMarketRequestKind::review_offers;
|
||||
request.manager_slot = state_.manager_slot; request.runtime_club = state_.runtime_club;
|
||||
request.revision = state_.revision; request.bid.manager = state_.manager_slot;
|
||||
request.bid.list_entry = item.list_entry; request.bid.player = item.player;
|
||||
request.bid.source_slot = item.source_slot;
|
||||
pending_ = request; feedback_.clear(); return request;
|
||||
}
|
||||
TransferMarketRequest TransferMarketScreen::make_open_offer(bool loan) {
|
||||
if(pending_||!selected_item_)return {};
|
||||
const auto& item=state_.items.at(size_t(*selected_item_));
|
||||
if(item.own_listing)return {};
|
||||
if(item.own_listing)return make_review(item);
|
||||
TransferMarketRequest request;request.kind=TransferMarketRequestKind::open_offer;request.offer_is_loan=loan;
|
||||
request.manager_slot=state_.manager_slot;request.runtime_club=state_.runtime_club;request.revision=state_.revision;
|
||||
if(item.own_bid)request.bid=*item.own_bid;
|
||||
request.bid.manager=state_.manager_slot;request.bid.list_entry=item.list_entry;request.bid.player=item.player;
|
||||
request.bid.source_slot=item.source_slot;
|
||||
for(size_t n=0;n<state_.squad.size();++n){if(std::find(marked_squad_.begin(),marked_squad_.end(),int(n))==marked_squad_.end())continue;const auto& marked=state_.squad[n];request.selected_players.push_back({-1,state_.roster.squad_start_offset+marked.row,marked.player,state_.runtime_club,marked.row});}
|
||||
for(int n:market_order()) {if(std::find(marked_items_.begin(),marked_items_.end(),n)==marked_items_.end())continue;const auto& marked=state_.items.at(size_t(n));request.selected_players.push_back({marked.list_entry,marked.source_slot,marked.player,marked.seller,-1});}
|
||||
if(request.selected_players.empty())request.selected_players.push_back({item.list_entry,item.source_slot,item.player,item.seller,-1});
|
||||
request.selected_players.push_back({item.list_entry,item.source_slot,item.player,item.seller,-1});
|
||||
pending_=request;return request;
|
||||
}
|
||||
TransferMarketRequest TransferMarketScreen::move(int x,int y) {
|
||||
@@ -669,14 +693,17 @@ TransferMarketRequest TransferMarketScreen::click(int x,int y,bool right) {
|
||||
if(x>=201&&x<=297&&y>=25&&y<115) {
|
||||
const size_t row=size_t((y-25)/15),index=first+row;
|
||||
if(index<order.size()&&row<6) {
|
||||
const int item=order[index];auto marked=std::find(marked_items_.begin(),marked_items_.end(),item);
|
||||
marked_squad_.clear();
|
||||
const int item=order[index];
|
||||
marked_items_.erase(std::remove_if(marked_items_.begin(),marked_items_.end(),[&](int n){return n!=item;}),marked_items_.end());
|
||||
auto marked=std::find(marked_items_.begin(),marked_items_.end(),item);
|
||||
if(marked==marked_items_.end())marked_items_.push_back(item);else marked_items_.erase(marked);
|
||||
return move(x,y);
|
||||
}
|
||||
}
|
||||
if(y>=202&&y<=212&&x>=185&&x<=318) {
|
||||
if(!marked_items_.empty()){selected_item_=marked_items_.front();selected_squad_.reset();selected_snapshot_.reset();return make_open_offer(x>=254);}
|
||||
if(!marked_squad_.empty()){selected_squad_=marked_squad_.front();selected_item_.reset();return make_listing(x>=254);}
|
||||
if(!marked_items_.empty()){selected_item_=marked_items_.back();selected_squad_.reset();selected_snapshot_.reset();return make_open_offer(x>=254);}
|
||||
if(!marked_squad_.empty()){selected_squad_=marked_squad_.back();selected_item_.reset();return make_listing(x>=254);}
|
||||
view_flags_^=0x1800;preview_.reset();return {};
|
||||
}
|
||||
}
|
||||
@@ -686,6 +713,8 @@ TransferMarketRequest TransferMarketScreen::click(int x,int y,bool right) {
|
||||
const auto found=std::find_if(state_.squad.begin(),state_.squad.end(),[&](const auto& item){return item.row==player.physical_row;});
|
||||
if(found==state_.squad.end())return {};
|
||||
const int index=int(found-state_.squad.begin());
|
||||
marked_items_.clear();
|
||||
marked_squad_.erase(std::remove_if(marked_squad_.begin(),marked_squad_.end(),[&](int n){return n!=index;}),marked_squad_.end());
|
||||
auto marked=std::find(marked_squad_.begin(),marked_squad_.end(),index);
|
||||
if(marked==marked_squad_.end())marked_squad_.push_back(index);else marked_squad_.erase(marked);
|
||||
return move(x,y);
|
||||
|
||||
@@ -65,7 +65,7 @@ TransferMarketState transfer_market_from_game(const GameState&, uint64_t revisio
|
||||
std::string transfer_market_state_json(const TransferMarketState&);
|
||||
TaxDialogProjection poach_notice_from_game(const GameState&,const PoachStart&,std::string original_message);
|
||||
|
||||
enum class TransferMarketRequestKind { none, submit_bid, list_player, open_offer, preview_quote, open_poach };
|
||||
enum class TransferMarketRequestKind { none, submit_bid, list_player, open_offer, preview_quote, open_poach, review_offers };
|
||||
struct TransferMarketSelection {
|
||||
int list_entry=-1,source_slot=-1,player=-1,seller=-1,squad_row=-1;
|
||||
};
|
||||
@@ -147,6 +147,7 @@ private:
|
||||
bool close_requested_ = false;
|
||||
void draw_text(Image&, int x, int y, std::string_view, uint8_t color) const;
|
||||
void commit_numeric_field();
|
||||
TransferMarketRequest make_review(const TransferMarketItem&);
|
||||
TransferMarketRequest make_bid();
|
||||
TransferMarketRequest make_listing(bool loan=false);
|
||||
TransferMarketRequest make_open_offer(bool loan=false);
|
||||
|
||||
@@ -70,6 +70,36 @@ int main(int argc,char** argv){
|
||||
check(request.kind==TransferMarketRequestKind::list_player&&request.squad_row==0&&request.expected_player==0,"existing listing request retains physical row stale-validation boundary");
|
||||
screen.reject_action("Für Müller: Aktion offen");check(screen.state_json().find("Für Müller")!=std::string::npos,"host feedback remains UTF8");
|
||||
|
||||
const auto rejected_frame = screen.render();
|
||||
screen.key("V");
|
||||
screen.reject_action("Anderer sichtbarer Hinweis");
|
||||
check(screen.render().pixels != rejected_frame.pixels, "host rejection is actually rendered in the footer");
|
||||
|
||||
TransferMarketScreen selected(argv[1],s);
|
||||
auto marked_market=selected.click(210,28);selected.acknowledge_preview(s,quote(marked_market));
|
||||
auto marked_squad=selected.click(20,32);selected.acknowledge_preview(s,quote(marked_squad));
|
||||
auto sale=selected.click(200,206);
|
||||
check(sale.kind==TransferMarketRequestKind::list_player&&sale.selected_players.size()==1&&sale.expected_player==0,
|
||||
"latest clicked squad selection replaces an old marked market row");
|
||||
|
||||
auto listed=s;listed.items[0].own_listing=true;listed.items[0].seller=listed.runtime_club;
|
||||
listed.items[0].player=0;listed.squad[0].already_listed=true;listed.items[0].offers=1;
|
||||
TransferMarketScreen review(argv[1],listed);
|
||||
auto hover_listing=review.click(20,32);review.acknowledge_preview(listed,quote(hover_listing));
|
||||
auto inspect=review.click(200,206);
|
||||
check(inspect.kind==TransferMarketRequestKind::review_offers&&inspect.bid.player==0&&inspect.bid.list_entry==4&&
|
||||
transfer_market_request_json(inspect).find("review_offers")!=std::string::npos,
|
||||
"selling an already listed own squad player requests guarded incoming offer review");
|
||||
review.acknowledge_unchanged();
|
||||
listed.items[0].offers=0;TransferMarketScreen waiting(argv[1],listed);
|
||||
auto hover_waiting=waiting.click(20,32);waiting.acknowledge_preview(listed,quote(hover_waiting));
|
||||
check(waiting.key("V").kind==TransferMarketRequestKind::none&&
|
||||
waiting.state_json().find("Noch keine Angebote")!=std::string::npos,
|
||||
"an own listing without incoming offers gives visible feedback");
|
||||
auto expired=fixture();expired.squad_slots[2932]=0x0fff;
|
||||
check(!transfer_market_from_game(expired,5).squad[0].already_listed,
|
||||
"cleared rejected/expired pool entry immediately makes the player listable again");
|
||||
|
||||
auto all=s;all.items.clear();for(int n=0;n<40;++n){auto item=s.items[0];item.list_entry=n;item.source_slot=2928+n;item.player=100+n;item.name="P"+std::to_string(n);item.position=n%4;item.strength=60+n%7;all.items.push_back(item);}
|
||||
TransferMarketScreen pages(argv[1],all);const auto first=visible(pages);std::set<int> reached;
|
||||
for(int page=0;page<7;++page){const auto rows=visible(pages);check(rows.size()==size_t(page==6?4:6),"six original rows per page with final four");reached.insert(rows.begin(),rows.end());pages.click(210,45,true);}
|
||||
|
||||
@@ -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; }
|
||||
@@ -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; }
|
||||
Reference in new issue
Block a user