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

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

No files matched your search

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