Files
Dreierpack-Manager/src/ui/stadium.cpp
T
ClaudeandClaude Sonnet 5.5 73af2a657d Explain the stadium, transfer, contract and application code in comments
Function and section comments for ui/stadium, ui/preparation_flow, the
transfer market, contract, outgoing and incoming transfer screens, and for
app/main, app/window_actions and app/desktop_actions. Comment lines only;
full build and runnable tests unchanged.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-06 11:21:31 +01:00

2312 lines
143 KiB
C++
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
// SPDX-License-Identifier: GPL-3.0-only
// Implementation of StadiumScreen and stadium_data_from_game()/stadium_data_points() (stadium.hpp): rendering of
// the scene, investment dialogs, block calculator and data page, pointer and key handling, and request
// construction. Source-tick timing for the calculator is advanced by the caller.
#include "formats/executable_layout.hpp"
#include "ui/stadium.hpp"
#include <algorithm>
#include <bit>
#include <limits>
#include <sstream>
#include <utility>
#include "formats/vga.hpp"
#include "game/messages.hpp"
#include "game/balance_plan.hpp"
#include "game/state.hpp"
#include "ui/manager.hpp"
#include "ui/setup.hpp"
namespace bmh::ui {
namespace {
// Fills a w*h rectangle with one palette index, clipped to the image. Used for panels, shadows and backgrounds.
void fill(Image& im, int x, int y, int w, int h, uint8_t color) {
for (int yy = std::max(0, y); yy < std::min(im.height, y + h); ++yy)
for (int xx = std::max(0, x); xx < std::min(im.width, x + w); ++xx)
im.at(xx, yy) = color;
}
// Draws a 1-pixel rectangle outline (w*h, clipped to the image). Used for hover and press highlights.
void outline(Image& im, int x, int y, int w, int h, uint8_t color) {
if (w <= 0 || h <= 0) return;
const int right = x + w - 1;
const int bottom = y + h - 1;
for (int xx = std::max(0, x); xx <= std::min(im.width - 1, right); ++xx) {
if (y >= 0 && y < im.height) im.at(xx, y) = color;
if (bottom >= 0 && bottom < im.height) im.at(xx, bottom) = color;
}
for (int yy = std::max(0, y); yy <= std::min(im.height - 1, bottom); ++yy) {
if (x >= 0 && x < im.width) im.at(x, yy) = color;
if (right >= 0 && right < im.width) im.at(right, yy) = color;
}
}
// Draws the 1-pixel panel border over the inclusive rectangle: 0x46 on top/left, 0x40 on bottom/right.
void source_border(Image& im, int left, int top, int right, int bottom) {
// PaintsFourBorderEdges draws these inclusive edges in this order. The bottom edge
// overwrites the lower-left pixel from the first edge; the right edge
// overwrites both right corners.
for (int y = top; y <= bottom; ++y) im.at(left, y) = 0x46;
for (int x = left; x <= right; ++x) im.at(x, top) = 0x46;
for (int x = left; x <= right; ++x) im.at(x, bottom) = 0x40;
for (int y = top; y <= bottom; ++y) im.at(right, y) = 0x40;
}
// Copies a w*h crop of src (starting at sx,sy) to dst at (x,y); pixels outside either image are skipped.
// With transparent=true, palette index 0 in the source is treated as the transparent key.
void copy_crop(Image& dst, const Image& src, int sx, int sy, int x, int y, int w, int h,
bool transparent = false) {
for (int yy = 0; yy < h; ++yy) for (int xx = 0; xx < w; ++xx) {
const int dx = x + xx, dy = y + yy, px = sx + xx, py = sy + yy;
if (dx < 0 || dy < 0 || dx >= dst.width || dy >= dst.height ||
px < 0 || py < 0 || px >= src.width || py >= src.height) continue;
const auto color = src.pixels[size_t(py) * size_t(src.width) + size_t(px)];
if (!transparent || color != 0) dst.at(dx, dy) = color;
}
}
// Draws the 2-pixel dark (0x40) shadow strips below and to the right of a w*h box at (x,y).
void source_shadow(Image& out, int x, int y, int w, int h) {
// ColorBottomRightBevel draws its two inclusive rectangles after clipping to the screen.
fill(out, x + 2, y + h, w, 2, 0x40);
fill(out, x + w, y + 2, 2, h, 0x40);
}
// Draws a dialog frame: optional shadow, a 16x16 background pattern read from the executable, the four
// corner pieces from the widget atlas, and the edge strips tiled in runs of 74 px (top/bottom) and 96 px (left/right).
void source_frame(Image& out, const Image& atlas, const LeImage& exe,
int x, int y, int w, int h, bool shadow = true) {
if (shadow) { fill(out, x + 2, y + h, w, 2, 0x40); fill(out, x + w, y + 2, 2, h, 0x40); }
for (int yy = 4; yy < h - 3; ++yy) for (int xx = 4; xx < w - 3; ++xx)
out.at(x + xx, y + yy) = exe.u8(::bmh::layout::Advertising_PatternRect_RuntimeField + size_t((yy - 4) & 15) * 16 + size_t((xx - 4) & 15));
copy_crop(out, atlas, 0, 0, x, y, 4, 4);
copy_crop(out, atlas, 4, 0, x + w - 4, y, 4, 4);
copy_crop(out, atlas, 0, 4, x, y + h - 4, 4, 4);
copy_crop(out, atlas, 4, 4, x + w - 4, y + h - 4, 4, 4);
for (int at = 4; at < w - 4; at += 74) {
const int n = std::min(74, w - 4 - at);
copy_crop(out, atlas, 0, 104, x + at, y, n, 4);
copy_crop(out, atlas, 0, 108, x + at, y + h - 4, n, 4);
}
for (int at = 4; at < h - 4; at += 96) {
const int n = std::min(96, h - 4 - at);
copy_crop(out, atlas, 0, 8, x, y + at, 4, n);
copy_crop(out, atlas, 4, 8, x + w - 4, y + at, 4, n);
}
}
// Draws text with its baseline at `baseline` (skipped entirely if it would leave the screen vertically).
// In gradient mode (executable flag == 2) a color found in the 32-entry gradient table is recolored per glyph row
// from a 6-row gradient; color 0x40 and unknown colors are drawn plain.
void draw_source_font(Image& out, const Font& font, const LeImage& exe, int x, int baseline,
std::string_view text, uint8_t color, bool gradient) {
const int y = baseline - font.baseline;
if (y < 0 || y + font.height > out.height) return;
if (!gradient || exe.u8(::bmh::layout::TextGradientMode) != 2 || color == 0x40) {
font.draw(out, x, y, text, color);
return;
}
unsigned slot = 0;
while (slot < 32 && exe.u8(::bmh::layout::Advertising_Text_RuntimeField2 + slot) != color) ++slot;
// color is not in the gradient table: fall back to a plain draw
if (slot == 32) { font.draw(out, x, y, text, color); return; }
Image mask(std::max(1, font.text_width(text)), font.height, 0);
font.draw(mask, 0, 0, text, 1);
for (int row = 0; row < mask.height; ++row)
for (int column = 0; column < mask.width; ++column)
if (mask.at(column, row) && x + column >= 0 && x + column < out.width)
out.at(x + column, y + row) = exe.u8(::bmh::layout::Advertising_Text_RuntimeField + slot * 6 + size_t(std::min(row, 5)));
}
// Reads a little-endian int32 from a manager record at byte offset `at` (bounds-checked).
int32_t record_i32(const std::vector<uint8_t>& bytes, size_t at) {
return int32_t(uint32_t(bytes.at(at)) | uint32_t(bytes.at(at + 1)) << 8 |
uint32_t(bytes.at(at + 2)) << 16 | uint32_t(bytes.at(at + 3)) << 24);
}
// Reads a little-endian uint16 from a manager record at byte offset `at` (bounds-checked).
uint16_t record_u16(const std::vector<uint8_t>& bytes, size_t at) {
return uint16_t(bytes.at(at) | uint16_t(bytes.at(at + 1)) << 8);
}
// Reads the base price and construction duration of the 8 investments from the executable tables.
StadiumInvestmentConstants investment_constants(const LeImage& exe) {
StadiumInvestmentConstants constants;
for (unsigned choice = 0; choice < 8; ++choice) {
constants.price[choice] = exe.u32(::bmh::layout::CareerSession_DispatchStadium_RuntimeField + choice * 4);
constants.weeks[choice] = exe.u8(::bmh::layout::CareerSession_DispatchStadium_RuntimeField2 + (14 + choice) * 5);
}
return constants;
}
// True if periphery object 0..13 can still be built: no construction running and not yet built
// (object 0 stays available until its level reaches 0xab).
bool periphery_available(const StadiumState& state, int object) {
return object >= 0 && object < 14 && state.days[size_t(object)] == 0 &&
(object == 0 ? state.level[0] < 0xab : state.level[size_t(object)] == 0);
}
// Display name of an investment row (its original label text).
std::string investment_name(const StadiumInvestmentRow& row) {
return row.original_label;
}
// Looks up a TEXTD string through a text pointer variable; empty if the id is out of range.
std::string textd_string(const TextDb& textd, uint32_t pointer_variable) {
const size_t id = text_id(pointer_variable);
return id < textd.strings.size() ? textd[id] : std::string{};
}
// Same as textd_string, using the texts loaded in the game state; empty if none are loaded.
std::string game_textd_string(const GameState& game, uint32_t pointer_variable) {
if (!game.texts) return {};
return textd_string(*game.texts, pointer_variable);
}
// Copies a stored name, replacing each ':' marker with the given separator text.
std::string expand_original_club_label(std::string_view name, std::string_view separator) {
std::string expanded;
for (char byte : name) {
if (byte == ':') expanded += separator;
else expanded.push_back(byte);
}
return expanded;
}
// Formats a duration: the number, then a unit text from TEXTD, an extra executable string when value != 1,
// and a trailing executable string.
std::string original_duration_text(const GameState& game, const TextDb& textd,
const LeImage& exe, int value, uint8_t format,
uint32_t unit_address) {
std::string result = format_number(game, value, format) + textd_string(textd, unit_address);
if (value != 1) result += exe.cstring(::bmh::layout::Stadium_FormatError_ExecutableField);
result += exe.cstring(::bmh::layout::CareerSession_FormatNumber_ExecutableField);
return result;
}
// Serializes a block expansion quote as a JSON object (part of the state dump).
std::string block_quote_json(const StadiumBlockExpansionQuote& q) {
std::ostringstream out;
out << "{\"manager\":" << q.manager << ",\"manager_club\":" << q.manager_club
<< ",\"slot\":" << unsigned(q.slot) << ",\"current_build_weeks\":" << unsigned(q.current_build_weeks)
<< ",\"current_raw_flags\":" << unsigned(q.current_raw_flags)
<< ",\"current_capacity_thousands\":" << unsigned(q.current_capacity_thousands)
<< ",\"current_future_capacity_thousands\":" << unsigned(q.current_future_capacity_thousands)
<< ",\"total_target_places\":" << q.total_target_places
<< ",\"desired_features\":" << unsigned(q.desired_features)
<< ",\"company_price_percent\":" << q.company_price_percent
<< ",\"price_per_1000\":" << q.price_per_1000 << ",\"max_places\":" << q.max_places
<< ",\"new_places\":" << q.new_places << ",\"new_places_cost\":" << q.new_places_cost
<< ",\"seats_cost\":" << q.seats_cost << ",\"roof_cost\":" << q.roof_cost
<< ",\"undiscounted_cost\":" << q.undiscounted_cost << ",\"base_price\":" << q.base_price
<< ",\"base_weeks\":" << unsigned(q.base_weeks) << '}';
return out.str();
}
// True for the request kinds that belong to the block expansion editor (they carry block fields).
bool block_request_kind(StadiumRequestKind kind) {
switch (kind) {
case StadiumRequestKind::expansion_select:
case StadiumRequestKind::expansion_set_total:
case StadiumRequestKind::expansion_toggle_feature:
case StadiumRequestKind::expansion_cancel:
case StadiumRequestKind::expansion_confirm:
case StadiumRequestKind::expansion_answer_tip: return true;
default: return false;
}
}
// True if two quotes describe the same manager, club, slot, current block state, price table entry and limits.
// The target-dependent costs are deliberately not compared.
bool same_block_quote_owner(const StadiumBlockExpansionQuote& a,
const StadiumBlockExpansionQuote& b) {
return a.manager == b.manager && a.manager_club == b.manager_club && a.slot == b.slot &&
a.current_build_weeks == b.current_build_weeks && a.current_raw_flags == b.current_raw_flags &&
a.current_capacity_thousands == b.current_capacity_thousands &&
a.current_future_capacity_thousands == b.current_future_capacity_thousands &&
a.company_price_percent == b.company_price_percent && a.price_per_1000 == b.price_per_1000 &&
a.max_places == b.max_places && a.base_weeks == b.base_weeks;
}
// Recomputes a block expansion quote from (total places, features) and the constants and returns true only if
// every field of `q` matches and all ranges are valid. Used to validate quotes in acknowledgements.
bool canonical_block_quote(const StadiumBlockExpansionQuote& q, uint32_t total,
uint8_t features,const StadiumBlockExpansionConstants& constants) {
const auto& prices=constants.price_per_1000;const auto& maxima=constants.max_places;const auto& weeks=constants.weeks;
const size_t slot = static_cast<uint8_t>(q.slot);
if (slot >= prices.size() || q.manager < 0 || q.manager_club < 0 ||
q.current_build_weeks != 0 || (q.current_raw_flags & ~uint8_t(3)) != 0 ||
(features & ~uint8_t(3)) != 0 ||
(features & uint8_t(q.current_raw_flags & 3)) != uint8_t(q.current_raw_flags & 3) ||
q.current_capacity_thousands * 1000u > maxima[slot] ||
total < uint32_t(q.current_capacity_thousands) * 1000u || total > maxima[slot] ||
total / 1000u > 255 || q.company_price_percent < 0 || q.company_price_percent > 427 ||
q.price_per_1000 != prices[slot] || q.max_places != maxima[slot] || q.base_weeks != weeks[slot])
return false;
const uint32_t current = uint32_t(q.current_capacity_thousands) * 1000u;
const uint32_t added = total - current;
// Cost component = price_per_1000 * (places/1000) * multiplier / divisor; fails if the product exceeds int32.
const auto component = [&](uint32_t places, uint32_t multiplier, uint32_t divisor,
uint32_t& out) {
const uint64_t value = uint64_t(q.price_per_1000) * (places / 1000u) * multiplier;
if (value > uint64_t(std::numeric_limits<int32_t>::max())) return false;
out = uint32_t(value / divisor);
return true;
};
// New places are charged in full; seats cost 45% and roof 30% of the per-place price. If the feature is
// already built (raw flag set), only the newly added places are charged for it, otherwise the whole block.
uint32_t new_cost = 0, seats = 0, roof = 0;
if (!component(added, 1, 1, new_cost) ||
((features & 1) && !component((q.current_raw_flags & 1) ? added : total, 45, 100, seats)) ||
((features & 2) && !component((q.current_raw_flags & 2) ? added : total, 30, 100, roof)))
return false;
const uint64_t sum = uint64_t(new_cost) + seats + roof;
if (sum > uint64_t(std::numeric_limits<int32_t>::max()) ||
sum * uint32_t(q.company_price_percent) > uint64_t(std::numeric_limits<int32_t>::max()))
return false;
return q.total_target_places == total && q.desired_features == features && q.new_places == added &&
q.new_places_cost == new_cost && q.seats_cost == seats && q.roof_cost == roof &&
q.undiscounted_cost == sum &&
q.base_price == uint32_t(sum * uint32_t(q.company_price_percent) / 100u);
}
// True if the editor mirrors its quote (target places, features) and the quote is canonical.
// header_text_variant must be in 3..10.
bool valid_editor_projection(const StadiumBlockExpansionEditor& editor,const StadiumBlockExpansionConstants& constants) {
return editor.total_target_places == editor.quote.total_target_places &&
editor.desired_features == editor.quote.desired_features &&
editor.header_text_variant >= 3 && editor.header_text_variant <= 10 &&
canonical_block_quote(editor.quote, editor.total_target_places, editor.desired_features,constants);
}
// True if all 8 block overviews are identical (construction weeks, flags, capacity levels, capacities).
bool same_block_overviews(const std::array<StadiumBlockOverview, 8>& a,
const std::array<StadiumBlockOverview, 8>& b) {
for (size_t i = 0; i < a.size(); ++i)
if (a[i].construction_weeks != b[i].construction_weeks || a[i].flags != b[i].flags ||
a[i].capacity_level != b[i].capacity_level || a[i].capacity != b[i].capacity)
return false;
return true;
}
// Like same_block_overviews, but ignores the slot that was just changed.
bool same_other_block_overviews(const std::array<StadiumBlockOverview, 8>& a,
const std::array<StadiumBlockOverview, 8>& b,
size_t changed_slot) {
for (size_t i = 0; i < a.size(); ++i) {
if (i == changed_slot) continue;
if (a[i].construction_weeks != b[i].construction_weeks || a[i].flags != b[i].flags ||
a[i].capacity_level != b[i].capacity_level || a[i].capacity != b[i].capacity)
return false;
}
return true;
}
// True if the presentation flags (backgrounds, dialog frame, gradient text) are identical.
bool same_source_stadium_style(const StadiumState& a, const StadiumState& b) {
return a.plain_background == b.plain_background && a.compact_dialog_frame == b.compact_dialog_frame &&
a.solid_panel_background == b.solid_panel_background && a.gradient_text == b.gradient_text;
}
// True if style and the inputs of the ticket compensation (level, live round, refund rate, season tickets)
// are unchanged; allow_ticket_cap permits season_tickets to differ (they may be capped after a build).
bool same_block_compensation_context(const StadiumState& a, const StadiumState& b,
bool allow_ticket_cap = false) {
return same_source_stadium_style(a, b) &&
a.source_level == b.source_level && a.live_league_round == b.live_league_round &&
a.ticket_refund_rate == b.ticket_refund_rate &&
(allow_ticket_cap || a.season_tickets == b.season_tickets);
}
// Sum of the capacity levels (thousands of places) of all blocks that are not under construction,
// excluding the block that is just becoming busy.
uint8_t source_usable_capacity_thousands(const std::array<StadiumBlockOverview, 8>& blocks,
size_t newly_busy_slot) {
uint8_t usable = 0;
for (size_t i = 0; i < blocks.size(); ++i) {
if (i == newly_busy_slot || blocks[i].construction_weeks != 0) continue;
usable = uint8_t(unsigned(usable) + unsigned(blocks[i].capacity_level));
}
return usable;
}
// Truncates a 64-bit value to 32 bits with wrap-around (two's complement), as 32-bit arithmetic would.
int32_t source_wrap_i32(int64_t value) {
return std::bit_cast<int32_t>(uint32_t(uint64_t(value)));
}
// Refund owed for season tickets that no longer fit into the usable capacity:
// missing tickets * min(15, 17 - live round) weeks * refund rate, wrapped to int32. Zero if everything fits.
int32_t source_immediate_compensation(uint16_t tickets, uint8_t usable_thousands,
uint8_t live_round, int32_t rate) {
const int32_t capacity = int32_t(usable_thousands) * 1000;
const int32_t missing = std::max(0, int32_t(tickets) - capacity);
if (missing == 0) return 0;
const int32_t weeks = std::min(15, 17 - int32_t(live_round));
return source_wrap_i32(int64_t(missing) * int64_t(weeks) * int64_t(rate));
}
// Season tickets capped to the usable capacity (thousands * 1000).
uint16_t source_ticket_cap(uint16_t tickets, uint8_t usable_thousands) {
return uint16_t(std::min<uint32_t>(tickets, uint32_t(usable_thousands) * 1000u));
}
}
// Projects the live game state of the active manager into a StadiumState for the screen: balance, texts,
// periphery levels/days, seat blocks and the 8 investment rows with their options.
// Throws FormatError if the active manager or its record is invalid.
StadiumState stadium_from_game(const GameState& game, const LeImage& exe, uint64_t revision,
int construction_percent) {
const int manager = int(game.memory.u8(::bmh::layout::ActiveManager));
// Each manager has a fixed 0xb0c-byte record in manager_records; all record offsets below are relative to it.
const size_t record = size_t(manager) * 0xb0c;
if (size_t(manager) >= game.manager_teams.size() || record + 0x5d > game.manager_records.size())
throw FormatError("stadium: invalid active manager or truncated record");
StadiumState state;
state.manager_slot = manager;
state.runtime_club = game.manager_teams.at(size_t(manager));
state.revision = revision;
// balance is stored at record offset 0x314
state.balance = record_i32(game.manager_records, record + 0x314);
state.balance_text = format_number(game, state.balance, 0x181);
state.construction_percent = construction_percent;
// Title and footer texts. The footer is the stadium name followed by the capacity in seats. The name comes
// from the stadium-name pool (indexed through club_heap_bc) unless a runtime flag selects a fixed text;
// if no name is found, a TEXTD prefix plus the club name is used instead.
if (state.runtime_club >= 0 && size_t(state.runtime_club) < game.club_ids.size()) {
state.original_stadium_title = game.club_name(state.runtime_club);
std::string footer_name;
const size_t heap_entry = size_t(state.runtime_club) * 2;
if ((!game.memory.has(::bmh::layout::LiveMatchday_FormatError_RuntimeField15) || game.memory.u8(::bmh::layout::LiveMatchday_FormatError_RuntimeField15) == 0) &&
state.runtime_club < exe.u16(::bmh::layout::CareerSession_DataDirectory_RuntimeField2) && heap_entry + 1 < game.club_heap_bc.size()) {
const size_t stadium_name = record_u16(game.club_heap_bc, heap_entry);
if (stadium_name < game.stadium_names.size() && game.stadium_names[stadium_name] != 0) {
for (size_t pos = stadium_name; pos < game.stadium_names.size() &&
game.stadium_names[pos] != 0; ++pos)
footer_name.push_back(char(game.stadium_names[pos]));
footer_name = expand_original_club_label(footer_name,
game_textd_string(game, ::bmh::layout::LiveMatchday_FormatError_TextPointer8));
}
}
if (game.memory.has(::bmh::layout::LiveMatchday_FormatError_RuntimeField15) && game.memory.u8(::bmh::layout::LiveMatchday_FormatError_RuntimeField15) != 0)
footer_name = game_textd_string(game, ::bmh::layout::LiveMatchday_FormatError_TextPointer7);
else if (footer_name.empty())
footer_name = game_textd_string(game, ::bmh::layout::LiveMatchday_FormatError_TextPointer9) + state.original_stadium_title;
state.original_stadium_footer = footer_name + exe.cstring(::bmh::layout::Stadium_FormatError_ExecutableField2) +
format_number(game, int32_t(uint32_t(game.manager_records.at(record + 0x5c)) * 1000), 1) +
game_textd_string(game, ::bmh::layout::Stadium_FormatError_ExecutableField3);
}
// Presentation flags read from game memory (absent memory counts as off).
state.plain_background = game.memory.has(::bmh::layout::PlainBackground) && game.memory.u8(::bmh::layout::PlainBackground) != 0;
state.compact_dialog_frame = game.memory.has(::bmh::layout::CompactDialogFrame) && game.memory.u8(::bmh::layout::CompactDialogFrame) != 0;
state.decorated_stadium_header = !state.plain_background;
state.periphery_animation_tick = game.memory.has(::bmh::layout::CareerSession_Invalid_RuntimeField2) ? game.memory.u32(::bmh::layout::CareerSession_Invalid_RuntimeField2) : 0;
state.periphery_balance_text = format_number(game, state.balance, 0x187) + exe.cstring(::bmh::layout::CareerSession_FormatNumber_ExecutableField);
// Pre-formatted price and duration texts of the 14 periphery objects.
for (size_t i = 0; i < 14; ++i) {
state.periphery_price_text[i] = format_number(game, int32_t(exe.u32(::bmh::layout::StadiumPriceTable + i * 4)), 0x187) +
exe.cstring(::bmh::layout::CareerSession_FormatNumber_ExecutableField);
const int days = exe.u8(::bmh::layout::CareerSession_DispatchStadium_RuntimeField2 + i * 5);
state.periphery_duration_text[i] = format_number(game, days, 0x81) + game_textd_string(game, ::bmh::layout::Stadium_FormatError_RuntimeField);
if (days != 1) state.periphery_duration_text[i] += exe.cstring(::bmh::layout::Stadium_FormatError_ExecutableField);
state.periphery_duration_text[i] += exe.cstring(::bmh::layout::CareerSession_FormatNumber_ExecutableField);
}
// Per-object build level (record +0) and remaining construction days (record +0x1e).
for (size_t i = 0; i < state.level.size(); ++i) {
state.level[i] = game.manager_records.at(record + i);
state.days[i] = game.manager_records.at(record + 0x1e + i);
}
// The 8 seat blocks: construction weeks (+0x34), flags (+0x44), capacity level (+0x4c), capacity (+0x54).
for (unsigned i = 0; i < 8; ++i) {
auto& block = state.blocks[i];
block.construction_weeks = game.manager_records.at(record + 0x34 + i);
block.flags = game.manager_records.at(record + 0x44 + i);
block.capacity_level = game.manager_records.at(record + 0x4c + i);
block.capacity = game.manager_records.at(record + 0x54 + i);
}
// The 8 investment rows: status (+0x3c), remaining weeks (+0x2c), the available options and their price texts.
// The price of option n is the base price times (n + 1).
const auto constants = investment_constants(exe);
for (unsigned i = 0; i < 8; ++i) {
auto& row = state.investments[i];
row.investment = static_cast<StadiumInvestment>(i);
row.current_status = game.manager_records.at(record + 0x3c + i);
row.current_level = row.current_status & 7;
row.construction_weeks = game.manager_records.at(record + 0x2c + i);
row.options = stadium_investment_options_source(game, manager, row.investment,
construction_percent, constants);
row.available = !row.options.empty();
row.option_price_text.clear();
for (size_t option = 0; option < row.options.size(); ++option) {
const uint32_t source_price = constants.price[i] * uint32_t(option + 1);
row.option_price_text.push_back(format_number(game, int32_t(source_price), 0x187) +
exe.cstring(::bmh::layout::CareerSession_FormatNumber_ExecutableField));
}
}
return state;
}
// Builds the data page projection for a manager (slot 0..4): ticket price, six history curves with their
// scale limits, the 3x7 statistics table texts and the required attendance text.
// Throws FormatError on invalid selectors or out-of-range record contents.
StadiumDataProjection stadium_data_from_game(const GameState& game, const LeImage& exe,
int manager, uint8_t flags) {
if (manager < 0 || manager > 4) throw FormatError("stadium data: invalid manager");
StadiumDataProjection out;
out.flags = flags;
const size_t at = size_t(manager) * 0xb0c;
const auto& r = game.manager_records;
out.ticket_price = r.at(at + 0x26e);
// Curves: the executable assigns each curve a history selector (0..3) whose record counter gives the
// number of samples. Sample values are read from different record arrays per curve; the scale limits come
// from executable tables.
for (int curve = 0; curve < 6; ++curve) {
const int selector = exe.u8(::bmh::layout::Analytics_FormatError_RuntimeField2 + 6 + curve);
if (selector < 0 || selector > 3) throw FormatError("stadium data: invalid Source history selector");
const int count = r.at(at + 0x283 + size_t(selector));
const int limit = selector == 0 ? 19 : selector == 2 ? 52 : 52;
if (count > limit) throw FormatError("stadium data: Source history exceeds its record bounds");
for (int sample = 0; sample < count; ++sample) {
const size_t n = size_t(sample);
int32_t value = 0;
switch (curve) {
case 0: value = record_i32(r, at + 0x340 + n * 4); break;
case 1: value = record_i32(r, at + 0x38c + n * 4); break;
case 2: value = r.at(at + 0x270 + n); break;
case 3: value = std::bit_cast<int32_t>(uint32_t(record_i32(r, at + 0x340 + n * 4)) * r.at(at + 0x270 + n)); break;
case 4: value = int32_t(r.at(at + 0x17a + n)) * 100; break;
case 5: value = record_i32(r, at + 0x648 + n * 4); break;
}
out.series[size_t(curve)].push_back(value);
}
out.minimum[size_t(curve)] = std::bit_cast<int32_t>(exe.u32(::bmh::layout::Analytics_FormatError_RuntimeField3 + 24 + curve * 4));
out.maximum[size_t(curve)] = std::bit_cast<int32_t>(exe.u32(::bmh::layout::Analytics_FormatError_RuntimeField4 + 24 + curve * 4));
}
// Maximum of curves 0 and 1 derives from the stadium capacity (record +0x5c, in thousands): x1000 and x20000.
out.maximum[0] = int32_t(r.at(at + 0x5c)) * 1000;
out.maximum[1] = int32_t(r.at(at + 0x5c)) * 20000;
// Formats a day counter as dd.mm.yy using the executable's separator string; '%' padding becomes '0'.
const auto date_text = [&](uint32_t counter) {
const auto date = desk_date(counter, exe);
auto text = format_number(game, date.day, 2) + exe.cstring(::bmh::layout::OtherGamesState_ResultText_ExecutableField) +
format_number(game, date.month, 2) + exe.cstring(::bmh::layout::OtherGamesState_ResultText_ExecutableField) +
format_number(game, date.year % 100, 0x42);
std::replace(text.begin(), text.end(), '%', '0');
return text;
};
// Statistics table: 3 columns (kind) x 7 rows. Rows 0..3 hold a record value with date or an opponent name
// (row 1 and 3 hold the name, rows 0 and 2 the value), rows 4..6 are numeric: a count, a value divided by that count, and a third stored value.
for (int kind = 0; kind < 3; ++kind) for (int row = 0; row < 7; ++row) {
auto text = row == 1 || row == 3 ? std::string{} : message_text(game, ::bmh::layout::Stadium_StadiumDataFromGame_TextPointer);
if (row < 4) {
const size_t base = at + 0x718 + size_t(row >= 2) * 24 + size_t(kind) * 8;
const int32_t value = record_i32(r, base);
if (value != 0) {
if (row == 0 || row == 2)
text = format_number(game, value, 0x87) + exe.cstring(::bmh::layout::Stadium_StadiumDataFromGame_ExecutableField) +
date_text(uint32_t(record_i32(r, base + 4))) + exe.cstring(::bmh::layout::SeriesRecords_Render_ExecutableField);
else {
const size_t offset = record_u16(r, at + 0x8c0 + size_t(row == 3) * 6 + size_t(kind) * 2);
if (offset >= game.club_names.size()) throw FormatError("stadium data: opponent name offset outside Source pool");
for (size_t i = offset; i < game.club_names.size() && game.club_names[i]; ++i)
text += char(game.club_names[i]);
}
}
} else {
const int count = int8_t(r.at(at + 0x28c + size_t(kind)));
int32_t value = 0;
if (count != 0) {
if (row == 4) value = count;
else if (row == 5) value = record_i32(r, at + 0x748 + size_t(kind) * 4) / count;
else value = record_i32(r, at + 0x754 + size_t(kind) * 4);
}
if (value != 0) text = format_number(game, value, 0x88);
}
out.table[size_t(row)][size_t(kind)] = std::move(text);
}
out.required_attendance_text = format_number(game, stadium_required_attendance(game, manager), 0x81);
return out;
}
// Converts one curve of the data page into screen points (x, y). Without the fixed-scale flag (0x40) the
// values are normalised to 0..100 first. The graph is 83 px high with its baseline at y=101, and x spreads
// the samples over 298 px starting at x=13.
std::vector<std::pair<int, int>> stadium_data_points(const StadiumDataProjection& data,
const LeImage& exe, int curve) {
if (curve < 0 || curve >= 6) throw FormatError("stadium data: invalid curve");
auto values = data.series[size_t(curve)];
if (values.empty()) return {};
int32_t low = data.minimum[size_t(curve)], high = data.maximum[size_t(curve)];
if (!(data.flags & 0x40)) {
const auto [minimum, maximum] = std::minmax_element(values.begin(), values.end());
const int32_t minimum_value = *minimum;
const uint32_t range = *maximum == 0 ? 0 : uint32_t(*maximum) - uint32_t(minimum_value);
for (auto& value : values) value = range ?
std::bit_cast<int32_t>((uint32_t(value) - uint32_t(minimum_value)) * 100) / int32_t(range) : 50;
low = 0; high = 100;
}
if (low > high) throw FormatError("stadium data: reversed Source graph scale");
const int selector = exe.u8(::bmh::layout::Analytics_FormatError_RuntimeField2 + 6 + curve);
// number of x slots the samples are spread over (at least 34 for selector 0, otherwise 17)
const int horizon = std::max(int(values.size()), selector == 0 ? 34 : 17);
std::vector<std::pair<int, int>> points;
for (size_t sample = 0; sample < values.size(); ++sample) {
const int32_t value = std::clamp(values[sample], low, high);
// Amount2 uses x87 truncate toward zero, after an 83-pixel quotient.
// With equal limits Source 0/0 converts to x87 integer-indefinite,
// whose low short is zero before the y=101-height step.
const int height = low == high ? 0 : int(double(int64_t(value) - low) * 83.0 / double(int64_t(high) - low));
points.emplace_back(13 + int(sample) * 298 / horizon, 101 - height);
}
return points;
}
// Only updates the construction percent; the investment options are reprojected by the owner of the game state.
void stadium_apply_price_table(StadiumState& state, const LeImage& exe, int construction_percent) {
(void)exe;
// Options must be reprojected from the live GameState by the App owner; this
// presentation-only helper intentionally cannot reconstruct/guess them.
state.construction_percent = construction_percent;
}
// Serializes the full StadiumState as JSON (state dump for tests and tooling).
std::string stadium_state_json(const StadiumState& s) {
std::ostringstream out;
out << "{\"manager_slot\":" << s.manager_slot << ",\"runtime_club\":" << s.runtime_club
<< ",\"stable_club_identity\":" << (s.stable_club_identity ? std::to_string(*s.stable_club_identity) : "null")
<< ",\"revision\":" << s.revision << ",\"scope\":" << s.scope << ",\"sequence\":" << s.sequence
<< ",\"source\":" << json_quote(s.source) << ",\"club_name\":" << json_quote(original_to_utf8(s.club_name))
<< ",\"balance\":" << s.balance << ",\"balance_text\":" << json_quote(original_to_utf8(s.balance_text))
<< ",\"original_stadium_title\":" << json_quote(original_to_utf8(s.original_stadium_title))
<< ",\"original_stadium_footer\":" << json_quote(original_to_utf8(s.original_stadium_footer))
<< ",\"decorated_stadium_header\":" << (s.decorated_stadium_header ? "true" : "false")
<< ",\"plain_background\":" << (s.plain_background ? "true" : "false")
<< ",\"compact_dialog_frame\":" << (s.compact_dialog_frame ? "true" : "false")
<< ",\"solid_panel_background\":" << (s.solid_panel_background ? "true" : "false")
<< ",\"construction_percent\":" << s.construction_percent
<< ",\"data_open\":" << (s.data ? "true" : "false")
<< ",\"data_flags\":" << (s.data ? std::to_string(s.data->flags) : "null")
<< ",\"data_ticket_price\":" << (s.data ? std::to_string(s.data->ticket_price) : "null")
<< ",\"data_required_attendance\":" << (s.data ? json_quote(s.data->required_attendance_text) : "null")
<< ",\"opened\":" << (s.opened ? "true" : "false")
<< ",\"investments_enabled\":" << (s.investments_enabled ? "true" : "false")
<< ",\"investments\":[";
for (size_t i = 0; i < s.investments.size(); ++i) {
if (i) out << ',';
const auto& row = s.investments[i];
out << "{\"choice\":" << i << ",\"label\":" << json_quote(original_to_utf8(row.original_label))
<< ",\"status\":" << unsigned(row.current_status) << ",\"level\":" << unsigned(row.current_level) << ",\"construction_weeks\":" << unsigned(row.construction_weeks)
<< ",\"available\":" << (row.available ? "true" : "false") << ",\"options\":[";
for (size_t j = 0; j < row.options.size(); ++j) {
if (j) out << ',';
const auto& option = row.options[j];
out << "{\"current_status\":" << unsigned(option.current_status)
<< ",\"current_level\":" << unsigned(option.current_level)
<< ",\"increment\":" << unsigned(option.increment)
<< ",\"target_level\":" << unsigned(option.target_level)
<< ",\"base_price\":" << option.base_price
<< ",\"base_weeks\":" << unsigned(option.base_weeks) << '}';
}
out << "]}";
}
out << "],\"selected_investment\":";
if (s.selected_investment) out << unsigned(*s.selected_investment); else out << "null";
out << ",\"selected_option\":" << (s.selected_option ? std::to_string(*s.selected_option) : "null")
<< ",\"investment_text_variant\":" << s.investment_text_variant
<< ",\"construction_tip_price\":" << s.construction_tip_price
<< ",\"construction_tip_dialog\":" << (s.construction_tip_dialog ? "true" : "false")
<< ",\"quoted_object\":" << (s.quoted_object ? std::to_string(*s.quoted_object) : "null")
<< ",\"quoted_price\":" << s.quoted_price << ",\"blocks\":[";
for (size_t i = 0; i < s.blocks.size(); ++i) {
if (i) out << ',';
const auto& b = s.blocks[i];
out << "{\"construction_weeks\":" << unsigned(b.construction_weeks)
<< ",\"flags\":" << unsigned(b.flags) << ",\"capacity_level\":" << unsigned(b.capacity_level)
<< ",\"capacity\":" << unsigned(b.capacity) << '}';
}
out << "],\"block_text_variant\":" << s.block_text_variant
<< ",\"block_expansion\":";
if (!s.block_expansion) out << "null";
else {
const auto& editor = *s.block_expansion;
out << "{\"quote\":" << block_quote_json(editor.quote)
<< ",\"total_target_places\":" << editor.total_target_places
<< ",\"desired_features\":" << unsigned(editor.desired_features)
<< ",\"header_text_variant\":" << editor.header_text_variant
<< ",\"offer\":";
if (editor.offer) out << "{\"percent\":" << editor.offer->percent
<< ",\"base_price\":" << editor.offer->base_price
<< ",\"offered_price\":" << editor.offer->offered_price
<< ",\"price\":" << editor.offer->price
<< ",\"base_days\":" << editor.offer->base_days
<< ",\"construction_days\":" << editor.offer->construction_days
<< ",\"decision\":" << unsigned(editor.offer->decision) << '}';
else out << "null";
out << ",\"current_places_text\":" << json_quote(original_to_utf8(editor.current_places_text))
<< ",\"new_places_text\":" << json_quote(original_to_utf8(editor.new_places_text))
<< ",\"target_places_text\":" << json_quote(original_to_utf8(editor.target_places_text))
<< ",\"per_thousand_cost_text\":" << json_quote(original_to_utf8(editor.per_thousand_cost_text))
<< ",\"new_places_cost_text\":" << json_quote(original_to_utf8(editor.new_places_cost_text))
<< ",\"seats_cost_text\":" << json_quote(original_to_utf8(editor.seats_cost_text))
<< ",\"roof_cost_text\":" << json_quote(original_to_utf8(editor.roof_cost_text))
<< ",\"total_cost_text\":" << json_quote(original_to_utf8(editor.total_cost_text))
<< ",\"discount_text\":" << json_quote(original_to_utf8(editor.discount_text)) << '}';
}
out << ",\"action_feedback\":" << (s.action_feedback.empty() ? "null" : json_quote(s.action_feedback)) << '}';
return out.str();
}
// Serializes a request, including its kind name and the optional expected block quote, as JSON.
std::string stadium_request_json(const StadiumRequest& r) {
const char* kind = "none";
switch (r.kind) {
case StadiumRequestKind::open: kind = "open"; break;
case StadiumRequestKind::quote_periphery: kind = "quote_periphery"; break;
case StadiumRequestKind::decline_periphery: kind = "decline_periphery"; break;
case StadiumRequestKind::build_periphery: kind = "build_periphery"; break;
case StadiumRequestKind::select_block: kind = "select_block"; break;
case StadiumRequestKind::prepare_block_offer: kind = "prepare_block_offer"; break;
case StadiumRequestKind::decline_block_offer: kind = "decline_block_offer"; break;
case StadiumRequestKind::build_stand_block: kind = "build_stand_block"; break;
case StadiumRequestKind::select_investment: kind = "select_investment"; break;
case StadiumRequestKind::select_investment_option: kind = "select_investment_option"; break;
case StadiumRequestKind::cancel_investment: kind = "cancel_investment"; break;
case StadiumRequestKind::confirm_investment: kind = "confirm_investment"; break;
case StadiumRequestKind::answer_construction_tip: kind = "answer_construction_tip"; break;
case StadiumRequestKind::close: kind = "close"; break;
case StadiumRequestKind::expansion_select: kind = "expansion_select"; break;
case StadiumRequestKind::expansion_set_total: kind = "expansion_set_total"; break;
case StadiumRequestKind::expansion_toggle_feature: kind = "expansion_toggle_feature"; break;
case StadiumRequestKind::expansion_cancel: kind = "expansion_cancel"; break;
case StadiumRequestKind::expansion_confirm: kind = "expansion_confirm"; break;
case StadiumRequestKind::expansion_answer_tip: kind = "expansion_answer_tip"; break;
case StadiumRequestKind::open_data: kind = "open_data"; break;
case StadiumRequestKind::toggle_data_curve: kind = "toggle_data_curve"; break;
case StadiumRequestKind::toggle_data_scale: kind = "toggle_data_scale"; break;
case StadiumRequestKind::set_data_ticket_price: kind = "set_data_ticket_price"; break;
case StadiumRequestKind::close_data: kind = "close_data"; break;
case StadiumRequestKind::none: break;
}
std::ostringstream out;
out << "{\"kind\":" << json_quote(kind) << ",\"manager_slot\":" << r.manager_slot
<< ",\"runtime_club\":" << r.runtime_club << ",\"stable_club_identity\":"
<< (r.stable_club_identity ? std::to_string(*r.stable_club_identity) : "null")
<< ",\"revision\":" << r.revision << ",\"scope\":" << r.scope << ",\"sequence\":" << r.sequence
<< ",\"object\":" << r.object << ",\"price\":" << r.price << ",\"option\":" << r.option
<< ",\"accept_tip\":" << (r.accept_tip ? "true" : "false")
<< ",\"block_slot\":" << r.block_slot << ",\"block_total_places\":" << r.block_total_places
<< ",\"block_features\":" << unsigned(r.block_features) << ",\"expected_block_quote\":";
if (r.expected_block_quote) out << block_quote_json(*r.expected_block_quote); else out << "null";
out << '}';
return out.str();
}
// Loads the executable, text database, graphics and fonts the screen needs and validates the scene sizes.
// Empty investment labels are filled from TEXTD (ids 734..741). Throws FormatError on unusable assets.
StadiumScreen::StadiumScreen(const std::filesystem::path& data, StadiumState state)
: state_(std::move(state)), data_(data), exe_(load_le(asset_path(data, "BMH.exe"))),
texts_(load_textd(asset_path(data, "TEXTD.BLK"))),
background_(load_vga(asset_path(data / "KB", "35.VGA"))),
header_background_(load_vga(asset_path(data / "KB", "129.VGA"))),
interior_(load_vga(asset_path(data / "KB", "38.VGA"))),
facilities_(load_vga(asset_path(data / "KB", "39.VGA"))),
panel_(load_vga(asset_path(data / "KB", "56.VGA"))),
periphery_overlay_(load_vga(asset_path(data / "KB", "70.VGA"))),
widgets_(load_vga(asset_path(data / "KB", "0.VGA"))),
calculator_art_(load_vga(asset_path(data / "KB", "6.VGA"))),
font_(load_font(asset_path(data / "F", "BMH3.FNT"))),
heading_font_(load_font(asset_path(data / "F", "BMH2.FNT"))), sprite_font_(data) {
if (background_.width <= 0 || header_background_.width <= 0 || interior_.width <= 0 || facilities_.width <= 0 ||
panel_.width <= 0 || calculator_art_.width < 113 || calculator_art_.height < 150 || state_.manager_slot < 0)
throw FormatError("stadium: unsupported scene or invalid manager");
for (size_t i = 0; i < state_.investments.size(); ++i) {
if (state_.investments[i].original_label.empty())
state_.investments[i].original_label = texts_[734 + i];
}
rebuild_tip_dialog();
}
// Draws text in the screen font at a baseline position; gradient is applied only if the state enables it.
void StadiumScreen::text_at(Image& out, int x, int baseline, std::string_view text, uint8_t color,
bool gradient) const {
draw_source_font(out, font_, exe_, x, baseline, text, color,
gradient && state_.gradient_text);
}
// Draws a button in the original style at (x,y) with size w*h; `selected` draws the pressed/active look.
// Wide buttons (w > 31) are assembled from left/middle/right slices of the widget atlas, narrow ones use a frame.
void StadiumScreen::original_button(Image& out, int x, int y, int w, int h,
std::string_view label, bool selected) const {
// FormatError3's requested 9px height becomes 10px for these wide controls.
// wide buttons requested with height 9 are drawn 10 px high
const int visible_h = w > 31 && h == 9 ? 10 : h;
if (visible_h != 10 && !(w <= 31 && visible_h == 9)) throw FormatError("stadium: unsupported Original button height");
if (selected) {
const auto under = out.at(x, y + visible_h);
fill(out, x, y, w <= 31 ? w + 1 : w, 2, under); fill(out, x, y, 2, visible_h + 1, under); x += 2; y += 2;
} else { fill(out, x + 2, y + visible_h, w, 2, 0x40); fill(out, x + w, y + 2, 2, visible_h, 0x40); }
if (w <= 31) {
source_frame(out, widgets_, exe_, x, y, w, visible_h, false);
sprite_font_.draw(out, x + w / 2 - sprite_font_.text_width(original_to_utf8(label)) / 2,
y + visible_h / 2 + 2, original_to_utf8(label), exe_.u8(::bmh::layout::Advertising_Button_RuntimeField + int(selected)));
return;
}
const int sy = selected ? 44 : 74;
copy_crop(out, widgets_, 24, sy, x, y, 31, 10);
int used = 31;
while (w - used > 20) {
const int n = std::min(8, w - used - 20);
copy_crop(out, widgets_, 24, sy + 10, x + used, y, n, 10); used += n;
}
copy_crop(out, widgets_, 45 - (w - used), sy + 20, x + used, y, w - used, 10);
sprite_font_.draw(out, x + w / 2 - sprite_font_.text_width(original_to_utf8(label)) / 2,
y + 7, original_to_utf8(label), exe_.u8(::bmh::layout::Advertising_Button_RuntimeField + int(selected)));
}
// Creates a request stamped with the identity of the current state (manager, club, scope, sequence and revision).
// acknowledge() later checks these stamps against the engine's answer, so stale requests are rejected.
StadiumRequest StadiumScreen::request(StadiumRequestKind kind, int object, int option,
int32_t price, bool accept_tip) const {
StadiumRequest r;
r.kind = kind; r.manager_slot = state_.manager_slot; r.runtime_club = state_.runtime_club;
r.stable_club_identity = state_.stable_club_identity; r.revision = state_.revision;
r.scope = state_.scope; r.sequence = state_.sequence; r.object = object;
r.option = option; r.price = price; r.accept_tip = accept_tip;
return r;
}
// Creates a request for the block expansion editor. It also carries the quote the editor currently shows
// (expected_block_quote), which the engine must still find unchanged. A zero total/features means 'keep the
// editor's current value'; set_total and toggle_feature always use the value passed in.
StadiumRequest StadiumScreen::block_request(StadiumRequestKind kind, uint32_t total,
uint8_t features) const {
if (!block_request_kind(kind)) throw FormatError("stadium: invalid block expansion request kind");
auto r = request(kind);
if (kind == StadiumRequestKind::expansion_select) {
if (pressed_ != Pressed::block_row || pressed_index_ < 0 || pressed_index_ >= 8)
throw FormatError("stadium: block selection has no Source row owner");
r.block_slot = pressed_index_;
return r; // Source entry carries only the slot; App supplies the immutable quote.
}
if (!state_.block_expansion) throw FormatError("stadium: block request has no editor owner");
const auto& editor = *state_.block_expansion;
r.block_slot = int(editor.quote.slot);
r.block_total_places = total ? total : editor.total_target_places;
r.block_features = features ? features : editor.desired_features;
if (kind == StadiumRequestKind::expansion_set_total) r.block_total_places = total;
if (kind == StadiumRequestKind::expansion_toggle_feature) r.block_features = features;
r.expected_block_quote = editor.quote;
return r;
}
// Creates the initial open request; it is also stored as pending until acknowledge() is called.
StadiumRequest StadiumScreen::initialize() {
if (pending_) throw FormatError("stadium: open already pending");
auto r = request(StadiumRequestKind::open);
pending_ = r;
return r;
}
// Rebuilds the modal dialogs (periphery quote and construction tip) over a snapshot of the current scene.
// Called after the state changes.
void StadiumScreen::rebuild_tip_dialog() {
tip_dialog_.reset();
periphery_dialog_.reset();
if (state_.periphery_quote_dialog) {
GameEndRenderOptions options{state_.plain_background, state_.gradient_text};
periphery_dialog_.emplace(data_, *state_.periphery_quote_dialog, options, render_scene());
}
if (state_.construction_tip_dialog) {
GameEndRenderOptions options;
options.gradient_text = state_.gradient_text;
if (state_.block_expansion) options.plain_background = state_.plain_background;
tip_dialog_.emplace(data_, *state_.construction_tip_dialog,
options, state_.block_expansion
? render_block_expansion(render_scene()) : render_investment_dialog(render_scene()));
}
}
// Renders the block expansion editor dialog (title, balance, duration, current and target places, per-feature
// icons and costs, total with discount, Build/Cancel buttons) over the given scene image.
Image StadiumScreen::render_block_expansion(Image out) const {
if (!state_.block_expansion) return out;
const auto& editor = *state_.block_expansion;
const unsigned slot = unsigned(editor.quote.slot);
if (slot >= state_.blocks.size()) throw FormatError("stadium: invalid block editor slot");
source_frame(out, widgets_, exe_, 1, 22, 214, 128, false);
const std::string title = texts_[742 + slot] + texts_[1089];
const int title_width = heading_font_.text_width(title);
draw_source_font(out, heading_font_, exe_, 1 + (215 - title_width) / 2,
33, title, 0x5f, false); // Front explicitly selects Font2.
text_at(out, 5, 46, texts_[text_id(::bmh::layout::Stadium_RenderBlockExpansion_TextPointer2)], 0x6c, true);
const std::string balance = state_.balance_text.empty() ? std::to_string(state_.balance) : state_.balance_text;
text_at(out, 148 - font_.text_width(balance), 46, balance, 0x6c, true);
const std::string weeks = original_duration_text(GameState{}, texts_, exe_, editor.quote.base_weeks, 0x82, ::bmh::layout::Stadium_FormatError_RuntimeField);
text_at(out, 5, 54, texts_[text_id(::bmh::layout::Stadium_RenderBlockExpansion_TextPointer3)], 0x6c, true);
text_at(out, 148 - font_.text_width(weeks), 54, weeks, 0x6c, true);
text_at(out, 5, 70, texts_[text_id(::bmh::layout::Stadium_RenderBlockExpansion_TextPointer4)], 0x6c, true);
if (editor.header_text_variant >= 0) {
const std::string variant = format_number(GameState{}, editor.header_text_variant, 0x82) +
texts_[text_id(::bmh::layout::Stadium_RenderBlockExpansion_TextPointer5)];
text_at(out, 148 - font_.text_width(variant), 70, variant, 0x6c, true);
}
fill(out, 5, 74, 100, 25, 0x63);
fill(out, 105, 76, 2, 25, 0x40);
fill(out, 7, 99, 100, 2, 0x40);
std::string block_label = texts_[text_id(::bmh::layout::Stadium_Out_TextPointer)];
if (block_label.size() > 6) block_label[6] = char('A' + slot);
text_at(out, 7, 81, block_label, 0x6b, true);
const std::string start = texts_[text_id(::bmh::layout::Stadium_RenderBlockExpansion_TextPointer6)] + editor.current_places_text +
exe_.cstring(::bmh::layout::Stadium_RenderBlockExpansion_TextPointer);
const std::string target = texts_[text_id(::bmh::layout::Stadium_RenderBlockExpansion_TextPointer7)] + editor.target_places_text +
texts_[text_id(::bmh::layout::Stadium_FormatError_ExecutableField3)];
text_at(out, 7, 89, start, 0x6b, true);
text_at(out, 7, 97, target, 0x6c, true);
text_at(out, 5, 112, texts_[text_id(::bmh::layout::Stadium_RenderBlockExpansion_TextPointer10)], 0x6a, true);
const std::string per_thousand_cost = editor.per_thousand_cost_text + exe_.cstring(::bmh::layout::CareerSession_FormatNumber_ExecutableField);
text_at(out, 148 - font_.text_width(per_thousand_cost), 112,
per_thousand_cost, 0x6c, true);
if (editor.quote.new_places != 0) {
text_at(out, 5, 120, texts_[text_id(::bmh::layout::Stadium_RenderBlockExpansion_TextPointer8)], 0x6a, true);
text_at(out, 148 - font_.text_width(editor.new_places_cost_text), 120,
editor.new_places_cost_text, 0x6c, true);
}
// Two feature rows: seats (bit 1) and roof (bit 2), each with an icon cropped from the interior atlas,
// an on/off status text and its cost.
for (unsigned feature = 0; feature < 2; ++feature) {
const uint8_t bit = uint8_t(1u << feature);
const int icon_y = feature == 0 ? 73 : 89;
const int source_y = feature == 0 ? 1 : 12;
copy_crop(out, interior_, 180, source_y, 120, icon_y, 10, 10, true);
const bool enabled = (editor.desired_features & bit) != 0;
const std::string status = texts_[enabled ? 1114 : 1115];
text_at(out, 140, feature == 0 ? 79 : 94, status, enabled ? 0x5f : 0x6a, true);
const std::string& cost = feature == 0 ? editor.seats_cost_text : editor.roof_cost_text;
text_at(out, 140, feature == 0 ? 86 : 101, cost, 0x6b, true);
}
text_at(out, 5, 130, texts_[text_id(::bmh::layout::Stadium_RenderBlockExpansion_TextPointer9)], 0x6a, true);
text_at(out, 148 - font_.text_width(editor.total_cost_text), 130, editor.total_cost_text, 0x6c, true);
text_at(out, 152, 130, editor.discount_text, 0x6c, true);
original_button(out, 7, 136, 70, 9, texts_[156], pressed_ == Pressed::block_build);
original_button(out, 107, 136, 70, 9, texts_[157], pressed_ == Pressed::block_cancel);
return out;
}
// Renders the numeric calculator window over the editor (only while it is open and not in its cancel wait).
// Its position (block_calculator_x_/y_) is draggable; key and preset positions come from executable tables.
Image StadiumScreen::render_block_calculator(Image out) const {
if (!block_calculator_open_ || block_calculator_cancel_wait_ || !state_.block_expansion) return out;
const int x0 = block_calculator_x_, y0 = block_calculator_y_;
copy_crop(out, calculator_art_, 0, 0, x0, y0, 113, 136);
fill(out, x0 + 113, y0 + 2, 2, 136, 0x40);
fill(out, x0 + 2, y0 + 136, 113, 2, 0x40);
const auto& editor = *state_.block_expansion;
const std::string title = texts_[1118];
const int width = font_.text_width(title);
text_at(out, x0 + 8 + (105 - 8) / 2 - width / 2, y0 + 14, title, 0x62, true);
// key labels in index order: digits 0-9, D delete, R restore, C clear, J accept, N cancel
constexpr std::string_view keys = "0123456789DRCJN";
for (int i = 0; i < 15; ++i) {
const int x = x0 + exe_.u16(::bmh::layout::Advertising_Click_RuntimeField + size_t(i) * 2);
const int y = y0 + exe_.u8(::bmh::layout::Advertising_Click_RuntimeField2 + size_t(i));
const bool pressed = block_calculator_pressed_key_ == i;
copy_crop(out, calculator_art_, pressed ? 15 : 0, 136, x + (pressed ? 1 : 0),
y + (pressed ? 1 : 0), 15 - int(pressed), 14 - int(pressed));
text_at(out, x + 5 + int(pressed), y + 9 + int(pressed), keys.substr(size_t(i), 1), 0x62, false);
}
const uint32_t current = uint32_t(editor.quote.current_capacity_thousands) * 1000;
// Preset buttons (indices 15..22): current capacity plus 0..5 thousand, the current capacity again, and the maximum.
// Presets above the maximum are not shown.
std::array<uint32_t, 8> presets{};
for (uint32_t i = 0; i < 6; ++i) presets[i] = current + i * 1000;
presets[6] = current; presets[7] = editor.quote.max_places;
for (size_t i = 0; i < presets.size(); ++i) {
if (presets[i] > editor.quote.max_places) continue;
const int x = x0 + exe_.u16(::bmh::layout::Advertising_Click_RuntimeField + (i + 15) * 2);
const int y = y0 + exe_.u8(::bmh::layout::Advertising_Click_RuntimeField2 + i + 15);
const std::string value = format_number(GameState{}, int32_t(presets[i]), 7);
text_at(out, x + 47 - font_.text_width(value), y + 12, value, 0x62, true);
}
const std::string value = format_number(GameState{}, int32_t(block_calculator_value_),
block_calculator_edited_ ? 8 : 7);
text_at(out, x0 + 106 - font_.text_width(value), y0 + 110, value, 0x00, true);
return out;
}
// Renders the panorama view: opaque underlay, capacity-dependent stands sprite, then every built or
// under-construction periphery object back to front, with construction details, plus the hover info box.
void StadiumScreen::render_panorama(Image& out) const {
// ConstructionPricePercent uses KB70 as the opaque panorama underlay; KB35 is an atlas,
// not a full-screen background. CopyCrop skips the Original zero key.
copy_crop(out, periphery_overlay_, 0, 0, 18, 25, 279, 183);
fill(out, 297, 32, 6, 183, 0x40);
fill(out, 25, 208, 272, 7, 0x40);
// Draws sprite `slot`: its screen rectangle and atlas source position come from executable tables.
const auto sprite = [&](unsigned slot) {
const int x = exe_.u16(::bmh::layout::Stadium_PeripheryObjectContains_ExecutableField + slot * 8), y = exe_.u16(::bmh::layout::Stadium_RenderPanorama_RuntimeField + slot * 8);
const int w = exe_.u16(::bmh::layout::Stadium_RenderPanorama_RuntimeField2 + slot * 8) - x + 1;
const int h = exe_.u16(::bmh::layout::Stadium_RenderPanorama_RuntimeField3 + slot * 8) - y + 1;
copy_crop(out, background_, exe_.u16(::bmh::layout::Stadium_RenderPanorama_RuntimeField4 + slot * 4),
exe_.u16(::bmh::layout::Stadium_RenderPanorama_RuntimeField5 + slot * 4), x, y, w, h, true);
};
unsigned capacity = 0;
for (const auto& block : state_.blocks) capacity += block.capacity_level;
// total capacity level of 10 or more selects one of up to four stands sprites
if (capacity > 9) sprite(14 + std::min(3u, (capacity - 10) / 10));
// Paint order is given by an executable table. Objects 0..5 are shown while under construction, others only
// once built (level != 0). Busy objects additionally draw their construction parts.
for (unsigned order = 0; order < 14; ++order) {
const unsigned object = exe_.u8(::bmh::layout::Stadium_RenderPanorama_RuntimeField6 + order);
const unsigned level = state_.level[object];
const bool busy = state_.days[object] != 0;
if ((object < 6 && busy) || level != 0) {
unsigned slot = object;
if (object == 0) {
slot = 18 + unsigned(busy && level != 0);
if (level != 0) slot += (level - 1) / 85;
}
sprite(slot);
}
if (!busy) continue;
const size_t first = exe_.u8(::bmh::layout::Stadium_RenderPanorama_RuntimeField7 + object);
const uint16_t packed = exe_.u16(::bmh::layout::Stadium_RenderPanorama_ExecutableField + first * 6);
const unsigned count = packed >> 8;
for (unsigned part = 0; part < count; ++part) {
const size_t at = ::bmh::layout::Stadium_RenderPanorama_ExecutableField + (first + part) * 6;
const unsigned tile = exe_.u16(at) & 0xff;
const size_t bounds = ::bmh::layout::Stadium_RenderPanorama_RuntimeField8 + tile * 4;
const int sx = 200 + exe_.u8(bounds), sy = exe_.u8(bounds + 1);
const int w = exe_.u8(bounds + 2) - exe_.u8(bounds) + 1;
const int h = exe_.u8(bounds + 3) - sy + 1;
// tile 8 is an animated part: it is mirrored depending on the animation tick and placed at a fixed position
const bool flip = tile == 8 && ((state_.periphery_animation_tick >> (object == 2)) & 1);
const int x = flip ? (object == 2 ? 28 : 104) : exe_.u16(at + 2);
const int y = flip ? 127 : exe_.u16(at + 4);
if (!flip) copy_crop(out, background_, sx, sy, x, y, w, h, true);
else for (int yy = 0; yy < h; ++yy) for (int xx = 0; xx < w; ++xx) {
const auto color = background_.pixels[size_t(sy + yy) * background_.width + sx + w - 1 - xx];
if (color != 0) out.at(x + xx, y + yy) = color;
}
}
}
// Hover info box for the object under the pointer: title plus either remaining days (under construction)
// or price, duration and balance (available to build).
if (periphery_hover_ < 0) return;
const size_t object = size_t(periphery_hover_);
copy_crop(out, periphery_overlay_, 8, 7, 26, 32, 180, 27);
const bool busy = state_.days[object] != 0;
const std::string title = texts_[text_id(::bmh::layout::Stadium_RenderPanorama_TextPointer + unsigned(object) * 4)] +
texts_[text_id(busy ? ::bmh::layout::Stadium_RenderPanorama_TextPointer2 : ::bmh::layout::Stadium_RenderPanorama_TextPointer6)];
if (busy) {
text_at(out, 26, 37, title, 0x27);
text_at(out, 26, 45, texts_[text_id(::bmh::layout::Stadium_RenderPanorama_TextPointer3)], 0x6c);
const std::string remaining = texts_[text_id(::bmh::layout::Stadium_RenderPanorama_TextPointer4)] +
format_number(GameState{}, state_.days[object], 1) + texts_[text_id(::bmh::layout::Stadium_RenderPanorama_TextPointer5)];
text_at(out, 155 - font_.text_width(remaining), 45, remaining, 0x5f);
} else {
int baseline = 37;
for (const auto& line : wrap_source_text(data_, title, 129)) {
text_at(out, 26, baseline, line, 0x27); baseline += font_.height;
}
for (unsigned line = 0; line < 3; ++line) {
const std::array<uint32_t, 3> captions{::bmh::layout::Stadium_RenderPanorama_ExecutableField2, ::bmh::layout::Stadium_RenderBlockExpansion_TextPointer3, ::bmh::layout::Stadium_RenderBlockExpansion_TextPointer2};
const std::string& value = line == 0 ? state_.periphery_price_text[object] :
line == 1 ? state_.periphery_duration_text[object] : state_.periphery_balance_text;
text_at(out, 26, 45 + int(line) * 7, texts_[text_id(captions[line])], 0x6c);
text_at(out, 155 - font_.text_width(value), 45 + int(line) * 7, value, 0x5f);
}
}
}
// True if (x,y) lies inside the inclusive hit rectangle of a periphery object (from an executable table).
bool StadiumScreen::periphery_object_contains(int object, int x, int y) const {
if (object < 0 || object >= 14) return false;
const size_t at = ::bmh::layout::Stadium_PeripheryObjectContains_ExecutableField + size_t(object) * 8;
return x >= exe_.u16(at) && y >= exe_.u16(at + 2) &&
x <= exe_.u16(at + 4) && y <= exe_.u16(at + 6);
}
// Returns the periphery object at (x,y) or -1. Only active in the panorama view with investments enabled.
// Candidates are objects under construction, or buildable ones when future information is shown.
int StadiumScreen::periphery_object_at(int x, int y) const {
if (!panorama_ || !state_.investments_enabled) return -1;
// Source hit order deliberately differs from the back-to-front paint order.
for (unsigned order = 0; order < 14; ++order) {
const int object = exe_.u8(::bmh::layout::Stadium_PeripheryObjectAt_RuntimeField + order);
if ((state_.days[size_t(object)] != 0 || (future_information_ && periphery_available(state_, object))) &&
(object < 11 || state_.level[size_t(object - 1)] != 0) &&
periphery_object_contains(object, x, y)) return object;
}
return -1;
}
// Renders the base scene: header, club title and footer, then either the panorama or the interior view with
// the 8 seat block rows and 8 investment icons, the three scene buttons and the feedback line.
Image StadiumScreen::render_scene() const {
Image out(320, 240);
if (state_.decorated_stadium_header) out = header_background_;
else { fill(out, 0, 4, 320, 13, 0x44); fill(out, 1, 5, 318, 11, 0x39);
fill(out, 0, 228, 320, 10, 0x44); fill(out, 1, 229, 318, 8, 0x39); }
const std::string title = state_.original_stadium_title.empty() ? state_.club_name :
state_.original_stadium_title;
sprite_font_.draw(out, 172 + (282 - 172) / 2 -
sprite_font_.text_width(original_to_utf8(title)) / 2, 13, original_to_utf8(title));
sprite_font_.draw(out, 5, 235, original_to_utf8(state_.original_stadium_footer.empty() ?
state_.club_name : state_.original_stadium_footer));
// Interior view layers, in order: shadow and interior picture, seat block rows (right column), investment icons.
if (panorama_) render_panorama(out);
else {
// ConstructionPricePercent draws ColorBottomRightBevel, then the opaque KB38 crop.
source_shadow(out, 17, 23, 179, 125);
copy_crop(out, interior_, 0, 0, 17, 23, 179, 125);
// Original's eight separate block rows (ConstructionPricePercent). These read-only facts
// retain the block branch's real records and never act as facility rows.
// Seat block rows A-H: 100x24 px cells at x=219, stacked from y=22. Shows the label, then either the current
// usable capacity and maximum, or (future information) the new capacity or construction state.
for (unsigned i = 0; i < state_.blocks.size(); ++i) {
const int row_y = 22 + int(i) * 24;
if (state_.solid_panel_background) {
// LoadGameEndTaxAnimationAssets's alternate panel mode fills the inclusive Source
// bounds before PaintsFourBorderEdges paints the four border edges.
fill(out, 219, row_y, 100, 24, 0x42);
} else {
// Source crop: (left, top-19) -> (left+1, top+1), 98x22.
copy_crop(out, panel_, 219, row_y - 19, 220, row_y + 1, 98, 22);
}
source_border(out, 219, row_y, 318, row_y + 23);
// hover frame around the row under the pointer
if (pressed_ == Pressed::none && hover_block_ == int(i)) outline(out, 219, row_y, 100, 24, 0x27);
const auto& block = state_.blocks[i];
std::string label = texts_[text_id(::bmh::layout::Stadium_Out_TextPointer)];
if (label.size() > 6) label[6] = char('A' + i);
text_at(out, 221, row_y + 7, label, 0x6b);
if (block.capacity || block.capacity_level) {
// Normal mode: current usable capacity, maximum, and icons for the built features (flag bits 1 and 2).
if (!future_information_) {
const unsigned available = block.capacity ? 0 : block.capacity_level;
const std::string current = format_number(GameState{}, int32_t(available * 1000), 0x85) +
texts_[text_id(::bmh::layout::Stadium_FormatError_ExecutableField3)];
text_at(out, 221, row_y + 15, current, 0x51);
const auto max_places = stadium_block_expansion_constants(exe_).max_places[i];
const std::string maximum = texts_[text_id(::bmh::layout::Stadium_Out_TextPointer5)] +
format_number(GameState{}, int32_t(max_places), 5) +
exe_.cstring(::bmh::layout::Stadium_Out_ExecutableField);
text_at(out, 221, row_y + 21, maximum, 0x51);
if (block.flags & 1) copy_crop(out, interior_, 180, 1, 307, row_y + 2, 10, 10, true);
if (block.flags & 2) copy_crop(out, interior_, 180, 12, 307, row_y + 12, 10, 10, true);
} else {
std::string first;
if (block.capacity == 0) {
first = texts_[text_id(::bmh::layout::Stadium_Out_TextPointer4)];
text_at(out, 221, row_y + 15, first, 0x6a);
} else {
first = texts_[text_id(::bmh::layout::Stadium_Out_TextPointer2)] +
format_number(GameState{}, int32_t(block.capacity * 1000), 5) +
exe_.cstring(::bmh::layout::Stadium_Out_ExecutableField);
text_at(out, 221, row_y + 15, first, 0x6c);
const std::string duration = texts_[text_id(::bmh::layout::Stadium_Out_TextPointer3)] +
original_duration_text(GameState{}, texts_, exe_,
block.construction_weeks, 2, ::bmh::layout::Stadium_FormatError_RuntimeField);
text_at(out, 221, row_y + 21, duration, 0x51);
}
// future information: pending features are stored in flag bits 4 and 5
const unsigned pending_flags = (block.flags >> 4) & 3;
if (pending_flags & 1) copy_crop(out, interior_, 180, 1, 307, row_y + 2, 10, 10, true);
if (pending_flags & 2) copy_crop(out, interior_, 180, 12, 307, row_y + 12, 10, 10, true);
}
}
}
// Investment icons: 53x29 px sprites at positions from executable tables. The level (status bits 0..2, or the
// target level in bits 4..6 with future information) selects the sprite; level 0 shows the empty slot.
for (unsigned choice = 0; choice < 8; ++choice) {
const uint32_t x_table = ::bmh::layout::Stadium_Out_ExecutableField2 + choice * 2;
const uint32_t y_table = ::bmh::layout::Stadium_Out_ExecutableField3 + choice * 2;
const int x = exe_.u8(x_table), y = exe_.u8(y_table);
const int sx = exe_.u16(::bmh::layout::Stadium_Out_RuntimeField + choice * 4);
const int sy = exe_.u16(::bmh::layout::Stadium_Out_RuntimeField2 + choice * 4);
const auto& row = state_.investments[choice];
unsigned visual_level = future_information_ ? (row.current_status >> 4) & 7 : 0;
if (visual_level == 0) visual_level = row.current_status & 7;
// choices 2 and 3 have one sprite less (their level is shifted down by one)
if (choice == 2 || choice == 3) {
if (visual_level > 0) --visual_level;
}
if (visual_level == 0) {
copy_crop(out, facilities_, sx, sy, x, y, 0x35, 0x1d);
copy_crop(out, facilities_, 0x6b, 0x75, x, y, 0x32, 0x1c, true);
} else {
const int sprite_y = sy + int(visual_level - 1) * 0x1d;
copy_crop(out, facilities_, sx, sprite_y, x, y, 0x35, 0x1d);
if (choice < 2 || choice > 3) {
const uint32_t labels = choice < 2 ? ::bmh::layout::Stadium_Out_ExecutableField5 : ::bmh::layout::Stadium_Out_ExecutableField4;
const std::string tier = texts_[text_id(labels + visual_level * 4)];
const int label_width = font_.text_width(tier);
text_at(out, x + (0x33 - label_width) / 2, y + 0x1b, tier, 0);
text_at(out, x + (0x35 - label_width) / 2, y + 0x1b, tier, 0x5f);
}
}
// hover/press frame around the icon
if ((pressed_ == Pressed::investment && pressed_index_ == int(choice)) ||
(pressed_ == Pressed::none && hover_investment_ == int(choice)))
outline(out, x, y, 0x35, 0x1d, 0x27);
if (future_information_ && row.construction_weeks) {
const std::string weeks = format_number(GameState{}, row.construction_weeks, 0x82) +
texts_[text_id(::bmh::layout::Stadium_Out_TextPointer6)];
text_at(out, x + 0x20, y + 7, weeks, 0);
text_at(out, x + 0x1f, y + 6, weeks, 0x5f);
}
}
}
// The three scene buttons at y=215: view switch (hidden when investments are disabled), future information
// switch, and data page.
const std::array<std::string, 3> labels = panorama_
? std::array<std::string, 3>{texts_[150], texts_[151], texts_[152]}
: std::array<std::string, 3>{texts_[153], texts_[154], texts_[155]};
const std::array<int, 3> bx{2, 125, 224}, bw{115, 90, 90};
for (int i = 0; i < 3; ++i) {
// In Source mode 1 the first scene switch is parked off-screen.
if (i == 0 && !state_.investments_enabled) continue;
const bool source_selected = (pressed_ == Pressed::scene_button && pressed_index_ == i) ||
(future_information_ && i == 1);
original_button(out, bx[size_t(i)], 215, bw[size_t(i)], 9, labels[size_t(i)], source_selected);
}
if (!feedback_.empty()) text_at(out, 8, 237, feedback_, 0x5f);
else if (!state_.action_feedback.empty()) text_at(out, 8, 237, state_.action_feedback, 0x5f);
return out;
}
// Renders the investment dialog for the selected investment: title, balance, duration, and up to three
// option icons with tier label and price, plus Build/Cancel buttons.
Image StadiumScreen::render_investment_dialog(Image out) const {
if (!state_.selected_investment) return out;
const unsigned choice = unsigned(*state_.selected_investment);
if (choice >= state_.investments.size()) return out;
const auto& row = state_.investments[choice];
source_frame(out, widgets_, exe_, 1, 22, 214, 128, false); // Front flags18.
const std::string title = investment_name(row) + texts_[text_id(::bmh::layout::Stadium_RenderInvestmentDialog_TextPointer)];
const int title_width = heading_font_.text_width(title);
const int title_y = 33 - heading_font_.baseline;
if (title_y >= 0) heading_font_.draw(out, 1 + (215 - title_width) / 2, title_y,
title, 0x5f);
// Dynamic captions come from TEXTD; numeric values are projected by the owner.
text_at(out, 5, 46, texts_[text_id(::bmh::layout::Stadium_RenderBlockExpansion_TextPointer2)], 0x6c);
text_at(out, 5, 54, texts_[text_id(::bmh::layout::Stadium_RenderBlockExpansion_TextPointer3)], 0x6c);
const std::string balance = state_.balance_text.empty() ? std::to_string(state_.balance) : state_.balance_text;
const int bw = font_.text_width(balance);
text_at(out, 148 - bw, 46, balance, 0x6c);
const int weeks_value = exe_.u8(::bmh::layout::CareerSession_DispatchStadium_RuntimeField2 + (choice + 14) * 5);
const std::string weeks = original_duration_text(GameState{}, texts_, exe_, weeks_value, 0x82, ::bmh::layout::Stadium_FormatError_RuntimeField);
text_at(out, 148 - font_.text_width(weeks), 54, weeks, 0x6c);
if (state_.investment_text_variant >= 0) {
const std::string label = texts_[text_id(::bmh::layout::Stadium_RenderBlockExpansion_TextPointer4)];
const std::string variant = format_number(GameState{}, state_.investment_text_variant, 0x82) +
texts_[text_id(::bmh::layout::Stadium_RenderBlockExpansion_TextPointer5)];
text_at(out, 5, 70, label, 0x6c);
text_at(out, 148 - font_.text_width(variant), 70, variant, 0x6c);
}
// Option cells: 60 px apart starting at x=5, sprite at y=74 (53x29 px), tier label at y=110, price at y=117.
for (size_t i = 0; i < row.options.size() && i < 3; ++i) {
const auto& option = row.options[i];
const int x = 5 + int(i) * 60;
const int sx = exe_.u16(::bmh::layout::Stadium_Out_RuntimeField + choice * 4);
const int source_y = exe_.u16(::bmh::layout::Stadium_Out_RuntimeField2 + choice * 4);
const int sy = (choice == 2 || choice == 3) ? source_y :
source_y + int(option.target_level - 1) * 0x1d;
copy_crop(out, facilities_, sx, sy, x, 74, 0x35, 0x1d);
if (choice != 2 && choice != 3) source_shadow(out, x, 74, 0x35, 0x1d);
if ((state_.selected_option && *state_.selected_option == int(i)) ||
(pressed_ == Pressed::option && pressed_index_ == int(i)))
outline(out, x, 74, 0x35, 0x1d, 0x27);
const uint32_t labels = choice < 2 ? ::bmh::layout::Stadium_Out_ExecutableField5 : ::bmh::layout::Stadium_Out_ExecutableField4;
const std::string tier = (choice == 2 || choice == 3) ? std::string{} :
texts_[text_id(labels + uint32_t(option.target_level) * 4)];
if (!tier.empty()) {
const int w = font_.text_width(tier);
text_at(out, x + (0x35 - w) / 2, 110, tier, 0x6c);
}
const std::string price = i < row.option_price_text.size() ?
row.option_price_text[i] : std::to_string(option.base_price);
text_at(out, x + (0x35 - font_.text_width(price)) / 2, 117, price,
choice == 2 || choice == 3 ? 0x5f : 0x6c);
}
original_button(out, 7, 136, 70, 9, texts_[156], pressed_ == Pressed::build);
original_button(out, 107, 136, 70, 9, texts_[157], pressed_ == Pressed::cancel);
return out;
}
// Hit test for the data page controls. Returns 0..5 for the curve buttons, 6..7 for the scale buttons,
// 8..23 for ticket prices 10..25, or -1.
int StadiumScreen::data_control_at(int x, int y) const {
for (int curve = 0; curve < 6; ++curve) {
const int bx = 27 + (curve % 2) * 120, by = 107 + (curve / 2) * 11;
if (x >= bx && x <= bx + 96 && y >= by && y <= by + 10) return curve;
}
for (int scale = 0; scale < 2; ++scale) {
const int by = 111 + scale * 11;
if (x >= 265 && x <= 295 && y >= by && y <= by + 9) return 6 + scale;
}
for (int price = 10; price <= 25; ++price) {
const int bx = 59 + (price - 10) * 16;
if (x >= bx && x <= bx + 14 && y >= 225 && y <= 234) return 8 + price - 10;
}
return -1;
}
// Renders the data page: header, graph frame and curves (with their toggle buttons and color keys), scale
// buttons, the statistics table, required attendance and the ticket price buttons (10..25).
Image StadiumScreen::render_data() const {
const auto& data = *state_.data;
Image out = header_background_;
if (state_.plain_background) { fill(out, 0, 17, 320, 223, 0);
fill(out, 0, 4, 320, 13, 0x44); fill(out, 1, 5, 318, 11, 0x39); }
const auto title = original_to_utf8(state_.original_stadium_title.empty() ? state_.club_name : state_.original_stadium_title);
sprite_font_.draw(out, 172 + 55 - sprite_font_.text_width(title) / 2, 13, title);
// Draws a clipped line from (x,y) to (end_x,end_y) with a Bresenham-style step loop.
const auto line = [&](int x, int y, int end_x, int end_y, uint8_t color) {
const int dx = std::abs(end_x - x), sx = x < end_x ? 1 : -1;
const int dy = std::abs(end_y - y), sy = y < end_y ? 1 : -1;
int error = 0;
for (int step = 0; step <= std::max(dx, dy); ++step) {
if (x >= 0 && x < 320 && y >= 0 && y < 240) out.at(x, y) = color;
if (dx > dy) { x += sx; error += dy; if (error >= dx) { error -= dx; y += sy; } }
else if (dy) { y += sy; error += dx; if (error >= dy) { error -= dy; x += sx; } }
}
};
// graph frame edges: coordinates and colors come from executable tables
for (int edge = 0; edge < 4; ++edge)
line(exe_.u16(::bmh::layout::Analytics_Render_RuntimeField3 + edge * 4 + 2), exe_.u8(::bmh::layout::Analytics_Render_RuntimeField2 + edge * 2 + 1) - 35,
exe_.u16(::bmh::layout::Analytics_Render_RuntimeField3 + edge * 4), exe_.u8(::bmh::layout::Analytics_Render_RuntimeField2 + edge * 2) - 35, exe_.u8(::bmh::layout::Analytics_Render_RuntimeField + edge));
// Per curve: color key, toggle button (selected when its flag bit is set or it is pressed) and, when shown,
// the polyline with a 3x3 marker per sample.
for (int curve = 0; curve < 6; ++curve) {
const int x = 27 + (curve % 2) * 120, y = 107 + (curve / 2) * 11;
const uint8_t color = exe_.u8(::bmh::layout::Analytics_FormatError_RuntimeField + curve);
fill(out, x - 7, y + 3, 5, 4, color);
line(x - 8, y + 2, x - 2, y + 2, 0x68); line(x - 8, y + 2, x - 8, y + 7, 0x68);
line(x - 2, y + 3, x - 2, y + 7, 0x62); line(x - 8, y + 7, x - 2, y + 7, 0x62);
out.at(x - 8, y + 2) = 0x6a;
original_button(out, x, y, 96, 9, exe_.cstring(exe_.u32(::bmh::layout::Analytics_FormatError_ExecutableField + (6 + curve) * 4)),
(data.flags & (1 << curve)) != 0 || (pressed_ == Pressed::data_control && pressed_index_ == curve));
if (!(data.flags & (1 << curve))) continue;
const auto points = stadium_data_points(data, exe_, curve);
for (size_t sample = 0; sample < points.size(); ++sample) {
const auto [px, py] = points[sample];
if (sample) line(points[sample - 1].first, points[sample - 1].second, px, py, color);
fill(out, px - 1, py - 1, 3, 3, color);
}
}
for (int scale = 0; scale < 2; ++scale)
original_button(out, 265, 111 + scale * 11, 30, 9, texts_[text_id(::bmh::layout::ClubPlayerDetail_RenderStatistics_ExecutableField + scale * 4)],
(data.flags & (1 << (6 + scale))) != 0 || (pressed_ == Pressed::data_control && pressed_index_ == 6 + scale));
if (state_.solid_panel_background) fill(out, 0, 145, 320, 95, 0x42);
else copy_crop(out, panel_, 0, 126, 1, 146, 318, 93);
source_border(out, 0, 145, 319, 239);
fill(out, 1, 227, 318, 12, 0x42);
// Draws text centred between the x positions left and right.
const auto centered = [&](int left, int right, int baseline, std::string_view text, uint8_t color) {
text_at(out, left + (right - left) / 2 - font_.text_width(text) / 2, baseline, text, color);
};
// Table header and rows: three columns 85 px apart. Rows 1 and 3 are 9 px high, others 7 px.
for (int kind = 0; kind < 3; ++kind)
centered(60 + kind * 85, 145 + kind * 85, 154, texts_[text_id(::bmh::layout::Stadium_CopyCrop_TextPointer + kind * 4)], 0x6a);
int y = 164;
for (int row = 0; row < 7; ++row) {
text_at(out, 3, y, texts_[text_id(::bmh::layout::Stadium_CopyCrop_TextPointer2 + row * 4)], 0x6b);
for (int kind = 0; kind < 3; ++kind) {
const auto& text = data.table[size_t(row)][size_t(kind)];
// texts starting with '(' are drawn one pixel lower
const int shift = row < 4 && !text.empty() && text[0] == '(' ? 1 : 0;
centered(60 + kind * 85, 145 + kind * 85, y + shift, text, 0x6c);
}
y += row == 1 || row == 3 ? 9 : 7;
}
// Required attendance line and ticket price buttons at the bottom of the page.
// TextId restores this seven-pixel region from TextId2's saved
// background; it adds no field frame or shadow.
const auto needed = texts_[text_id(::bmh::layout::Stadium_CopyCrop_TextPointer4)] + std::to_string(data.ticket_price) + texts_[text_id(::bmh::layout::Stadium_CopyCrop_TextPointer5)];
text_at(out, 59, 222, needed, 0x6b);
text_at(out, 313 - font_.text_width(data.required_attendance_text), 222, data.required_attendance_text, 0x6c);
text_at(out, 3, 231, texts_[text_id(::bmh::layout::Stadium_CopyCrop_TextPointer3)], 0x6a);
for (int price = 10; price <= 25; ++price)
original_button(out, 59 + (price - 10) * 16, 225, 14, 9, std::to_string(price),
data.ticket_price == price || (pressed_ == Pressed::data_control && pressed_index_ == price - 10 + 8));
return out;
}
// Renders the current frame. Priority: data page, then construction tip dialog, then the scene with the
// active editor/dialog, the calculator, or the periphery question on top.
Image StadiumScreen::render() const {
if (state_.data) return render_data();
if (state_.construction_tip_dialog && tip_dialog_) {
const auto pressed = pressed_ == Pressed::tip_yes ? GameEndTaxDialog::Button::yes :
pressed_ == Pressed::tip_no ? GameEndTaxDialog::Button::no : GameEndTaxDialog::Button::none;
return tip_dialog_->render(pressed);
}
Image out = state_.block_expansion
? render_block_expansion(render_scene())
: render_investment_dialog(render_scene());
if (block_calculator_open_) return render_block_calculator(std::move(out));
if (periphery_dialog_) {
std::optional<GameEndTaxDialog::Button> button;
if (pressed_ == Pressed::periphery_yes) button = GameEndTaxDialog::Button::yes;
if (pressed_ == Pressed::periphery_no) button = GameEndTaxDialog::Button::no;
return periphery_dialog_->render(button);
}
return out;
}
// Image shown behind a construction notice: the scene with the active block editor or investment dialog.
Image StadiumScreen::construction_notice_backdrop() const {
return state_.block_expansion ? render_block_expansion(render_scene())
: render_investment_dialog(render_scene());
}
// Text input for the block calculator (digits only). Appends digits to the value (clamped to the block's
// maximum, at most 10 digits). Returns true if the value changed.
bool StadiumScreen::text(std::string_view input) {
if (pending_ || calculator_source_waiting() || !block_calculator_open_ ||
!state_.block_expansion || input.empty()) return false;
for (const char c : input) if (c < '0' || c > '9') return false;
const uint32_t maximum = state_.block_expansion->quote.max_places;
bool changed = false;
for (const char c : input) {
if (block_calculator_digits_ >= 10) continue;
block_calculator_value_ = uint32_t(std::min<uint64_t>(
uint64_t(block_calculator_value_) * 10 + unsigned(c - '0'), maximum));
++block_calculator_digits_;
// Source recomputes local18 from the numeric text only for nonzero
// values. Zero input must retain its separately counted digits.
if (block_calculator_value_ != 0)
block_calculator_digits_ = unsigned(std::to_string(block_calculator_value_).size());
changed = true;
}
if (!changed) return false;
block_calculator_text_ = std::to_string(block_calculator_value_);
block_calculator_edited_ = true;
return true;
}
// Moves the calculator window to (x,y), clamped so it stays on the 320x240 screen. Returns true if it moved.
bool StadiumScreen::calculator_drag_to(int x, int y) {
if (!block_calculator_open_ || block_calculator_cancel_wait_) return false;
x = std::clamp(x, 0, 207);
y = std::clamp(y, 0, 104);
if (block_calculator_x_ == x && block_calculator_y_ == y) return false;
block_calculator_x_ = x; block_calculator_y_ = y;
return true;
}
// Called after the frame was shown: starts the key-press delay once a key (or the cancel wait) is visible.
void StadiumScreen::calculator_mark_presented() {
if (block_calculator_pressed_key_ >= 0 || block_calculator_cancel_wait_)
block_calculator_presented_ = true;
}
// Advances the calculator's wait timer by `ticks` (only counts after the frame was presented). When it reaches
// zero the key is released, the cancel wait closes the calculator, or a pending keyboard accept is applied.
// Returns true if the visible state changed.
bool StadiumScreen::calculator_advance_source_ticks(unsigned ticks) {
if (!calculator_source_waiting() || !block_calculator_presented_ || ticks == 0) return false;
const unsigned before = block_calculator_ticks_;
block_calculator_ticks_ = ticks >= before ? 0 : before - ticks;
if (block_calculator_ticks_ == 0) {
block_calculator_presented_ = false;
if (block_calculator_cancel_wait_) {
block_calculator_cancel_wait_ = false;
block_calculator_open_ = false;
block_calculator_text_.clear();
}
else {
block_calculator_pressed_key_ = -1;
if (block_calculator_keyboard_j_) {
block_calculator_keyboard_j_ = false;
(void)accept_block_calculator_value();
}
}
}
return block_calculator_ticks_ != before || before == 0;
}
// True while the calculator is in a timed wait (key held down or cancel pending); input is ignored then.
bool StadiumScreen::calculator_source_waiting() const {
return block_calculator_ticks_ != 0 &&
(block_calculator_pressed_key_ >= 0 || block_calculator_cancel_wait_);
}
// True while a calculator key is held by the mouse (not by the keyboard accept).
bool StadiumScreen::calculator_waiting_for_key_release() const {
return pressed_ == Pressed::block_calculator_key && !block_calculator_keyboard_j_;
}
// Accepts the calculator value (J key or Enter). A value below the current capacity is first clamped up and the
// calculator stays open; otherwise a set_total request is issued and stored as pending. Returns {} when nothing is sent.
StadiumRequest StadiumScreen::accept_block_calculator_value() {
if (!state_.block_expansion || pending_ || calculator_source_waiting()) return {};
const uint32_t minimum = uint32_t(state_.block_expansion->quote.current_capacity_thousands) * 1000;
if (block_calculator_value_ < minimum) {
// Source clamps the first confirmation to C and stays in the keypad.
block_calculator_value_ = minimum;
block_calculator_text_ = std::to_string(minimum);
if (minimum != 0) block_calculator_digits_ = unsigned(block_calculator_text_.size());
block_calculator_edited_ = true;
return {};
}
const auto result = block_request(StadiumRequestKind::expansion_set_total,
block_calculator_value_,
state_.block_expansion->desired_features);
block_calculator_open_ = false;
pending_ = result;
return result;
}
// Executes the calculator key with index 0..14 (digits, D, R, C, J, N). Only J can return a request.
StadiumRequest StadiumScreen::activate_block_calculator_key(int key_index) {
if (!state_.block_expansion || !block_calculator_open_ || pending_) return {};
if (key_index >= 0 && key_index <= 9) {
text(std::string_view("0123456789").substr(size_t(key_index), 1));
return {};
}
switch (key_index) {
case 10: // D: delete the last digit
if (block_calculator_digits_ != 0) {
block_calculator_value_ /= 10;
--block_calculator_digits_;
}
block_calculator_text_ = std::to_string(block_calculator_value_);
if (block_calculator_value_ != 0) block_calculator_digits_ = unsigned(block_calculator_text_.size());
block_calculator_edited_ = true;
return {};
case 11: // R: restore the Original initial amount
block_calculator_value_ = state_.block_expansion->quote.new_places;
block_calculator_text_ = std::to_string(block_calculator_value_);
block_calculator_digits_ = unsigned(block_calculator_text_.size());
block_calculator_edited_ = true;
return {};
case 12: // C: clear
block_calculator_value_ = 0;
block_calculator_text_ = "0";
block_calculator_digits_ = 0;
block_calculator_edited_ = true;
return {};
case 13: return accept_block_calculator_value(); // J: accept
// N: sets the value to the 'cancelled' sentinel and starts a 50-tick wait before the calculator closes
case 14: // N: cancel local calculator edit
block_calculator_value_ = UINT32_MAX;
block_calculator_text_ = std::to_string(block_calculator_value_);
block_calculator_edited_ = true;
block_calculator_pressed_key_ = -1;
block_calculator_cancel_wait_ = true;
block_calculator_ticks_ = 50;
block_calculator_presented_ = false;
return {};
default: return {};
}
}
// Handles a mouse button press at (x,y) and decides which control becomes `pressed_` (the request is only sent
// on release). Right button closes the current level (data page, editor or scene). Returns true if the press
// was used. Layers are checked from top to bottom: data page, tip dialog, calculator, block editor,
// periphery question, investment dialog, scene.
bool StadiumScreen::pointer_down(int x, int y, bool right) {
if (pending_ || calculator_source_waiting()) return false;
pressed_ = Pressed::none; pressed_index_ = -1; pressed_x_ = x; pressed_y_ = y;
if (state_.data) {
if (right) { pending_ = request(StadiumRequestKind::close_data); return true; }
pressed_index_ = data_control_at(x, y);
if (pressed_index_ >= 0) { pressed_ = Pressed::data_control; return true; }
return false;
}
if (state_.construction_tip_dialog && tip_dialog_) {
if (right) return false;
const auto button = tip_dialog_->hit_test(x, y);
pressed_ = button == GameEndTaxDialog::Button::yes ? Pressed::tip_yes :
button == GameEndTaxDialog::Button::no ? Pressed::tip_no : Pressed::none;
return pressed_ != Pressed::none;
}
if (block_calculator_open_ && state_.block_expansion) {
if (right || calculator_source_waiting()) return false;
const int x0 = block_calculator_x_, y0 = block_calculator_y_;
for (int i = 0; i < 15; ++i) {
const int key_x = x0 + exe_.u16(::bmh::layout::Advertising_Click_RuntimeField + size_t(i) * 2);
const int key_y = y0 + exe_.u8(::bmh::layout::Advertising_Click_RuntimeField2 + size_t(i));
// key hit box: 17x15 pixels
if (x >= key_x && x <= key_x + 16 && y >= key_y && y <= key_y + 14) {
if (i == 14) {
// Source N jumps straight to4ad4e: restore the backdrop,
// wait50 after its Present, and never flash the N key.
(void)activate_block_calculator_key(i);
return true;
}
pressed_ = Pressed::block_calculator_key; pressed_index_ = i;
block_calculator_pressed_key_ = i;
block_calculator_ticks_ = 4; block_calculator_presented_ = false;
return true;
}
}
const auto& quote = state_.block_expansion->quote;
const uint32_t current = uint32_t(quote.current_capacity_thousands) * 1000;
for (size_t i = 0; i < 8; ++i) {
uint32_t value = i < 6 ? current + uint32_t(i) * 1000 :
i == 6 ? current : quote.max_places;
if (value > quote.max_places) continue;
const int key_x = x0 + exe_.u16(::bmh::layout::Advertising_Click_RuntimeField + (i + 15) * 2);
const int key_y = y0 + exe_.u8(::bmh::layout::Advertising_Click_RuntimeField2 + i + 15);
// preset button hit box: 54x15 pixels
if (x >= key_x && x <= key_x + 53 && y >= key_y && y <= key_y + 14) {
pressed_ = Pressed::block_calculator_preset; pressed_index_ = int(i);
return true;
}
}
// top strip of the calculator window: starts dragging it
if (x >= x0 && x <= x0 + 113 && y >= y0 && y <= y0 + 16) {
pressed_ = Pressed::block_calculator_drag;
return true;
}
return false;
}
if (state_.block_expansion) {
if (right) {
// PrepareStandBlockOffer's nested detail loop treats physical event 8 as an
// editor exit. It returns to the A–H overview without accepting
// the quote or consuming any construction RNG.
pending_ = block_request(StadiumRequestKind::expansion_cancel);
return true;
}
// Editor hit boxes: Build button, Cancel button, amount field (opens the calculator), and the seats and roof
// rows (only if that feature is not already built).
if (x >= 7 && x <= 76 && y >= 136 && y <= 145) pressed_ = Pressed::block_build;
else if (x >= 107 && x <= 176 && y >= 136 && y <= 145) pressed_ = Pressed::block_cancel;
else if (x >= 5 && x <= 99 && y >= 74 && y <= 99) pressed_ = Pressed::block_amount;
else if (x >= 120 && x <= 210 && y >= 73 && y <= 85 &&
!(state_.block_expansion->quote.current_raw_flags & 1)) pressed_ = Pressed::block_seats;
else if (x >= 120 && x <= 210 && y >= 88 && y <= 100 &&
!(state_.block_expansion->quote.current_raw_flags & 2)) pressed_ = Pressed::block_roof;
return pressed_ != Pressed::none;
}
if (state_.quoted_object) {
if (right) return false;
if (!periphery_dialog_) return false;
const auto button = periphery_dialog_->hit_test(x, y);
if (button == GameEndTaxDialog::Button::yes) pressed_ = Pressed::periphery_yes;
else if (button == GameEndTaxDialog::Button::no) pressed_ = Pressed::periphery_no;
return pressed_ != Pressed::none;
}
if (state_.selected_investment) {
if (right) return false;
// Investment dialog hit boxes: Build button, Cancel button, and the option cells (60 px wide, from x=5).
if (x >= 7 && x <= 76 && y >= 136 && y <= 145) pressed_ = Pressed::build;
else if (x >= 107 && x <= 176 && y >= 136 && y <= 145) pressed_ = Pressed::cancel;
else if (y >= 74 && y <= 103 && x >= 5 && x < 5 + int(state_.investments[size_t(*state_.selected_investment)].options.size()) * 60) {
const int option = (x - 5) / 60;
pressed_ = Pressed::option; pressed_index_ = option;
}
return pressed_ != Pressed::none;
}
if (right) {
// ConstructionPricePercent's outer scene recognizes right-button event 8 and exits the
// stadium immediately. The detail and tip loops above ignore it.
pending_ = request(StadiumRequestKind::close);
return true;
}
// Scene buttons row (y 215..224): view switch, future information and data page.
if (y >= 215 && y <= 224) {
if (x >= 2 && x < 117) {
if (!state_.investments_enabled) return false;
pressed_ = Pressed::scene_button; pressed_index_ = 0; return true;
}
if (x >= 125 && x < 215) { pressed_ = Pressed::scene_button; pressed_index_ = 1; return true; }
if (x >= 224 && x < 314) { pressed_ = Pressed::scene_button; pressed_index_ = 2; return true; }
}
// Investment icon grid in the interior view: 4 columns x 2 rows of 54x30 cells starting at (3,153).
if (!panorama_ && y >= 153 && y <= 211 && x >= 3 && x <= 217) {
const int col = (x - 3) / 54, row = (y - 153) / 30;
const int choice = row * 4 + col;
if (choice >= 0 && choice < 8 && state_.investments_enabled && state_.investments[size_t(choice)].available) {
pressed_ = Pressed::investment; pressed_index_ = choice; return true;
}
return false;
}
if (panorama_) {
periphery_hover_ = periphery_object_at(x, y);
if (future_information_ && periphery_available(state_, periphery_hover_)) {
pressed_ = Pressed::periphery_item; pressed_index_ = periphery_hover_; return true;
}
return false;
}
// Seat block rows: 24 px tall starting at y=22; blocks under construction cannot be selected.
if (!panorama_ && x >= 219 && x <= 319 && y >= 22 && y <= 213) {
const int slot = (y - 22) / 24;
if (slot >= 0 && slot < 8 && state_.blocks[size_t(slot)].construction_weeks == 0) {
pressed_ = Pressed::block_row; pressed_index_ = slot;
return true;
}
return false;
}
return false;
}
// Handles pointer movement. Without a pressed control it updates the hover highlight (investment icon, seat
// block row or panorama object). With a pressed control it cancels the press when the pointer leaves it,
// and drags the calculator window. Returns true if something visible changed.
bool StadiumScreen::pointer_move(int x, int y) {
if (calculator_source_waiting()) return false;
if (pressed_ == Pressed::none) {
if (pending_ || state_.quoted_object || state_.data) return false;
if (!panorama_) {
// the same targets a click acts on: an available investment icon or a finished seat block
int investment = -1, block = -1;
if (y >= 153 && y <= 211 && x >= 3 && x <= 217) {
const int choice = ((y - 153) / 30) * 4 + (x - 3) / 54;
if (choice >= 0 && choice < 8 && state_.investments_enabled && state_.investments[size_t(choice)].available)
investment = choice;
} else if (x >= 219 && x <= 319 && y >= 22 && y <= 213) {
const int slot = (y - 22) / 24;
if (slot >= 0 && slot < 8 && state_.blocks[size_t(slot)].construction_weeks == 0) block = slot;
}
const bool changed = investment != hover_investment_ || block != hover_block_;
hover_investment_ = investment;
hover_block_ = block;
return changed;
}
const int hover = periphery_object_at(x, y);
if (hover == periphery_hover_) return false;
periphery_hover_ = hover;
return true;
}
if (pressed_ == Pressed::block_calculator_drag) {
calculator_drag_to(block_calculator_x_ + (x - pressed_x_), block_calculator_y_ + (y - pressed_y_));
pressed_x_ = x; pressed_y_ = y;
return true;
}
// Is the pointer still inside the pressed control? These rectangles must match the ones in pointer_down.
bool inside = false;
switch (pressed_) {
case Pressed::scene_button:
inside = y >= 215 && y <= 224 &&
((pressed_index_ == 0 && x >= 2 && x < 117) || (pressed_index_ == 1 && x >= 125 && x < 215) ||
(pressed_index_ == 2 && x >= 224 && x < 314)); break;
case Pressed::investment:
inside = !panorama_ && x >= 3 && x <= 217 && y >= 153 && y <= 211 &&
((y - 153) / 30) * 4 + (x - 3) / 54 == pressed_index_; break;
case Pressed::option:
inside = x >= 5 + pressed_index_ * 60 && x < 5 + (pressed_index_ + 1) * 60 && y >= 74 && y <= 103; break;
case Pressed::build: inside = x >= 7 && x <= 76 && y >= 136 && y <= 145; break;
case Pressed::cancel: inside = x >= 107 && x <= 176 && y >= 136 && y <= 145; break;
// Yes/No buttons of the tip dialog
case Pressed::tip_yes: inside = x >= 62 && x <= 137 && y >= 166 && y <= 176; break;
case Pressed::tip_no: inside = x >= 175 && x <= 250 && y >= 166 && y <= 176; break;
case Pressed::periphery_item: inside = panorama_ && future_information_ &&
periphery_object_at(x, y) == pressed_index_; break;
case Pressed::periphery_yes: inside = periphery_dialog_ && periphery_dialog_->hit_test(x, y) == GameEndTaxDialog::Button::yes; break;
case Pressed::periphery_no: inside = periphery_dialog_ && periphery_dialog_->hit_test(x, y) == GameEndTaxDialog::Button::no; break;
// bottom-left corner area
case Pressed::close: inside = x < 50 && y > 218; break;
case Pressed::block_row: inside = !panorama_ && x >= 219 && x <= 319 && y >= 22 && y <= 213 &&
(y - 22) / 24 == pressed_index_; break;
case Pressed::block_amount: inside = x >= 5 && x <= 99 && y >= 74 && y <= 99; break;
case Pressed::block_seats: inside = x >= 120 && x <= 210 && y >= 73 && y <= 85; break;
case Pressed::block_roof: inside = x >= 120 && x <= 210 && y >= 88 && y <= 100; break;
case Pressed::block_build: inside = x >= 7 && x <= 76 && y >= 136 && y <= 145; break;
case Pressed::block_cancel: inside = x >= 107 && x <= 176 && y >= 136 && y <= 145; break;
case Pressed::block_calculator_key: {
const int x0 = block_calculator_x_, y0 = block_calculator_y_;
const int key_x = x0 + exe_.u16(::bmh::layout::Advertising_Click_RuntimeField + size_t(pressed_index_) * 2);
const int key_y = y0 + exe_.u8(::bmh::layout::Advertising_Click_RuntimeField2 + size_t(pressed_index_));
inside = x >= key_x && x <= key_x + 16 && y >= key_y && y <= key_y + 14;
break;
}
case Pressed::block_calculator_preset: {
const int x0 = block_calculator_x_, y0 = block_calculator_y_;
const int key_x = x0 + exe_.u16(::bmh::layout::Advertising_Click_RuntimeField + size_t(pressed_index_ + 15) * 2);
const int key_y = y0 + exe_.u8(::bmh::layout::Advertising_Click_RuntimeField2 + size_t(pressed_index_ + 15));
inside = x >= key_x && x <= key_x + 53 && y >= key_y && y <= key_y + 14;
break;
}
case Pressed::data_control: inside = state_.data && data_control_at(x, y) == pressed_index_; break;
case Pressed::none: break;
}
if (!inside) {
if (pressed_ == Pressed::block_calculator_key || pressed_ == Pressed::block_calculator_preset) {
block_calculator_pressed_key_ = -1;
if (pressed_ == Pressed::block_calculator_key) block_calculator_ticks_ = 0;
block_calculator_presented_ = false;
}
pressed_ = Pressed::none; pressed_index_ = -1; return true;
}
return false;
}
// Handles a mouse button release. If the pointer is released inside the control that was pressed, the matching
// request is created, stored as pending and returned. Local actions (view switches, calculator input) return {}.
StadiumRequest StadiumScreen::release(int x, int y, bool right) {
if (pending_) return {};
if (calculator_source_waiting()) return {};
const Pressed pressed = pressed_;
const int index = pressed_index_;
const int down_x = pressed_x_, down_y = pressed_y_;
pressed_ = Pressed::none; pressed_index_ = -1; pressed_x_ = pressed_y_ = -1;
if (right || pressed == Pressed::none) return {};
// Validate UP against the same source button, while allowing movement within it.
const bool released_inside =
(pressed == Pressed::data_control && state_.data && data_control_at(x, y) == index) ||
(pressed == Pressed::scene_button && y >= 215 && y <= 224 &&
((index == 0 && x >= 2 && x < 117) || (index == 1 && x >= 125 && x < 215) || (index == 2 && x >= 224 && x < 314))) ||
(pressed == Pressed::investment && !panorama_ && x >= 3 && x <= 217 && y >= 153 && y <= 211 &&
((y - 153) / 30) * 4 + (x - 3) / 54 == index) ||
(pressed == Pressed::option && x >= 5 + index * 60 && x < 5 + (index + 1) * 60 && y >= 74 && y <= 103) ||
(pressed == Pressed::build && x >= 7 && x <= 76 && y >= 136 && y <= 145) ||
(pressed == Pressed::cancel && x >= 107 && x <= 176 && y >= 136 && y <= 145) ||
(pressed == Pressed::tip_yes && x >= 62 && x <= 137 && y >= 166 && y <= 176) ||
(pressed == Pressed::tip_no && x >= 175 && x <= 250 && y >= 166 && y <= 176) ||
(pressed == Pressed::periphery_item && panorama_ && future_information_ && periphery_object_at(x, y) == index) ||
(pressed == Pressed::periphery_yes && periphery_dialog_ && periphery_dialog_->hit_test(x, y) == GameEndTaxDialog::Button::yes) ||
(pressed == Pressed::periphery_no && periphery_dialog_ && periphery_dialog_->hit_test(x, y) == GameEndTaxDialog::Button::no) ||
(pressed == Pressed::block_row && !panorama_ && x >= 219 && x <= 319 && y >= 22 && y <= 213 && (y - 22) / 24 == index) ||
(pressed == Pressed::block_amount && x >= 5 && x <= 99 && y >= 74 && y <= 99) ||
(pressed == Pressed::block_seats && x >= 120 && x <= 210 && y >= 73 && y <= 85) ||
(pressed == Pressed::block_roof && x >= 120 && x <= 210 && y >= 88 && y <= 100) ||
(pressed == Pressed::block_build && x >= 7 && x <= 76 && y >= 136 && y <= 145) ||
(pressed == Pressed::block_cancel && x >= 107 && x <= 176 && y >= 136 && y <= 145) ||
(pressed == Pressed::block_calculator_key && x >= block_calculator_x_ + exe_.u16(::bmh::layout::Advertising_Click_RuntimeField + size_t(index) * 2) &&
x <= block_calculator_x_ + exe_.u16(::bmh::layout::Advertising_Click_RuntimeField + size_t(index) * 2) + 16 &&
y >= block_calculator_y_ + exe_.u8(::bmh::layout::Advertising_Click_RuntimeField2 + size_t(index)) && y <= block_calculator_y_ + exe_.u8(::bmh::layout::Advertising_Click_RuntimeField2 + size_t(index)) + 14) ||
(pressed == Pressed::block_calculator_preset && x >= block_calculator_x_ + exe_.u16(::bmh::layout::Advertising_Click_RuntimeField + size_t(index + 15) * 2) &&
x <= block_calculator_x_ + exe_.u16(::bmh::layout::Advertising_Click_RuntimeField + size_t(index + 15) * 2) + 53 &&
y >= block_calculator_y_ + exe_.u8(::bmh::layout::Advertising_Click_RuntimeField2 + size_t(index + 15)) && y <= block_calculator_y_ + exe_.u8(::bmh::layout::Advertising_Click_RuntimeField2 + size_t(index + 15)) + 14) ||
(pressed == Pressed::block_calculator_drag);
if (!released_inside || down_x < 0 || down_y < 0) return {};
// Stores the request as pending (blocks further input until acknowledge or reject_action) and returns it.
const auto emit = [this](StadiumRequest result) { pending_ = result; return result; };
if (pressed == Pressed::data_control) {
if (index < 6) return emit(request(StadiumRequestKind::toggle_data_curve, index));
if (index < 8) return emit(request(StadiumRequestKind::toggle_data_scale, index - 6));
return emit(request(StadiumRequestKind::set_data_ticket_price, index - 8 + 10));
}
// Scene buttons: 0 toggles panorama/interior, 1 toggles future information (both purely local), 2 requests the data page.
if (pressed == Pressed::scene_button) {
if (index == 0) { panorama_ = !panorama_; future_information_ = false; periphery_hover_ = -1; hover_investment_ = hover_block_ = -1; return {}; }
if (index == 1) { future_information_ = !future_information_; periphery_hover_ = -1; hover_investment_ = hover_block_ = -1; return {}; }
return emit(request(StadiumRequestKind::open_data));
}
if (pressed == Pressed::investment)
return emit(request(StadiumRequestKind::select_investment, index));
if (pressed == Pressed::periphery_item)
return emit(request(StadiumRequestKind::quote_periphery, index));
if (pressed == Pressed::option && state_.selected_investment) {
const auto& options = state_.investments[size_t(*state_.selected_investment)].options;
if (index < 0 || size_t(index) >= options.size()) return {};
return emit(request(StadiumRequestKind::select_investment_option,
int(*state_.selected_investment), index, int32_t(options[size_t(index)].base_price)));
}
if (pressed == Pressed::build && state_.selected_investment && state_.selected_option) {
const auto& row = state_.investments[size_t(*state_.selected_investment)];
if (*state_.selected_option < 0 || size_t(*state_.selected_option) >= row.options.size()) return {};
const auto& option = row.options[size_t(*state_.selected_option)];
return emit(request(StadiumRequestKind::confirm_investment, int(*state_.selected_investment),
*state_.selected_option, int32_t(option.base_price)));
}
if (pressed == Pressed::cancel && state_.selected_investment)
return emit(request(StadiumRequestKind::cancel_investment, int(*state_.selected_investment)));
// Answer to the construction tip dialog. For blocks the editor request is used; for investments the price
// is the tip price on Yes and the option's base price on No.
if (pressed == Pressed::tip_yes || pressed == Pressed::tip_no) {
if (state_.block_expansion) {
auto result = block_request(StadiumRequestKind::expansion_answer_tip);
result.accept_tip = pressed == Pressed::tip_yes;
return emit(std::move(result));
}
int32_t price = 0;
if (state_.selected_investment && state_.selected_option) {
const auto& options = state_.investments[size_t(*state_.selected_investment)].options;
if (*state_.selected_option >= 0 && size_t(*state_.selected_option) < options.size())
price = int32_t(pressed == Pressed::tip_yes ? state_.construction_tip_price :
options[size_t(*state_.selected_option)].base_price);
}
return emit(request(StadiumRequestKind::answer_construction_tip,
state_.selected_investment ? int(*state_.selected_investment) : -1,
state_.selected_option.value_or(-1), price, pressed == Pressed::tip_yes));
}
if (pressed == Pressed::periphery_yes && state_.quoted_object)
return emit(request(StadiumRequestKind::build_periphery, *state_.quoted_object, -1, state_.quoted_price));
if (pressed == Pressed::periphery_no && state_.quoted_object)
return emit(request(StadiumRequestKind::decline_periphery, *state_.quoted_object, -1, state_.quoted_price));
if (pressed == Pressed::block_row) {
auto result = request(StadiumRequestKind::expansion_select);
result.block_slot = index;
return emit(std::move(result));
}
// Opens the calculator initialised with the quote's new places and resets all calculator state.
if (pressed == Pressed::block_amount && state_.block_expansion) {
block_calculator_open_ = true;
block_calculator_value_ = state_.block_expansion->quote.new_places;
block_calculator_text_ = std::to_string(block_calculator_value_);
block_calculator_digits_ = block_calculator_value_ == 0 ? 0 : unsigned(block_calculator_text_.size());
block_calculator_cancel_wait_ = false;
block_calculator_keyboard_j_ = false;
block_calculator_pressed_key_ = -1;
block_calculator_ticks_ = 0;
block_calculator_presented_ = false;
block_calculator_edited_ = false;
return {};
}
// Toggles the seats (bit 1) or roof (bit 2) feature of the editor.
if (pressed == Pressed::block_seats || pressed == Pressed::block_roof) {
if (!state_.block_expansion) return {};
const uint8_t bit = pressed == Pressed::block_seats ? 1 : 2;
const uint8_t desired = uint8_t(state_.block_expansion->desired_features ^ bit);
return emit(block_request(StadiumRequestKind::expansion_toggle_feature,
state_.block_expansion->total_target_places, desired));
}
if (pressed == Pressed::block_build && state_.block_expansion)
return emit(block_request(StadiumRequestKind::expansion_confirm));
if (pressed == Pressed::block_cancel && state_.block_expansion)
return emit(block_request(StadiumRequestKind::expansion_cancel));
if (pressed == Pressed::block_calculator_key)
return activate_block_calculator_key(index);
// A preset button copies its value into the calculator (indices 0..5: current + n thousand, 6: current, 7: maximum).
if (pressed == Pressed::block_calculator_preset && state_.block_expansion) {
const auto& quote = state_.block_expansion->quote;
const uint32_t current = uint32_t(quote.current_capacity_thousands) * 1000;
block_calculator_value_ = size_t(index) < 6 ? current + uint32_t(index) * 1000 :
size_t(index) == 6 ? current : quote.max_places;
block_calculator_text_ = std::to_string(block_calculator_value_);
if (block_calculator_value_ != 0) block_calculator_digits_ = unsigned(block_calculator_text_.size());
block_calculator_edited_ = true;
}
if (pressed == Pressed::block_calculator_drag) return {};
return {};
}
// Convenience: a press immediately followed by a release at the same position.
StadiumRequest StadiumScreen::click(int x, int y, bool right) {
if (!pointer_down(x, y, right)) return {};
return release(x, y, right);
}
// Handles a key press. Data page: ESC closes it. Calculator: Enter accepts, Backspace deletes, Space clears,
// digits are typed (each starts a short key-press wait). Scene: ESC closes the stadium (not during dialogs).
StadiumRequest StadiumScreen::key(std::string_view key) {
if (pending_ || calculator_source_waiting() || pressed_ != Pressed::none) return {};
if (state_.data) {
if (key == "ESC") { auto r = request(StadiumRequestKind::close_data); pending_ = r; return r; }
return {};
}
if (state_.construction_tip_dialog) return {};
if (block_calculator_open_) {
if (key == "ENTER" || key == "RETURN") {
block_calculator_keyboard_j_ = true;
block_calculator_pressed_key_ = 13;
block_calculator_ticks_ = 4;
block_calculator_presented_ = false;
return {};
}
int pressed_key = -1;
if (key == "BACKSPACE") pressed_key = 10;
else if (key == "SPACE") pressed_key = 12;
else if (key.size() == 1 && key[0] >= '0' && key[0] <= '9')
pressed_key = int(key[0] - '0');
if (pressed_key >= 0) {
const auto result = activate_block_calculator_key(pressed_key);
block_calculator_pressed_key_ = pressed_key;
block_calculator_keyboard_j_ = false;
block_calculator_ticks_ = 4; block_calculator_presented_ = false;
return result;
}
return {};
}
if (key == "ESC") {
if (state_.selected_investment || state_.quoted_object) return {};
auto r = request(StadiumRequestKind::close); pending_ = r; return r;
}
return {};
}
// Called when the shared process timer runs out. Answers pending questions with No, closes the calculator
// or editor, or closes the stadium.
StadiumRequest StadiumScreen::process_timer_expired() {
if (pending_ || calculator_source_waiting() || pressed_ != Pressed::none) return {};
//PresentManagerDialog forces button1 (No) after the shared process clock expires.
//PrepareStandBlockOffer still performs the already confirmed build at its base price.
if (state_.construction_tip_dialog || state_.periphery_quote_dialog)
return expire_construction_tip();
if (state_.selected_investment || state_.quoted_object) return {};
if (block_calculator_open_) {
//BalanceFromGame/event8 restores the editor and returns ffffffff. Unlike N,
//the Source checks its fifty-tick wait before assigning that sentinel.
//No accepted total or quote is changed, and no new wait is invented.
block_calculator_value_ = UINT32_MAX;
block_calculator_open_ = false;
block_calculator_text_.clear();
block_calculator_edited_ = true;
block_calculator_pressed_key_ = -1;
block_calculator_presented_ = false;
block_calculator_keyboard_j_ = false;
return {};
}
if (state_.block_expansion) {
//ConstructionPricePercent's block-detail poll28259 returns without the build event0.
pending_ = block_request(StadiumRequestKind::expansion_cancel);
return *pending_;
}
return key("ESC"); // existing scene/data close owners
}
// Answers an open question with No when the timer expires: periphery quote -> decline, block tip -> refuse tip,
// investment tip -> answer without the tip (base price). Returns {} if no such question is open.
StadiumRequest StadiumScreen::expire_construction_tip() {
if (pending_) return {};
// The existing deadline entry also owns the flags1 periphery question:
// PresentManagerDialog's No returns without PayConstruction or any construction payment.
if (state_.quoted_object && state_.periphery_quote_dialog) {
auto r = request(StadiumRequestKind::decline_periphery, *state_.quoted_object,
-1, state_.quoted_price);
pending_ = r;
pressed_ = Pressed::none; pressed_index_ = -1; pressed_x_ = pressed_y_ = -1;
return r;
}
if (!state_.construction_tip_dialog) return {};
if (state_.block_expansion) {
auto r = block_request(StadiumRequestKind::expansion_answer_tip);
r.accept_tip = false;
pending_ = r;
pressed_ = Pressed::none; pressed_index_ = -1; pressed_x_ = pressed_y_ = -1;
return r;
}
if (!state_.selected_investment || !state_.selected_option) return {};
const auto selected = *state_.selected_investment;
if (unsigned(selected) >= state_.investments.size()) return {};
const auto& options = state_.investments[size_t(selected)].options;
if (*state_.selected_option < 0 || size_t(*state_.selected_option) >= options.size()) return {};
auto r = request(StadiumRequestKind::answer_construction_tip, int(selected),
*state_.selected_option,
int32_t(options[size_t(*state_.selected_option)].base_price), false);
pending_ = r;
// The timeout itself answers the modal. A later mouse-up from the physical
// press must not be interpreted as a second answer.
pressed_ = Pressed::none; pressed_index_ = -1; pressed_x_ = pressed_y_ = -1;
return r;
}
// Applies the engine's answer to the pending request. The answer must carry the same identity (manager, club,
// scope) and exactly the next sequence and revision; otherwise the stale or forged answer is rejected with
// FormatError. Then the new state is validated per request kind (what the engine must have changed and what
// it must not have touched). Only after all checks are the dialogs rebuilt and the new state adopted.
void StadiumScreen::acknowledge(StadiumState updated) {
if (!pending_) throw FormatError("stadium: acknowledgement without a pending request");
const auto& req = *pending_;
if (req.manager_slot != state_.manager_slot || req.runtime_club != state_.runtime_club ||
req.stable_club_identity != state_.stable_club_identity || req.revision != state_.revision ||
updated.manager_slot != state_.manager_slot || updated.runtime_club != state_.runtime_club ||
updated.stable_club_identity != req.stable_club_identity ||
state_.revision == UINT64_MAX || updated.revision != req.revision + 1)
throw FormatError("stadium: acknowledgement identity or revision mismatch");
if (updated.decorated_stadium_header != !updated.plain_background)
throw FormatError("stadium: decorated header does not match independent Source plain_background state");
if (!same_source_stadium_style(state_, updated))
throw FormatError("stadium: acknowledgement changed immutable Source presentation flags");
if (req.kind == StadiumRequestKind::open) {
if (req.scope != 0 || req.sequence != 0 || state_.scope != 0 || state_.sequence != 0 ||
updated.scope == 0 || updated.sequence != 1)
throw FormatError("stadium: invalid initial stadium scope acknowledgement");
} else if (req.sequence == UINT64_MAX || updated.scope != state_.scope ||
updated.sequence != req.sequence + 1 ||
req.scope != state_.scope || req.sequence != state_.sequence) {
throw FormatError("stadium: acknowledgement scope or sequence mismatch");
}
// Field contract: block requests carry only block fields, other requests none of them; only tip answers may accept a tip.
const bool block_action = block_request_kind(req.kind);
if ((!block_action && (req.block_slot != -1 || req.block_total_places != 0 ||
req.block_features != 0 || req.expected_block_quote)) ||
(block_action && (req.object != -1 || req.option != -1 || req.price != 0)) ||
(req.kind != StadiumRequestKind::expansion_answer_tip &&
req.kind != StadiumRequestKind::answer_construction_tip && req.accept_tip))
throw FormatError("stadium: request contains fields outside its action contract");
if (block_action && (req.block_slot < 0 || req.block_slot >= int(state_.blocks.size())))
throw FormatError("stadium: invalid block request slot");
if (req.kind != StadiumRequestKind::open && req.kind != StadiumRequestKind::expansion_answer_tip &&
!same_block_compensation_context(state_, updated))
throw FormatError("stadium: immutable Source compensation context changed");
// Block requests must refer to the editor quote that is currently shown (expected quote, slot, owner).
const StadiumBlockExpansionEditor* old_editor = state_.block_expansion
? &*state_.block_expansion : nullptr;
if (req.kind == StadiumRequestKind::expansion_select) {
if (req.block_total_places != 0 || req.block_features != 0 || req.expected_block_quote ||
old_editor || state_.selected_investment || state_.quoted_object ||
state_.blocks[size_t(req.block_slot)].construction_weeks != 0)
throw FormatError("stadium: block selection is not an idle Source row transition");
} else if (block_action) {
if (!old_editor || req.block_slot != int(old_editor->quote.slot) ||
old_editor->quote.manager != req.manager_slot || old_editor->quote.manager_club != req.runtime_club ||
!req.expected_block_quote ||
*req.expected_block_quote != old_editor->quote || !valid_editor_projection(*old_editor,stadium_block_expansion_constants(exe_)) ||
((req.kind != StadiumRequestKind::expansion_set_total &&
req.kind != StadiumRequestKind::expansion_toggle_feature) &&
(req.block_total_places != old_editor->total_target_places ||
req.block_features != old_editor->desired_features)))
throw FormatError("stadium: block request does not match the accepted editor quote");
}
// Only data page requests may change the data page; they must also leave no other modal open.
const bool data_action = req.kind == StadiumRequestKind::open_data ||
req.kind == StadiumRequestKind::close_data || req.kind == StadiumRequestKind::toggle_data_curve ||
req.kind == StadiumRequestKind::toggle_data_scale || req.kind == StadiumRequestKind::set_data_ticket_price;
if ((!data_action && state_.data != updated.data) ||
(data_action && (!updated.opened || updated.selected_investment || updated.quoted_object ||
updated.block_expansion || updated.construction_tip_dialog)))
throw FormatError("stadium: acknowledgement changed independent data modal context");
// Per-kind validation of the new state against the old state and the request.
bool valid = true;
switch (req.kind) {
case StadiumRequestKind::open: valid = updated.opened && !updated.data; break;
case StadiumRequestKind::open_data:
valid = !state_.data && updated.data && req.object == -1 && req.option == -1 && req.price == 0 &&
!state_.selected_investment && !state_.quoted_object && !state_.block_expansion && !state_.construction_tip_dialog;
break;
case StadiumRequestKind::close_data:
valid = state_.data && !updated.data && updated.opened && req.object == -1 && req.option == -1 && req.price == 0;
break;
case StadiumRequestKind::toggle_data_curve:
case StadiumRequestKind::toggle_data_scale:
case StadiumRequestKind::set_data_ticket_price: {
valid = state_.data && updated.data && req.option == -1 && req.price == 0;
if (!valid) break;
auto expected = *state_.data;
if (req.kind == StadiumRequestKind::toggle_data_curve) {
valid = req.object >= 0 && req.object < 6;
if (valid) expected.flags ^= uint8_t(1 << req.object);
} else if (req.kind == StadiumRequestKind::toggle_data_scale) {
valid = req.object == 0 || req.object == 1;
if (valid) expected.flags ^= 0xc0;
} else {
valid = req.object >= 10 && req.object <= 25;
expected.ticket_price = uint8_t(req.object);
expected.required_attendance_text = updated.data->required_attendance_text;
valid = valid && !expected.required_attendance_text.empty();
}
valid = valid && expected == *updated.data;
break;
}
// request kinds that are never accepted as an engine answer
case StadiumRequestKind::select_block:
case StadiumRequestKind::prepare_block_offer:
case StadiumRequestKind::decline_block_offer:
case StadiumRequestKind::build_stand_block: valid = false; break;
case StadiumRequestKind::select_investment:
valid = updated.selected_investment && unsigned(*updated.selected_investment) == unsigned(req.object); break;
case StadiumRequestKind::select_investment_option:
valid = updated.selected_investment && unsigned(*updated.selected_investment) == unsigned(req.object) &&
updated.selected_option && *updated.selected_option == req.option; break;
case StadiumRequestKind::cancel_investment:
valid = !updated.selected_investment && !updated.construction_tip_dialog; break;
case StadiumRequestKind::confirm_investment:
valid = updated.construction_tip_dialog.has_value(); break;
case StadiumRequestKind::answer_construction_tip:
valid = !updated.construction_tip_dialog; break;
case StadiumRequestKind::quote_periphery:
valid = updated.quoted_object && *updated.quoted_object == req.object && updated.quoted_price > 0; break;
case StadiumRequestKind::decline_periphery: valid = !updated.quoted_object; break;
case StadiumRequestKind::build_periphery:
valid = !updated.quoted_object && !updated.periphery_quote_dialog &&
state_.days[size_t(req.object)] == 0 &&
(updated.days[size_t(req.object)] != 0 ||
(updated.days == state_.days && updated.level == state_.level && updated.balance == state_.balance));
break;
case StadiumRequestKind::close:
valid = !updated.opened && !updated.quoted_object && !updated.selected_investment &&
!updated.selected_option && !updated.construction_tip_dialog &&
same_block_compensation_context(state_, updated);
break;
case StadiumRequestKind::expansion_select: {
if (!updated.block_expansion) { valid = false; break; }
const auto& editor = *updated.block_expansion;
const auto& quote = editor.quote;
valid = int(quote.slot) == req.block_slot && quote.manager == req.manager_slot &&
quote.manager_club == req.runtime_club && quote.current_build_weeks == 0 &&
quote.company_price_percent == state_.construction_percent &&
quote.current_raw_flags == state_.blocks[size_t(req.block_slot)].flags &&
quote.current_capacity_thousands == state_.blocks[size_t(req.block_slot)].capacity_level &&
quote.current_future_capacity_thousands == state_.blocks[size_t(req.block_slot)].capacity &&
quote.desired_features == uint8_t(quote.current_raw_flags & 3) &&
quote.total_target_places == uint32_t(quote.current_capacity_thousands) * 1000u &&
quote.new_places == 0 &&
editor.total_target_places == quote.total_target_places &&
editor.desired_features == quote.desired_features &&
valid_editor_projection(editor,stadium_block_expansion_constants(exe_)) &&
!editor.offer && !updated.construction_tip_dialog &&
same_block_overviews(state_.blocks, updated.blocks) && updated.balance == state_.balance &&
!updated.selected_investment && !updated.quoted_object;
break;
}
case StadiumRequestKind::expansion_set_total: {
if (!old_editor || !updated.block_expansion) { valid = false; break; }
const auto& next = *updated.block_expansion;
const uint32_t minimum = uint32_t(old_editor->quote.current_capacity_thousands) * 1000;
const uint32_t total = req.block_total_places;
valid = total >= minimum && total <= old_editor->quote.max_places &&
req.block_features == old_editor->desired_features &&
same_block_quote_owner(old_editor->quote, next.quote) &&
canonical_block_quote(next.quote, total, req.block_features,stadium_block_expansion_constants(exe_)) &&
next.quote.total_target_places == total && next.quote.desired_features == req.block_features &&
next.total_target_places == total && next.desired_features == req.block_features &&
!next.offer && !updated.construction_tip_dialog &&
same_block_overviews(state_.blocks, updated.blocks) && updated.balance == state_.balance;
break;
}
case StadiumRequestKind::expansion_toggle_feature: {
if (!old_editor || !updated.block_expansion) { valid = false; break; }
const auto& next = *updated.block_expansion;
const uint8_t changed = uint8_t(old_editor->desired_features ^ req.block_features);
valid = (req.block_features & ~uint8_t(3)) == 0 && (changed == 1 || changed == 2) &&
!(old_editor->quote.current_raw_flags & changed) &&
same_block_quote_owner(old_editor->quote, next.quote) &&
canonical_block_quote(next.quote, old_editor->total_target_places, req.block_features,stadium_block_expansion_constants(exe_)) &&
next.quote.total_target_places == old_editor->total_target_places &&
next.quote.desired_features == req.block_features &&
next.total_target_places == old_editor->total_target_places &&
next.desired_features == req.block_features && !next.offer && !updated.construction_tip_dialog &&
same_block_overviews(state_.blocks, updated.blocks) && updated.balance == state_.balance;
break;
}
case StadiumRequestKind::expansion_cancel:
valid = old_editor && !updated.block_expansion && !updated.construction_tip_dialog &&
!updated.selected_investment && !updated.quoted_object &&
same_block_overviews(state_.blocks, updated.blocks) && updated.balance == state_.balance;
break;
// Confirm: a zero price builds directly; otherwise the engine must open an offer question (6..14 percent
// surcharge on the base price) with unchanged quote.
case StadiumRequestKind::expansion_confirm: {
if (!old_editor) { valid = false; break; }
if (old_editor->quote.base_price == 0) {
valid = !updated.block_expansion && !updated.construction_tip_dialog &&
same_block_overviews(state_.blocks, updated.blocks) && updated.balance == state_.balance;
break;
}
if (!updated.block_expansion) { valid = false; break; }
const auto& next = *updated.block_expansion;
valid = next.offer.has_value() && updated.construction_tip_dialog.has_value() &&
updated.construction_tip_dialog->kind == TaxDialogKind::question &&
updated.construction_tip_dialog->compact_dialog_frame == updated.compact_dialog_frame &&
updated.construction_tip_dialog->source_manager_flags == req.manager_slot &&
req.manager_slot >= 0 && req.manager_slot <= 3 &&
updated.construction_tip_dialog->source_flags == 0x204 &&
next.offer->decision == StandBlockOfferDecision::Pending &&
valid_editor_projection(next,stadium_block_expansion_constants(exe_)) && next.offer->percent >= 6 && next.offer->percent <= 14 &&
next.offer->base_price == old_editor->quote.base_price &&
next.offer->price == old_editor->quote.base_price &&
next.offer->construction_days == old_editor->quote.base_weeks &&
next.offer->base_days == old_editor->quote.base_weeks &&
next.offer->offered_price == uint32_t(uint64_t(old_editor->quote.base_price) * uint32_t(100 + next.offer->percent) / 100u) &&
next.quote == old_editor->quote &&
next.total_target_places == old_editor->total_target_places &&
next.desired_features == old_editor->desired_features &&
same_block_overviews(state_.blocks, updated.blocks) && updated.balance == state_.balance;
break;
}
// Answer to the offer question: the block row must either be unchanged or show the construction the answer
// implies (weeks in the allowed range for the chosen offer, capacity, pending flags), with balance, season
// tickets and ticket compensation updated accordingly.
case StadiumRequestKind::expansion_answer_tip: {
if (!old_editor || !old_editor->offer || !state_.construction_tip_dialog) { valid = false; break; }
valid = old_editor->offer->decision == StandBlockOfferDecision::Pending &&
state_.construction_tip_dialog->kind == TaxDialogKind::question &&
state_.construction_tip_dialog->compact_dialog_frame == state_.compact_dialog_frame &&
state_.construction_tip_dialog->source_manager_flags == req.manager_slot &&
req.manager_slot >= 0 && req.manager_slot <= 3 &&
state_.construction_tip_dialog->source_flags == 0x204 &&
valid_editor_projection(*old_editor,stadium_block_expansion_constants(exe_)) && old_editor->offer->percent >= 6 && old_editor->offer->percent <= 14 &&
old_editor->offer->base_price == old_editor->quote.base_price &&
old_editor->offer->price == old_editor->quote.base_price &&
old_editor->offer->construction_days == old_editor->quote.base_weeks &&
old_editor->offer->base_days == old_editor->quote.base_weeks &&
old_editor->offer->offered_price == uint32_t(uint64_t(old_editor->quote.base_price) * uint32_t(100 + old_editor->offer->percent) / 100u) &&
!updated.construction_tip_dialog && !updated.block_expansion &&
!updated.selected_investment && !updated.quoted_object;
if (valid) {
const auto slot = size_t(req.block_slot);
const auto& before = state_.blocks[slot];
const auto& after = updated.blocks[slot];
const bool unchanged = after.construction_weeks == before.construction_weeks &&
after.flags == before.flags && after.capacity_level == before.capacity_level &&
after.capacity == before.capacity;
const uint8_t expected_flags = uint8_t(before.flags |
uint8_t(old_editor->desired_features << 4));
const auto& offer = *old_editor->offer;
const bool offer_arithmetic_ok = !req.accept_tip ||
uint64_t(old_editor->quote.base_price) * uint32_t(100 + offer.percent) <=
uint64_t(std::numeric_limits<int32_t>::max());
// with the tip accepted, construction time lies between base_weeks minus half and base_weeks minus an eighth
const uint8_t shortest = uint8_t(old_editor->quote.base_weeks -
(old_editor->quote.base_weeks >> 1));
const uint8_t longest = uint8_t(old_editor->quote.base_weeks -
(old_editor->quote.base_weeks >> 3));
const bool weeks_match = req.accept_tip
? after.construction_weeks >= shortest && after.construction_weeks <= longest
: after.construction_weeks == old_editor->quote.base_weeks;
const bool constructed = weeks_match &&
after.capacity == uint8_t(old_editor->total_target_places / 1000) &&
after.capacity_level == before.capacity_level && after.flags == expected_flags;
const uint32_t expected_payment = req.accept_tip ? offer.offered_price : offer.base_price;
const uint8_t usable = source_usable_capacity_thousands(state_.blocks, slot);
const int32_t compensation = source_immediate_compensation(
state_.season_tickets, usable, state_.live_league_round, state_.ticket_refund_rate);
const uint16_t expected_tickets = source_ticket_cap(state_.season_tickets, usable);
const uint32_t old_balance_bits = std::bit_cast<uint32_t>(state_.balance);
const int32_t expected_balance = state_.source_level == 0 ? state_.balance :
std::bit_cast<int32_t>(old_balance_bits - expected_payment - uint32_t(compensation));
const bool balance_matches = unchanged ? updated.balance == state_.balance :
updated.balance == expected_balance;
const bool ticket_match = unchanged ? updated.season_tickets == state_.season_tickets :
updated.season_tickets == expected_tickets;
valid = offer_arithmetic_ok && same_block_compensation_context(state_, updated, constructed) &&
balance_matches && ticket_match && (unchanged || constructed) &&
same_other_block_overviews(state_.blocks, updated.blocks, slot);
}
break;
}
case StadiumRequestKind::none: valid = false; break;
}
if (!valid) throw FormatError("stadium: engine projection did not confirm request");
const bool acknowledged_close = req.kind == StadiumRequestKind::close;
// Build every nested notice and its restored frame while the accepted
// owner/pending request is still untouched. A decode/allocation failure
// therefore leaves the old question retryable.
std::optional<GameEndTaxDialog> staged_tip, staged_periphery;
if (updated.periphery_quote_dialog) {
const GameEndRenderOptions options{updated.plain_background, updated.gradient_text};
staged_periphery.emplace(data_, *updated.periphery_quote_dialog, options, render_scene());
}
if (updated.construction_tip_dialog) {
StadiumScreen staged_screen(data_, updated);
staged_tip = std::move(staged_screen.tip_dialog_);
}
pressed_ = Pressed::none; pressed_index_ = -1; pressed_x_ = pressed_y_ = -1;
if (block_request_kind(req.kind)) {
block_calculator_open_ = false;
block_calculator_text_.clear();
}
state_ = std::move(updated); pending_.reset(); feedback_ = "";
tip_dialog_ = std::move(staged_tip);
periphery_dialog_ = std::move(staged_periphery);
if (acknowledged_close) close_requested_ = true;
}
// Called when the engine refuses the pending request: drops it and shows the reason as feedback text.
void StadiumScreen::reject_action(std::string reason) {
if (!pending_ || reason.empty()) throw FormatError("stadium: rejection requires pending request and reason");
pending_.reset(); pressed_ = Pressed::none; pressed_index_ = -1; feedback_ = std::move(reason);
}
// State dump: the StadiumState JSON extended with the screen's pending request, view flags and calculator state.
std::string StadiumScreen::state_json() const {
auto result = stadium_state_json(state_); result.pop_back();
return result + ",\"pending_action\":" + (pending_ ? stadium_request_json(*pending_) : "null") +
",\"panorama\":" + (panorama_ ? "true" : "false") +
",\"future_information\":" + (future_information_ ? "true" : "false") +
",\"periphery_hover\":" + std::to_string(periphery_hover_) +
",\"pressed\":" + std::to_string(int(pressed_)) +
",\"calculator\":{\"open\":" + (calculator_open() ? "true" : "false") +
",\"frame_visible\":" + (block_calculator_open_ && !block_calculator_cancel_wait_ ? "true" : "false") +
",\"value\":" + std::to_string(block_calculator_value_) +
",\"text\":" + json_quote(block_calculator_text_) +
",\"digit_count\":" + std::to_string(block_calculator_digits_) +
",\"x\":" + std::to_string(block_calculator_x_) +
",\"y\":" + std::to_string(block_calculator_y_) +
",\"pressed_key\":" + std::to_string(block_calculator_pressed_key_) +
",\"remaining_ticks\":" + std::to_string(block_calculator_ticks_) +
",\"presented\":" + (block_calculator_presented_ ? "true" : "false") +
",\"cancel_wait\":" + (block_calculator_cancel_wait_ ? "true" : "false") +
",\"keyboard_j\":" + (block_calculator_keyboard_j_ ? "true" : "false") +
",\"edited\":" + (block_calculator_edited_ ? "true" : "false") +
",\"waiting_for_key_release\":" + (calculator_waiting_for_key_release() ? "true" : "false") + "}" +
",\"feedback\":" + (feedback_.empty() ? "null" : json_quote(feedback_)) + '}';
}
// True while a mouse button is held on a Yes/No button of one of the questions.
bool StadiumScreen::construction_tip_held() const {
// Both PresentManagerDialog questions retain their physical button until release.
return pressed_ == Pressed::tip_yes || pressed_ == Pressed::tip_no ||
pressed_ == Pressed::periphery_yes || pressed_ == Pressed::periphery_no;
}
} // namespace bmh::ui