struct App moves out of main.cpp into app/app.hpp (state and declarations; the return types are spelled out now, taken from the compiler) and its 94 member functions into app_run.cpp handle() and run(): wiring, title screen, event loop app_live.cpp live match, interventions, event animations, reality mode app_transfer.cpp offers, decisions, market sales, loan returns, poaching app_season.cpp season end and start: tax, promotion, highscore, cup draw app_services.cpp timers and deadlines served between inputs app_club.cpp the club dialogs app_sportschau.cpp the Sportschau app_notices.cpp notices and questions over a screen main.cpp keeps main(): game data, window, sound (238 lines instead of 4,550). The function bodies moved unchanged. docs/DIFFERENCES.md is regenerated (a marker moved to app_run.cpp). Verified: 211 of 211 tests; careers, UI walk and robot (234 commands) identical; long robot run (52 kick-offs to April of the season, indoor tournament included): every desk picture identical. Co-Authored-By: Claude <noreply@anthropic.com>
1326 lines
80 KiB
C++
1326 lines
80 KiB
C++
// SPDX-License-Identifier: GPL-3.0-only
|
|
// App: the live match (minute display, the observer with its interventions, the event animations, reality mode, phase results).
|
|
// (moved out of main.cpp unchanged; the class is declared in app/app.hpp)
|
|
#include "app/app.hpp"
|
|
|
|
// Live-match intervention: opens the lineup/pitch screen for the clicked team and runs it
|
|
// until closed. Returns true if the intervention was completed successfully.
|
|
auto App::present_live_lineup(int minute, MatchEngine& engine, std::vector<MatchGroup>& groups,
|
|
GameState& state, uint64_t& live_revision, int selected_team, int selected_opponent,
|
|
const app::LiveLineupDispatcher& dispatch, const app::LiveTacticsDispatcher& dispatch_tactic,
|
|
const app::LivePitchDispatcher& dispatch_pitch,
|
|
const app::LiveInterventionScopeDispatcher& dispatch_scope,
|
|
bool live_skipped, bool event_origin) -> bool {
|
|
// Shows the engine's notice about a refused substitution as a dialog over the pitch.
|
|
const auto show_live_substitution_notice = [&](const app::LiveSubstitutionResult& result,
|
|
const Image& backdrop, const char* parent_title) {
|
|
if (result.status != app::LiveSubstitutionStatus::source_notice) return;
|
|
if (result.manager_slot < 0 || result.source_text_address == 0)
|
|
throw FormatError("live substitution notice has no Source owner or text");
|
|
const PendingOfferNotice notice{result.manager_slot, -1, result.source_text_address,
|
|
message_text(state, result.source_text_address)};
|
|
const auto projection = ui::pending_offer_notice_dialog(state, notice);
|
|
if (present_pending_dialog(state, projection, backdrop,
|
|
"OpenBMH - live_substitution_notice") == PendingOfferAnswer::unsupported)
|
|
throw FormatError("live substitution notice presenter stopped");
|
|
SDL_FlushEvents(SDL_MOUSEMOTION, SDL_MOUSEBUTTONUP);
|
|
SDL_SetWindowTitle(window, parent_title);
|
|
};
|
|
bool completed = false;
|
|
const int selected_manager = selected_team >= 0 ? state.manager_of(selected_team) : -1;
|
|
// Only for a human-managed team, and only when started from a match event or while the
|
|
// match is not being skipped past its first two minutes.
|
|
if ((event_origin || (!live_skipped && minute > 2)) && selected_team >= 0 && selected_manager >= 0) {
|
|
bool scope_started = false, scope_finished = false;
|
|
std::string scope_error;
|
|
try {
|
|
if (!dispatch_scope(app::LiveInterventionBoundary::begin, 2,
|
|
selected_manager, selected_team, scope_error))
|
|
throw FormatError(scope_error.empty() ? "live intervention could not begin" : scope_error);
|
|
scope_started = true;
|
|
// FindManagerForClub selects the manager owned by
|
|
// the clicked side. The live scope owns that
|
|
// manager until Source menu completion or abort.
|
|
auto lineup_state = state;
|
|
if (lineup_state.memory.has(::bmh::layout::ActiveManager))
|
|
lineup_state.memory.set8(::bmh::layout::ActiveManager, uint8_t(selected_manager));
|
|
auto live_lineup = ui::lineup_from_game(lineup_state, season_exe, live_revision);
|
|
live_lineup.in_match = true;
|
|
live_lineup.entry_prepared = true;
|
|
// The live menu owns the same native display word and both pages
|
|
// as the desk. A separate team-sheet parent can hide a saved
|
|
// pitch page and strand its navigation request after return.
|
|
ui::PitchScreen screen(data, std::move(live_lineup),
|
|
ui::pitch_extras_from_game(state, season_exe, live_revision, selected_opponent));
|
|
// Window title depends on which page (bit 8 of the display word) is showing.
|
|
const auto live_title = [&] {
|
|
return (screen.extras().native_display_word & 8)
|
|
? "OpenBMH - live_pitch" : "OpenBMH - live_lineup";
|
|
};
|
|
SDL_SetWindowTitle(window, live_title());
|
|
bool closed = false;
|
|
// Executes a request from the pitch screen: player info card or a substitution/order
|
|
// change through the engine, then refreshes or reports the result on the screen.
|
|
const auto apply_live_pitch = [&](const ui::PitchRequest& action) {
|
|
if (action.kind == ui::PitchRequestKind::none) return;
|
|
pitch_pointer.show({}, renderer);
|
|
if (action.kind == ui::PitchRequestKind::open_player_info) {
|
|
try {
|
|
if (action.row < 0 || size_t(action.row) >= screen.state().players.size() ||
|
|
screen.state().players.at(size_t(action.row)).player_id != action.player_id)
|
|
throw FormatError("live player information request is stale");
|
|
auto services = session->live_club_modal_services(live_revision);
|
|
const ClubPlayerDetailSelection selection{selected_team, action.player_id,
|
|
action.row, action.row, -1};
|
|
if (!present_player_detail)
|
|
throw FormatError("live player information presenter stopped");
|
|
const auto return_parent = present_player_detail(services, selection, screen.render());
|
|
if (!return_parent) throw FormatError("live player information presenter stopped");
|
|
if (*return_parent) closed = true;
|
|
} catch (const std::exception& e) {
|
|
std::fprintf(stderr, "live player information: %s\n", e.what());
|
|
}
|
|
screen.resolve_local_navigation();
|
|
} else {
|
|
const auto result = dispatch_pitch(action);
|
|
if (result.status == app::LiveSubstitutionStatus::applied) {
|
|
auto updated = ui::lineup_from_game(state, season_exe, live_revision);
|
|
updated.in_match = true; updated.entry_prepared = true;
|
|
screen.acknowledge(std::move(updated),
|
|
ui::pitch_extras_from_game(state, season_exe, live_revision, selected_opponent));
|
|
} else if (result.status == app::LiveSubstitutionStatus::source_notice) {
|
|
show_live_substitution_notice(result, screen.render(), live_title());
|
|
auto updated = ui::lineup_from_game(state, season_exe, live_revision);
|
|
updated.in_match = true; updated.entry_prepared = true;
|
|
screen = ui::PitchScreen(data, std::move(updated),
|
|
ui::pitch_extras_from_game(state, season_exe, live_revision, selected_opponent));
|
|
} else {
|
|
screen.reject_action(result.error.empty()
|
|
? "Der Spielerwechsel ist nicht freigegeben." : result.error);
|
|
}
|
|
}
|
|
SDL_SetWindowTitle(window, live_title());
|
|
};
|
|
// left_held/right_held pair a release with its press. left_release_consumed is set when the
|
|
// screen already acted on the press, so the release must not act a second time.
|
|
bool left_held = false, left_release_consumed = false, right_held = false;
|
|
// Modal sub-loop: draws the pitch every pass and polls events itself.
|
|
while (running && !closed) {
|
|
pitch_pointer.show(screen.pointer_cursor(palette), renderer);
|
|
const Image image = screen.render();
|
|
canvas.show(image, palette);
|
|
SDL_Event modal;
|
|
bool redrawn = false;
|
|
while (quit_confirmation.poll(&modal)) {
|
|
if (modal.type == SDL_QUIT) { running = false; closed = true; break; }
|
|
if (modal.type == SDL_KEYDOWN && modal.key.keysym.sym == SDLK_ESCAPE) {
|
|
screen.key("ESC"); closed = true; break;
|
|
}
|
|
if (modal.type == SDL_MOUSEBUTTONDOWN && modal.button.button == SDL_BUTTON_LEFT) {
|
|
left_held = true;
|
|
const auto action = screen.pointer_down(modal.button.x, modal.button.y);
|
|
// Release barrier: remember whether this press already triggered its action.
|
|
left_release_consumed = screen.take_source_down_release_barrier();
|
|
// Native page/order controls act on DOWN. ACK before
|
|
// polling another event; their UP cannot toggle twice.
|
|
apply_live_pitch(action);
|
|
redrawn = true;
|
|
} else if (modal.type == SDL_MOUSEBUTTONUP && modal.button.button == SDL_BUTTON_LEFT && left_held) {
|
|
left_held = false;
|
|
if (!left_release_consumed)
|
|
apply_live_pitch(screen.click(modal.button.x, modal.button.y));
|
|
left_release_consumed = false;
|
|
redrawn = true;
|
|
} else if (modal.type == SDL_MOUSEBUTTONDOWN && modal.button.button == SDL_BUTTON_RIGHT) {
|
|
right_held = true;
|
|
(void)screen.pointer_down(modal.button.x, modal.button.y, true);
|
|
(void)screen.take_source_down_release_barrier();
|
|
redrawn = true;
|
|
} else if (modal.type == SDL_MOUSEBUTTONUP && modal.button.button == SDL_BUTTON_RIGHT && right_held) {
|
|
right_held = false;
|
|
// Mouse movement between DOWN and UP must not leave
|
|
// a closed modal or an accepted request suspended.
|
|
if (screen.close_requested()) closed = true;
|
|
redrawn = true;
|
|
} else if (modal.type == SDL_MOUSEMOTION) {
|
|
redrawn |= screen.move(modal.motion.x, modal.motion.y);
|
|
}
|
|
if (closed) break;
|
|
}
|
|
if (!redrawn && !closed) SDL_Delay(8);
|
|
}
|
|
// Leaving: quitting aborts the live intervention, otherwise it is finished normally.
|
|
if (!running) {
|
|
dispatch_scope(app::LiveInterventionBoundary::abort, 2, selected_manager,
|
|
selected_team, scope_error);
|
|
scope_finished = true;
|
|
} else if (!dispatch_scope(app::LiveInterventionBoundary::finish, 2,
|
|
selected_manager, selected_team, scope_error)) {
|
|
std::fprintf(stderr, "live intervention finish: %s\n", scope_error.c_str());
|
|
dispatch_scope(app::LiveInterventionBoundary::abort, 2,
|
|
selected_manager, selected_team, scope_error);
|
|
scope_finished = true;
|
|
} else {
|
|
scope_finished = true;
|
|
completed = true;
|
|
}
|
|
pitch_pointer.show({}, renderer);
|
|
SDL_SetWindowTitle(window, "OpenBMH - live_matchday");
|
|
} catch (const std::exception& e) {
|
|
pitch_pointer.show({}, renderer);
|
|
if (scope_started && !scope_finished)
|
|
dispatch_scope(app::LiveInterventionBoundary::abort, 2,
|
|
selected_manager, selected_team, scope_error);
|
|
std::fprintf(stderr, "live lineup: %s\n", e.what());
|
|
if (event_origin) throw;
|
|
}
|
|
}
|
|
return completed;
|
|
}
|
|
|
|
// Presents the overview shown while the matchday is running (league table, other games,
|
|
// statistics) in its own loop, driven by the engine's overview dispatcher.
|
|
auto App::present_running_overview(std::optional<app::CareerSession::LiveOverviewProjection> projection,
|
|
const GameState& state, uint64_t& live_revision,
|
|
const RunningOverviewDispatcher& dispatch_overview,
|
|
const PhaseResultRequest* phase_result) -> bool {
|
|
const int manager = projection->owner.manager_slot;
|
|
std::unique_ptr<ui::LeagueTableScreen> table_screen;
|
|
// Only one of table/pairings/strengths/cup screen exists at a time, matching projection->kind.
|
|
std::unique_ptr<ui::LeaguePairingsScreen> pairings_screen;
|
|
std::unique_ptr<ui::StrengthsScreen> strengths_screen;
|
|
std::unique_ptr<ui::OtherGamesScreen> cup_screen;
|
|
const auto overview_clock_start = std::chrono::steady_clock::now();
|
|
// Seconds since the overview opened, converted to source units for the pairings screen.
|
|
const auto overview_source_seconds = [&] {
|
|
const auto milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(
|
|
std::chrono::steady_clock::now() - overview_clock_start).count();
|
|
return ui::league_pairings_source_seconds(uint64_t(milliseconds));
|
|
};
|
|
// Creates the screen that matches the current projection kind (throws if its data is missing).
|
|
const auto rebuild_screen = [&] {
|
|
table_screen.reset(); pairings_screen.reset(); strengths_screen.reset(); cup_screen.reset();
|
|
if (projection->kind == app::CareerSession::LiveOverviewKind::league_table &&
|
|
projection->table) {
|
|
auto tables = ui::league_tables_from_game(state, manager);
|
|
const int selected = projection->table->league_id;
|
|
if (selected < 0 || selected >= int(tables.size()))
|
|
throw FormatError("live overview: Source table league is invalid");
|
|
tables[size_t(selected)] = *projection->table;
|
|
table_screen = std::make_unique<ui::LeagueTableScreen>(data,
|
|
std::move(tables), selected,
|
|
ui::LeagueTableScreen::FamilyMode{projection->family_identity, 0});
|
|
} else if (projection->kind == app::CareerSession::LiveOverviewKind::league_pairings &&
|
|
projection->pairings) {
|
|
pairings_screen = std::make_unique<ui::LeaguePairingsScreen>(data,
|
|
*projection->pairings,
|
|
ui::LeaguePairingsScreen::FamilyMode{projection->family_identity});
|
|
} else if (projection->kind == app::CareerSession::LiveOverviewKind::league_strengths &&
|
|
projection->strengths) {
|
|
strengths_screen = std::make_unique<ui::StrengthsScreen>(data, *projection->strengths);
|
|
} else if (projection->kind == app::CareerSession::LiveOverviewKind::cup_other_games &&
|
|
projection->cup) {
|
|
cup_screen = std::make_unique<ui::OtherGamesScreen>(data, *projection->cup);
|
|
} else {
|
|
throw FormatError("live overview: Source presenter projection is missing");
|
|
}
|
|
};
|
|
// Window title of the overview; inside a phase result it also carries the phase end minute
|
|
// and group index.
|
|
const auto overview_title = [&]() -> std::string {
|
|
if (phase_result) {
|
|
const std::string prefix = "OpenBMH - phase_";
|
|
const std::string suffix = "_" + std::to_string(phase_result->phase_end_minute) +
|
|
"_" + std::to_string(phase_result->group_index);
|
|
switch (projection->kind) {
|
|
case app::CareerSession::LiveOverviewKind::league_table: return prefix+"table"+suffix;
|
|
case app::CareerSession::LiveOverviewKind::league_pairings: return prefix+"pairings"+suffix;
|
|
case app::CareerSession::LiveOverviewKind::league_strengths: return prefix+"strengths"+suffix;
|
|
case app::CareerSession::LiveOverviewKind::cup_other_games: return prefix+"cup"+suffix;
|
|
}
|
|
}
|
|
switch (projection->kind) {
|
|
case app::CareerSession::LiveOverviewKind::league_table:
|
|
return "OpenBMH - live_league_table";
|
|
case app::CareerSession::LiveOverviewKind::league_pairings:
|
|
return "OpenBMH - live_pairings";
|
|
case app::CareerSession::LiveOverviewKind::league_strengths:
|
|
return "OpenBMH - live_strengths";
|
|
case app::CareerSession::LiveOverviewKind::cup_other_games:
|
|
return "OpenBMH - live_other_games";
|
|
}
|
|
return "OpenBMH - live_overview";
|
|
};
|
|
// Draws the active overview screen and presents it.
|
|
const auto render_overview = [&] {
|
|
const Image image = table_screen ? table_screen->render()
|
|
: pairings_screen ? pairings_screen->render()
|
|
: strengths_screen ? strengths_screen->render() : cup_screen->render();
|
|
SDL_SetWindowTitle(window, overview_title().c_str());
|
|
canvas.show(image, palette);
|
|
if (pairings_screen)
|
|
pairings_screen->mark_presented_source_seconds(overview_source_seconds());
|
|
};
|
|
rebuild_screen();
|
|
render_overview();
|
|
bool closed = false;
|
|
// The mouse press currently held; once the overview is closed its release is still
|
|
// swallowed here so it does not reach whatever is shown next.
|
|
std::optional<SDL_MouseButtonEvent> down;
|
|
// Modal table range dialog (same key queueing as the poach table version): returns its
|
|
// accept/cancel outcome.
|
|
const auto run_table_range = [&](const Image& backdrop,
|
|
ui::TableRangeDialogProfile profile) -> ui::TableRangeDialogOutcome {
|
|
ui::LeagueTableRangeDialog dialog(data, backdrop, std::move(profile));
|
|
std::deque<std::string> keys;
|
|
Uint32 clock_anchor = SDL_GetTicks();
|
|
std::optional<ui::TableRangeDialogOutcome> outcome;
|
|
// Presents the range dialog and lets it report an outcome and restart its tick clock.
|
|
const auto show_dialog = [&] {
|
|
const Image image = dialog.render();
|
|
SDL_SetWindowTitle(window, "OpenBMH - live_table_range");
|
|
canvas.show(image, palette);
|
|
outcome = dialog.after_present();
|
|
clock_anchor = SDL_GetTicks();
|
|
};
|
|
show_dialog();
|
|
while (running && !outcome) {
|
|
SDL_Event input;
|
|
while (quit_confirmation.poll(&input)) {
|
|
if (input.type == SDL_QUIT) { running = false; break; }
|
|
bool changed = false;
|
|
if (input.type == SDL_TEXTINPUT) {
|
|
for (char c : std::string_view(input.text.text))
|
|
if (c >= '0' && c <= '9') keys.emplace_back(1, c);
|
|
} else if (input.type == SDL_KEYDOWN) {
|
|
if (input.key.keysym.sym == SDLK_RETURN) keys.emplace_back("ENTER");
|
|
else if (input.key.keysym.sym == SDLK_BACKSPACE) keys.emplace_back("BACKSPACE");
|
|
else if (input.key.keysym.sym == SDLK_SPACE) keys.emplace_back("SPACE");
|
|
} else if (input.type == SDL_MOUSEMOTION)
|
|
changed = dialog.move(input.motion.x, input.motion.y);
|
|
else if (input.type == SDL_MOUSEBUTTONDOWN &&
|
|
(input.button.button == SDL_BUTTON_LEFT ||
|
|
input.button.button == SDL_BUTTON_RIGHT))
|
|
changed = dialog.pointer_down(input.button.x, input.button.y,
|
|
input.button.button == SDL_BUTTON_RIGHT);
|
|
else if (input.type == SDL_MOUSEBUTTONUP &&
|
|
(input.button.button == SDL_BUTTON_LEFT ||
|
|
input.button.button == SDL_BUTTON_RIGHT))
|
|
changed = dialog.pointer_up(input.button.x, input.button.y,
|
|
input.button.button == SDL_BUTTON_RIGHT);
|
|
if (changed && input.type != SDL_MOUSEBUTTONUP) show_dialog();
|
|
if (outcome) break;
|
|
}
|
|
if (!running || outcome) break;
|
|
while (!keys.empty() && dialog.source_input_ready()) {
|
|
const std::string key = std::move(keys.front());
|
|
keys.pop_front();
|
|
if (dialog.key(key)) show_dialog();
|
|
if (outcome) break;
|
|
}
|
|
const Uint32 now = SDL_GetTicks();
|
|
const Uint32 units = Uint32(now - clock_anchor) / 20;
|
|
if (units) {
|
|
clock_anchor += units * 20;
|
|
if (dialog.tick_source_units(units)) show_dialog();
|
|
}
|
|
SDL_Delay(10);
|
|
}
|
|
if (!outcome) throw FormatError("live table range presenter stopped");
|
|
return *outcome;
|
|
};
|
|
// Sends an action of the overview to the engine and applies the answer: close, switch to
|
|
// another overview kind, or run the range dialog and send its result back (recursive).
|
|
std::function<void(const app::CareerSession::LiveOverviewAction&)> dispatch_action;
|
|
dispatch_action = [&](const app::CareerSession::LiveOverviewAction& action) {
|
|
const Image previous_table = table_screen ? table_screen->render() : Image{};
|
|
std::string dispatch_error;
|
|
auto result = dispatch_overview(action, dispatch_error, [&](app::ClubModalServices& services, int selected_team,
|
|
const Image&) {
|
|
return present_club_information(services, selected_team) && running;
|
|
});
|
|
if (!result) {
|
|
if (!dispatch_error.empty())
|
|
std::fprintf(stderr, "live overview: %s\n", dispatch_error.c_str());
|
|
rebuild_screen();
|
|
render_overview();
|
|
return;
|
|
}
|
|
if (result->closed) { closed = true; return; }
|
|
projection->kind = result->kind;
|
|
if (result->family_identity.manager >= 0)
|
|
projection->family_identity = result->family_identity;
|
|
projection->table = std::move(result->table);
|
|
projection->pairings = std::move(result->pairings);
|
|
projection->strengths = std::move(result->strengths);
|
|
projection->cup = std::move(result->cup);
|
|
rebuild_screen();
|
|
const bool table_dialog_pending =
|
|
projection->kind == app::CareerSession::LiveOverviewKind::league_table &&
|
|
result->table_dialog && result->table_phase != app::CareerSession::TableDispatchPhase::ready;
|
|
if (!table_dialog_pending) render_overview();
|
|
if (table_dialog_pending) {
|
|
auto profile = *result->table_dialog;
|
|
auto range = run_table_range(previous_table, std::move(profile));
|
|
ui::LeagueFamilyRequest reply;
|
|
reply.identity = projection->family_identity;
|
|
reply.kind = ui::LeagueFamilyRequestKind::table_range_result;
|
|
reply.from_child = 1;
|
|
reply.control_index = 9;
|
|
reply.table_dialog_reply = ui::TableDialogReply{
|
|
result->table_phase == app::CareerSession::TableDispatchPhase::range_start
|
|
? ui::TableDialogStage::start : ui::TableDialogStage::end,
|
|
range.result == ui::TableRangeDialogResult::accept
|
|
? ui::TableDialogOutcome::accept : ui::TableDialogOutcome::cancel,
|
|
range.result == ui::TableRangeDialogResult::accept ? int(range.value) : 0,
|
|
range.x, range.y};
|
|
dispatch_action(app::CareerSession::LiveOverviewAction{reply});
|
|
} else if (projection->kind == app::CareerSession::LiveOverviewKind::league_table &&
|
|
result->table_phase == app::CareerSession::TableDispatchPhase::forecast_pending_present) {
|
|
ui::LeagueFamilyRequest ack;
|
|
ack.identity = projection->family_identity;
|
|
ack.kind = ui::LeagueFamilyRequestKind::table_forecast_presented;
|
|
ack.from_child = 1;
|
|
dispatch_action(app::CareerSession::LiveOverviewAction{ack});
|
|
}
|
|
};
|
|
// Drop stale key releases left over from the match.
|
|
SDL_FlushEvent(SDL_KEYUP);
|
|
// Modal sub-loop. After closing it keeps polling until the held button's release has
|
|
// arrived, so that release is not seen by the caller.
|
|
while (running && (!closed || down)) {
|
|
SDL_Event input;
|
|
bool redrawn = false;
|
|
while (quit_confirmation.poll(&input)) {
|
|
if (input.type == SDL_QUIT) { running = false; break; }
|
|
if (closed) {
|
|
if (input.type == SDL_MOUSEBUTTONUP && down &&
|
|
input.button.button == down->button) { down.reset(); break; }
|
|
continue;
|
|
}
|
|
if (input.type == SDL_MOUSEMOTION) {
|
|
const bool changed = table_screen ? table_screen->move(input.motion.x, input.motion.y)
|
|
: pairings_screen ? pairings_screen->move(input.motion.x, input.motion.y)
|
|
: strengths_screen ? strengths_screen->move(input.motion.x, input.motion.y)
|
|
: cup_screen->move(input.motion.x, input.motion.y);
|
|
if (changed) { render_overview(); redrawn = true; }
|
|
} else if (input.type == SDL_MOUSEBUTTONDOWN &&
|
|
(input.button.button == SDL_BUTTON_LEFT || input.button.button == SDL_BUTTON_RIGHT)) {
|
|
down = input.button;
|
|
if (table_screen) table_screen->pointer_down(input.button.x, input.button.y,
|
|
input.button.button == SDL_BUTTON_RIGHT);
|
|
else if (pairings_screen) pairings_screen->pointer_down(input.button.x,
|
|
input.button.y, input.button.button == SDL_BUTTON_RIGHT);
|
|
else if (strengths_screen) strengths_screen->pointer_down(input.button.x,
|
|
input.button.y, input.button.button == SDL_BUTTON_RIGHT);
|
|
else cup_screen->pointer_down(input.button.x, input.button.y,
|
|
input.button.button == SDL_BUTTON_RIGHT);
|
|
} else if (input.type == SDL_MOUSEBUTTONUP && down &&
|
|
input.button.button == down->button) {
|
|
down.reset();
|
|
if (table_screen) table_screen->click(input.button.x, input.button.y,
|
|
input.button.button == SDL_BUTTON_RIGHT);
|
|
else if (pairings_screen) pairings_screen->release(input.button.x, input.button.y);
|
|
else if (strengths_screen) strengths_screen->release(input.button.x, input.button.y);
|
|
else cup_screen->release(input.button.x, input.button.y);
|
|
}
|
|
|
|
// Whichever screen exists reports a pending request through its own accessor.
|
|
std::optional<app::CareerSession::LiveOverviewAction> action;
|
|
if (table_screen && table_screen->pending_family_action())
|
|
action = *table_screen->pending_family_action();
|
|
else if (pairings_screen && pairings_screen->pending_family_action())
|
|
action = *pairings_screen->pending_family_action();
|
|
else if (pairings_screen && pairings_screen->pending())
|
|
action = *pairings_screen->pending();
|
|
else if (strengths_screen && strengths_screen->pending())
|
|
action = *strengths_screen->pending();
|
|
else if (cup_screen && cup_screen->pending())
|
|
action = *cup_screen->pending();
|
|
if (action) { dispatch_action(*action); redrawn = true; }
|
|
if ((closed && !down) || !running) break;
|
|
}
|
|
if (!running || (closed && !down)) break;
|
|
if (closed) { SDL_Delay(8); continue; }
|
|
// The pairings screen has a timer in source seconds that may raise a request by itself.
|
|
if (pairings_screen && pairings_screen->tick_source_seconds(overview_source_seconds())) {
|
|
if (pairings_screen->pending())
|
|
dispatch_action(app::CareerSession::LiveOverviewAction{*pairings_screen->pending()});
|
|
redrawn = true;
|
|
}
|
|
if ((closed && !down) || !running) break;
|
|
if (!redrawn) SDL_Delay(8);
|
|
}
|
|
return running && closed;
|
|
}
|
|
|
|
// Callback per simulated match minute: shows the live matchday frame (unless skipped)
|
|
// and waits frame_delay ms, taken from --live-frame-ms or from the game's own speed setting.
|
|
auto App::present_live_minute(int minute, const std::vector<MatchGroup>& groups, const GameState& state) -> void {
|
|
if (!running) return;
|
|
bool live_frame_shown = false;
|
|
if (!live_skipped) {
|
|
const auto frame = ui::live_matchday_frame(minute, groups, state);
|
|
if (!frame.matches.empty()) {
|
|
SDL_SetWindowTitle(window, "OpenBMH - live_matchday");
|
|
const Image live_image = live_screen.render(frame);
|
|
canvas.show(live_image, palette);
|
|
live_frame_shown = true;
|
|
}
|
|
}
|
|
const int frame_delay = live_frame_ms_explicit ? live_frame_ms :
|
|
int(ui::live_delay_milliseconds(state.memory.u8(::bmh::layout::Main_FormatError_ExecutableField)));
|
|
if (live_frame_shown && !live_skipped && frame_delay > 0)
|
|
SDL_Delay(Uint32(frame_delay));
|
|
}
|
|
|
|
// =====================================================================================
|
|
// Live match observer
|
|
// =====================================================================================
|
|
// Called by the engine once per simulated minute of a live match. Besides pausing, it is
|
|
// where the player interacts: ESC or window close skips the live display, P pauses, the
|
|
// keys for overview/table/settings open their modal screens (key letters come from the
|
|
// game executable), clicks on the top strip open an overview or the settings, and clicks
|
|
// on the scoreboard rows open the lineup (left) or tactics (right) of that team.
|
|
auto App::observe_live_minute(int minute, MatchEngine& engine, std::vector<MatchGroup>& groups,
|
|
GameState& state, uint64_t& live_revision,
|
|
const app::LiveLineupDispatcher& dispatch,
|
|
const app::LiveTacticsDispatcher& dispatch_tactic,
|
|
const app::LivePitchDispatcher& dispatch_pitch,
|
|
const app::LiveInterventionScopeDispatcher& dispatch_scope) -> void {
|
|
if (!running) return;
|
|
bool quit = false;
|
|
// Shows the engine's notice about a refused substitution as a dialog.
|
|
const auto show_live_substitution_notice = [&](const app::LiveSubstitutionResult& result,
|
|
const Image& backdrop, const char* parent_title) {
|
|
if (result.status != app::LiveSubstitutionStatus::source_notice) return;
|
|
if (result.manager_slot < 0 || result.source_text_address == 0)
|
|
throw FormatError("live substitution notice has no Source owner or text");
|
|
const PendingOfferNotice notice{result.manager_slot, -1,
|
|
result.source_text_address,
|
|
message_text(state, result.source_text_address)};
|
|
const auto projection = ui::pending_offer_notice_dialog(state, notice);
|
|
if (present_pending_dialog(state, projection, backdrop,
|
|
"OpenBMH - live_substitution_notice") == PendingOfferAnswer::unsupported)
|
|
throw FormatError("live substitution notice presenter stopped");
|
|
// SDLFlushEvents3 is a timed Source notice. Do not let its release
|
|
// event become another click in the resumed parent screen.
|
|
SDL_FlushEvents(SDL_MOUSEMOTION, SDL_MOUSEBUTTONUP);
|
|
SDL_SetWindowTitle(window, parent_title);
|
|
};
|
|
// Opens the tactics screen for the team on the clicked scoreboard row (side 0 = home,
|
|
// row positions come from the game executable, 32 pixels tall, at most 4 rows). Only for
|
|
// human-managed teams, after minute 2 and when the display is not skipped. The
|
|
// intervention scope is begun first and finished or aborted afterwards.
|
|
const auto open_live_tactics = [&](int side, int y) {
|
|
const auto frame = ui::live_matchday_frame(minute, groups, state);
|
|
int selected_team = -1;
|
|
for (size_t row = 0; row < frame.matches.size() && row < 4; ++row) {
|
|
const int row_y = season_exe.u8(::bmh::layout::LiveMatchday_Render_ExecutableFieldUnsigned + uint32_t(row));
|
|
if (y < row_y || y > row_y + 32) continue;
|
|
selected_team = side == 0 ? frame.matches[row].home_team : frame.matches[row].away_team;
|
|
break;
|
|
}
|
|
const int selected_manager = selected_team >= 0 ? state.manager_of(selected_team) : -1;
|
|
if (live_skipped || minute <= 2 || selected_team < 0 || selected_manager < 0) return;
|
|
std::string scope_error;
|
|
if (!dispatch_scope(app::LiveInterventionBoundary::begin, 8,
|
|
selected_manager, selected_team, scope_error)) {
|
|
std::fprintf(stderr, "live tactics: %s\n", scope_error.c_str());
|
|
return;
|
|
}
|
|
bool scope_active = true;
|
|
try {
|
|
auto tactics_game = state;
|
|
if (tactics_game.memory.has(::bmh::layout::ActiveManager))
|
|
tactics_game.memory.set8(::bmh::layout::ActiveManager, uint8_t(selected_manager));
|
|
ui::TacticsScreen screen(data,
|
|
ui::tactics_from_game(tactics_game, season_exe, live_revision));
|
|
SDL_SetWindowTitle(window, "OpenBMH - live_tactics");
|
|
bool closed = false;
|
|
// A click counts only when the release matches the press (same button and position).
|
|
std::optional<SDL_MouseButtonEvent> tactics_down;
|
|
bool source_completed = false;
|
|
while (running && !closed) {
|
|
const Image image = screen.render();
|
|
canvas.show(image, palette);
|
|
SDL_Event modal;
|
|
bool redrawn = false;
|
|
while (quit_confirmation.poll(&modal)) {
|
|
if (modal.type == SDL_QUIT) { running = false; closed = true; break; }
|
|
if (modal.type == SDL_MOUSEBUTTONDOWN &&
|
|
(modal.button.button == SDL_BUTTON_LEFT || modal.button.button == SDL_BUTTON_RIGHT))
|
|
tactics_down = modal.button;
|
|
else if (modal.type == SDL_MOUSEBUTTONUP && tactics_down &&
|
|
modal.button.button == tactics_down->button &&
|
|
modal.button.x == tactics_down->x && modal.button.y == tactics_down->y) {
|
|
tactics_down.reset();
|
|
const auto request = screen.click(modal.button.x, modal.button.y,
|
|
modal.button.button == SDL_BUTTON_RIGHT);
|
|
if (screen.close_requested()) { source_completed = true; closed = true; break; }
|
|
if (request.kind == ui::TacticsRequestKind::set_tactic) {
|
|
std::string error;
|
|
if (dispatch_tactic(request, error)) {
|
|
tactics_game = state;
|
|
if (tactics_game.memory.has(::bmh::layout::ActiveManager))
|
|
tactics_game.memory.set8(::bmh::layout::ActiveManager, uint8_t(selected_manager));
|
|
screen.acknowledge(ui::tactics_from_game(
|
|
tactics_game, season_exe, live_revision));
|
|
} else screen.reject_action(error);
|
|
redrawn = true;
|
|
}
|
|
}
|
|
}
|
|
if (!redrawn && !closed) SDL_Delay(8);
|
|
}
|
|
// Closing through the screen's own close control finishes the intervention; leaving any
|
|
// other way (or quitting) aborts it.
|
|
if (scope_active && source_completed) {
|
|
if (!dispatch_scope(app::LiveInterventionBoundary::finish, 8,
|
|
selected_manager, selected_team, scope_error)) {
|
|
std::fprintf(stderr, "live tactics: %s\n", scope_error.c_str());
|
|
dispatch_scope(app::LiveInterventionBoundary::abort, 8,
|
|
selected_manager, selected_team, scope_error);
|
|
}
|
|
scope_active = false;
|
|
} else if (scope_active) {
|
|
dispatch_scope(app::LiveInterventionBoundary::abort, 8,
|
|
selected_manager, selected_team, scope_error);
|
|
scope_active = false;
|
|
}
|
|
SDL_SetWindowTitle(window, "OpenBMH - live_matchday");
|
|
} catch (const std::exception& e) {
|
|
if (scope_active)
|
|
dispatch_scope(app::LiveInterventionBoundary::abort, 8,
|
|
selected_manager, selected_team, scope_error);
|
|
std::fprintf(stderr, "live tactics: %s\n", e.what());
|
|
}
|
|
};
|
|
// The pause key is stored in the executable; pausing is only offered when it is P.
|
|
const uint8_t source_pause_key = season_exe.u8(::bmh::layout::Main_Screen_RuntimeField);
|
|
const bool source_pause_is_p = source_pause_key == 'p' || source_pause_key == 'P';
|
|
// Shows the current live frame as paused and waits until P is pressed again (key repeats
|
|
// ignored) or the program quits.
|
|
const auto pause_live_match = [&] {
|
|
if (!source_pause_is_p) return;
|
|
const auto frame = ui::live_matchday_frame(minute, groups, state);
|
|
const Image image = live_screen.render(frame);
|
|
for (size_t i = 0; i < pixels.size(); ++i)
|
|
pixels[i] = palette.argb[image.pixels[i]];
|
|
SDL_UpdateTexture(texture, nullptr, pixels.data(), 320 * 4);
|
|
SDL_RenderClear(renderer);
|
|
SDL_RenderCopy(renderer, texture, nullptr, nullptr);
|
|
SDL_SetWindowTitle(window, "OpenBMH - live_paused");
|
|
app::present(renderer);
|
|
|
|
bool resumed = false;
|
|
while (running && !resumed) {
|
|
SDL_Event paused_event;
|
|
while (quit_confirmation.poll(&paused_event)) {
|
|
if (paused_event.type == SDL_QUIT) {
|
|
quit = true;
|
|
live_skipped = true;
|
|
running = false;
|
|
break;
|
|
}
|
|
if (paused_event.type == SDL_KEYDOWN && !paused_event.key.repeat &&
|
|
paused_event.key.keysym.sym == SDLK_p)
|
|
resumed = true;
|
|
}
|
|
if (!resumed && running) SDL_Delay(8);
|
|
}
|
|
if (running) SDL_SetWindowTitle(window, "OpenBMH - live_matchday");
|
|
};
|
|
// Redraws the live matchday frame after a modal screen has closed.
|
|
const auto restore_live_frame = [&] {
|
|
if (!running) return;
|
|
const Image image = live_screen.render(ui::live_matchday_frame(minute, groups, state));
|
|
SDL_SetWindowTitle(window, "OpenBMH - live_matchday");
|
|
canvas.show(image, palette);
|
|
};
|
|
// Opens the overview selected by key_slot through the session and runs it via
|
|
// present_running_overview. The sequence counter numbers the overviews opened in this
|
|
// match; the overview is taken from the first live group.
|
|
const auto show_live_overview = [&](int key_slot) {
|
|
if (!running || live_skipped || live_overview_sequence == UINT64_MAX) return;
|
|
const int manager = state.memory.has(::bmh::layout::ActiveManager) ? state.memory.u8(::bmh::layout::ActiveManager) : -1;
|
|
// EndPhase reads the keyboard overview descriptor from the
|
|
// first live group (CareerSessionRuntimeField5 = MatchdayGroupDescriptors + 0xcc). DeskPosition is
|
|
// the later per-group processing cursor and is not this owner.
|
|
const int group_index = groups.empty() ? -1 : 0;
|
|
if (manager < 0 || size_t(manager) >= state.manager_teams.size() ||
|
|
group_index < 0 || size_t(group_index) >= groups.size()) return;
|
|
const int team = state.manager_teams[size_t(manager)];
|
|
const auto frame = ui::live_matchday_frame(minute, groups, state);
|
|
const Image underlay = live_screen.render(frame);
|
|
app::CareerSession::LiveOverviewRequest request;
|
|
request.key_slot = key_slot;
|
|
request.minute = minute;
|
|
request.group_index = group_index;
|
|
request.manager_slot = manager;
|
|
request.runtime_team = team;
|
|
request.revision = live_revision;
|
|
request.sequence = live_overview_sequence + 1;
|
|
std::string error;
|
|
auto projection = session->open_live_overview(request, engine, live_revision,
|
|
underlay, error);
|
|
if (!projection) {
|
|
if (!error.empty()) std::fprintf(stderr, "live overview: %s\n", error.c_str());
|
|
return;
|
|
}
|
|
++live_overview_sequence;
|
|
|
|
const bool closed = present_running_overview(std::move(projection), state, live_revision,
|
|
[&](const app::CareerSession::LiveOverviewAction& action, std::string& dispatch_error,
|
|
const app::TransferOfferTeamInfoPresenter& team_info) {
|
|
return session->dispatch_live_overview(action, engine, live_revision, dispatch_error, team_info);
|
|
}, nullptr);
|
|
if (running && closed) restore_live_frame();
|
|
};
|
|
// Modal settings screen inside a live match. `trigger` is the mouse press that opened it,
|
|
// so that its release can be matched. Every change is dispatched to the session.
|
|
const auto show_live_settings = [&](std::optional<SDL_MouseButtonEvent> trigger = std::nullopt) {
|
|
if (!running || live_skipped || !state.memory.has(::bmh::layout::ActiveManager)) return;
|
|
const int manager = state.memory.u8(::bmh::layout::ActiveManager);
|
|
if (manager < 0 || size_t(manager) >= state.manager_teams.size()) return;
|
|
app::CareerSession::LiveSettingsRequest request;
|
|
request.minute = minute;
|
|
request.manager_slot = manager;
|
|
request.runtime_team = state.manager_teams[size_t(manager)];
|
|
request.revision = live_revision;
|
|
request.sequence = 0; // Session assigns and returns the scoped owner nonce.
|
|
std::string error;
|
|
auto projection = session->open_live_settings(request, engine, live_revision, error);
|
|
if (!projection) {
|
|
if (!error.empty()) std::fprintf(stderr, "live settings: %s\n", error.c_str());
|
|
return;
|
|
}
|
|
app::original_audio_command(playback, 1); // SavePathInDirectory before the live settings modal.
|
|
ui::SettingsScreen screen(data, projection->state);
|
|
std::unique_ptr<ui::SettingsReadmeScreen> readme;
|
|
// Draws the settings screen, or its readme viewer when that is open.
|
|
const auto render_settings = [&] {
|
|
const Image image = readme ? readme->render() : screen.render();
|
|
SDL_SetWindowTitle(window, readme ? "OpenBMH - settings_readme" : "OpenBMH - live_settings");
|
|
canvas.show(image, palette);
|
|
};
|
|
render_settings();
|
|
// Modal save/load screen for settings files opened from the settings screen; the result is
|
|
// dispatched to the session and the settings screen is shown again afterwards.
|
|
const auto show_settings_file = [&] {
|
|
const auto* pending = screen.pending_file();
|
|
if (!pending) return;
|
|
const auto menu_request = *pending;
|
|
ui::SaveLoadScreen file_screen(data, save_directory,
|
|
menu_request.action == ui::SaveLoadAction::load ?
|
|
ui::SaveLoadMode::load : ui::SaveLoadMode::save,
|
|
menu_request.manager_slot, live_revision, screen.render(),
|
|
!state.memory.has(::bmh::layout::PlainBackground) || state.memory.u8(::bmh::layout::PlainBackground) == 0,
|
|
ui::SaveLoadFileKind::settings, menu_request.origin_item_id);
|
|
// Draws the settings file screen.
|
|
const auto render_file = [&] {
|
|
const Image image = file_screen.render();
|
|
SDL_SetWindowTitle(window, "OpenBMH - live_settings_file");
|
|
canvas.show(image, palette);
|
|
};
|
|
render_file();
|
|
// Give the filename field the native text input focus.
|
|
focus_filename_input(renderer);
|
|
bool finished = false;
|
|
while (running && !finished) {
|
|
SDL_Event file_input;
|
|
bool file_changed = false;
|
|
while (quit_confirmation.poll(&file_input)) {
|
|
if (file_input.type == SDL_QUIT) { running = false; break; }
|
|
if (file_input.type == SDL_MOUSEBUTTONUP &&
|
|
(file_input.button.button == SDL_BUTTON_LEFT ||
|
|
file_input.button.button == SDL_BUTTON_RIGHT)) {
|
|
// clicks >= 2 reports a double click.
|
|
file_changed |= file_screen.click(file_input.button.x,
|
|
file_input.button.y,
|
|
file_input.button.button == SDL_BUTTON_RIGHT,
|
|
file_input.button.clicks >= 2);
|
|
// Only keys the file screen understands are forwarded; Ctrl/Cmd+A means select all.
|
|
} else if (file_input.type == SDL_KEYDOWN && !file_input.key.repeat) {
|
|
std::string_view key;
|
|
switch (file_input.key.keysym.sym) {
|
|
case SDLK_ESCAPE: key = "ESC"; break;
|
|
case SDLK_RETURN: key = "ENTER"; break;
|
|
case SDLK_BACKSPACE: key = "BACKSPACE"; break;
|
|
case SDLK_UP: key = "UP"; break;
|
|
case SDLK_DOWN: key = "DOWN"; break;
|
|
case SDLK_LEFT: key = "LEFT"; break;
|
|
case SDLK_RIGHT: key = "RIGHT"; break;
|
|
case SDLK_a:
|
|
if (file_input.key.keysym.mod & (KMOD_CTRL | KMOD_GUI)) key = "SELECT_ALL";
|
|
break;
|
|
default: break;
|
|
}
|
|
if (!key.empty()) file_changed |= file_screen.key(key);
|
|
} else if (file_input.type == SDL_TEXTINPUT) {
|
|
file_changed |= file_screen.text(file_input.text.text);
|
|
}
|
|
if (const auto& file_request = file_screen.pending()) {
|
|
const app::CareerSession::LiveSettingsAction action{
|
|
app::CareerSession::LiveSettingsFile{
|
|
projection->owner.sequence, *file_request}};
|
|
auto result = session->dispatch_live_settings(action,
|
|
engine, live_revision, error);
|
|
if (!result) {
|
|
file_screen.reject(error.empty() ?
|
|
"Dateiaktion fehlgeschlagen." : error);
|
|
file_changed = true;
|
|
} else {
|
|
projection->owner = result->owner;
|
|
screen.acknowledge_file(std::move(result->state));
|
|
file_screen.acknowledge();
|
|
finished = true;
|
|
}
|
|
} else if (file_screen.close_requested()) {
|
|
screen.cancel_file_request();
|
|
finished = true;
|
|
}
|
|
if (!running || finished) break;
|
|
if (file_changed) render_file();
|
|
}
|
|
if (!file_changed && running && !finished) SDL_Delay(8);
|
|
}
|
|
if (running) render_settings();
|
|
};
|
|
// settings_down tracks the held press so its release is matched. readme_release_barrier is
|
|
// set when the readme was closed by a press: that press's release must not act on the
|
|
// settings screen.
|
|
bool closed = false;
|
|
bool readme_release_barrier = false;
|
|
std::optional<SDL_MouseButtonEvent> settings_down = trigger;
|
|
while (running && !closed) {
|
|
SDL_Event input;
|
|
bool changed = false;
|
|
while (quit_confirmation.poll(&input)) {
|
|
if (input.type == SDL_QUIT) { running = false; break; }
|
|
if (readme) {
|
|
if (input.type == SDL_MOUSEBUTTONDOWN &&
|
|
(input.button.button == SDL_BUTTON_LEFT ||
|
|
input.button.button == SDL_BUTTON_RIGHT)) {
|
|
settings_down = input.button;
|
|
readme->pointer_down(true);
|
|
if (readme->close_requested()) {
|
|
readme.reset();
|
|
readme_release_barrier = true;
|
|
}
|
|
render_settings();
|
|
}
|
|
// SDLFlushEvents2 waits for a mouse press; keys and
|
|
// motion do not close the Source readme viewer.
|
|
continue;
|
|
}
|
|
if (input.type == SDL_KEYDOWN && !input.key.repeat &&
|
|
input.key.keysym.sym == SDLK_ESCAPE) {
|
|
screen.key("ESC");
|
|
changed = true;
|
|
} else if (input.type == SDL_MOUSEBUTTONDOWN &&
|
|
(input.button.button == SDL_BUTTON_LEFT ||
|
|
input.button.button == SDL_BUTTON_RIGHT)) {
|
|
settings_down = input.button;
|
|
// The footer buttons (x 1..54, y 188..223) act on the matching release; other controls
|
|
// act on the press itself.
|
|
const bool footer_button = input.button.button == SDL_BUTTON_LEFT &&
|
|
input.button.x >= 1 && input.button.x < 55 &&
|
|
input.button.y >= 188 && input.button.y < 224;
|
|
if (!footer_button)
|
|
changed = screen.click(input.button.x, input.button.y,
|
|
input.button.button == SDL_BUTTON_RIGHT);
|
|
} else if (input.type == SDL_MOUSEBUTTONUP && settings_down &&
|
|
input.button.button == settings_down->button &&
|
|
input.button.x == settings_down->x && input.button.y == settings_down->y) {
|
|
if (readme_release_barrier) {
|
|
readme_release_barrier = false;
|
|
} else if (input.button.button == SDL_BUTTON_LEFT &&
|
|
input.button.x >= 1 && input.button.x < 55 &&
|
|
input.button.y >= 188 && input.button.y < 224)
|
|
changed = screen.click(input.button.x, input.button.y);
|
|
settings_down.reset(); // Cells act on DOWN; file buttons on matching UP.
|
|
}
|
|
|
|
if (!running) break;
|
|
if (screen.readme_requested()) {
|
|
screen.consume_readme_request();
|
|
readme = std::make_unique<ui::SettingsReadmeScreen>(
|
|
data, screen.state().decorated_background);
|
|
changed = true;
|
|
}
|
|
if (screen.pending_file()) {
|
|
show_settings_file();
|
|
changed = false; // The child restores its parent on return.
|
|
}
|
|
if (const auto* write = screen.pending()) {
|
|
const auto request_write = *write;
|
|
const app::CareerSession::LiveSettingsAction action{
|
|
app::CareerSession::LiveSettingsWrite{projection->owner.sequence,
|
|
request_write}};
|
|
auto result = session->dispatch_live_settings(action, engine, live_revision, error);
|
|
if (!result) {
|
|
const auto notice = ui::settings_source_refusal(state, request_write, live_revision);
|
|
if (notice && error == ui::original_to_utf8(message_text(state, *notice))) {
|
|
auto view = ui::environment_notice_dialog(state, request_write.manager_slot,
|
|
message_text(state, *notice));
|
|
(void)present_pending_dialog(state, std::move(view), screen.render(),
|
|
"OpenBMH - live_settings_notice");
|
|
screen.reject({});
|
|
screen.consume_release();
|
|
settings_down.reset();
|
|
SDL_FlushEvents(SDL_MOUSEMOTION, SDL_MOUSEBUTTONUP);
|
|
SDL_SetWindowTitle(window, "OpenBMH - live_settings");
|
|
} else {
|
|
screen.reject(error.empty() ? "Diese Einstellung wurde nicht übernommen." : error);
|
|
std::fprintf(stderr, "live settings: %s\n", error.c_str());
|
|
}
|
|
} else {
|
|
projection->owner = result->owner;
|
|
screen.acknowledge(std::move(result->state));
|
|
playback.set_original_options(
|
|
app::original_audio_options(session->state(), music_enabled));
|
|
}
|
|
changed = true;
|
|
}
|
|
if (screen.close_requested()) {
|
|
const app::CareerSession::LiveSettingsAction action{
|
|
app::CareerSession::LiveSettingsCloseRequest{projection->owner}};
|
|
auto result = session->dispatch_live_settings(action, engine, live_revision, error);
|
|
if (!result || !result->closed) {
|
|
std::fprintf(stderr, "live settings close: %s\n",
|
|
error.empty() ? "Source close rejected" : error.c_str());
|
|
running = false;
|
|
} else {
|
|
projection->owner = result->owner;
|
|
closed = true;
|
|
}
|
|
} else if (changed) {
|
|
render_settings();
|
|
}
|
|
if (closed || !running) break;
|
|
}
|
|
if (!running || closed) break;
|
|
if (!changed) SDL_Delay(8);
|
|
}
|
|
// A Source close may be requested on the opening/closing DOWN;
|
|
// consume its physical release before the live observer resumes.
|
|
if (closed) SDL_FlushEvent(SDL_MOUSEBUTTONUP);
|
|
if (running && closed) app::original_match_audio_command(playback, state, 3);
|
|
if (running && closed) restore_live_frame();
|
|
};
|
|
// True at the first minute of a phase (1, then 21 indoors or 46/91/106 outdoors); the
|
|
// pause and overview keys and strip clicks are ignored then.
|
|
const bool source_phase_start = minute == 1 ||
|
|
(state.indoor ? minute == 21 : (minute == 46 || minute == 91 || minute == 106));
|
|
// Poll this minute's events directly (the live display is its own input loop).
|
|
SDL_Event event;
|
|
while (quit_confirmation.poll(&event)) {
|
|
if (event.type == SDL_QUIT) { quit = true; live_skipped = true; }
|
|
else if (event.type == SDL_KEYDOWN && event.key.keysym.sym == SDLK_ESCAPE)
|
|
live_skipped = true;
|
|
else if (!source_phase_start && source_pause_is_p && event.type == SDL_KEYDOWN &&
|
|
!event.key.repeat && event.key.keysym.sym == SDLK_p)
|
|
pause_live_match();
|
|
else if (!source_phase_start && event.type == SDL_KEYDOWN && !event.key.repeat &&
|
|
season_exe.u8(::bmh::layout::Main_FileScreen_RuntimeField) == 'g' && event.key.keysym.sym == SDLK_g)
|
|
show_live_overview(0);
|
|
else if (!source_phase_start && event.type == SDL_KEYDOWN && !event.key.repeat &&
|
|
season_exe.u8(::bmh::layout::Main_FileScreen_RuntimeField2) == 't' && event.key.keysym.sym == SDLK_t)
|
|
show_live_overview(1);
|
|
else if (!source_phase_start && event.type == SDL_KEYDOWN && !event.key.repeat &&
|
|
season_exe.u8(::bmh::layout::Main_FileScreen_RuntimeField3) == 's' && event.key.keysym.sym == SDLK_s)
|
|
show_live_settings();
|
|
// Press on the top strip (x 0..63, y 50..64) opens an overview or the settings.
|
|
else if (event.type == SDL_MOUSEBUTTONDOWN &&
|
|
(event.button.button == SDL_BUTTON_LEFT || event.button.button == SDL_BUTTON_RIGHT) &&
|
|
event.button.x >= 0 && event.button.x <= 63 &&
|
|
event.button.y > 49 && event.button.y < 65) {
|
|
// OriginalMouseSound sets CareerSession_BeginFriendlyOpponentTable_ExecutableField2 from this physical event: left=2,
|
|
// right=8. Keep it as input context; do not persist it in GameState.
|
|
const uint8_t source_mouse_mode =
|
|
event.button.button == SDL_BUTTON_LEFT ? 2 : 8;
|
|
if ((source_mouse_mode != 2 && source_mouse_mode != 8) ||
|
|
source_phase_start || minute <= 2)
|
|
continue;
|
|
// EndPhase retains the sampled coordinates while each
|
|
// modal runs. Its inclusive ranges overlap at21/42:
|
|
// after closing the first viewer, enter its neighbour
|
|
// before resuming the same match minute.
|
|
for (int candidate = 0; candidate < 3 && running; ++candidate) {
|
|
const int left = candidate * 21;
|
|
if (event.button.x >= left && event.button.x <= left + 21) {
|
|
if (candidate < 2) show_live_overview(candidate);
|
|
else show_live_settings(event.button);
|
|
}
|
|
}
|
|
}
|
|
// Press on a scoreboard side: right = tactics, left = lineup of the clicked row's team.
|
|
else if (const auto side = app::live_matchday_board_side(event, minute, state.indoor)) {
|
|
if (event.button.button == SDL_BUTTON_RIGHT) {
|
|
open_live_tactics(*side, event.button.y);
|
|
continue;
|
|
}
|
|
const auto frame = ui::live_matchday_frame(minute, groups, state);
|
|
int selected_team = -1, selected_opponent = -1;
|
|
for (size_t row = 0; row < frame.matches.size() && row < 4; ++row) {
|
|
const int y = season_exe.u8(::bmh::layout::LiveMatchday_Render_ExecutableFieldUnsigned + uint32_t(row));
|
|
if (event.button.y < y || event.button.y > y + 32) continue;
|
|
if (*side == 0) {
|
|
selected_team = frame.matches[row].home_team;
|
|
selected_opponent = frame.matches[row].away_team;
|
|
} else {
|
|
selected_team = frame.matches[row].away_team;
|
|
selected_opponent = frame.matches[row].home_team;
|
|
}
|
|
break;
|
|
}
|
|
// EndPhase: physical left-DOWN is Source mode 2; the
|
|
// matching right-DOWN is mode 8.
|
|
(void)present_live_lineup(minute, engine, groups,
|
|
state, live_revision, selected_team, selected_opponent,
|
|
dispatch, dispatch_tactic, dispatch_pitch, dispatch_scope, live_skipped, false);
|
|
}
|
|
}
|
|
if (quit) running = false;
|
|
}
|
|
|
|
// Next callback: a lineup change forced by a live match event; runs the same lineup
|
|
// screen as the click on the scoreboard. It must complete unless the program quits.
|
|
auto App::present_live_event_lineup(const LiveMatchEvent& event, MatchEngine& engine,
|
|
std::vector<MatchGroup>& groups, GameState& state, uint64_t& live_revision,
|
|
const app::LiveLineupDispatcher& dispatch,
|
|
const app::LiveTacticsDispatcher& dispatch_tactic,
|
|
const app::LivePitchDispatcher& dispatch_pitch,
|
|
const app::LiveInterventionScopeDispatcher& dispatch_scope) -> void {
|
|
if (!running) return;
|
|
const bool completed = present_live_lineup(event.minute, engine, groups, state, live_revision,
|
|
event.team, event.opponent, dispatch, dispatch_tactic, dispatch_pitch,
|
|
dispatch_scope, false, true);
|
|
if (!running) return; // SDL_QUIT aborts the Source scope without failing the event.
|
|
if (!completed)
|
|
throw FormatError("The Source event line-up did not complete.");
|
|
}
|
|
|
|
// =====================================================================================
|
|
// Live match animation callbacks
|
|
// =====================================================================================
|
|
// The following callbacks each show one kind of match event (ball movement, chance, shot,
|
|
// set piece, booking, penalty shootout, reality mode) and then pause. The pause is
|
|
// --live-frame-ms when given, otherwise a value saved in the game memory: values below 6
|
|
// are halved and each unit is 20 ms. Only a window close request is consumed here; other
|
|
// input stays queued for the per-minute observer.
|
|
//
|
|
// Callback: ball movement frames of one displacement.
|
|
auto App::animate_ball(const LiveBallEvent& event, const std::vector<MatchGroup>& groups,
|
|
const GameState& state) -> void {
|
|
if (!running || live_skipped) return;
|
|
const auto frame = live_score_reveal.project(ui::live_matchday_frame(event.minute, groups, state));
|
|
if (frame.matches.empty()) return;
|
|
// Local helper: paints an image with the normal palette and presents it.
|
|
const auto present = [&](const Image& image) {
|
|
canvas.show(image, palette);
|
|
};
|
|
const int count = ui::LiveMatchdayScreen::ball_frame_count(event.displacement);
|
|
// Converts the saved pause number at the given row into milliseconds.
|
|
const auto source_delay = [&](int pause) {
|
|
const uint32_t address = ::bmh::layout::Main_FormatError_ExecutableFieldUnsigned + uint32_t(pause * 9);
|
|
const int saved = state.memory.has(address) ? state.memory.u8(address) : 0;
|
|
return (saved < 6 ? saved / 2 : saved) * 20;
|
|
};
|
|
for (int index = 0; index < count && running; ++index) {
|
|
const std::string title = "OpenBMH - live_ball_" + std::to_string(event.minute) + "_" +
|
|
std::to_string(event.group) + "_" + std::to_string(event.match) + "_" +
|
|
std::to_string(event.displacement) + "_" + std::to_string(index);
|
|
SDL_SetWindowTitle(window, title.c_str());
|
|
const auto* chance = live_chance_context &&
|
|
live_chance_context->minute == event.minute &&
|
|
live_chance_context->group == event.group &&
|
|
live_chance_context->match == event.match ? &*live_chance_context : nullptr;
|
|
present(live_screen.render_ball(frame, event.displacement, index, chance));
|
|
SDL_PumpEvents();
|
|
SDL_Event quit_event;
|
|
if (quit_confirmation.peep(&quit_event, 1, SDL_GETEVENT, SDL_QUIT, SDL_QUIT) > 0) {
|
|
running = false;
|
|
break;
|
|
}
|
|
// AdvanceStep(5) reads a252c; DecodeTaxAnimationScript2 uses 20ms ticks.
|
|
// Retain key/mouse events for the live-minute input boundary.
|
|
const int delay = live_frame_ms_explicit ? live_frame_ms :
|
|
source_delay(5);
|
|
if (delay > 0) SDL_Delay(Uint32(delay));
|
|
}
|
|
if (running) {
|
|
const int final_delay = live_frame_ms_explicit ? live_frame_ms : source_delay(6);
|
|
if (final_delay > 0) SDL_Delay(Uint32(final_delay));
|
|
SDL_SetWindowTitle(window, "OpenBMH - live_matchday");
|
|
present(live_screen.render(frame));
|
|
}
|
|
}
|
|
|
|
// Next callback: a scoring chance, shown as a preview and again as its result.
|
|
auto App::animate_chance(const LiveChanceEvent& event, const std::vector<MatchGroup>& groups,
|
|
const GameState& state) -> void {
|
|
if (!running || live_skipped) return;
|
|
// Preview: the chance is already in the event log, but its statistics must not count yet.
|
|
const auto frame = event.stage == LiveChanceStage::preview
|
|
? ui::live_matchday_frame_before_chance(event.minute, groups, state, event)
|
|
: ui::live_matchday_frame(event.minute, groups, state);
|
|
live_score_reveal.observe(event.stage, frame);
|
|
if (frame.matches.empty()) return;
|
|
const auto chance = ui::live_chance_projection(event, groups, state, season_exe);
|
|
if (event.stage == LiveChanceStage::preview) live_chance_context = chance;
|
|
const std::string title = std::string("OpenBMH - live_chance_") +
|
|
(event.stage == LiveChanceStage::preview ? "preview_" : "result_") +
|
|
std::to_string(event.minute) + "_" + std::to_string(event.group) + "_" +
|
|
std::to_string(event.match) + "_" + std::to_string(event.side) + "_" +
|
|
std::to_string(event.kind) + "_" + std::to_string(int(event.goal));
|
|
SDL_SetWindowTitle(window, title.c_str());
|
|
const Image image = live_screen.render_chance(frame, chance);
|
|
canvas.show(image, palette);
|
|
SDL_PumpEvents();
|
|
SDL_Event quit_event;
|
|
if (quit_confirmation.peep(&quit_event, 1, SDL_GETEVENT, SDL_QUIT, SDL_QUIT) > 0) {
|
|
running = false;
|
|
live_chance_context.reset();
|
|
return;
|
|
}
|
|
// Pause row: 12 for the preview, 1 after a goal, otherwise 2.
|
|
const int pause = event.stage == LiveChanceStage::preview ? 12 : (event.goal ? 1 : 2);
|
|
const uint32_t address = ::bmh::layout::Main_FormatError_ExecutableFieldUnsigned + uint32_t(pause * 9);
|
|
const int saved = state.memory.has(address) ? state.memory.u8(address) : 0;
|
|
const int delay = live_frame_ms_explicit ? live_frame_ms :
|
|
(saved < 6 ? saved / 2 : saved) * 20;
|
|
if (delay > 0) SDL_Delay(Uint32(delay));
|
|
if (event.stage == LiveChanceStage::result) live_chance_context.reset();
|
|
}
|
|
|
|
// Next callback: shot animation, drawn with the shot's own palette. After the frames it
|
|
// either waits for a click or applies the saved pause.
|
|
auto App::animate_shot(const LiveShotEvent& event, const std::vector<MatchGroup>& groups,
|
|
const GameState& state) -> void {
|
|
if (!running || live_skipped) return;
|
|
const auto frame = live_score_reveal.project(ui::live_matchday_frame(event.minute, groups, state));
|
|
if (frame.matches.empty()) return;
|
|
const auto frames = live_screen.render_shot(frame, event);
|
|
const auto shot_colors = live_screen.shot_palette(palette, event, groups, state);
|
|
const std::string identity = std::to_string(event.minute) + "_" +
|
|
std::to_string(event.group) + "_" + std::to_string(event.match) + "_" +
|
|
std::to_string(event.acting_side) + "_" + std::to_string(int(event.miss));
|
|
for (size_t index = 0; index < frames.size() && running; ++index) {
|
|
const std::string title = "OpenBMH - live_shot_" + identity + "_" + std::to_string(index);
|
|
SDL_SetWindowTitle(window, title.c_str());
|
|
canvas.show(frames[index], shot_colors);
|
|
SDL_PumpEvents();
|
|
SDL_Event input;
|
|
if (quit_confirmation.peep(&input, 1, SDL_GETEVENT, SDL_QUIT, SDL_QUIT) > 0) {
|
|
running = false;
|
|
return;
|
|
}
|
|
// Source waits Main_FormatError_RuntimeField vertical retraces after each frame (70 Hz).
|
|
const int retraces = state.memory.has(::bmh::layout::Main_FormatError_RuntimeField) ?
|
|
std::max(0, int(int8_t(state.memory.u8(::bmh::layout::Main_FormatError_RuntimeField)))) : 0;
|
|
const int delay = live_frame_ms_explicit ? live_frame_ms : retraces * 1000 / 70;
|
|
if (delay > 0) SDL_Delay(Uint32(delay));
|
|
}
|
|
if (!running) return;
|
|
if (!live_frame_ms_explicit) SDL_Delay(200); // LiveMatchdayFrame -> DecodeTaxAnimationScript2(10)
|
|
if (app::match_sound_enabled(state))
|
|
app::original_audio_command(playback, event.miss ? 20 : 19); // SetPieceAnimation, before its ACK.
|
|
if (state.memory.has(::bmh::layout::Main_FormatError_RuntimeField5) && state.memory.u8(::bmh::layout::Main_FormatError_RuntimeField5) == 0) {
|
|
// SDLFlushEvents2 accepts a fresh left/right press, not a keyboard skip.
|
|
const std::string title = "OpenBMH - live_shot_wait_" + identity;
|
|
SDL_SetWindowTitle(window, title.c_str());
|
|
SDL_FlushEvents(SDL_MOUSEBUTTONDOWN, SDL_MOUSEBUTTONUP);
|
|
SDL_Event input;
|
|
bool acknowledged = false;
|
|
while (running && !acknowledged) {
|
|
while (quit_confirmation.poll(&input)) {
|
|
if (input.type == SDL_QUIT) { running = false; break; }
|
|
if (input.type == SDL_MOUSEBUTTONDOWN &&
|
|
(input.button.button == SDL_BUTTON_LEFT || input.button.button == SDL_BUTTON_RIGHT)) {
|
|
acknowledged = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!acknowledged && running) SDL_Delay(10);
|
|
}
|
|
} else {
|
|
// AdvanceStep(15): the ordinary saved pause instead of a click.
|
|
const int saved = state.memory.has(::bmh::layout::Main_FormatError_RuntimeField7) ? state.memory.u8(::bmh::layout::Main_FormatError_RuntimeField7) : 0;
|
|
const int delay = live_frame_ms_explicit ? live_frame_ms : (saved < 6 ? saved / 2 : saved) * 20;
|
|
if (delay > 0) SDL_Delay(Uint32(delay));
|
|
}
|
|
}
|
|
|
|
// Next callback: set piece animation frames (first frame held 40 retraces at 70 Hz).
|
|
auto App::animate_set_piece(const LiveSetPieceEvent& event, const std::vector<MatchGroup>& groups,
|
|
const GameState& state) -> void {
|
|
if (!running || live_skipped) return;
|
|
const auto frame=live_score_reveal.project(ui::live_matchday_frame(event.minute,groups,state));
|
|
if (frame.matches.empty()) return;
|
|
const auto images=live_screen.render_set_piece(frame,event);
|
|
LiveShotEvent palette_event;
|
|
palette_event.group=event.group;palette_event.match=event.match;
|
|
const auto colors=live_screen.shot_palette(palette,palette_event,groups,state);
|
|
for (size_t index=0;index<images.size() && running;++index) {
|
|
const std::string title="OpenBMH - live_set_piece_"+std::to_string(event.minute)+"_"+
|
|
std::to_string(event.group)+"_"+std::to_string(event.match)+"_"+
|
|
std::to_string(event.source_side)+"_"+std::to_string(event.kind)+"_"+
|
|
std::to_string(index)+"_"+std::to_string(images.size());
|
|
SDL_SetWindowTitle(window,title.c_str());
|
|
canvas.show(images[index], colors);
|
|
SDL_PumpEvents();SDL_Event input;
|
|
if (quit_confirmation.peep(&input,1,SDL_GETEVENT,SDL_QUIT,SDL_QUIT)>0) { running=false;return; }
|
|
// FirstThen holds the first frame for 40 retraces; later frames
|
|
// use saved Main_FormatError_RuntimeField2. Keyboard/mouse input remains for the minute hook.
|
|
const int retraces=index==0?40:(state.memory.has(::bmh::layout::Main_FormatError_RuntimeField2)?state.memory.u8(::bmh::layout::Main_FormatError_RuntimeField2):0);
|
|
const int delay=live_frame_ms_explicit?live_frame_ms:retraces*1000/70;
|
|
if (delay>0) SDL_Delay(Uint32(delay));
|
|
}
|
|
if (running && !live_frame_ms_explicit) SDL_Delay(200); // LiveMatchdayFrame
|
|
}
|
|
|
|
// Next callback: booking/injury box; pause row 3 for kind 0, otherwise 4.
|
|
auto App::animate_booking(const LiveBookingEvent& event, const std::vector<MatchGroup>& groups,
|
|
const GameState& state) -> void {
|
|
if (!running || live_skipped) return;
|
|
const auto frame=ui::live_matchday_frame(event.minute,groups,state);
|
|
if (frame.matches.empty()) return;
|
|
const auto booking=ui::live_booking_projection(event,groups,state,season_exe);
|
|
const std::string title="OpenBMH - live_booking_"+std::to_string(event.minute)+"_"+
|
|
std::to_string(event.group)+"_"+std::to_string(event.match)+"_"+
|
|
std::to_string(event.side)+"_"+std::to_string(event.kind)+"_"+std::to_string(event.player);
|
|
const auto present=[&](const Image& image) {
|
|
canvas.show(image, palette);
|
|
};
|
|
SDL_SetWindowTitle(window,title.c_str());present(live_screen.render_booking(frame,booking));
|
|
if (event.kind != 2 && app::match_sound_enabled(state))
|
|
app::original_audio_command(playback, 17); // EventImpl/SDLPumpEvents, no injury whistle.
|
|
SDL_PumpEvents();SDL_Event input;
|
|
if (quit_confirmation.peep(&input,1,SDL_GETEVENT,SDL_QUIT,SDL_QUIT)>0) { running=false;return; }
|
|
const int pause=event.kind==0?3:4;
|
|
const uint32_t address=::bmh::layout::Main_FormatError_ExecutableFieldUnsigned+uint32_t(pause*9);
|
|
const int saved=state.memory.has(address)?state.memory.u8(address):0;
|
|
const int delay=live_frame_ms_explicit?live_frame_ms:(saved<6?saved/2:saved)*20;
|
|
if (delay>0) SDL_Delay(Uint32(delay));
|
|
// EventImpl clears the box after its pause; no Source click wait here.
|
|
SDL_SetWindowTitle(window,"OpenBMH - live_matchday");present(live_screen.render(frame));
|
|
}
|
|
|
|
// Next callback: penalty shootout step; the saved pause is repeated 4 times for the
|
|
// preview and twice for the result.
|
|
auto App::animate_shootout(const LiveShootoutEvent& event, const std::vector<MatchGroup>& groups,
|
|
const GameState& state) -> void {
|
|
if (!running || live_skipped) return;
|
|
const auto frame=ui::live_matchday_frame(event.minute,groups,state);
|
|
if (frame.matches.empty()) return;
|
|
const auto projection=ui::live_shootout_projection(event,groups,state,season_exe);
|
|
const std::string title="OpenBMH - live_shootout_"+std::to_string(int(event.stage))+"_"+
|
|
std::to_string(event.group)+"_"+std::to_string(event.match)+"_"+
|
|
std::to_string(event.side)+"_"+std::to_string(event.round)+"_"+
|
|
std::to_string(event.of)+"_"+std::to_string(event.player);
|
|
SDL_SetWindowTitle(window,title.c_str());
|
|
const auto image=live_screen.render_shootout(frame,projection);
|
|
canvas.show(image, palette);
|
|
SDL_PumpEvents();SDL_Event input;
|
|
if (quit_confirmation.peep(&input,1,SDL_GETEVENT,SDL_QUIT,SDL_QUIT)>0) { running=false;return; }
|
|
const int repeats=event.stage==LiveShootoutStage::preview?4:2;
|
|
const int saved=state.memory.has(::bmh::layout::Main_FormatError_RuntimeField6)?state.memory.u8(::bmh::layout::Main_FormatError_RuntimeField6):0;
|
|
const int delay=live_frame_ms_explicit?live_frame_ms:(saved<6?saved/2:saved)*20;
|
|
for (int i=0;i<repeats && running;++i) if (delay>0) SDL_Delay(Uint32(delay));
|
|
}
|
|
|
|
// Next callback: reality mode (running commentary with a moving field). Stages: begin
|
|
// (builds the screens), one call per round, settling and end. Returns true when the
|
|
// player ended it with ESC or a right press, or when the program quits.
|
|
auto App::present_reality(const LiveRealityEvent& event, const std::vector<MatchGroup>& groups,
|
|
const GameState& state) -> bool {
|
|
if (!running || live_skipped) return false;
|
|
const auto frame = ui::live_matchday_frame(event.minute,groups,state);
|
|
const auto present = [&](const Image& image,const Palette& colors,const std::string& title) {
|
|
SDL_SetWindowTitle(window,title.c_str());
|
|
canvas.show(image, colors);
|
|
};
|
|
const auto delay = [&](uint32_t address) {
|
|
const int saved=state.memory.has(address)?state.memory.u8(address):0;
|
|
const int ms=live_frame_ms_explicit?live_frame_ms:(saved<6?saved/2:saved)*20;
|
|
if (ms>0) SDL_Delay(Uint32(ms));
|
|
};
|
|
const std::string identity=std::to_string(event.minute)+"_"+std::to_string(event.group)+"_"+
|
|
std::to_string(event.match)+"_"+std::to_string(event.side);
|
|
if (event.stage==LiveRealityStage::begin) {
|
|
LiveChanceEvent header_event;header_event.minute=event.minute;
|
|
header_event.group=event.group;header_event.match=event.match;header_event.side=event.side;
|
|
const auto header=ui::live_chance_projection(header_event,groups,state,season_exe);
|
|
reality_pristine=live_screen.render_reality(frame,header);
|
|
reality_surface=reality_pristine;reality_layout={};
|
|
reality_field=std::make_unique<ui::RealityFieldScreen>(data,
|
|
state.memory.has(::bmh::layout::Main_FormatError_RuntimeField3)?state.memory.u8(::bmh::layout::Main_FormatError_RuntimeField3):0);
|
|
LiveShotEvent colors_event;colors_event.group=event.group;colors_event.match=event.match;
|
|
reality_colors=live_screen.shot_palette(palette,colors_event,groups,state);
|
|
present(reality_surface,reality_colors,"OpenBMH - live_reality_begin_"+identity);
|
|
return false;
|
|
}
|
|
if (event.stage==LiveRealityStage::settling) {
|
|
reality_field.reset();
|
|
const int ms=live_frame_ms_explicit?live_frame_ms:200; // DecodeTaxAnimationScript2(10)
|
|
if (ms>0) SDL_Delay(Uint32(ms));
|
|
return false;
|
|
}
|
|
if (event.stage==LiveRealityStage::end) {
|
|
present(live_screen.render(frame),palette,"OpenBMH - live_matchday");
|
|
return false;
|
|
}
|
|
if (!reality_field) throw FormatError("Reality presentation: round without Source header");
|
|
for (const auto& report:event.tick.reports)
|
|
reality_reporter.append(reality_surface,reality_layout,report.text,frame.gradient_text);
|
|
const std::string round_identity=identity+"_"+std::to_string(event.tick.round);
|
|
if (event.tick.motion) {
|
|
size_t index=0;
|
|
for (const auto& motion:event.tick.motion->frames) {
|
|
auto backdrop=reality_pristine;
|
|
// Keep the first 129 rows of the current surface on the fresh backdrop.
|
|
std::copy_n(reality_surface.pixels.begin(),320*129,backdrop.pixels.begin());
|
|
reality_surface=reality_field->render(motion,backdrop);
|
|
present(reality_surface,reality_colors,"OpenBMH - live_reality_round_"+
|
|
round_identity+"_"+std::to_string(index++));
|
|
delay(::bmh::layout::Main_FormatError_ExecutableField2); // RealityFieldScreen: the saved Reality speed
|
|
}
|
|
delay(::bmh::layout::Main_FormatError_ExecutableField+10*9); // AdvanceStep(10), after all eleven frames
|
|
} else {
|
|
present(reality_surface,reality_colors,"OpenBMH - live_reality_report_"+round_identity);
|
|
}
|
|
// Only ESC or a right press is taken from the queue as the exit; other input stays.
|
|
SDL_PumpEvents();SDL_Event input;
|
|
if (quit_confirmation.peep(&input,1,SDL_GETEVENT,SDL_QUIT,SDL_QUIT)>0) {running=false;return true;}
|
|
// Consume only the Source exit for this scene. Other input remains
|
|
// queued for the existing live-minute/manager intervention boundary.
|
|
if (quit_confirmation.peep(&input,1,SDL_PEEKEVENT,SDL_KEYDOWN,SDL_KEYDOWN)>0 &&
|
|
input.key.keysym.sym==SDLK_ESCAPE) {
|
|
quit_confirmation.peep(&input,1,SDL_GETEVENT,SDL_KEYDOWN,SDL_KEYDOWN);return true;
|
|
}
|
|
if (quit_confirmation.peep(&input,1,SDL_PEEKEVENT,SDL_MOUSEBUTTONDOWN,SDL_MOUSEBUTTONDOWN)>0 &&
|
|
input.button.button==SDL_BUTTON_RIGHT) {
|
|
quit_confirmation.peep(&input,1,SDL_GETEVENT,SDL_MOUSEBUTTONDOWN,SDL_MOUSEBUTTONDOWN);return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Next callback: results viewer at the end of a match phase; throws if it was stopped
|
|
// before being acknowledged.
|
|
auto App::present_phase_result(const PhaseResultRequest& request, const std::vector<MatchGroup>& groups,
|
|
const GameState& state) -> void {
|
|
if (!running) throw FormatError("phase results: presentation stopped");
|
|
const auto frame = ui::live_matchday_frame(request.phase_end_minute, groups, state);
|
|
std::string error;
|
|
auto projection = session->open_phase_results(revision, live_screen.render(frame), error);
|
|
if (!projection) throw FormatError(error.empty() ? "phase results: Source viewer unavailable" : error);
|
|
const bool closed = present_running_overview(std::move(projection), state, revision,
|
|
[&](const app::CareerSession::LiveOverviewAction& action, std::string& dispatch_error,
|
|
const app::TransferOfferTeamInfoPresenter& team_info) {
|
|
return session->dispatch_phase_results(action, revision, dispatch_error, team_info);
|
|
}, &request);
|
|
if (!closed) throw FormatError("phase results: viewer stopped before Source ACK");
|
|
}
|