From 8baf80564ab7ce60042e87b6f10b64628d5f383f Mon Sep 17 00:00:00 2001 From: Codex Date: Sun, 1 Nov 2026 17:51:50 +0100 Subject: [PATCH] (by Codex) Fix seller transfer review and fresh-arrival contract flags --- CMakeLists.txt | 9 ++ docs/CLI_CONCEPT/06-verein.md | 2 + docs/COMPATIBILITY.md | 22 +++++ src/app/career_session.cpp | 32 +++++- src/app/career_session.hpp | 3 +- src/app/controller.cpp | 26 +++-- src/app/window_actions.cpp | 8 +- src/app/window_actions.hpp | 3 +- src/cli/console/windows_transfer.cpp | 38 ++++++++ src/game/desk_actions.cpp | 7 ++ src/game/desk_actions.hpp | 7 ++ src/game/national.cpp | 3 + src/game/weekly.cpp | 43 +++++++++ src/ui/incoming_transfer.cpp | 5 +- src/ui/transfer_market.cpp | 51 +++++++--- src/ui/transfer_market.hpp | 3 +- src/ui/transfer_market_tests.cpp | 30 ++++++ tests/transfer_seller_actions_tests.cpp | 74 ++++++++++++++ tests/transfer_seller_app_tests.cpp | 123 ++++++++++++++++++++++++ 19 files changed, 461 insertions(+), 28 deletions(-) create mode 100644 tests/transfer_seller_actions_tests.cpp create mode 100644 tests/transfer_seller_app_tests.cpp diff --git a/CMakeLists.txt b/CMakeLists.txt index 5d9f6a4..9096b17 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -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}") diff --git a/docs/CLI_CONCEPT/06-verein.md b/docs/CLI_CONCEPT/06-verein.md index 453f455..0ae0f48 100644 --- a/docs/CLI_CONCEPT/06-verein.md +++ b/docs/CLI_CONCEPT/06-verein.md @@ -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 | diff --git a/docs/COMPATIBILITY.md b/docs/COMPATIBILITY.md index aba2b44..0833960 100644 --- a/docs/COMPATIBILITY.md +++ b/docs/COMPATIBILITY.md @@ -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. diff --git a/src/app/career_session.cpp b/src/app/career_session.cpp index 356d9cd..2303aba 100644 --- a/src/app/career_session.cpp +++ b/src/app/career_session.cpp @@ -3985,7 +3985,8 @@ std::optional CareerSession::previ std::optional 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& 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 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 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); diff --git a/src/app/career_session.hpp b/src/app/career_session.hpp index 110b27d..808c752 100644 --- a/src/app/career_session.hpp +++ b/src/app/career_session.hpp @@ -175,7 +175,8 @@ public: // result with valid dependent projections becomes the live state. std::optional dispatch_transfer_market( const ui::TransferMarketRequest&, const HumanBuyerSaleHooks&, - uint64_t& revision, std::string& error); + uint64_t& revision, std::string& error, + const std::function& review = {}); struct TransferMarketPreviewDispatch { ui::PreparationState preparation; diff --git a/src/app/controller.cpp b/src/app/controller.cpp index 8e3e3b1..1eed9e2 100644 --- a/src/app/controller.cpp +++ b/src/app/controller.cpp @@ -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(result.submenu_action)) { serve_transfer_action(flow, *session, std::get(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(result.submenu_action)) { serve_transfer_offer(flow, *session, std::get(result.submenu_action), revision, diff --git a/src/app/window_actions.cpp b/src/app/window_actions.cpp index bb640dc..d502d6d 100644 --- a/src/app/window_actions.cpp +++ b/src/app/window_actions.cpp @@ -108,12 +108,13 @@ bool TransferActions::apply(uint64_t& revision, const std::function& act std::optional 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& review) { std::optional 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 {}; } diff --git a/src/app/window_actions.hpp b/src/app/window_actions.hpp index 830e11f..9536b37 100644 --- a/src/app/window_actions.hpp +++ b/src/app/window_actions.hpp @@ -38,7 +38,8 @@ public: std::optional market(const ui::TransferMarketRequest&, const HumanBuyerSaleHooks&, uint64_t& revision, std::string& error, HumanBuyerMarketEntryPolicy = HumanBuyerMarketEntryPolicy::normal_interactive, - const MarketAccept& = {}); + const MarketAccept& = {}, + const std::function& review = {}); std::optional open_offer(const ui::TransferMarketRequest&, uint64_t& revision, std::string& error, const OfferAccept& = {}); std::optional preview(const ui::TransferMarketRequest&, diff --git a/src/cli/console/windows_transfer.cpp b/src/cli/console/windows_transfer.cpp index 72c9127..07d8abf 100644 --- a/src/cli/console/windows_transfer.cpp +++ b/src/cli/console/windows_transfer.cpp @@ -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> 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"); diff --git a/src/game/desk_actions.cpp b/src/game/desk_actions.cpp index e1fed7c..4c4fcd7 100644 --- a/src/game/desk_actions.cpp +++ b/src/game/desk_actions.cpp @@ -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; diff --git a/src/game/desk_actions.hpp b/src/game/desk_actions.hpp index 2bc1fef..d9d376f 100644 --- a/src/game/desk_actions.hpp +++ b/src/game/desk_actions.hpp @@ -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); diff --git a/src/game/national.cpp b/src/game/national.cpp index 77cf4f8..e09ec25 100644 --- a/src/game/national.cpp +++ b/src/game/national.cpp @@ -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; diff --git a/src/game/weekly.cpp b/src/game/weekly.cpp index e4671fa..12f871d 100644 --- a/src/game/weekly.cpp +++ b/src/game/weekly.cpp @@ -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; diff --git a/src/ui/incoming_transfer.cpp b/src/ui/incoming_transfer.cpp index 2d8048c..f00372d 100644 --- a/src/ui/incoming_transfer.cpp +++ b/src/ui/incoming_transfer.cpp @@ -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)) + diff --git a/src/ui/transfer_market.cpp b/src/ui/transfer_market.cpp index 49a1d44..48c1f96 100644 --- a/src/ui/transfer_market.cpp +++ b/src/ui/transfer_market.cpp @@ -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=201&&x<=297&&y>=25&&y<115) { const size_t row=size_t((y-25)/15),index=first+row; if(index=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); diff --git a/src/ui/transfer_market.hpp b/src/ui/transfer_market.hpp index cf6751d..f671fd7 100644 --- a/src/ui/transfer_market.hpp +++ b/src/ui/transfer_market.hpp @@ -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); diff --git a/src/ui/transfer_market_tests.cpp b/src/ui/transfer_market_tests.cpp index d2df2a2..5dc2f91 100644 --- a/src/ui/transfer_market_tests.cpp +++ b/src/ui/transfer_market_tests.cpp @@ -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 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);} diff --git a/tests/transfer_seller_actions_tests.cpp b/tests/transfer_seller_actions_tests.cpp new file mode 100644 index 0000000..ab897e3 --- /dev/null +++ b/tests/transfer_seller_actions_tests.cpp @@ -0,0 +1,74 @@ +// SPDX-License-Identifier: GPL-3.0-only +#include +#include +#include +#include +#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; } diff --git a/tests/transfer_seller_app_tests.cpp b/tests/transfer_seller_app_tests.cpp new file mode 100644 index 0000000..879ffc1 --- /dev/null +++ b/tests/transfer_seller_app_tests.cpp @@ -0,0 +1,123 @@ +// SPDX-License-Identifier: GPL-3.0-only +#include +#include +#include +#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; }