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