Files
Dreierpack-Manager/src/ui/incoming_transfer.cpp
T

608 lines
34 KiB
C++

// SPDX-License-Identifier: GPL-3.0-only
#include "game/state.hpp"
#include "formats/badge_policy.hpp"
#include "formats/executable_layout.hpp"
#include "ui/incoming_transfer.hpp"
#include "ui/game_end.hpp"
#include <algorithm>
#include <sstream>
#include "formats/textd.hpp"
#include "game/state.hpp"
#include "game/weekly.hpp"
#include "ui/manager.hpp"
#include "ui/pending_offer.hpp"
#include "ui/setup.hpp"
namespace bmh::ui {
namespace {
constexpr uint32_t kTitleText = ::bmh::layout::TitleText;
constexpr uint32_t kPurchaseTitleText = ::bmh::layout::PurchaseTitleText;
constexpr uint32_t kLoanTitleText = ::bmh::layout::LoanTitleText;
constexpr uint32_t kTextBase = ::bmh::layout::TextPointerTable;
constexpr size_t kManagerRecord = 0xb0c;
std::string_view text_at(const TextDb& texts, uint32_t address) {
if (address < kTextBase || (address - kTextBase) % 4 != 0)
throw FormatError("incoming transfer: invalid original text address");
return texts[(address - kTextBase) / 4];
}
void copy_region(Image& target, const Image& source, int sx, int sy, int x, int y,
int width, int height, int transparent_index = -1) {
if (sx < 0 || sy < 0 || x < 0 || y < 0 || width < 0 || height < 0 ||
sx + width > source.width || sy + height > source.height ||
x + width > target.width || y + height > target.height)
throw FormatError("incoming transfer: invalid original sprite bounds");
for (int yy = 0; yy < height; ++yy) for (int xx = 0; xx < width; ++xx) {
const auto value = source.pixels[size_t(sy + yy) * size_t(source.width) + size_t(xx + sx)];
if (transparent_index < 0 || value != transparent_index) target.at(x + xx, y + yy) = value;
}
}
std::string source_number(uint32_t value, int width, bool grouping = true) {
std::string digits = std::to_string(value);
const int actual = int(digits.size());
const int padding = std::max(0, width - actual);
digits.insert(0, size_t(padding), '%');
if (grouping) {
for (int from = actual - 3; from > 0; from -= 3)
digits.insert(size_t(padding + from), ".");
const int wanted = width > 3 ? (width - 4) / 3 + 1 : 0;
const int used = actual > 3 ? (actual - 1) / 3 : 0;
if (wanted > used) digits.insert(0, size_t(wanted - used), ' ');
}
return digits;
}
std::string source_money(uint32_t value, int width, uint32_t numerator, uint32_t denominator) {
if (denominator != 0)
value = uint32_t((uint64_t(value) * uint64_t(numerator)) / uint64_t(denominator));
return source_number(value, width, true) + " EU";
}
int team_badge(const GameState& game, int team) {
if (team < 0 || team >= runtime_dimensions.record_teams || size_t(team) * 2 + 2 > game.club_heap_78.size()) return -1;
return (int(game.club_heap_78[size_t(team) * 2]) |
int(game.club_heap_78[size_t(team) * 2 + 1]) << 8) & 0x1ff;
}
int manager_badge(const GameState& game, int manager) {
if (manager < 0 || size_t(manager) >= game.manager_teams.size() ||
size_t(manager) * kManagerRecord + 0x223 > game.manager_records.size()) return -1;
const int team = game.manager_teams[size_t(manager)];
if (team < 0 || size_t(team) * 2 + 2 > game.club_heap_78.size()) return -1;
return team_badge(game, team);
}
int source_seller_team_token(const IncomingTransferDecisionState& state) {
const int token = state.seller_team_token >= 0 ? state.seller_team_token : state.seller;
return token >= 0 ? (token & 0x0fff) : token;
}
bool source_neutral_seller_token(int token) {
return original_badge_fallback(token);
}
} // namespace
namespace {
IncomingTransferDecisionState incoming_transfer_decision_from_game_impl(
const GameState& game, const IncomingTransferDecisionView& view, bool pending_offer_source) {
// the outgoing offer editor also runs on the special rows 40..43 when poaching
// (src/game/poach.hpp)
const bool entry_valid = pending_offer_source
? view.list_entry >= 40 && view.list_entry < 44
: view.list_entry >= 0 && view.list_entry < (view.source_outgoing_editor_context ? 44 : 40);
if (!view.valid || !entry_valid ||
view.player < 0 || size_t(view.player) >= game.players.size() ||
(view.seller != 0x0fff && view.seller != kNoTeam && (view.seller < 0 || size_t(view.seller) >= game.club_ids.size())) ||
view.seller_manager < -1 || view.viewer_manager < -1 ||
view.preferred_bid_index < -1 || view.preferred_bid_index >= 4)
throw FormatError("incoming transfer: invalid decision context");
IncomingTransferDecisionState out;
out.pending_offer_source = pending_offer_source;
out.source_outgoing_editor_context = view.source_outgoing_editor_context;
out.list_entry = view.list_entry;
out.player = view.player;
out.seller = view.seller;
out.seller_team_token = view.seller;
out.seller_manager = view.seller_manager;
out.viewer_manager = view.viewer_manager;
out.preferred_bid_index = view.preferred_bid_index;
out.has_preferred_bid = view.has_preferred_bid;
out.preferred_bid_passed_random_check = view.preferred_bid_passed_random_check;
out.player_name = game.player_name(view.player);
out.seller_name = (view.seller == 0x0fff || view.seller == kNoTeam) ? std::string() : game.club_name(view.seller);
// ClubName2 derives this label from the seller team token. A club is
// named directly; the player-pool token resolves to the original adviser.
out.negotiator_name = (view.seller == 0x0fff || view.seller == kNoTeam)
? (game.texts ? (*game.texts)[925] : "SPIELERBERATER")
: out.seller_name;
out.age = game.players[size_t(view.player)].age();
out.position = game.players[size_t(view.player)].position();
out.strength = game.players[size_t(view.player)].strength();
out.asking_fee = view.asking_fee;
out.asking_monthly_salary = view.asking_monthly_salary;
out.quoted_fee = view.quoted_fee;
out.quoted_monthly_salary = view.quoted_monthly_salary;
if (game.memory.has(::bmh::layout::CurrencyMultiplier)) out.currency_numerator = game.memory.u32(::bmh::layout::CurrencyMultiplier);
if (game.memory.has(::bmh::layout::CurrencyDivisor)) out.currency_denominator = game.memory.u32(::bmh::layout::CurrencyDivisor);
out.quoted_years = view.quoted_years;
out.notice_text = view.notice_text;
out.notice_text_address = view.notice_text_address;
out.offers = view.offers;
out.seller_badge_sprite = team_badge(game, view.seller);
const int manager = view.viewer_manager >= 0 ? view.viewer_manager : view.seller_manager;
out.viewer_manager = manager;
if (manager >= 0) {
if ((!pending_offer_source && size_t(manager) >= game.manager_teams.size()) ||
size_t(manager) * kManagerRecord + 0x223 > game.manager_records.size())
throw FormatError("incoming transfer: invalid viewer manager");
const int pending_team = pending_offer_source ? pending_offer_owner_team(game, manager) : -1;
const size_t name_at = size_t(manager) * kManagerRecord + 0xa8;
const size_t end = std::min(name_at + 26, game.manager_records.size());
size_t nul = name_at;
while (nul < end && game.manager_records[nul] != 0) ++nul;
out.viewer_name.assign(reinterpret_cast<const char*>(game.manager_records.data() + name_at), nul - name_at);
out.manager_portrait = game.manager_records[size_t(manager) * kManagerRecord + 0x221];
// The KB31 panel uses its static manager artwork and does not draw
// this portrait. Source notices can use portrait 12..14 as well.
if (out.manager_portrait > ((pending_offer_source || out.source_outgoing_editor_context) ? 14 : 11))
throw FormatError("incoming transfer: invalid viewer portrait");
out.notice_badge_fallback=source_badge_fallback(pending_offer_source?pending_team:game.manager_teams[size_t(manager)]);
out.badge_sprite = pending_offer_source ? team_badge(game, pending_team) : manager_badge(game, manager);
}
for (int i = 0; i < 4; ++i) {
auto& offer = out.offers[size_t(i)];
if (offer.present) {
const bool spare_buyer = pending_offer_source && i == 0 && offer.buyer_manager == 4 &&
pending_offer_spare_buyer(game, view.list_entry - 40, offer.buyer);
if (offer.bid_index != i || offer.buyer < 0 || size_t(offer.buyer) >= game.club_ids.size() ||
offer.buyer_manager < -1 || (!spare_buyer && offer.buyer_manager >= int(game.manager_teams.size())) ||
offer.contract_months == 0 || offer.contract_months > 84)
throw FormatError("incoming transfer: invalid raw bid slot");
out.buyer_names[size_t(i)] = game.club_name(offer.buyer);
} else if (offer.bid_index != -1 && offer.bid_index != i) {
throw FormatError("incoming transfer: empty slot has mismatched identity");
}
}
if (out.preferred_bid_index >= 0 && !out.offers[size_t(out.preferred_bid_index)].present)
throw FormatError("incoming transfer: preferred bid slot is empty");
if (pending_offer_source) {
if (!out.offers[0].present || out.offers[0].bid_index != 0 ||
std::any_of(out.offers.begin() + 1, out.offers.end(),
[](const IncomingTransferOfferSlot& offer) { return offer.present; }))
throw FormatError("incoming transfer: pending Source entry must contain only raw bid0");
}
return out;
}
} // namespace
IncomingTransferDecisionState incoming_transfer_decision_from_game(
const GameState& game, const IncomingTransferDecisionView& view) {
return incoming_transfer_decision_from_game_impl(game, view, false);
}
IncomingTransferDecisionState incoming_transfer_pending_decision_from_game(
const GameState& game, const TransferOfferListView& source) {
if (!source.valid || source.list_entry < 40 || source.list_entry >= 44 ||
source.seller_manager < 0 ||
source.offer_count != 1 || !source.offers[0].present || source.offers[0].bid_index != 0 ||
std::any_of(source.offers.begin() + 1, source.offers.end(),
[](const TransferOfferCandidateView& offer) { return offer.present; }))
throw FormatError("incoming transfer: invalid DispatchClubPlayerPendingOffers special entry");
IncomingTransferDecisionView view;
view.valid = source.valid;
view.list_entry = source.list_entry;
view.player = source.player;
view.seller = source.seller;
view.seller_manager = source.seller_manager;
view.viewer_manager = source.seller_manager;
view.preferred_bid_index = source.preferred_bid_index;
view.has_preferred_bid = source.preferred_bid_index >= 0;
view.preferred_bid_passed_random_check = source.preferred_bid_passed_random_check;
view.asking_fee = source.asking_fee;
view.asking_monthly_salary = source.asking_monthly_salary;
view.quoted_fee = source.quoted_fee;
view.quoted_monthly_salary = source.quoted_monthly_salary;
view.quoted_years = source.quoted_years;
// DispatchClubPlayerPendingOffers owns pending-action notices through PendingOfferHooks::notice.
// Its Source continuation redraws the chooser after SDLFlushEvents3, so this
// special adapter must not create the generic retry overlay a second time.
view.notice_text_address = 0;
for (size_t i = 0; i < view.offers.size(); ++i) {
const auto& from = source.offers[i];
auto& to = view.offers[i];
to.bid_index = from.bid_index;
to.buyer = from.buyer;
to.buyer_manager = from.buyer_manager;
to.fee = from.fee;
to.monthly_salary = from.monthly_salary;
to.fee_reference = from.fee_reference;
to.salary_reference = from.salary_reference;
to.contract_months = from.contract_months;
to.loan = from.loan;
to.bonuses = from.bonuses;
to.present = from.present;
to.eligible = from.eligible;
to.transaction_supported = from.transaction_supported;
}
return incoming_transfer_decision_from_game_impl(game, view, true);
}
std::string incoming_transfer_decision_json(const IncomingTransferDecisionState& state) {
std::ostringstream out;
out << "{\"screen\":\"incoming_transfer_decision\",\"pending_offer_source\":"
<< (state.pending_offer_source ? "true" : "false") << ",\"list_entry\":" << state.list_entry
<< ",\"title\":" << unsigned(state.title)
<< ",\"source_outgoing_editor_context\":" <<
(state.source_outgoing_editor_context ? "true" : "false")
<< ",\"player\":" << state.player << ",\"player_name\":" << json_quote(original_to_utf8(state.player_name))
<< ",\"seller\":" << state.seller << ",\"seller_name\":" << json_quote(original_to_utf8(state.seller_name))
<< ",\"seller_team_token\":" << state.seller_team_token
<< ",\"seller_manager\":" << state.seller_manager
<< ",\"viewer_manager\":" << state.viewer_manager
<< ",\"manager_portrait\":" << state.manager_portrait
<< ",\"badge_sprite\":" << state.badge_sprite
<< ",\"seller_badge_sprite\":" << state.seller_badge_sprite
<< ",\"age\":" << state.age << ",\"position\":" << state.position
<< ",\"strength\":" << state.strength
<< ",\"notice_text_address\":" << state.notice_text_address
<< ",\"preferred_bid_index\":" << state.preferred_bid_index
<< ",\"has_preferred_bid\":" << (state.has_preferred_bid ? "true" : "false")
<< ",\"preferred_bid_passed_random_check\":"
<< (state.preferred_bid_passed_random_check ? "true" : "false")
<< ",\"negotiator_name\":" << json_quote(original_to_utf8(state.negotiator_name))
<< ",\"asking_fee\":" << state.asking_fee << ",\"asking_monthly_salary\":" << state.asking_monthly_salary
<< ",\"quoted_fee\":" << state.quoted_fee << ",\"quoted_monthly_salary\":" << state.quoted_monthly_salary
<< ",\"currency_numerator\":" << state.currency_numerator
<< ",\"currency_denominator\":" << state.currency_denominator
<< ",\"quoted_years\":" << unsigned(state.quoted_years) << ",\"offers\":[";
for (size_t i = 0; i < state.offers.size(); ++i) {
if (i) out << ',';
const auto& offer = state.offers[i];
out << "{\"bid_index\":" << offer.bid_index << ",\"present\":" << (offer.present ? "true" : "false")
<< ",\"buyer\":" << offer.buyer << ",\"buyer_name\":" << json_quote(original_to_utf8(state.buyer_names[i]))
<< ",\"buyer_manager\":" << offer.buyer_manager << ",\"fee\":" << offer.fee
<< ",\"monthly_salary\":" << offer.monthly_salary << ",\"fee_reference\":" << offer.fee_reference
<< ",\"salary_reference\":" << offer.salary_reference << ",\"contract_months\":" << unsigned(offer.contract_months)
<< ",\"loan\":" << (offer.loan ? "true" : "false") << ",\"eligible\":" << (offer.eligible ? "true" : "false")
<< ",\"transaction_supported\":" << (offer.transaction_supported ? "true" : "false")
<< ",\"bonuses\":[";
for (size_t bonus = 0; bonus < offer.bonuses.size(); ++bonus) {
if (bonus) out << ',';
out << unsigned(offer.bonuses[bonus]);
}
out << "]}";
}
out << "]}";
return out.str();
}
IncomingTransferScreen::IncomingTransferScreen(const std::filesystem::path& data,
IncomingTransferDecisionState state,
bool gradient_text)
: state_(std::move(state)), exe_(load_le(asset_path(data, "BMH.exe"))),
texts_(load_textd(asset_path(data, "TEXTD.BLK"))),
body_(load_font(asset_path(data / "F", "BMH3.FNT"))),
heading_(load_font(asset_path(data / "F", "BMH2.FNT"))),
sprite_font_(data),
background_(load_vga(asset_path(data / "KB", "129.VGA"))),
negotiation_(load_vga(asset_path(data / "KB", "31.VGA"))),
gradient_text_(gradient_text), widgets_(load_vga(asset_path(data / "KB", "0.VGA"))),
faces_(load_vga(asset_path(data / "KB", "26.VGA"))) {
const bool entry_valid = state_.pending_offer_source
? state_.list_entry >= 40 && state_.list_entry < 44
: state_.list_entry >= 0 && state_.list_entry < (state_.source_outgoing_editor_context ? 44 : 40); // poaching rows
if (!entry_valid || state_.player < 0 || state_.player_name.empty() ||
background_.width != 320 || background_.height != 240 || negotiation_.width != 320 || negotiation_.height != 206 ||
state_.manager_portrait > ((state_.pending_offer_source || state_.source_outgoing_editor_context) ? 14 : 11) ||
(state_.preferred_bid_index >= 0 && !state_.offers[size_t(state_.preferred_bid_index)].present))
throw FormatError("incoming transfer: invalid owned view or original assets");
if (state_.pending_offer_source && (!state_.offers[0].present || state_.offers[0].bid_index != 0 ||
std::any_of(state_.offers.begin() + 1, state_.offers.end(),
[](const IncomingTransferOfferSlot& offer) { return offer.present; })))
throw FormatError("incoming transfer: pending Source view must contain only raw bid0");
badge_atlas_=state_.notice_badge_fallback||state_.badge_sprite<0?widgets_:
load_vga(asset_path(data/"W",std::to_string(state_.badge_sprite>>3)+".VGA"));
// SourceBadgeFallback chooses the neutral fallback from the raw team token before
// indexing ClubBadgeSelectors. A real selector can itself be 90..137 and must still
// load its W atlas, so do not classify seller art by selector value.
seller_badge_atlas_ = source_neutral_seller_token(source_seller_team_token(state_)) ||
state_.seller_badge_sprite < 0 ? widgets_ :
load_vga(asset_path(data / "W", std::to_string(state_.seller_badge_sprite >> 3) + ".VGA"));
notice_active_ = !state_.notice_text.empty();
if (!notice_active_ && state_.notice_text_address != 0) {
state_.notice_text = text_at(texts_, state_.notice_text_address);
notice_active_ = !state_.notice_text.empty();
}
}
void IncomingTransferScreen::draw_body(Image& out, int x, int baseline, std::string_view text,
uint8_t color) const {
draw_top(out, x, baseline - body_.baseline, text, color);
}
void IncomingTransferScreen::draw_top(Image& out, int x, int y, std::string_view text,
uint8_t color) const {
if (text.empty()) return;
const int top = y;
const int width = body_.text_width(text);
if (x < 0 || top < 0 || x + width > out.width || top + body_.height > out.height) return;
if (!gradient_text_ || exe_.u8(::bmh::layout::TextGradientMode) != 2) { body_.draw(out, x, top, text, color); return; }
Image mask(std::max(1, width), body_.height);
body_.draw(mask, 0, 0, text, 1);
int gradient = 0;
while (gradient < 32 && exe_.u8(::bmh::layout::Advertising_Text_RuntimeField2 + uint32_t(gradient)) != color) ++gradient;
for (int yy = 0; yy < body_.height; ++yy)
for (int xx = 0; xx < width; ++xx)
if (mask.at(xx, yy)) out.at(x + xx, top + yy) =
gradient < 32 ? exe_.u8(::bmh::layout::Advertising_Text_RuntimeField + uint32_t(gradient * 6 + std::min(yy, 5))) : color;
}
void IncomingTransferScreen::draw_heading(Image& out, int x, int baseline, std::string_view text,
uint8_t color) const {
const int top = baseline - heading_.baseline;
if (x < 0 || top < 0 || x + heading_.text_width(text) > out.width || top + heading_.height > out.height) return;
heading_.draw(out, x, top, text, color);
}
Image IncomingTransferScreen::render() const { return render_at_elapsed(0); }
void IncomingTransferScreen::begin_outcome(int row_count, int accepted_bid_index, uint8_t outcome_delay_disabled) {
if (row_count < 0 || row_count > int(state_.offers.size()) || accepted_bid_index < -1 ||
accepted_bid_index >= row_count ||
(accepted_bid_index >= 0 && !state_.offers[size_t(accepted_bid_index)].present))
throw FormatError("incoming transfer: invalid passive outcome");
outcome_row_count_ = row_count;
outcome_accepted_bid_index_ = accepted_bid_index;
outcome_speed_setting_ = outcome_delay_disabled;
outcome_dismissed_ = false;
}
uint64_t IncomingTransferScreen::outcome_duration_ms() const {
if (outcome_row_count_ < 0) return 0;
const int rows = outcome_accepted_bid_index_ >= 0
? outcome_accepted_bid_index_ + 1 : outcome_row_count_;
return uint64_t(rows) * 8u * (outcome_speed_setting_ == 0 ? outcome_phase_ms : 0u);
}
IncomingTransferOutcomeFrame IncomingTransferScreen::outcome_frame_at(uint64_t elapsed_ms) const {
IncomingTransferOutcomeFrame frame;
if (outcome_row_count_ < 0 || outcome_dismissed_) return frame;
const uint64_t phase_duration = outcome_speed_setting_ == 0 ? outcome_phase_ms : 0u;
const uint64_t row_duration = phase_duration * 8u;
const int resolved_rows = outcome_accepted_bid_index_ >= 0
? outcome_accepted_bid_index_ + 1 : outcome_row_count_;
for (int row = 0; row < resolved_rows && row < 4; ++row) {
const uint64_t row_start = uint64_t(row) * row_duration;
const uint64_t row_end = row_start + row_duration;
if (phase_duration != 0 && elapsed_ms < row_end) {
const auto phase = uint8_t((elapsed_ms - row_start) / phase_duration);
frame.blink_phase = phase;
frame.marks[size_t(row)] = IncomingTransferOutcomeMark::blinking_question;
frame.colors[size_t(row)] = exe_.u8(::bmh::layout::IncomingTransfer_OutcomeFrameAt_RuntimeField + uint32_t(phase % 2));
break;
}
if (outcome_accepted_bid_index_ == row) {
frame.marks[size_t(row)] = IncomingTransferOutcomeMark::accepted;
frame.colors[size_t(row)] = 0x27;
break;
}
frame.marks[size_t(row)] = IncomingTransferOutcomeMark::rejected;
frame.colors[size_t(row)] = 0x6c;
}
frame.complete = elapsed_ms >= outcome_duration_ms();
return frame;
}
Image IncomingTransferScreen::render_at_elapsed(uint64_t elapsed_ms) const {
if (confirmation_mode_) {
Image out = *confirmation_backdrop_;
draw_notice(out);
return out;
}
Image out = background_;
// OpenTransferEditor layers KB31 at native y=0x13 over the ordinary KB129 header/footer.
out.blit(negotiation_, 0, 0x13);
const uint32_t title_address = state_.title == IncomingTransferTitle::player_purchase
? kPurchaseTitleText : state_.title == IncomingTransferTitle::player_loan
? kLoanTitleText : kTitleText;
const auto title = original_to_utf8(text_at(texts_, title_address));
sprite_font_.draw(out, SpriteFont::centered_title_x(sprite_font_.text_width(title)), 13, title, 5);
sprite_font_.draw(out, 5, 235, original_to_utf8(state_.player_name), 5);
auto centered = [&](int left, int right, int baseline, std::string_view text, uint8_t color) {
const int width = body_.text_width(text);
draw_body(out, left + (right - left) / 2 - width / 2, baseline, text, color);
};
// OpenTransferEditor composes the player descriptor with the Source position,
// age and seller/team descriptor; the mode-1 text call uses baseline 25.
const auto pos = text_at(texts_, ::bmh::layout::IncomingTransfer_RenderAtElapsed_TextPointer2 + uint32_t(state_.position & 3) * 4);
const auto years_old = text_at(texts_, ::bmh::layout::IncomingTransfer_RenderAtElapsed_TextPointer6);
const std::string detail = state_.player_name + exe_.cstring(::bmh::layout::Fltd_Layout_TextPointer) + std::string(pos) +
exe_.cstring(::bmh::layout::Fltd_Layout_TextPointer) + source_number(uint32_t(state_.age), 2, false) + std::string(years_old) +
exe_.cstring(::bmh::layout::CupDraw_FormatError_TextPointer) + source_number(uint32_t(state_.strength), 2) + exe_.cstring(::bmh::layout::CupDraw_FormatError_ExecutableField);
centered(0, 319, 25, detail, 0x6a);
// DrawnFirstBy(..., 0x40): draw the flat shadow two pixels right/down.
auto shadow_text = [&](int x, int baseline, std::string_view text, uint8_t color) {
if (x + 2 + body_.text_width(text) <= out.width && baseline + 2 < out.height)
body_.draw(out, x + 2, baseline + 2 - body_.baseline, text, 0x40);
draw_body(out, x, baseline, text, color);
};
shadow_text(6, 39, text_at(texts_, ::bmh::layout::IncomingTransfer_RenderAtElapsed_TextPointer7), 0x6a);
if (!state_.negotiator_name.empty()) shadow_text(6, 46, state_.negotiator_name, 0x5f);
shadow_text(170, 39, text_at(texts_, ::bmh::layout::IncomingTransfer_RenderAtElapsed_TextPointer8), 0x6a);
shadow_text(170, 46, state_.player_name, 0x5f);
const bool source_neutral_badge =
source_neutral_seller_token(source_seller_team_token(state_));
if (source_neutral_badge) {
// SourceBadgeFallback passes seller|0x8000. These Source token families route
// through FormatError(type 14): frame first, then the neutral KB0 tile.
for (int y = 50; y <= 89; ++y) out.at(101, y) = 0x46;
for (int x = 101; x <= 140; ++x) out.at(x, 50) = 0x46;
for (int x = 101; x <= 140; ++x) out.at(x, 89) = 0x40;
for (int y = 50; y <= 89; ++y) out.at(140, y) = 0x40;
copy_region(out, widgets_, 8, 0, 102, 51, 38, 38, 0xff);
} else if (state_.seller_badge_sprite >= 0) {
const int sprite = state_.seller_badge_sprite;
if (seller_badge_atlas_.width >= (sprite % 8 + 1) * 38)
copy_region(out, seller_badge_atlas_, (sprite & 7) * 38, 0, 102, 51, 38, 38);
}
// OpenTransferEditor's seller view uses the single quoted line at baseline 32;
// the separate "Angebot" strings are only drawn when param_3 == -1.
std::string quote = std::string(text_at(texts_, ::bmh::layout::IncomingTransfer_RenderAtElapsed_TextPointer12)) +
source_money(state_.quoted_fee, 1, state_.currency_numerator, state_.currency_denominator) +
std::string(text_at(texts_, ::bmh::layout::IncomingTransfer_RenderAtElapsed_TextPointer13)) +
source_money(state_.quoted_monthly_salary, 1, state_.currency_numerator, state_.currency_denominator) +
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);
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)) +
source_money(state_.asking_monthly_salary, 5, state_.currency_numerator, state_.currency_denominator), 0x6a);
centered(2, 166, 139, text_at(texts_, ::bmh::layout::IncomingTransfer_RenderAtElapsed_TextPointer5), 0x6a);
for (size_t i = 0; i < state_.offers.size(); ++i) {
const auto& offer = state_.offers[i];
if (!offer.present) {
draw_body(out, 4, 0x99 + int(i) * 0x11, text_at(texts_, ::bmh::layout::IncomingTransfer_RenderAtElapsed_TextPointer9), 0x67);
continue;
}
const int years = (int(offer.contract_months) - 1) / 12 + 1;
const uint8_t offer_color = offer.loan ? 0x69 : 0x6c;
const std::string first = state_.buyer_names[i] + exe_.cstring(::bmh::layout::Fltd_Layout_TextPointer2) +
source_number(uint32_t(years), 1, false) + texts_[1327];
const std::string second = source_money(offer.fee, 7, state_.currency_numerator, state_.currency_denominator) + texts_[1328] +
source_money(offer.monthly_salary, 5, state_.currency_numerator, state_.currency_denominator) + texts_[1329];
draw_body(out, 4, 0x95 + int(i) * 0x11, first, offer_color);
draw_body(out, 4, 0x9d + int(i) * 0x11, second, offer_color);
}
if (outcome_row_count_ >= 0 && !outcome_dismissed_) {
const auto outcome = outcome_frame_at(elapsed_ms);
const auto question = exe_.cstring(::bmh::layout::IncomingTransfer_RenderAtElapsed_ExecutableField);
const auto rejected = text_at(texts_, ::bmh::layout::IncomingTransfer_RenderAtElapsed_TextPointer4);
const auto accepted = text_at(texts_, ::bmh::layout::IncomingTransfer_RenderAtElapsed_TextPointer3);
for (size_t row = 0; row < outcome.marks.size(); ++row) {
std::string_view text;
switch (outcome.marks[row]) {
case IncomingTransferOutcomeMark::blinking_question: text = question; break;
case IncomingTransferOutcomeMark::rejected: text = rejected; break;
case IncomingTransferOutcomeMark::accepted: text = accepted; break;
case IncomingTransferOutcomeMark::none: break;
}
// Source draws directly into the same framebuffer. Its final dark
// question glyphs remain wherever NEIN/OK does not overwrite them.
if (outcome.marks[row] == IncomingTransferOutcomeMark::rejected ||
outcome.marks[row] == IncomingTransferOutcomeMark::accepted)
draw_body(out, 0xb2, 0x98 + int(row) * 0x11, question, exe_.u8(::bmh::layout::IncomingTransfer_RenderAtElapsed_RuntimeField));
if (!text.empty()) draw_body(out, 0xb2, 0x98 + int(row) * 0x11, text,
outcome.colors[row]);
}
}
if (notice_active_) draw_notice(out);
return out;
}
void IncomingTransferScreen::show_confirmation(uint32_t original_text_address, const Image& backdrop) {
if (backdrop.width != 320 || backdrop.height != 240 || state_.viewer_manager < 0 ||
state_.manager_portrait < 0 || state_.badge_sprite < 0)
throw FormatError("incoming transfer: invalid confirmation context");
state_.notice_text_address = original_text_address;
state_.notice_text = text_at(texts_, original_text_address);
notice_active_ = true;
confirmation_mode_ = true;
confirmation_dismissed_ = false;
confirmation_backdrop_ = backdrop;
}
bool IncomingTransferScreen::dismiss_notice() {
if (confirmation_mode_ || !notice_active_) return false;
notice_active_ = false;
return true;
}
std::optional<int> IncomingTransferScreen::click(int x, int y, bool right, uint64_t elapsed_ms) {
if (confirmation_mode_) {
if (!right && x >= 95 && x <= 220 && y >= 166 && y <= 176)
confirmation_dismissed_ = true;
return std::nullopt;
}
if (outcome_row_count_ >= 0) {
// SDLFlushEvents2 is reached only after all result rows have settled.
// The caller passes the same deterministic elapsed clock as render_at_elapsed.
if (!outcome_dismissed_ && right && outcome_frame_at(elapsed_ms).complete)
outcome_dismissed_ = true;
return std::nullopt;
}
if (notice_active_) { dismiss_notice(); return std::nullopt; }
if (answer_) return std::nullopt;
if (right) { answer_ = -1; return answer_; }
// IncomingTransferScreen: InsideInclusive(4,0x8f,0xbe,0xd3,-1,0), then
// row=(mouse_y-0x8f)/0x11; the raw record slot is the same row index.
// InsideInclusive includes x=190 and y=211. The last bottom-edge pixel
// computes raw row 4, so keep it inert rather than indexing past four slots.
if (x < 4 || x > 190 || y < 0x8f || y >= 0xd3) return std::nullopt;
const int slot = (y - 0x8f) / 0x11;
if (slot < 0 || slot >= int(state_.offers.size()) || !state_.offers[size_t(slot)].present ||
(!state_.pending_offer_source && !state_.offers[size_t(slot)].transaction_supported))
return std::nullopt;
answer_ = slot;
return answer_;
}
std::optional<int> IncomingTransferScreen::key(std::string_view name) {
if (confirmation_mode_ || outcome_row_count_ >= 0) return std::nullopt;
if (notice_active_) { dismiss_notice(); return std::nullopt; }
if (answer_) return std::nullopt;
if (name == "ESC" || name == "ESCAPE") { answer_ = -1; return answer_; }
return std::nullopt;
}
std::string IncomingTransferScreen::state_json() const {
auto json = incoming_transfer_decision_json(state_);
if (answer_) {
const auto at = json.rfind('}');
json.insert(at, std::string(",\"answer\":") + std::to_string(*answer_));
}
if (notice_active_) {
const auto at = json.rfind('}');
json.insert(at, std::string(",\"notice_active\":true,\"notice_text\":") +
json_quote(original_to_utf8(state_.notice_text)));
}
if (outcome_row_count_ >= 0) {
const auto at = json.rfind('}');
json.insert(at, std::string(",\"outcome_row_count\":") + std::to_string(outcome_row_count_) +
",\"outcome_accepted_bid_index\":" +
std::to_string(outcome_accepted_bid_index_) +
",\"outcome_speed_setting\":" + std::to_string(outcome_speed_setting_) +
",\"outcome_dismissed\":" + (outcome_dismissed_ ? "true" : "false"));
}
if (confirmation_mode_) {
json.insert(json.rfind('}'), std::string(",\"confirmation_mode\":true,\"confirmation_dismissed\":") +
(confirmation_dismissed_ ? "true" : "false"));
}
return json;
}
void IncomingTransferScreen::draw_notice(Image& out) const {
if (state_.viewer_manager < 0 || state_.manager_portrait < 0 || state_.badge_sprite < 0) return;
TaxDialogProjection notice;
notice.manager_name=state_.viewer_name;
notice.portrait=state_.manager_portrait;
notice.badge_sprite=state_.badge_sprite;
notice.badge_fallback=state_.notice_badge_fallback;
notice.body=state_.notice_text;
notice.source_manager_flags=confirmation_mode_?0x80:0x40;
draw_source_dialog(out,{widgets_,faces_,&badge_atlas_,body_,heading_,exe_,
sprite_font_,texts_},notice,gradient_text_);
}
} // namespace bmh::ui