(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

+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);}