Files
Dreierpack-Manager/src/game/sportschau_presentation.hpp
T

219 lines
10 KiB
C++

// SPDX-License-Identifier: GPL-3.0-only
#pragma once
// Immutable, source-word-preserving input to Sportschau presentation callbacks.
// Presentation callbacks remain immutable; Source replay and award work have
// separate Core owners, independent of whether a UI observer is installed.
#include <cstdint>
#include <array>
#include <cstddef>
#include <functional>
#include <optional>
#include <vector>
#include "game/presentation.hpp"
#include "game/match_engine.hpp"
namespace bmh {
struct GameState;
struct MatchGroup;
class WatcomRandom;
class LeImage;
// MatchdayIntro walks the group's flat 16-bit log in two-word steps. The third
// word it reads is a look-ahead into the next record, and some codes consume
// that next pair as a secondary player/distance. Keep both the decoded fields
// and exact words so a presenter cannot accidentally reinterpret the stream.
struct SportschauLogEvent {
uint8_t group = 0;
uint8_t fixture = 0;
uint16_t event_ordinal = 0; // ordinal after filtering this fixture's teams
uint16_t source_word_index = 0; // index of the first word in MatchGroup::log
uint16_t source_code_player_word = 0;
uint16_t source_team_value_word = 0;
uint8_t source_code = 0; // high four bits of the first word
uint16_t player_id = 0x0fff;
int16_t team_id = -1;
uint8_t source_value = 0; // low seven bits of the second word
bool consumes_following_pair = false; // source codes 0 (goal) and 1 (miss)
bool has_following_word = false;
bool has_following_pair = false;
uint16_t following_code_player_word = 0;
uint16_t following_team_value_word = 0;
std::vector<uint8_t> player_name; // Original encoded bytes
std::vector<uint8_t> following_player_name; // empty when no valid look-ahead player
};
struct SportschauFixtureView {
uint8_t group = 0;
uint8_t fixture = 0;
uint8_t competition_type = 0;
uint8_t fixture_flags = 0;
uint8_t source_footer_variant = 0; // MatchdayIntro local_44: 0 normal,1 extra-time,2 indoor
bool has_replay_progression_mode = false;
uint8_t replay_progression_mode = 0; // saved byte; controls selected-progressive scene path
bool has_replay_chance_mode = false;
uint8_t replay_chance_mode = 0; // saved byte; controls selected scene/panel restoration
bool source_selection_available = false;
bool source_selected = false; // ResetSportschauSelection(pair,1), resolved from pre-match state
uint32_t competition_id = 0;
int16_t source_setting_index = -1; // SportschauPresentationOperation(desc,5), or -1 if unavailable
int16_t home_team = -1;
int16_t away_team = -1;
uint8_t source_played_minute = 0; // descriptor +0x04, indexed by Source fixture ordinal
uint16_t home_badge_word = 0xffff; // raw ClubBadgeSelectors u16 consumed by SourceBadgeFallback
uint16_t away_badge_word = 0xffff;
bool score_known = false;
uint8_t home_goals = 0;
uint8_t away_goals = 0;
std::vector<uint8_t> home_name; // Original encoded bytes
std::vector<uint8_t> away_name; // Original encoded bytes
std::vector<uint8_t> home_short_name; // exact ClubShortNameOffsets substring for team ids < 168
std::vector<uint8_t> away_short_name;
bool home_short_name_available = false;
bool away_short_name_available = false;
bool home_name_requires_font_fit = true; // caller trims by two bytes until FNT3 width < 48
bool away_name_requires_font_fit = true;
bool home_name_requires_longest_word = false; // TextWidth foreign-team branch, team >= 168
bool away_name_requires_longest_word = false;
std::vector<SportschauLogEvent> log_events; // Source log order, fixture-filtered
std::vector<ShowEvent> show_events; // Distinct live-animation stream, not the report log
};
struct SportschauCompetitionView {
uint8_t group = 0;
uint8_t type = 0;
uint32_t id = 0;
int16_t source_setting_index = -1;
};
struct SportschauIntroView {
int group_index = -1; // -1 post-simulation, otherwise a Source group-entry point
std::vector<SportschauCompetitionView> groups;
};
// FinishEvent's pre-play KB136 competition list, independent of report selection.
struct MatchdayIntroView {
std::vector<std::string> competition_names; // Original encoded bytes
};
using MatchdayIntroHook = std::function<void(const GameState&, const MatchdayIntroView&)>;
std::optional<MatchdayIntroView> matchday_intro_view(const GameState&,
const std::vector<MatchGroup>&);
// Intro gets all group competition ids so App can evaluate Source's global
// setting-matrix eligibility test without guessing from the current fixture.
using SportschauIntroHook = std::function<void(const GameState&, const SportschauIntroView&)>;
using SportschauFixtureHook = std::function<void(const GameState&, const SportschauFixtureView&)>;
struct SportschauAwardPlayer {
uint16_t squad_slot = 0, player_id = 0x0fff;
int16_t team_id = -1;
uint8_t score = 0;
std::string player_name, club_name; // Original encoded bytes
};
struct SportschauAwardsView {
uint8_t group = 0;
uint32_t competition_id = 0;
std::string competition_title; // Void4, Original encoded bytes
bool source_backdrop_available = true; // SportschauIntro/5c1c7, independent of C7 animation
std::array<SportschauAwardPlayer, 11> players;
};
using SportschauAwardsHook = std::function<void(const GameState&, const SportschauAwardsView&)>;
// SportschauEleven: complete-eleven gate, Source manager counter, then pure viewer input.
// The statistic reads the score byte as a slot (confirmed in x86), whereas
// the displayed names use the separate u16 squad-slot array at descriptor+9c.
std::optional<SportschauAwardsView> finish_sportschau_awards(GameState& state,
const MatchGroup& group, int group_index);
struct SportschauTeamInfoView {
uint8_t group = 0;
uint32_t competition_id = 0;
std::string competition_title;
bool source_backdrop_available = true;
// Source descriptor +bc,+c0,+c4,+c8: yellow, red, spectators, goals.
std::array<int32_t, 4> totals{};
};
using SportschauTeamInfoHook = std::function<void(const GameState&, const SportschauTeamInfoView&)>;
std::string sportschau_competition_title(const GameState& state, const MatchGroup& group);
std::optional<SportschauTeamInfoView> sportschau_team_info_view(const GameState& state,
const MatchGroup& group, int group_index);
struct SportschauReportStep {
size_t visible_log_entries = 0;
uint8_t progress_minute = 0;
bool minute_wait = false;
bool chance_wait = false;
bool terminal_wait = false;
};
std::vector<SportschauReportStep> sportschau_report_steps(const SportschauFixtureView& fixture);
struct SportschauSceneView {
SportschauReportStep report_step;
int home_goals_before = 0, away_goals_before = 0;
std::vector<MatchGroup> groups; // owned single-group context; shot.group ==0
std::optional<LiveSetPieceEvent> set_piece;
LiveShotEvent shot;
};
struct SportschauReplayHooks {
// Return only the Source left=2 latch; Core applies it after a minute wait.
std::function<bool(const GameState&, const SportschauFixtureView&, const SportschauReportStep&)> step;
std::function<void(const GameState&, const SportschauFixtureView&, const SportschauSceneView&)> scene;
};
// CompetitionWinnerScreen(param1=0), called at title settlement before title-history writes.
struct CompetitionWinnerView { uint8_t title = 0; uint16_t team = 0; };
using CompetitionWinnerHook = std::function<void(const GameState&, const CompetitionWinnerView&)>;
struct SportschauPresentationHooks {
CompetitionWinnerHook winner;
MatchdayIntroHook kickoff;
SportschauIntroHook intro;
SportschauFixtureHook fixture;
SportschauReplayHooks replay;
SportschauAwardsHook awards;
SportschauTeamInfoHook team_info;
};
struct SportschauRatingTables {
std::array<int8_t, 4> position_limit{}, opponent_misses{}, chance_actor{}, own_chances{}, scorer_bonus{};
std::array<uint8_t, 4> award_begin{}, award_end{};
uint16_t domestic_teams = 0;
};
SportschauRatingTables sportschau_rating_tables(const LeImage& exe);
// MatchdayIntro, after replay and before morale/development. Updates eleven Source
// award scores and global squad-slot ids in the group's descriptor, not players.
void rate_sportschau_players(const GameState& state, MatchGroup& group,
const SportschauFixtureView& fixture, WatcomRandom& rand, const SportschauRatingTables& tables);
struct SportschauSourceOptions {
uint8_t intro_after_matchday = 0; // unsaved EXE byte CareerSession_SportschauSourceOptions_ExecutableField
uint8_t intro_each_group = 0; // unsaved EXE byte CareerSession_DispatchTransferOffer_ExecutableField2
uint16_t rated_club_threshold = 90; // EXE TeamsWithSquads, ResetSportschauSelection's extra fifty points
std::optional<SportschauRatingTables> ratings; // loaded EXE policy, not FBM data
};
// Read-only projection for one already-completed fixture. Source's flat log is
// filtered by the two fixture teams, while its pair stride and look-ahead words
// remain intact. This helper does not mutate Native state or either RNG.
SportschauFixtureView sportschau_fixture_view(const GameState& state, const MatchGroup& group,
int group_index, int fixture_index,
const std::vector<ShowEvent>& show_events);
int sportschau_source_setting_index(const GameState& state, const MatchGroup& group);
// ResetSportschauSelection modes0/2/1. Only the pre-match caller may rate candidates; foreign
// teams consume the real Watcom generator even with capacity A8 ==0.
void reset_sportschau_selection(GameState& state);
bool consider_sportschau_fixture(GameState& state, const MatchGroup& group,
int home, int away, WatcomRandom& rand);
bool sportschau_selected(const GameState& state, int home);
// MatchdayIntro/ShotAnimation: owns scene draws between table updates and morale.
// With no UI callbacks, it still consumes the same enabled Source scene work.
void present_sportschau_replay(GameState& state, const MatchGroup& group,
const SportschauFixtureView& fixture, GameRandom& game, WatcomRandom& rand,
const SportschauReplayHooks& hooks);
} // namespace bmh