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

288 lines
15 KiB
C++

// SPDX-License-Identifier: GPL-3.0-only
#include "formats/executable_layout.hpp"
#include "ui/statistics_rankings.hpp"
#include <algorithm>
#include <stdexcept>
#include <utility>
#include "ui/setup.hpp"
#include "ui/manager.hpp"
namespace bmh::ui {
namespace {
constexpr uint32_t kTitles = ::bmh::layout::Titles;
constexpr uint32_t kTitleCount = 9;
constexpr uint32_t kSeasonCount = 50;
// OtherGames_Layout_ExecutableField and SeasonEntrants_FormatError_TextPointer2 are runtime TEXTD pointer tables, not initialized
// pointers in BMH.exe's static image. Their TEXTD slots are 601 and 623.
constexpr size_t kAlternateTitleTextBase = 601;
constexpr size_t kTitleTextBase = 623;
constexpr size_t kEmptyTitleText = 913;
void copy_transparent(Image& out, const Image& src, int sx, int sy, int x, int y, int w, int h) {
if (sx < 0 || sy < 0 || x < 0 || y < 0 || w < 0 || h < 0 ||
sx + w > src.width || sy + h > src.height || x + w > out.width || y + h > out.height)
throw FormatError("statistics rankings: Original sprite bounds");
for (int yy = 0; yy < h; ++yy)
for (int xx = 0; xx < w; ++xx) {
const uint8_t color = src.pixels[size_t(sy + yy) * size_t(src.width) + size_t(sx + xx)];
if (color != 0xc0) out.at(x + xx, y + yy) = color;
}
}
void fill(Image& out, int x, int y, int w, int h, uint8_t color) {
if (x < 0 || y < 0 || w < 0 || h < 0 || x + w > out.width || y + h > out.height)
throw FormatError("statistics rankings: Original button bounds");
for (int yy = y; yy < y + h; ++yy)
for (int xx = x; xx < x + w; ++xx) out.at(xx, yy) = color;
}
uint8_t original_name_color(const GameState& game, int runtime_team) {
const size_t count = std::min<size_t>(game.manager_teams.size(), 4);
const int active = game.memory.has(::bmh::layout::ActiveManager) ? game.memory.u8(::bmh::layout::ActiveManager) : -1;
const int manager_count = game.memory.has(::bmh::layout::ManagerCount) ? game.memory.u8(::bmh::layout::ManagerCount) : int(count);
const bool current = game.memory.has(::bmh::layout::DeskPosition) && game.memory.u8(::bmh::layout::DeskPosition) < manager_count;
for (size_t slot = 0; slot < count; ++slot) {
const size_t at = slot * 0xb0c;
if (at + 0xa8 >= game.manager_records.size() || game.manager_records[at + 0xa8] == 0) continue;
if (game.manager_teams[slot] == runtime_team)
return int(slot) == active && current ? 0x7a : 0x75;
}
if (game.memory.has(::bmh::layout::AlltimeTable_TeamColor_RuntimeField) && game.memory.u16(::bmh::layout::AlltimeTable_TeamColor_RuntimeField) == runtime_team) return 0xf7;
return 0x5f;
}
} // namespace
StatisticsRankingState statistics_rankings_from_game(const GameState& game, const LeImage& exe,
int manager_slot, int category, int first_season,
const Image& underlay) {
if (category < 0 || category >= int(kTitleCount)) throw FormatError("statistics rankings: category outside 0..8");
if (first_season < 0 || (first_season % 4) != 0)
throw FormatError("statistics rankings: Source page must start at a four-season boundary");
if (!game.memory.has(kTitles + kTitleCount * kSeasonCount * 2 - 1))
throw FormatError("statistics rankings: save lacks the Original Titles title-holder block");
if (manager_slot < 0 || manager_slot >= 4 ||
size_t(manager_slot) * 0xb0c + 0x2aa + 1 >= game.manager_records.size())
throw FormatError("statistics rankings: missing Source manager season-number field");
if (underlay.width != 320 || underlay.height != 240)
throw FormatError("statistics rankings: expected accepted 320x240 parent underlay");
StatisticsRankingState out;
out.category = category;
out.first_season = first_season;
out.manager_slot = manager_slot;
const uint32_t manager_year_at = uint32_t(manager_slot) * 0xb0c + 0x2aa;
out.season_number_base = int(exe.u16(::bmh::layout::Achievements_FormatError_RuntimeField2)) +
int(game.manager_records[manager_year_at] | (uint16_t(game.manager_records[manager_year_at + 1]) << 8));
const auto history = title_history_rows(game);
if (history.empty()) throw FormatError("statistics rankings: missing title history");
out.history_first_season = int(history.begin()->first);
out.current_season = game.season - out.history_first_season;
if (out.current_season < 0 || first_season > out.current_season)
throw FormatError("statistics rankings: history page outside known career");
out.season_number_base += out.history_first_season - std::max(0, game.season - 49);
out.season_known.assign(size_t(out.current_season) + 1, false);
out.underlay = underlay;
for (uint32_t index = 0; index < kTitleCount; ++index) {
const uint8_t title_id = exe.u8(::bmh::layout::StatisticsRankings_FormatError_RuntimeField + index);
const bool alternate = exe.u8(::bmh::layout::StatisticsRankings_FormatError_RuntimeField2 + index) != 0;
if (title_id >= kTitleCount) throw FormatError("statistics rankings: Source title id outside nine stored lists");
out.categories[index] = StatisticsRankingCategory{title_id, alternate};
}
for (size_t category = 0; category < 9; ++category) {
const auto count = size_t(out.current_season) + 1;
out.title_holders[category].assign(count, 0xffff);
out.club_names[category].resize(count);
out.club_name_colors[category].assign(count, 0x5f);
out.title_present[category].assign(count, false);
for (const auto& [season, names] : history) {
if (int(season) > game.season) throw FormatError("statistics rankings: future archived season");
const auto index = size_t(int(season) - out.history_first_season);
out.season_known[index] = true;
out.club_names[category][index] = names[category];
out.title_present[category][index] = !names[category].empty();
const int native_index = int(season) - std::max(0, game.season - 49);
if (native_index >= 0 && native_index < 50) {
const auto team = game.memory.u16(kTitles + uint32_t(category) * 100 + uint32_t(native_index) * 2);
out.title_holders[category][index] = team;
if (team != 0xffff) out.club_name_colors[category][index] = original_name_color(game, team);
}
}
}
return out;
}
StatisticsRankingsScreen::StatisticsRankingsScreen(const std::filesystem::path& data,
StatisticsRankingState state)
: state_(std::move(state)), exe_(load_le(asset_path(data, "BMH.exe"))),
font_(load_font(asset_path(data / "F", "BMH3.FNT"))), sprite_(data),
button_art_(load_vga(asset_path(data / "KB", "0.VGA"))),
texts_(load_textd(asset_path(data, "TEXTD.BLK"))) {
if (state_.category < 0 || state_.category >= int(kTitleCount) || state_.current_season < 0 ||
state_.first_season < 0 || state_.first_season > state_.current_season || state_.first_season % 4 != 0 ||
state_.underlay.width != 320 || state_.underlay.height != 240 ||
button_art_.width < 76 || button_art_.height < 84)
throw FormatError("statistics rankings: incomplete Source projection");
for (size_t i = 0; i < 9; ++i)
if (state_.club_names[i].size() != size_t(state_.current_season) + 1 ||
state_.club_name_colors[i].size() != state_.club_names[i].size() ||
state_.title_present[i].size() != state_.club_names[i].size() ||
state_.season_known.size() != state_.club_names[i].size())
throw FormatError("statistics rankings: incomplete archived rows");
for (size_t i = 0; i < state_.categories.size(); ++i) {
const auto& category = state_.categories[i];
if (category.title_id >= kTitleCount)
throw FormatError("statistics rankings: incomplete Source category map");
const size_t base = category.alternate_label_table ? kAlternateTitleTextBase : kTitleTextBase;
category_labels_[i] = texts_[base + category.title_id];
if (category_labels_[i].empty())
throw FormatError("statistics rankings: missing Source TEXTD category label");
}
empty_label_ = texts_[kEmptyTitleText];
}
void StatisticsRankingsScreen::draw_category_button(Image& out, int index, bool pressed) const {
const int col = index / 3, row = index % 3;
const int x = col * 0x5b + 0x17, y = row * 0x0c + 0x9a;
const int dx = x + (pressed ? 2 : 0), dy = y + (pressed ? 2 : 0);
// Source FormatError3 uses the KB/0 button slices at x=0x18, y=0x2c/0x4a
// (pressed) or 0x4a/0x5e (released), with 8-pixel center repeats.
const int source_y = pressed ? 44 : 74;
if (pressed) {
const uint8_t background = out.at(x, y + 10);
fill(out, x, y, 0x59 + 1, 2, background);
fill(out, x, y, 2, 10, background);
} else {
fill(out, x + 2, y + 10, 0x59, 2, 0x40);
fill(out, x + 0x59, y + 2, 2, 9, 0x40);
}
copy_transparent(out, button_art_, 24, source_y, dx, dy, 31, 10);
int used = 31;
while (0x59 - used > 20) {
const int amount = std::min(8, 0x59 - used - 20);
copy_transparent(out, button_art_, 24, source_y + 10, dx + used, dy, amount, 10);
used += amount;
}
const int tail = 0x59 - used;
copy_transparent(out, button_art_, 45 - tail, source_y + 20, dx + used, dy, tail, 10);
const auto& label = category_labels_[size_t(index)];
const int mode = exe_.u8(::bmh::layout::Advertising_Button_RuntimeField + uint32_t(pressed));
const int measured = sprite_.text_width(original_to_utf8(label));
sprite_.draw(out, dx + (0x59 - measured) / 2, dy + 7,
original_to_utf8(label), mode);
}
Image StatisticsRankingsScreen::render() const {
Image out = state_.underlay;
// The parent supplies its accepted frame; StatisticsRankingsFromGame owns these nine
// category controls and the historical title-holder rows.
for (int index = 0; index < 9; ++index)
draw_category_button(out, index, index == state_.category || index == pressed_category_);
// StatisticsRankingsFromGame2(0x18,0x24,0x10e,0x74) is the opaque Source list-pane helper.
// The parent owns its pixels; this overlay writes only the rows it contains.
const int end = std::min(state_.current_season, state_.first_season + 15);
for (int season = state_.first_season; season <= end; ++season) {
const int visible = season - state_.first_season;
const int y = 0x31 + visible * 6;
const bool has_title = state_.title_present[size_t(state_.category)][size_t(season)];
if (season < state_.current_season || has_title) {
const int source_season_number = state_.season_number_base + season + 1;
std::string n = std::to_string(source_season_number);
while (n.size() < 4) n.insert(n.begin(), '%');
n += "%%"; // FormatNumber(...,0xc4,&StatisticsRankingsRuntimeField): width-four Source number and suffix.
const uint8_t year_color = !has_title &&
(state_.category == 5 || state_.category == 6) ? 0x67 : 0x6b;
font_.draw(out, 100, y - font_.baseline, n, year_color);
if (has_title) {
font_.draw(out, 130, y - font_.baseline,
state_.club_names[size_t(state_.category)][size_t(season)],
state_.club_name_colors[size_t(state_.category)][size_t(season)]);
} else {
font_.draw(out, 130, y - font_.baseline,
state_.season_known[size_t(season)] ? empty_label_ : "Unbekannt", 0x67);
}
}
}
return out;
}
bool StatisticsRankingsScreen::pointer_down(int x, int y, bool right) {
if (pending_) return false;
if (right) {
pending_ = StatisticsRankingsRequest{StatisticsRankingsRequestKind::close, state_.category};
return true;
}
pressed_category_ = -1;
for (int index = 0; index < 9; ++index) {
const int col = index / 3, row = index % 3;
const int left = col * 0x5b + 0x17, top = row * 0x0c + 0x9a;
if (x >= left && x <= left + 0x59 && y >= top && y <= top + 9) {
pressed_category_ = index;
return true;
}
}
// StatisticsRankingsFromGame handles the Original scroll event after the category-button
// hit test: upper half moves four seasons toward the present, lower half back.
if (x >= 0x18 && x <= 0x18 + 0x10e && y >= 0x24 && y <= 0x24 + 0x74) {
scroll(y < 0x5e ? -1 : 1);
return true;
}
return false;
}
bool StatisticsRankingsScreen::move(int x, int y) {
if (pressed_category_ < 0) return false;
const int col = pressed_category_ / 3, row = pressed_category_ % 3;
const int left = col * 0x5b + 0x17, top = row * 0x0c + 0x9a;
if (x >= left && x <= left + 0x59 && y >= top && y <= top + 9) return false;
pressed_category_ = -1;
return true;
}
bool StatisticsRankingsScreen::release(int x, int y) {
if (pending_) return false;
const int index = pressed_category_;
pressed_category_ = -1;
if (index < 0) return false;
const int col = index / 3, row = index % 3;
const int left = col * 0x5b + 0x17, top = row * 0x0c + 0x9a;
if (x < left || x > left + 0x59 || y < top || y > top + 9) return true;
if (index == state_.category) {
// StatisticsRankingsFromGame leaves the inner loop active for the already-selected
// button; its matching mouse event is then interpreted by the scroll
// branch using that button's y coordinate (below 0x5e => false).
scroll(1);
return true;
}
pending_ = StatisticsRankingsRequest{StatisticsRankingsRequestKind::select_category, index};
return true;
}
void StatisticsRankingsScreen::reject_action() {
if (!pending_) throw FormatError("statistics rankings: no pending action to reject");
pending_.reset();
pressed_category_ = -1;
}
void StatisticsRankingsScreen::acknowledge_category(StatisticsRankingState accepted) {
if (!pending_ || pending_->kind != StatisticsRankingsRequestKind::select_category ||
accepted.category != pending_->category || accepted.first_season != 0 ||
accepted.underlay.pixels != state_.underlay.pixels)
throw FormatError("statistics rankings: mismatched category acknowledgement");
state_ = std::move(accepted);
pending_.reset();
pressed_category_ = -1;
}
void StatisticsRankingsScreen::scroll(int delta) {
if (pending_ || delta == 0) return;
int next = state_.first_season + (delta < 0 ? -4 : 4);
const int max_first = state_.current_season >= 12
? ((state_.current_season - 12) / 4) * 4 : 0;
state_.first_season = std::clamp(next, 0, max_first);
}
} // namespace bmh::ui