// SPDX-License-Identifier: GPL-3.0-only #include "formats/badge_policy.hpp" #include "formats/executable_layout.hpp" #include "app/start_screen.hpp" #include "ui/live_timing.hpp" // openbmh_play - the UI of src/ui connected to the engine: options, manager dialogs, a new // career initialised by the engine (app/career_session.hpp) and its desk. // // Usage: openbmh_play [] [--seed ] [--save-directory ] [--mute] [--volume <0..1>] [--music] [--live-frame-ms <0..1000>] // (also as --data ): the game directory, its BMH.EXE, or a ZIP/7z archive with // exactly one game (src/launch). Without a game the system's file dialog asks for one. #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "app/controller.hpp" #include "app/quit_confirmation.hpp" #include "launch/archive.hpp" #include "launch/file_dialog.hpp" #include "launch/game_data.hpp" #include "version.hpp" #include "app/video_session.hpp" #include "app/live_matchday_events.hpp" #include "app/pitch_pointer.hpp" #include "audio/playback.hpp" #include "app/audio.hpp" #include "formats/palette.hpp" #include "formats/textd.hpp" #include "ui/flow.hpp" #include "ui/source_hold.hpp" #include "ui/live_matchday.hpp" #include "ui/live_reality.hpp" #include "ui/reality_reporter.hpp" #include "ui/league_table.hpp" #include "ui/league_pairings.hpp" #include "ui/other_games.hpp" #include "ui/process_timer.hpp" #include "ui/strengths.hpp" #include "ui/league_table_range_dialog.hpp" #include "ui/settings.hpp" #include "ui/lineup.hpp" #include "ui/tactics.hpp" #include "ui/sportschau.hpp" #include "ui/incoming_transfer.hpp" #include "ui/outgoing_transfer.hpp" #include "ui/pending_offer.hpp" #include "ui/season_entrants.hpp" #include "ui/season_promotion.hpp" #include "ui/cup_draw.hpp" #include "ui/club_info.hpp" #include "ui/team_statistics.hpp" #include "ui/club_player_detail.hpp" #include "ui/game_end.hpp" #include "ui/game_end_alternate.hpp" #include "ui/game_end_tax_animation.hpp" #include "ui/contracts.hpp" #include "game/month.hpp" #include "game/driver.hpp" #include "game/messages.hpp" namespace fs = std::filesystem; using namespace bmh; // Why the game cannot start: a message box, and the same text on stderr. static void show_start_error(const std::string& text) { std::fprintf(stderr, "%s\n", text.c_str()); SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, "OpenBMH", text.c_str(), nullptr); } // Reattach the native editor when an in-game filename field takes focus. Cocoa // owns a field-editor responder in addition to SDL's TEXTINPUT enable flag. static void focus_filename_input(SDL_Renderer* renderer) { int left, top, right, bottom; SDL_RenderLogicalToWindow(renderer, 106, 209, &left, &top); SDL_RenderLogicalToWindow(renderer, 262, 219, &right, &bottom); const SDL_Rect field{left, top, std::max(1, right - left), std::max(1, bottom - top)}; SDL_StopTextInput(); SDL_SetTextInputRect(&field); SDL_StartTextInput(); } #ifdef _WIN32 // The game is a Windows GUI program (no console window on double-click). Started from a // console, it writes --version, --help and start errors there (kernel32 AttachConsole). extern "C" __declspec(dllimport) int __stdcall AttachConsole(unsigned long process_id); static void attach_parent_console() { // (an output redirected to a file or pipe stays there; a GUI program without one has no // valid stream, fileno < 0) const bool out_free = _fileno(stdout) < 0, err_free = _fileno(stderr) < 0; if ((out_free || err_free) && AttachConsole(static_cast(-1))) { // ATTACH_PARENT_PROCESS std::FILE* f = nullptr; if (out_free) freopen_s(&f, "CONOUT$", "w", stdout); if (err_free) freopen_s(&f, "CONOUT$", "w", stderr); } } #else static void attach_parent_console() {} #endif int main(int argc, char** argv) { attach_parent_console(); const std::vector args = launch::utf8_arguments(argc, argv); // (file names beyond the code page) fs::path data, save_directory; uint32_t seed = uint32_t(std::chrono::system_clock::now().time_since_epoch().count()); bool muted = false, music_enabled = true; int live_frame_ms = 0; bool live_frame_ms_explicit = false; if (const char* configured = std::getenv("BMH_LIVE_FRAME_MS")) { live_frame_ms = std::clamp(std::atoi(configured), 0, 1000); live_frame_ms_explicit = true; } float volume = 1.0F; for (size_t i = 1; i < args.size(); ++i) { const auto is = [&](const char* name) { return args[i] == name; }; const bool value = i + 1 < args.size(); if (is("--mute")) { muted = true; } else if (is("--music")) { music_enabled = true; } else if (is("--no-music")) { music_enabled = false; } else if (is("--live-frame-ms") && value) { live_frame_ms = std::clamp(std::atoi(args[++i].c_str()), 0, 1000); live_frame_ms_explicit = true; } else if (is("--data") && value) { data = launch::path_from_utf8(args[++i]); } else if (is("--seed") && value) { seed = uint32_t(std::strtoul(args[++i].c_str(), nullptr, 0)); } else if (is("--save-directory") && value) { save_directory = launch::path_from_utf8(args[++i]); } else if (is("--volume") && value) { volume = std::strtof(args[++i].c_str(), nullptr); } else if (is("--version")) { std::printf("OpenBMH %s\n", bmh::kOpenBmhVersion); return 0; } else if (is("--help") || is("-h")) { std::printf("usage: OpenBMH [] [--seed ] " "[--save-directory ] [--mute] [--volume <0..1>] [--no-music] [--live-frame-ms <0..1000>]\n"); return 0; } else if (args[i].rfind("--", 0) != 0 && data.empty()) { data = launch::path_from_utf8(args[i]); } } std::optional video; try { video.emplace(); } catch (const std::exception& error) { show_start_error(error.what()); return 1; } // the game: as given (directory, EXE or archive); else the directory OpenBMH itself lies in, // when it holds a playable game (the simplest install: openbmh next to BMH.EXE); else // chosen in the file dialog if (data.empty()) { if (char* base = SDL_GetBasePath()) { const fs::path here = launch::path_from_utf8(base); SDL_free(base); try { const launch::ResolvedGame game = launch::resolve_game(here, launch::default_cache_directory()); if (game.error.empty() && game.check.playable) data = here; } catch (const std::exception&) { // (not a game directory: fall through to the file dialog) } } } if (data.empty()) { try { const auto chosen = launch::choose_game_file("OpenBMH"); if (!chosen) return 0; // cancelled data = *chosen; } catch (const std::exception& e) { show_start_error(std::string(e.what()) + "\nStart OpenBMH with the game as argument: openbmh_play "); return 1; } } bool english_game = false; // (the window title marks the English version as experimental) { const launch::ResolvedGame game = launch::resolve_game(data, launch::default_cache_directory()); if (!game.error.empty() || !game.check.playable) { show_start_error("The game cannot be started:\n" + launch::describe(game)); return 1; } english_game = game.check.family == launch::GameFamily::english; // (from an archive: its unpacked copy in the cache, which then also keeps the saves) data = game.check.directory; } if (save_directory.empty()) save_directory = data; try { const Palette palette = load_palette(ui::asset_path(data, "M3PC.COL")); ui::StartupFlow flow(data, save_directory); std::unique_ptr session; uint64_t revision = 0; openbmh::audio::Playback playback; std::string audio_error; playback.initialize(audio_error); // Audio is optional; the game continues without a device. playback.set_muted(muted); playback.set_volume(volume); std::optional audio_session; SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "0"); const std::string window_title = std::string("OpenBMH ") + bmh::kOpenBmhVersion + (english_game ? " - Football Limited (experimental)" : ""); SDL_Window* window = SDL_CreateWindow(window_title.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 960, 720, SDL_WINDOW_RESIZABLE | SDL_WINDOW_ALLOW_HIGHDPI); if (!window) throw FormatError(SDL_GetError()); SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_PRESENTVSYNC); if (!renderer) renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_SOFTWARE); if (!renderer) throw FormatError(SDL_GetError()); SDL_RenderSetLogicalSize(renderer, 320, 240); SDL_Texture* texture = SDL_CreateTexture(renderer, SDL_PIXELFORMAT_ARGB8888, SDL_TEXTUREACCESS_STREAMING, 320, 240); if (!texture) throw FormatError(SDL_GetError()); app::PitchPointer pitch_pointer; std::vector pixels(320 * 240); ui::LiveMatchdayScreen live_screen(data); ui::RealityReporterPanel reality_reporter(data); ui::SportschauIntro sportschau_intro(data); ui::MatchdayIntro matchday_intro(data); ui::SportschauEleven sportschau_eleven(data); ui::SportschauTeamInfo sportschau_team_info(data); ui::CompetitionWinnerScreen competition_winner(data); const auto season_exe = load_le(ui::asset_path(data, "BMH.exe")); english_game = english_game || season_exe.u8(layout::LeagueSizes) == 20; app::QuitConfirmation quit_confirmation(window, english_game); try { if (!playback.initialize_original(app::original_audio_assets(data, season_exe), audio_error)) std::fprintf(stderr, "audio: %s\n", audio_error.c_str()); playback.set_original_options({music_enabled, true, true}); app::original_audio_command(playback, 0); } catch (const std::exception& error) { std::fprintf(stderr, "audio: %s\n", error.what()); } app::OriginalMouseSound mouse_sound(playback); const auto season_texts = load_textd(ui::asset_path(data, "TEXTD.BLK")); const auto process_clock_origin = std::chrono::steady_clock::now(); const auto process_source_seconds = [&] { return uint64_t(std::chrono::duration_cast( std::chrono::steady_clock::now()-process_clock_origin).count()); }; ui::ProcessTimer process_timer; struct ProcessTimerOwner { uint64_t session; int manager; uint32_t day; bool operator==(const ProcessTimerOwner&) const = default; }; std::optional process_timer_owner; std::optional process_timer_frame; const auto process_timer_image = [&](Image image) { if (!process_timer.paused() && process_timer_frame) ui::ProcessTimer::paint(image, *process_timer_frame, season_exe); return image; }; // Sample writes only y0. Nested synchronous presenters poll the // same Desk-owned clock without re-entering Session/Flow dispatch. const auto poll_process_timer = [&](bool update_texture, bool present) { const auto sample = process_timer.sample(process_source_seconds()); const bool changed_bar = sample && !sample->expired && (!process_timer_frame || sample->percent != process_timer_frame->percent); process_timer_frame = sample; if (changed_bar && update_texture) { Image bar(320,240); ui::ProcessTimer::paint(bar,*sample,season_exe); for (size_t x=0;x<320;++x) pixels[x]=palette.argb[bar.pixels[x]]; const SDL_Rect top{0,0,320,1}; if (SDL_UpdateTexture(texture,&top,pixels.data(),320*4)!=0) throw std::runtime_error(std::string("Process timer texture: ")+SDL_GetError()); if (present) { SDL_RenderClear(renderer); SDL_RenderCopy(renderer,texture,nullptr,nullptr); SDL_RenderPresent(renderer); } } return sample && sample->expired; }; bool running = true, dirty = true; struct Press { int x, y; uint32_t time; std::string screen; uint64_t source_tick, revision; bool pitch_hold_attempted = false; }; std::optional press; std::optional right_press_screen; auto transfer_view = [](const GameState& state, const TransferOfferListView& offers, int viewer_manager) { ui::IncomingTransferDecisionView view; view.valid = offers.valid; view.list_entry = offers.list_entry; view.player = offers.player; view.seller = offers.seller; view.seller_manager = offers.seller_manager; view.viewer_manager = viewer_manager; view.preferred_bid_index = offers.preferred_bid_index; view.has_preferred_bid = offers.preferred_bid_index >= 0; view.preferred_bid_passed_random_check = offers.preferred_bid_passed_random_check; if (offers.seller != 0x0fff && offers.seller != kNoTeam) view.negotiator_name = state.club_name(offers.seller); view.asking_fee = offers.asking_fee; view.asking_monthly_salary = offers.asking_monthly_salary; view.quoted_fee = offers.quoted_fee; view.quoted_monthly_salary = offers.quoted_monthly_salary; view.quoted_years = offers.quoted_years; view.notice_text_address = offers.notice_text_address; for (size_t row = 0; row < view.offers.size(); ++row) { const auto& source = offers.offers[row]; auto& slot = view.offers[row]; slot.bid_index = source.bid_index; slot.buyer = source.buyer; slot.buyer_manager = source.buyer_manager; slot.fee = source.fee; slot.monthly_salary = source.monthly_salary; slot.fee_reference = source.fee_reference; slot.salary_reference = source.salary_reference; slot.contract_months = source.contract_months; slot.loan = source.loan; slot.transaction_supported = source.transaction_supported || (source.loan && !source.loan_permitted); slot.present = source.present; slot.eligible = source.eligible; slot.bonuses = source.bonuses; } return view; }; std::optional season_backdrop; auto present_season = [&](const Image& image, const char* title, const Palette* palette_override = nullptr) { SDL_SetWindowTitle(window, title); season_backdrop = image; const Palette& frame_palette = palette_override ? *palette_override : palette; const Image painted = process_timer_image(image); for (size_t i = 0; i < pixels.size(); ++i) pixels[i] = frame_palette.argb[painted.pixels[i]]; SDL_UpdateTexture(texture, nullptr, pixels.data(), 320 * 4); SDL_RenderClear(renderer); SDL_RenderCopy(renderer, texture, nullptr, nullptr); SDL_RenderPresent(renderer); }; const auto present_desk_record_points = [&] { if(!flow.desk_records_points_active())return; while(flow.advance_desk_records_point()) present_season(flow.render(),"OpenBMH - highscore"); if(flow.finish_desk_records_points()) present_season(flow.render(),"OpenBMH - highscore"); dirty=false; }; auto contract_expiry_presenter = [&](GameState& staged, WatcomRandom& random, int manager, int expired_row) -> int { const GameState before = staged; const WatcomRandom random_before = random; try { uint64_t local_revision = revision; uint64_t next_quote_id = 1; auto initial = ui::contracts_from_game(staged, manager, local_revision); ui::ContractsScreen screen(data, std::move(initial)); bool renewed_expired_player = false; bool dirty_contracts = true; while (running) { if (dirty_contracts) { present_season(screen.render(), "OpenBMH - contracts"); dirty_contracts = false; } if (screen.close_requested()) return renewed_expired_player ? 1 : 0; SDL_Event event; bool changed = false; while (quit_confirmation.poll(&event)) { if (event.type == SDL_QUIT) { running = false; staged = before; random = random_before; return -2; } if (event.type == SDL_MOUSEBUTTONUP && (event.button.button == SDL_BUTTON_LEFT || event.button.button == SDL_BUTTON_RIGHT)) { changed |= screen.click(event.button.x, event.button.y, event.button.button == SDL_BUTTON_RIGHT); } else if (event.type == SDL_MOUSEMOTION) { changed |= screen.move(event.motion.x, event.motion.y); } else if (event.type == SDL_TEXTINPUT) { changed |= screen.text(event.text.text); } else if (event.type == SDL_KEYDOWN) { if (event.key.keysym.sym == SDLK_ESCAPE) changed |= screen.key("ESC"); else if (event.key.keysym.sym == SDLK_BACKSPACE) changed |= screen.key("BACKSPACE"); } if (const ui::ContractRequest* pending = screen.pending()) { const ui::ContractRequest request = *pending; const auto old_game = staged; const auto old_random = random; try { if (request.manager_slot != manager || request.runtime_club != staged.manager_teams.at(size_t(manager)) || request.row < 0 || request.row >= 24) throw FormatError("Vertragsaktion gehört nicht zum aktuellen Verein"); if (request.kind == ui::ContractActionKind::request_demands) { auto demands = contract_demands(staged, manager, request.row, false, random); auto next = ui::contracts_from_game(staged, manager, ++local_revision); next.demands = demands; next.quote_id = next_quote_id++; next.quote_row = request.row; screen.acknowledge_quote(next); } else if (request.kind == ui::ContractActionKind::submit_offer) { if (request.term_column >= 4 || request.quote_id != screen.state().quote_id || request.row != screen.state().quote_row || !screen.state().demands || request.demand != (*screen.state().demands)[request.term_column] || request.monthly_salary > 200000) throw FormatError("Vertragsangebot ist nicht mehr aktuell"); const bool accepted = contract_offer(staged, manager, request.row, request.term_column, request.monthly_salary, request.demand, false, request.row == expired_row, random, &request.proposed_bonuses); auto next = ui::contracts_from_game(staged, manager, ++local_revision); next.feedback = accepted ? "Der Vertrag wurde verlängert." : "Das Angebot wurde abgelehnt."; screen.acknowledge_offer(next); if (accepted && request.row == expired_row) renewed_expired_player = true; } else if (request.kind == ui::ContractActionKind::submit_bonuses) { const bool accepted = contract_bonuses(staged, manager, request.row, request.proposed_bonuses); auto next = ui::contracts_from_game(staged, manager, ++local_revision); next.feedback = accepted ? "Die Prämien wurden übernommen." : "Die Prämien wurden nicht geändert."; screen.acknowledge_bonus_offer(next); } else if (request.kind == ui::ContractActionKind::insure_player) { const auto insured = contract_insurance(staged, manager, request.row, request.term_column, request.insurance_months); if (!insured.accepted) { screen.reject("Die Versicherung konnte nicht übernommen werden."); } else { auto next = ui::contracts_from_game(staged, manager, ++local_revision); next.demands = screen.state().demands; next.quote_id = screen.state().quote_id; next.quote_row = screen.state().quote_row; screen.acknowledge_insurance(next); } } else { throw FormatError("Unbekannte Vertragsaktion"); } changed = true; } catch (...) { staged = old_game; random = old_random; throw; } } if (screen.close_requested()) return renewed_expired_player ? 1 : 0; if (renewed_expired_player && !screen.result_page_open()) return 1; dirty_contracts |= changed; } if (playback.needs_pump()) playback.pump(audio_error); SDL_Delay(10); } staged = before; random = random_before; return -2; } catch (const std::exception&) { staged = before; random = random_before; return -2; } }; auto game_end_options = [&](const GameState& state) { return ui::GameEndRenderOptions{ state.memory.has(::bmh::layout::PlainBackground) && state.memory.u8(::bmh::layout::PlainBackground) != 0, (!state.memory.has(::bmh::layout::TextGradientDisabled) || state.memory.u8(::bmh::layout::TextGradientDisabled) == 0) && season_exe.u8(::bmh::layout::TextGradientMode) == 2}; }; auto wait_season_ack = [&] { // Source SDLFlushEvents2/SDLFlushEvents flush pending mouse events, then wait for // a new left/right press. Physical keyboard ESC is not event8. SDL_FlushEvents(SDL_MOUSEMOTION, SDL_MOUSEBUTTONUP); while (running) { SDL_Event event; while (quit_confirmation.poll(&event)) { if (event.type == SDL_QUIT) { running = false; return; } if (event.type == SDL_MOUSEBUTTONDOWN && (event.button.button == SDL_BUTTON_LEFT || event.button.button == SDL_BUTTON_RIGHT)) return; } SDL_Delay(10); } }; auto wait_sportschau_ack = [&] { // Source SDLFlushEvents2 flushes pending mouse input, then accepts fresh // left/right input. Keyboard Escape is not an Original ACK here. SDL_FlushEvents(SDL_MOUSEMOTION, SDL_MOUSEBUTTONUP); while (running) { SDL_Event event; while (quit_confirmation.poll(&event)) { if (event.type == SDL_QUIT) { running = false; return; } if (event.type == SDL_MOUSEBUTTONDOWN && (event.button.button == SDL_BUTTON_LEFT || event.button.button == SDL_BUTTON_RIGHT)) return; } SDL_Delay(10); } }; auto source_tick_wait = [&](unsigned ticks) { for (unsigned i = 0; running && i < ticks; ++i) { SDL_Delay(20); // Source timer unit used by the traced intro path. SDL_PumpEvents(); SDL_Event close; while (quit_confirmation.peep(&close, 1, SDL_GETEVENT, SDL_QUIT, SDL_QUIT) > 0) running = false; // platform close is the only intro-loop escape } }; auto wait_source_retraces = [&](unsigned count) { // Keep the VGA cadence on 60/120/144-Hz host displays alike. constexpr auto refresh_hz = ui::kOriginalRefreshHz; const Uint64 frequency = SDL_GetPerformanceFrequency(); const Uint64 ticks_per_wait = (frequency + Uint64(refresh_hz) - 1) / Uint64(refresh_hz); for (unsigned i = 0; running && i < count; ++i) { const Uint64 started = SDL_GetPerformanceCounter(); while (running && SDL_GetPerformanceCounter() - started < ticks_per_wait) { SDL_PumpEvents(); SDL_Event close; while (quit_confirmation.peep(&close, 1, SDL_GETEVENT, SDL_QUIT, SDL_QUIT) > 0) running = false; // platform close is the only animation-loop escape if (running) SDL_Delay(1); } } }; SportschauPresentationHooks sportschau_presenter; sportschau_presenter.intro = [&](const GameState&, const SportschauIntroView&) { if (!running) return; // PaletteOverride installs KB132's embedded palette; SportschauIntro restores the // normal palette on return. Keep the override local to intro frames. const auto& intro_palette = sportschau_intro.palette_override(); const Palette* intro_colors = intro_palette ? &*intro_palette : nullptr; for (uint32_t frame = 0; running && frame < ui::SportschauIntro::frame_count; ++frame) { if (frame != 0) wait_source_retraces(5); if (!running) return; present_season(sportschau_intro.render_frame(frame), "OpenBMH - sportschau_intro", intro_colors); if (frame == 0) { source_tick_wait(70); app::original_audio_command(playback, 2); // SportschauIntro, Original S/2002 fanfare. source_tick_wait(45); } } if (!running) return; source_tick_wait(100); app::original_audio_command(playback, 1); if (!running) return; present_season(sportschau_intro.render_frame(ui::SportschauIntro::frame_count - 1), "OpenBMH - sportschau_intro_ack", intro_colors); wait_sportschau_ack(); }; const auto sportschau_context = [&](const GameState& state) { ui::SportschauReportContext context; context.solid_panel_background = state.memory.has(::bmh::layout::SolidPanelBackground) && state.memory.u8(::bmh::layout::SolidPanelBackground) != 0; context.gradient_text = state.memory.has(::bmh::layout::TextGradientDisabled) && state.memory.u8(::bmh::layout::TextGradientDisabled) == 0 && season_exe.u8(::bmh::layout::TextGradientMode) == 2; return context; }; sportschau_presenter.kickoff = [&](const GameState&, const MatchdayIntroView& view) { if (!running) return; present_season(matchday_intro.render(view), "OpenBMH - matchday_intro", matchday_intro.palette_override() ? &*matchday_intro.palette_override() : nullptr); // SDLGetTicks reads BIOS ticks at BDA46c (PIT1193182 /65536 Hz), // unlike the separate 20ms units of DecodeTaxAnimationScript2. Source waits36 ticks. constexpr Uint32 duration = (36ull * 65536 * 1000 + 1193181) / 1193182; const Uint32 start = SDL_GetTicks(); SDL_FlushEvents(SDL_MOUSEBUTTONDOWN, SDL_MOUSEBUTTONUP); bool skipped = false; while (running && !skipped && SDL_GetTicks() - start < duration) { SDL_Event input; while (quit_confirmation.poll(&input)) { if (input.type == SDL_QUIT) running = false; if (input.type == SDL_MOUSEBUTTONDOWN && input.button.button == SDL_BUTTON_LEFT) skipped = true; } if (running && !skipped) SDL_Delay(1); } SDL_FlushEvents(SDL_MOUSEBUTTONDOWN, SDL_MOUSEBUTTONUP); }; std::optional sportschau_replay_screen; size_t sportschau_step_index = 0; sportschau_presenter.replay.step = [&](const GameState& state, const SportschauFixtureView& fixture, const SportschauReportStep& step) { if (!running) return true; if (step.visible_log_entries == 0 && step.progress_minute == 0) { app::original_match_audio_command(playback, state, 3); sportschau_replay_screen.emplace(data, fixture, sportschau_context(state)); sportschau_step_index = 0; } if (!sportschau_replay_screen) throw FormatError("sportschau: missing report owner"); bool skip = false; SDL_Event input; if (step.minute_wait) { while (quit_confirmation.poll(&input)) { if (input.type == SDL_QUIT) running = false; if (input.type == SDL_MOUSEBUTTONDOWN && input.button.button == SDL_BUTTON_LEFT) skip = true; } } else { SDL_PumpEvents(); while (quit_confirmation.peep(&input, 1, SDL_GETEVENT, SDL_QUIT, SDL_QUIT) > 0) running = false; } if (!running) return true; const std::string title = "OpenBMH - sportschau_replay_" + std::to_string(fixture.group) + "_" + std::to_string(fixture.fixture) + "_" + std::to_string(sportschau_step_index++); present_season(sportschau_replay_screen->render_report(step), title.c_str()); const int raw = state.memory.has(::bmh::layout::Main_FormatError_RuntimeField4) ? state.memory.u8(::bmh::layout::Main_FormatError_RuntimeField4) : 0; if (step.minute_wait) source_tick_wait(unsigned(raw < 6 ? raw / 2 : raw)); if (step.chance_wait) source_tick_wait(50); return skip; }; sportschau_presenter.replay.scene = [&](const GameState& state, const SportschauFixtureView& fixture, const SportschauSceneView& scene) { if (!running) return; ui::LiveMatchdayFrame frame; frame.gradient_text = sportschau_context(state).gradient_text; LiveChanceEvent event; event.group = 0; event.match = scene.shot.match; event.side = scene.shot.acting_side; event.minute = scene.shot.minute; const auto header = ui::live_chance_projection(event, scene.groups, state, season_exe); const auto backdrop = live_screen.render_sportschau_header(header, scene.home_goals_before, scene.away_goals_before, frame.gradient_text); const auto colors = live_screen.shot_palette(palette, scene.shot, scene.groups, state); const std::string id = std::to_string(fixture.group) + "_" + std::to_string(fixture.fixture) + "_" + std::to_string(scene.report_step.visible_log_entries); const auto delay = [&](int row) { const uint32_t address = ::bmh::layout::Main_FormatError_ExecutableFieldUnsigned + uint32_t(row * 9); const int raw = state.memory.has(address) ? state.memory.u8(address) : 0; source_tick_wait(unsigned(raw < 6 ? raw / 2 : raw)); }; present_season(backdrop, ("OpenBMH - sportschau_scene_header_" + id).c_str(), &colors); delay(12); // AdvanceStep(12), header preview in ShotAnimation if (scene.set_piece) { const auto frames = live_screen.render_set_piece(frame, *scene.set_piece, &backdrop); for (size_t i = 0; running && i < frames.size(); ++i) { present_season(frames[i], ("OpenBMH - sportschau_set_piece_" + id + "_" + std::to_string(i)).c_str(), &colors); const unsigned retraces = i == 0 ? 40u : (state.memory.has(::bmh::layout::Main_FormatError_RuntimeField2) ? state.memory.u8(::bmh::layout::Main_FormatError_RuntimeField2) : 0u); wait_source_retraces(retraces); // FirstThen: first40, then F8 } } const auto frames = live_screen.render_shot(frame, scene.shot, &backdrop); for (size_t i = 0; running && i < frames.size(); ++i) { present_season(frames[i], ("OpenBMH - sportschau_shot_" + id + "_" + std::to_string(i)).c_str(), &colors); const int speed = state.memory.has(::bmh::layout::Main_FormatError_RuntimeField) ? int(int8_t(state.memory.u8(::bmh::layout::Main_FormatError_RuntimeField))) : 0; wait_source_retraces(unsigned(std::max(0, speed))); } source_tick_wait(10); // LiveMatchdayFrame's final ten ticks if (!running) return; if (app::match_sound_enabled(state)) app::original_audio_command(playback, scene.shot.miss ? 20 : 19); // SetPieceAnimation. if (state.memory.has(::bmh::layout::Main_FormatError_RuntimeField5) && state.memory.u8(::bmh::layout::Main_FormatError_RuntimeField5) == 0) { present_season(frames.back(), ("OpenBMH - sportschau_shot_ack_" + id).c_str(), &colors); wait_sportschau_ack(); } else delay(15); if (!running) return; auto restored = scene.report_step; restored.chance_wait = false; present_season(sportschau_replay_screen->render_report(restored), ("OpenBMH - sportschau_scene_restored_" + id).c_str()); }; sportschau_presenter.fixture = [&](const GameState& state, const SportschauFixtureView& fixture) { if (!running) return; ui::SportschauMatchReport screen(data, fixture, sportschau_context(state)); present_season(screen.render_report(fixture.log_events.size()), "OpenBMH - sportschau_report"); wait_sportschau_ack(); sportschau_replay_screen.reset(); }; sportschau_presenter.winner = [&](const GameState& state, const CompetitionWinnerView& view) { if (!running) return; const auto& colors = competition_winner.palette_override(view.title); present_season(competition_winner.render(state, view), ("OpenBMH - competition_winner_" + std::to_string(view.title) + "_" + std::to_string(view.team)).c_str(), colors ? &*colors : nullptr); wait_sportschau_ack(); // SDLFlushEvents2 waits for a mouse press; ESC is ignored. }; sportschau_presenter.awards = [&](const GameState& state, const SportschauAwardsView& view) { if (!running) return; present_season(sportschau_eleven.render(view, sportschau_context(state).gradient_text), ("OpenBMH - sportschau_eleven_" + std::to_string(view.group)).c_str()); wait_sportschau_ack(); }; sportschau_presenter.team_info = [&](const GameState& state, const SportschauTeamInfoView& view) { if (!running) return; present_season(sportschau_team_info.render(view, sportschau_context(state).gradient_text), ("OpenBMH - sportschau_teaminfo_" + std::to_string(view.group)).c_str()); wait_sportschau_ack(); }; auto show_tax = [&](const GameState& state, const SeasonTaxEvent& event) -> bool { if (!running) return false; const size_t base = size_t(event.manager_slot) * 0xb0c; ui::TaxDialogProjection view; view.kind = event.kind == SeasonTaxEventKind::question ? ui::TaxDialogKind::question : ui::TaxDialogKind::acknowledgement; view.compact_dialog_frame = state.memory.has(::bmh::layout::CompactDialogFrame) && state.memory.u8(::bmh::layout::CompactDialogFrame) != 0; for (size_t i = 0; i < 30 && state.manager_records[base + 0xa8 + i]; ++i) view.manager_name += char(state.manager_records[base + 0xa8 + i]); view.body = event.text; view.portrait = state.manager_records[base + 0x221]; view.badge_fallback = original_badge_fallback(event.team); view.badge_sprite = view.badge_fallback ? 0 : le16(state.club_heap_78, size_t(event.team) * 2) & 0x1ff; ui::GameEndTaxDialog screen(data, std::move(view), game_end_options(state), event.kind == SeasonTaxEventKind::outcome ? season_backdrop : std::optional{}); auto complete = [&](bool answer) { present_season(screen.backdrop(), "OpenBMH - season_tax_restored"); return answer; }; present_season(screen.render(), event.kind == SeasonTaxEventKind::question ? "OpenBMH - season_tax_question" : event.kind == SeasonTaxEventKind::notice ? "OpenBMH - season_tax_notice" : "OpenBMH - season_tax_outcome"); auto pressed = ui::GameEndTaxDialog::Button::none; while (running) { SDL_Event input; while (quit_confirmation.poll(&input)) { if (input.type == SDL_QUIT) { running = false; return false; } if (input.type == SDL_MOUSEBUTTONDOWN) { if (event.kind != SeasonTaxEventKind::question && input.button.button == SDL_BUTTON_RIGHT) return complete(false); if (input.button.button != SDL_BUTTON_LEFT) continue; pressed = screen.hit_test(input.button.x, input.button.y); if (event.kind != SeasonTaxEventKind::question && pressed == ui::GameEndTaxDialog::Button::none) return complete(false); } else if (input.type == SDL_MOUSEMOTION && screen.hit_test(input.motion.x, input.motion.y) != pressed) { pressed = ui::GameEndTaxDialog::Button::none; } else if (input.type == SDL_MOUSEBUTTONUP && input.button.button == SDL_BUTTON_LEFT) { const auto button = screen.hit_test(input.button.x, input.button.y); if (pressed != ui::GameEndTaxDialog::Button::none && button == pressed) { if (button == ui::GameEndTaxDialog::Button::yes) return complete(true); return complete(false); } pressed = ui::GameEndTaxDialog::Button::none; } } SDL_Delay(10); } return false; }; SeasonTaxHooks tax_presenter; tax_presenter.choose = show_tax; tax_presenter.observe = [&](const GameState& state, const SeasonTaxEvent& event) { if (event.kind == SeasonTaxEventKind::notice || event.kind == SeasonTaxEventKind::outcome) (void)show_tax(state, event); if (running && event.kind == SeasonTaxEventKind::animation) { ui::GameEndTaxAnimationScreen animation(ui::load_game_end_tax_animation_assets(data), unsigned(event.animation_variant), season_backdrop ? *season_backdrop : flow.render(), state.memory.has(::bmh::layout::SolidPanelBackground) && state.memory.u8(::bmh::layout::SolidPanelBackground) != 0); while (running && animation.advance_step()) { present_season(animation.render(), "OpenBMH - season_tax_animation"); const auto started = SDL_GetTicks(); while (running && Uint32(SDL_GetTicks() - started) < animation.wait_milliseconds()) { SDL_Event input; while (quit_confirmation.poll(&input)) if (input.type == SDL_QUIT) running = false; // Source param4=0: clicks/keys cannot change this script or RNG. SDL_Delay(10); } } // Source marker150 flips buffers without copying the visible frame. // Outcome ACK must start on the older drawing frame in this case. season_backdrop = animation.drawing_frame(); } }; auto wait_promotion_time = [&](Uint32 milliseconds) { const auto start = SDL_GetTicks(); while (running && Uint32(SDL_GetTicks() - start) < milliseconds) { // SeasonPromotionScreen does not read gameplay input. Keep queued mouse/keyboard // events for the next Original input boundary; only handle SDL exit. SDL_PumpEvents(); SDL_Event quit; if (quit_confirmation.peep(&quit, 1, SDL_GETEVENT, SDL_QUIT, SDL_QUIT) > 0) running = false; if (running) SDL_Delay(10); } }; SeasonPromotionHook promotion_presenter = [&](const GameState& state, const SeasonPromotionEvent& event) { if (!running) return; auto view = ui::season_promotion_from_game(state, event, season_exe, season_texts); ui::SeasonPromotionScreen screen(data, std::move(view)); const auto show_step = [&](int step) { const auto title = "OpenBMH - season_promotion_" + std::to_string(event.group) + "_" + std::to_string(step); present_season(screen.render(step), title.c_str()); }; show_step(0); // Original checks the manager's stored animation-skip flag once, // after presenting the starting table, before both 50-tick waits. if (state.memory.has(::bmh::layout::BalancePlan_BalanceFromGame_RuntimeField) && state.memory.u8(::bmh::layout::BalancePlan_BalanceFromGame_RuntimeField) != 0) return; wait_promotion_time(50 * 20); for (int step = 1; running && step <= 38; ++step) show_step(step); if (running) wait_promotion_time(50 * 20); }; auto present_pending_dialog = [&](const GameState& state, ui::TaxDialogProjection view, const Image& backdrop, const char* title, std::optional effective_options = {}) -> PendingOfferAnswer { if (!running) return PendingOfferAnswer::unsupported; const bool question = view.kind == ui::TaxDialogKind::question; if (question) press.reset(); // PresentManagerDialog owns the caller's input now. ui::GameEndTaxDialog screen(data, std::move(view), effective_options ? *effective_options : game_end_options(state), backdrop); const bool timed = screen.source_timed_notice(); if (!question) app::original_audio_command(playback, timed ? 13 : 14); // PresentManagerDialog / SystemIdentity. const Uint32 started = SDL_GetTicks(); auto pressed = ui::GameEndTaxDialog::Button::none; const auto show = [&] { std::string name = title; if (pressed == ui::GameEndTaxDialog::Button::yes) name += "_pressed_yes"; else if (pressed == ui::GameEndTaxDialog::Button::no) name += "_pressed_no"; else if (pressed == ui::GameEndTaxDialog::Button::acknowledge) name += "_pressed_ack"; present_season(screen.render(pressed), name.c_str()); }; const auto complete = [&](PendingOfferAnswer answer) { present_season(screen.backdrop(), "OpenBMH - pending_offer_dialog_restored"); return answer; }; show(); if (!state.memory.has(::bmh::layout::Main_Screen_RuntimeField2) || state.memory.u8(::bmh::layout::Main_Screen_RuntimeField2) == 0) SDL_FlushEvents(SDL_MOUSEMOTION, SDL_MOUSEBUTTONUP); while (running) { // PresentManagerDialog polls2de66 after its initial Present.ExpireQuestion keeps // a held left control until its UP/leave while the clock runs. if (question && poll_process_timer(true,true) && pressed == ui::GameEndTaxDialog::Button::none) return complete(PendingOfferAnswer::no); if (timed && Uint32(SDL_GetTicks() - started) >= 70 * 3 * 20) return complete(PendingOfferAnswer::yes); SDL_Event input; while (quit_confirmation.poll(&input)) { if (input.type == SDL_QUIT) { running = false; return PendingOfferAnswer::unsupported; } const bool question_deadline = question && poll_process_timer(true,true); if (question_deadline && pressed == ui::GameEndTaxDialog::Button::none) return complete(PendingOfferAnswer::no); if (input.type == SDL_MOUSEBUTTONDOWN) { if (timed && (input.button.button == SDL_BUTTON_LEFT || input.button.button == SDL_BUTTON_RIGHT)) return complete(PendingOfferAnswer::yes); // ExpireQuestion consumes the paired left release. Right/ESC // do not choose a question answer or interrupt that hold. if (!question && pressed == ui::GameEndTaxDialog::Button::none && input.button.button == SDL_BUTTON_RIGHT) return complete(PendingOfferAnswer::yes); if (input.button.button != SDL_BUTTON_LEFT) continue; pressed = screen.hit_test(input.button.x, input.button.y); if (!question && pressed == ui::GameEndTaxDialog::Button::none) return complete(PendingOfferAnswer::yes); show(); } else if (input.type == SDL_MOUSEMOTION && pressed != ui::GameEndTaxDialog::Button::none && screen.hit_test(input.motion.x, input.motion.y) != pressed) { if (!question) return complete(PendingOfferAnswer::yes); pressed = ui::GameEndTaxDialog::Button::none; show(); } else if (input.type == SDL_MOUSEBUTTONUP && input.button.button == SDL_BUTTON_LEFT) { //PresentManagerDialog forces button1/No after4885b returns when the //signed Source deadline is negative, even after Yes UP. if (question_deadline) return complete(PendingOfferAnswer::no); const auto released = screen.hit_test(input.button.x, input.button.y); if (pressed != ui::GameEndTaxDialog::Button::none && released == pressed) return complete(pressed == ui::GameEndTaxDialog::Button::no ? PendingOfferAnswer::no : PendingOfferAnswer::yes); if (!question && pressed != ui::GameEndTaxDialog::Button::none) return complete(PendingOfferAnswer::yes); pressed = ui::GameEndTaxDialog::Button::none; show(); } } SDL_Delay(10); } return PendingOfferAnswer::unsupported; }; auto loan_return_presenter = [&](GameState& state, WatcomRandom&, int manager, const std::string& question) -> int { if (!running) return -1; const Image backdrop = season_backdrop ? *season_backdrop : flow.render(); const auto answer = present_pending_dialog(state, ui::loan_return_question_dialog(state, manager, question), backdrop, "OpenBMH - loan_return_question"); if (answer == PendingOfferAnswer::yes) return 1; if (answer == PendingOfferAnswer::no) return 0; return -1; }; auto make_pending_offer_hooks = [&](Image backdrop) { auto pending_backdrop = std::make_shared(std::move(backdrop)); PendingOfferHooks hooks; hooks.answer = [&, pending_backdrop](const GameState& staged, const PendingOfferQuestion& question) { return present_pending_dialog(staged, ui::pending_offer_question_dialog(staged, question), *pending_backdrop, question.kind == PendingOfferQuestionKind::salary_demand ? "OpenBMH - pending_offer_salary_question" : "OpenBMH - pending_offer_severance_question"); }; hooks.select_transfer = [&, pending_backdrop](const GameState& staged, const TransferOfferListView& offers) { ui::IncomingTransferScreen screen(data, ui::pending_offer_transfer_decision_from_game(staged, offers), staged.memory.u8(::bmh::layout::TextGradientDisabled) == 0); *pending_backdrop = screen.render(); present_season(*pending_backdrop, "OpenBMH - pending_offer_transfer"); SDL_FlushEvents(SDL_MOUSEMOTION, SDL_MOUSEBUTTONUP); // DecodeTaxAnimationScript/SDLFlushEvents redraw boundary while (running) { SDL_Event input; while (quit_confirmation.poll(&input)) { if (input.type == SDL_QUIT) { running = false; return PendingOfferTransferChoice{}; } std::optional bid; if (input.type == SDL_MOUSEBUTTONDOWN && (input.button.button == SDL_BUTTON_LEFT || input.button.button == SDL_BUTTON_RIGHT)) bid = screen.click(input.button.x, input.button.y, input.button.button == SDL_BUTTON_RIGHT); // IncomingTransferScreen reads event2/8 directly: release and // physical ESC never select or decline this row. if (bid) return PendingOfferTransferChoice{ *bid < 0 ? PendingOfferTransferChoiceKind::decline : PendingOfferTransferChoiceKind::bid, *bid}; } SDL_Delay(10); } return PendingOfferTransferChoice{}; }; hooks.notice = [&, pending_backdrop](const GameState& staged, const PendingOfferNotice& notice) { if (present_pending_dialog(staged, ui::pending_offer_notice_dialog(staged, notice), *pending_backdrop, "OpenBMH - pending_offer_notice") == PendingOfferAnswer::unsupported) throw std::runtime_error("pending offer presenter stopped"); }; hooks.program_error = [&, pending_backdrop](const GameState& staged, uint16_t code) { ui::ProgramErrorScreen screen(data,code,game_end_options(staged)); press.reset(); SDL_FlushEvents(SDL_MOUSEMOTION,SDL_MOUSEBUTTONUP); present_season(screen.render(),"OpenBMH - program_error"); bool acknowledged=false; while(running && !acknowledged) { SDL_Event event; while(quit_confirmation.poll(&event)) { if(event.type==SDL_QUIT){running=false;break;} if(event.type==SDL_MOUSEBUTTONDOWN && (event.button.button==SDL_BUTTON_LEFT || event.button.button==SDL_BUTTON_RIGHT)) { acknowledged=true;break; } } if(!acknowledged && running)SDL_Delay(10); } if(!running)throw std::runtime_error("program-error acknowledgement interrupted"); present_season(*pending_backdrop,"OpenBMH - pending_offer_dialog_restored"); }; return hooks; }; auto make_market_sale_hooks = [&](Image backdrop) { auto market_backdrop = std::make_shared(std::move(backdrop)); HumanBuyerSaleHooks hooks; hooks.notice = [&, market_backdrop](const GameState& staged, const HumanBuyerSaleNotice& notice) { const PendingOfferNotice projection_notice{notice.manager, notice.raw_offer_slot, notice.source_text_address, notice.original_message}; if (present_pending_dialog(staged, ui::pending_offer_notice_dialog(staged, projection_notice), *market_backdrop, "OpenBMH - transfer_market_notice") == PendingOfferAnswer::unsupported) throw std::runtime_error("transfer market presenter stopped"); }; return hooks; }; std::function present_club_information; std::function(app::ClubModalServices&,const ClubPlayerDetailSelection&,const Image&)> present_player_detail; auto loan_return_offer_presenter = [&](GameState& staged, GameRandom& game_random, WatcomRandom& watcom_random, app::ClubModalServices& services, int manager, int source_slot, int list_entry, const HumanBuyerSaleHooks& sale_hooks) -> int { if (!running || manager < 0 || manager >= 4 || list_entry < 40 || list_entry >= 44 || source_slot != 2928 + list_entry || !staged.memory.has(::bmh::layout::EditorList + uint32_t(list_entry) * 0x58 + 0x57)) return -1; const uint32_t row = ::bmh::layout::EditorList + uint32_t(list_entry) * 0x58; const int player = staged.squad_slots.at(size_t(source_slot)) & 0x0fff; const uint16_t seller_word = staged.memory.u16(row + 8); int bid_slot = -1; for (int i = 0; i < 4; ++i) { const uint16_t word = staged.memory.u16(row + uint32_t(i) * 2); if (word == 0xffff || word == staged.manager_teams.at(size_t(manager))) { bid_slot = i; break; } } TransferOfferEditorRequest input; input.manager = manager; input.runtime_club = staged.manager_teams.at(size_t(manager)); input.list_entry = list_entry; input.source_slot = source_slot; input.expected_player = player; input.expected_seller_word = seller_word; input.expected_bid_slot = bid_slot; input.loan = false; input.loan_return_entry = true; auto owner = open_transfer_offer_editor_source(staged, input, game_random, watcom_random); if (!owner.supported || owner.closed) return -1; ui::OutgoingTransferScreen screen(data, app::loan_return_offer_editor_projection( staged, owner, revision, (!staged.memory.has(::bmh::layout::TextGradientDisabled) || staged.memory.u8(::bmh::layout::TextGradientDisabled) == 0) && season_exe.u8(::bmh::layout::TextGradientMode) == 2)); const Image backdrop = flow.render(); const auto draw = [&] { present_season(screen.render(), "OpenBMH - loan_return_offer"); }; SDL_FlushEvents(SDL_MOUSEMOTION, SDL_MOUSEBUTTONUP); draw(); while (running) { SDL_Event event; while (quit_confirmation.poll(&event)) { if (event.type == SDL_QUIT) { running = false; return -1; } ui::OutgoingTransferRequest action; if (event.type == SDL_MOUSEMOTION) continue; if (event.type == SDL_MOUSEBUTTONDOWN) { action = screen.click(event.button.x, event.button.y, event.button.button == SDL_BUTTON_RIGHT, event.button.clicks > 1); } else if (event.type == SDL_KEYDOWN) { const char* name = SDL_GetKeyName(event.key.keysym.sym); std::string key = name ? name : ""; std::transform(key.begin(), key.end(), key.begin(), [](unsigned char c) { return char(std::toupper(c)); }); action = screen.key(key); } else if (event.type == SDL_TEXTINPUT) { (void)screen.text(event.text.text); } if (action.kind == ui::OutgoingTransferRequestKind::none) { draw(); continue; } if (action.kind == ui::OutgoingTransferRequestKind::cancel) { (void)cancel_transfer_offer_editor_source(staged, owner); return 0; } if (action.kind == ui::OutgoingTransferRequestKind::edit_field || action.kind == ui::OutgoingTransferRequestKind::quote_change) { owner = app::edit_transfer_offer_from_ui(staged, owner, action, game_random, watcom_random); if (!owner.supported) return -1; screen.acknowledge(app::loan_return_offer_editor_projection(staged, owner, revision, (!staged.memory.has(::bmh::layout::TextGradientDisabled) || staged.memory.u8(::bmh::layout::TextGradientDisabled) == 0) && season_exe.u8(::bmh::layout::TextGradientMode) == 2)); draw(); continue; } if (action.kind == ui::OutgoingTransferRequestKind::team_info) { const auto validated = cancel_transfer_offer_editor_source(staged, owner); if (!validated.supported || !present_club_information || !present_club_information(services, int(seller_word & 0x7fff))) return -1; owner = resume_transfer_offer_team_info_source(staged, owner, watcom_random); if (!owner.supported) return -1; screen.acknowledge(app::loan_return_offer_editor_projection(staged, owner, revision, (!staged.memory.has(::bmh::layout::TextGradientDisabled) || staged.memory.u8(::bmh::layout::TextGradientDisabled) == 0) && season_exe.u8(::bmh::layout::TextGradientMode) == 2)); draw(); continue; } if (action.kind == ui::OutgoingTransferRequestKind::player_info) { if (!present_player_detail) return -1; const auto selection = transfer_offer_player_info_selection_source(staged, owner); services.set_runtime_byte(::bmh::layout::CareerSession_DispatchPoachUi_ExecutableField, 1); if (!present_player_detail(services, selection, screen.render()).has_value()) return -1; owner = resume_transfer_offer_player_info_source(staged, owner, services.runtime_byte(::bmh::layout::CareerSession_DispatchTransferOffer_ExecutableField), services.runtime_byte(::bmh::layout::CareerSession_DispatchTransferOffer_ExecutableField2), watcom_random); if (!owner.supported) return -1; screen.acknowledge(app::loan_return_offer_editor_projection(staged, owner, revision, (!staged.memory.has(::bmh::layout::TextGradientDisabled) || staged.memory.u8(::bmh::layout::TextGradientDisabled) == 0) && season_exe.u8(::bmh::layout::TextGradientMode) == 2)); draw(); continue; } if (action.kind == ui::OutgoingTransferRequestKind::submit) { MinuteReport report; auto submitted = submit_transfer_offer_editor_source(staged, owner, watcom_random, sale_hooks, report); if (report.unsupported || submitted.action.status == TransferActionStatus::unsupported) return -1; if (submitted.editor.closed || submitted.action.status == TransferActionStatus::pending || submitted.action.status == TransferActionStatus::rejected || submitted.action.status == TransferActionStatus::insufficient_funds) return 1; owner = std::move(submitted.editor); screen.acknowledge(app::loan_return_offer_editor_projection(staged, owner, revision, (!staged.memory.has(::bmh::layout::TextGradientDisabled) || staged.memory.u8(::bmh::layout::TextGradientDisabled) == 0) && season_exe.u8(::bmh::layout::TextGradientMode) == 2)); draw(); } } if (playback.needs_pump()) playback.pump(audio_error); SDL_Delay(10); } (void)backdrop; return -1; }; // Assigned to the genuine Source submodal presenters below before the // controller advances a new career or annual transition. std::function present_club_player; std::function present_club_statistics; bool poach_selection_active=false; std::optional poach_card_selection; present_club_information = [&](app::ClubModalServices& services, int team) -> bool { if (!running) return false; //ClubInfoFromGame owns the opening DOWN and consumes its paired UP inside // this synchronous loop. The parent must not retain a held press // after that UP has already been consumed by the child. press.reset(); ui::ClubInfoView selected_view = ui::ClubInfoView::data_a; std::unique_ptr club_screen; const auto redraw = [&] { std::string error; ClubInfoEntry snapshot; if (team == kNoTeam || team < season_exe.u16(::bmh::layout::CareerSession_DispatchLineup_RuntimeField)) { snapshot = services.enter_club(team); } auto projection = ui::club_info_from_game(services.state(), team, snapshot, season_exe, season_texts); projection.view = selected_view; club_screen = std::make_unique(data, std::move(projection)); }; const auto show = [&] { auto title = "OpenBMH - cup_club_info_" + std::to_string(team) + "_" + std::to_string(int(selected_view)) + "_category_" + std::to_string(club_screen->projection().category); if (club_screen->pressed_button()) title += "_pressed_" + std::to_string(int(*club_screen->pressed_button())); else if (club_screen->hovered_row()) title += "_hover_" + std::to_string(*club_screen->hovered_row()); present_season(club_screen->render(), title.c_str()); }; redraw(); show(); SDL_FlushEvents(SDL_MOUSEMOTION, SDL_MOUSEBUTTONUP); const auto deadline_expired = [&] { return !club_screen->pressed_button() && poll_process_timer(true, true); }; while (running) { if (deadline_expired()) return true; //ClubInfoFromGame event8 returns to its owning caller. SDL_Event input; while (quit_confirmation.poll(&input)) { if (input.type == SDL_QUIT) { running = false; return false; } if (deadline_expired()) return true; ui::ClubInfoRequest request; if (input.type == SDL_MOUSEMOTION) { if (club_screen->move(input.motion.x, input.motion.y)) show(); } else if (input.type == SDL_MOUSEBUTTONDOWN) { if (input.button.button == SDL_BUTTON_RIGHT) return true; if (input.button.button != SDL_BUTTON_LEFT) continue; (void)club_screen->move(input.button.x, input.button.y); request = club_screen->pointer_down(input.button.x, input.button.y); if (request.kind == ui::ClubInfoRequestKind::none) { club_screen->press(input.button.x, input.button.y); show(); } } else if (input.type == SDL_MOUSEBUTTONUP && input.button.button == SDL_BUTTON_LEFT) { request = club_screen->release(input.button.x, input.button.y); show(); } switch (request.kind) { case ui::ClubInfoRequestKind::none: break; case ui::ClubInfoRequestKind::close: return true; case ui::ClubInfoRequestKind::toggle_view: selected_view = selected_view == ui::ClubInfoView::data_a ? ui::ClubInfoView::data_b : ui::ClubInfoView::data_a; redraw(); show(); break; case ui::ClubInfoRequestKind::change_category: { std::string error; const auto applied = services.change_category(team, request.requested_category); // Source changes the icon without re-entering2af41 or // altering the list's owned pre-cleanup drawing flags. auto projection = club_screen->projection(); projection.category = applied; club_screen = std::make_unique(data, std::move(projection)); show(); break; } case ui::ClubInfoRequestKind::open_statistics: if (!present_club_statistics) throw FormatError("club statistics presenter is unavailable"); present_club_statistics(services, team, club_screen->render()); if (!running) return false; redraw(); show(); SDL_FlushEvents(SDL_MOUSEMOTION, SDL_MOUSEBUTTONUP); break; case ui::ClubInfoRequestKind::open_player_detail: if (!present_club_player) throw FormatError("club player presenter is unavailable"); if (present_club_player(services, request, club_screen->render())) return true; if (!running) return false; redraw(); show(); SDL_FlushEvents(SDL_MOUSEMOTION, SDL_MOUSEBUTTONUP); break; } } SDL_Delay(10); } return false; }; present_club_player = [&](app::ClubModalServices& services, const ui::ClubInfoRequest& selected, const Image& parent_image) { if (!running) return false; const ClubPlayerDetailSelection selection{selected.runtime_team, selected.player_id, selected.rendered_row, selected.physical_row, selected.human_loan_index}; const uint8_t prior_mode = services.runtime_byte(::bmh::layout::CareerSession_DispatchPoachUi_ExecutableField); const uint8_t input_mode = club_player_detail_input_mode(prior_mode); struct PlayerInputModeRestore { app::ClubModalServices& services; uint8_t prior; ~PlayerInputModeRestore() { services.set_runtime_byte(::bmh::layout::CareerSession_DispatchPoachUi_ExecutableField, prior); } } mode_restore{services, prior_mode}; services.set_runtime_byte(::bmh::layout::CareerSession_DispatchPoachUi_ExecutableField, input_mode); if(!present_player_detail)throw FormatError("generic player presenter unavailable"); return present_player_detail(services,selection,parent_image).value_or(false); }; present_player_detail = [&](app::ClubModalServices& services,const ClubPlayerDetailSelection& selection,const Image& parent_image) -> std::optional { if(!running)return std::nullopt; press.reset(); //ClubPlayerDetailFromGame now owns physical hold/release through its own Source wait. const uint8_t input_mode=services.runtime_byte(::bmh::layout::CareerSession_DispatchPoachUi_ExecutableField); size_t rebuild_count = 0; const auto rebuild = [&] { std::string error; auto redraw = services.redraw_player(selection); ++rebuild_count; return ui::club_player_detail_from_game(services.state(), std::move(redraw), season_exe); }; ui::ClubPlayerDetailScreen card(data, rebuild(), parent_image); const auto show = [&] { const auto title = "OpenBMH - cup_player_detail_" + std::to_string(selection.runtime_team) + "_" + std::to_string(selection.player_id) + (card.in_statistics() ? "_player_statistics_" : "_card_") + "_statistics_flags_" + std::to_string(card.projection().statistics_flags) + "_rebuild_" + std::to_string(rebuild_count); present_season(card.render(), title.c_str()); }; const auto wait_prior_left_release = [&] { if (input_mode == 0) return; // Source waits only for an already set CareerSession_InitializeClubModalRuntime_ExecutableField (>25 held ticks), // then clears it. A fresh list DOWN is not an already held flag. const bool prior_long_hold = services.runtime_byte(::bmh::layout::CareerSession_InitializeClubModalRuntime_ExecutableField) != 0; if (!prior_long_hold) return; SDL_PumpEvents(); while (running && (SDL_GetMouseState(nullptr, nullptr) & SDL_BUTTON_LMASK)) { SDL_Event input; while (quit_confirmation.poll(&input)) if (input.type == SDL_QUIT) { running = false; return; } SDL_PumpEvents(); if (running) SDL_Delay(10); } services.set_runtime_byte(::bmh::layout::CareerSession_InitializeClubModalRuntime_ExecutableField, 0); // Source consumes the owned hold flag. }; show(); wait_prior_left_release(); std::optional held_left_since; SDL_PumpEvents(); // ClubPlayerDetailFromGame consumes the opening DOWN when bbcde!=0. Only its // selection mode retains that inherited DOWN as a hold candidate. if (input_mode == 0 && (SDL_GetMouseState(nullptr, nullptr) & SDL_BUTTON_LMASK)) held_left_since = ui::pointer_hold_source_ticks(SDL_GetTicks64()); const auto apply_request = [&](ui::ClubPlayerDetailRequest request) -> std::optional { switch (request.kind) { case ui::ClubPlayerDetailRequestKind::none: return std::nullopt; case ui::ClubPlayerDetailRequestKind::close: if(poach_selection_active && input_mode==0 && request.source_return>0) poach_card_selection=request.selection; present_season(parent_image, "OpenBMH - cup_club_player_restored"); return request.close_parent(); case ui::ClubPlayerDetailRequestKind::redraw_card: { // CopyOpaqueSlice saves active-manager preferences only on exit. const int manager = card.projection().redraw.context.active_manager; const uint32_t flags = ::bmh::layout::Flags + uint32_t(manager) * 3 + 2; if (!services.state().memory.has(flags)) throw FormatError("club player statistics: active preference block missing"); services.state().memory.set8(flags, request.statistics_flags); card.replace_redraw(rebuild()); // One actual42dbd rebuild, never per presentation. held_left_since.reset(); show(); wait_prior_left_release(); return std::nullopt; } case ui::ClubPlayerDetailRequestKind::national_action: { present_season(parent_image, "OpenBMH - cup_club_player_restored"); std::string error; (void)services.national_action(request.selection); // Source returnsff even when a full national squad prevents an add. return request.close_parent(); } case ui::ClubPlayerDetailRequestKind::offer_action: { // ClubPlayerDetailFromGame restores its saved parent before3140f; the // question overlays the club list, not the departed card. present_season(parent_image, "OpenBMH - pending_offer_parent_restored"); const auto hooks = make_pending_offer_hooks(parent_image); std::string error; try { (void)services.pending_offers(request.selection, hooks); } catch(const std::exception& e) { if(services.transactional)throw; if(running) {std::fprintf(stderr,"pending offer: %s\n",e.what());show();} return std::nullopt; } present_season(parent_image, "OpenBMH - cup_club_player_restored"); return request.close_parent(); } } return std::nullopt; }; const auto expire_card = [&]() -> std::optional { if (card.source_mouse_wait_release_pending()) return std::nullopt; if (poll_process_timer(true, true) && card.process_timer_expired()) return apply_request(card.take_request()); return std::nullopt; }; while (running) { if (const auto complete = expire_card()) return *complete; SDL_Event input; while (quit_confirmation.poll(&input)) { if (input.type == SDL_QUIT) { running = false; return std::nullopt; } if (const auto complete = expire_card()) return *complete; bool changed = false; if (input.type == SDL_MOUSEMOTION) { changed = card.move(input.motion.x, input.motion.y); if (changed) held_left_since.reset(); // ExpireQuestion move-out cancels its held press. } else if (input.type == SDL_MOUSEBUTTONDOWN) { if (input.button.button == SDL_BUTTON_RIGHT) { held_left_since.reset(); changed = card.press(input.button.x, input.button.y, true); } else if (input.button.button == SDL_BUTTON_LEFT) { // ExpireQuestion waits for the paired release itself; // its button hold does not run42dbd's hold shortcut. held_left_since.reset(); changed = card.press(input.button.x, input.button.y); } } else if (input.type == SDL_MOUSEBUTTONUP && input.button.button == SDL_BUTTON_LEFT) { held_left_since.reset(); changed = card.release(input.button.x, input.button.y); } const auto request = card.take_request(); if (const auto complete = apply_request(request)) return *complete; if (!running) return std::nullopt; if (changed && request.kind == ui::ClubPlayerDetailRequestKind::none) show(); } if (held_left_since) { SDL_PumpEvents(); if (!(SDL_GetMouseState(nullptr, nullptr) & SDL_BUTTON_LMASK)) held_left_since.reset(); else if (card.held_left_ticks(uint32_t(ui::pointer_hold_source_ticks(SDL_GetTicks64()) - *held_left_since))) { if (const auto complete = apply_request(card.take_request())) return *complete; } } SDL_Delay(10); } return std::nullopt; }; present_club_statistics = [&](app::ClubModalServices& services, int team, const Image& parent_frame) { if (!running) return; auto mode = ui::TeamStatisticsMode::combined; std::unique_ptr statistics; const auto rebuild = [&] { auto projection = ui::team_statistics_from_game(services.state(), team, mode, season_exe, season_texts); statistics = std::make_unique(data, std::move(projection), parent_frame); }; const auto show = [&] { auto title = "OpenBMH - cup_team_statistics_" + std::to_string(team) + "_mode_" + std::to_string(int(mode)); if (statistics->pressed_button()) title += "_pressed_" + std::to_string(int(*statistics->pressed_button())); present_season(statistics->render(), title.c_str()); }; rebuild(); show(); SDL_FlushEvents(SDL_MOUSEMOTION, SDL_MOUSEBUTTONUP); const auto deadline_expired = [&] { return !statistics->pressed_button() && poll_process_timer(true, true); }; while (running) { if (deadline_expired()) return; //LeagueCalculations frees its child before4f548 polls again. SDL_Event input; while (quit_confirmation.poll(&input)) { if (input.type == SDL_QUIT) { running = false; return; } if (deadline_expired()) return; if (input.type == SDL_MOUSEBUTTONDOWN && input.button.button == SDL_BUTTON_RIGHT) return; // ExpireQuestion right DOWN: do not wait for release. if (input.type == SDL_MOUSEMOTION) { if (statistics->move(input.motion.x, input.motion.y)) show(); } else if (input.type == SDL_MOUSEBUTTONDOWN && input.button.button == SDL_BUTTON_LEFT) { statistics->press(input.button.x, input.button.y); show(); } else if (input.type == SDL_MOUSEBUTTONUP && input.button.button == SDL_BUTTON_LEFT) { const auto request = statistics->release(input.button.x, input.button.y); if (request.kind == ui::TeamStatisticsRequestKind::close) return; if (request.kind == ui::TeamStatisticsRequestKind::change_mode) { mode = request.mode; rebuild(); // Pure Source table projection; neither RNG advances. SDL_FlushEvents(SDL_MOUSEMOTION, SDL_MOUSEBUTTONUP); } show(); } // OriginalMouseSound keys, including ESC, do not select a button. } SDL_Delay(10); } }; app::CareerSession::PoachPlayerSelector poach_player_selector = [&](app::CareerSession& staged,app::ClubModalServices&,int manager, uint64_t& selection_revision,const Image& transfer_backdrop) -> std::optional { using Phase=app::CareerSession::TableDispatchPhase; press.reset(); // The synchronous Source player-selection loop owns its input. std::string error; auto page=staged.current_league_table_dispatch(error); if(!page)throw FormatError(error); const auto present=[&](const Image& frame,const std::string& title) { SDL_SetWindowTitle(window,title.c_str());season_backdrop=frame; const auto painted=process_timer_image(frame); for(size_t i=0;i table; const auto rebuild=[&] { auto tables=ui::league_tables_from_game(staged.state(),manager); tables[size_t(page->identity.league)]=page->page; table=std::make_unique(data,std::move(tables),page->identity.league, ui::LeagueTableScreen::FamilyMode{page->identity,1}); }; const auto show_table=[&] { present(table->render(),"OpenBMH - poach_table_"+std::to_string(page->identity.league)); if(page->phase==Phase::forecast_pending_present) { ui::LeagueFamilyRequest ack; ack.identity=page->identity;ack.kind=ui::LeagueFamilyRequestKind::table_forecast_presented; ack.from_child=1; page=staged.acknowledge_league_forecast_present(ack,selection_revision,error); if(!page)throw FormatError(error); rebuild(); // Retain forecast pixels, refresh only the stale-request token. } }; const auto run_range=[&](Image backdrop,ui::TableRangeDialogProfile profile) -> ui::TableRangeDialogOutcome { ui::LeagueTableRangeDialog dialog(data,std::move(backdrop),std::move(profile)); std::deque keys; Uint32 clock_anchor=SDL_GetTicks(); std::optional outcome; const auto show=[&] { present(dialog.render(),"OpenBMH - poach_table_range"); outcome=dialog.after_present();clock_anchor=SDL_GetTicks(); }; const auto expire_range=[&] { //BalanceFromGame polls raw event8 before its next input. Keep its //key/N waits and accepted value owner; expose cancellation //only after the restored backdrop has actually been shown. if(!dialog.source_input_ready() || !poll_process_timer(true,true) || !dialog.cancel_from_source_event())return false; show(); return true; }; show(); while(running&&!outcome) { if(expire_range())break; SDL_Event input; while(quit_confirmation.poll(&input)) { if(input.type==SDL_QUIT){running=false;break;} if(expire_range())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.push_back("ENTER"); else if(input.key.keysym.sym==SDLK_BACKSPACE)keys.push_back("BACKSPACE"); else if(input.key.keysym.sym==SDLK_SPACE)keys.push_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); // A drag-only release does not restart an existing Source wait. if(changed&&input.type!=SDL_MOUSEBUTTONUP)show(); if(outcome)break; } if(!running||outcome)break; while(!keys.empty()&&dialog.source_input_ready()) { if(expire_range())break; const auto key=std::move(keys.front());keys.pop_front(); if(dialog.key(key))show(); if(outcome)break; } const Uint32 now=SDL_GetTicks(),units=Uint32(now-clock_anchor)/20; if(units) { clock_anchor+=units*20; if(dialog.tick_source_units(units))show(); } SDL_Delay(10); } if(!outcome)throw FormatError("poach: range presenter stopped"); return *outcome; }; rebuild();show_table(); poach_selection_active=true;poach_card_selection.reset(); struct ResetSelection { bool& active;~ResetSelection(){active=false;} } reset{poach_selection_active}; const auto deadline_expired=[&] { if(table->pending_family_action() || table->source_mouse_wait_release_pending() || !poll_process_timer(true,true))return false; //Move/4ffe0 selection owner must close before19c1c resumes. if(!table->pointer_down(0,0,true) || !table->pending_family_action() || table->pending_family_action()->kind!=ui::LeagueFamilyRequestKind::close) throw FormatError("poach: timer close has no table owner"); if(!staged.close_poach_table_selection(*table->pending_family_action(),error)) throw FormatError(error); present(transfer_backdrop,"OpenBMH - poach_transfer_restored"); return true; }; while(running) { if(deadline_expired())return std::nullopt; SDL_Event input; while(quit_confirmation.poll(&input)) { if(input.type==SDL_QUIT){running=false;break;} if(deadline_expired())return std::nullopt; bool changed=false; if(input.type==SDL_MOUSEBUTTONDOWN&& (input.button.button==SDL_BUTTON_LEFT||input.button.button==SDL_BUTTON_RIGHT)) changed=table->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) changed=table->click(input.button.x,input.button.y); else if(input.type==SDL_MOUSEMOTION)changed=table->move(input.motion.x,input.motion.y); if(!table->pending_family_action()) {if(changed)show_table();continue;} const auto request=*table->pending_family_action(); if(request.kind==ui::LeagueFamilyRequestKind::close) { if(!staged.close_poach_table_selection(request,error))throw FormatError(error); present(transfer_backdrop,"OpenBMH - poach_transfer_restored"); return std::nullopt; } if(request.kind==ui::LeagueFamilyRequestKind::select_league || request.kind==ui::LeagueFamilyRequestKind::toggle_league_group) { const int prior_league=page->identity.league; if(!staged.select_league_family_page(request,selection_revision,error))throw FormatError(error); page=staged.current_league_table_dispatch(error);if(!page)throw FormatError(error); if(page->identity.league==prior_league) { table->acknowledge_same_league_selector(request,page->identity); if(request.kind==ui::LeagueFamilyRequestKind::toggle_league_group)show_table(); } else {rebuild();show_table();} } else if(request.kind==ui::LeagueFamilyRequestKind::team_info) { poach_card_selection.reset(); const auto identity=staged.dispatch_family_table_team_info(request,selection_revision,error, [&](app::ClubModalServices& services,int team,const Image&) { return present_club_information(services,team)&&running; },&poach_card_selection); if(!identity)throw FormatError(error); if(poach_card_selection) { present(transfer_backdrop,"OpenBMH - poach_transfer_restored"); return poach_card_selection; } page=staged.current_league_table_dispatch(error);if(!page)throw FormatError(error); rebuild();show_table(); } else if(request.kind==ui::LeagueFamilyRequestKind::control) { const auto modal_backdrop=table->render(); page=staged.dispatch_league_table_control(request,selection_revision,error); if(!page)throw FormatError(error); while(page->dialog) { const auto stage=page->phase==Phase::range_start?ui::TableDialogStage::start:ui::TableDialogStage::end; const auto outcome=run_range(modal_backdrop,*page->dialog); ui::LeagueFamilyRequest reply; reply.identity=page->identity;reply.kind=ui::LeagueFamilyRequestKind::table_range_result; reply.from_child=1;reply.control_index=9; reply.table_dialog_reply=ui::TableDialogReply{stage, outcome.result==ui::TableRangeDialogResult::accept?ui::TableDialogOutcome::accept:ui::TableDialogOutcome::cancel, outcome.result==ui::TableRangeDialogResult::accept?int(outcome.value):0,outcome.x,outcome.y}; page=staged.dispatch_league_table_range_reply(reply,selection_revision,error); if(!page)throw FormatError(error); } rebuild();show_table(); } } SDL_Delay(10); } throw FormatError("poach: player selection presenter stopped"); }; // CupDrawFromGame local_14 belongs to the whole linked-record traversal. A // skipped reveal still presents every overview; a normal reveal ACK or // the right press leaving an overview does not skip subsequent groups. bool group_reveal_skipped = false; SeasonCupDrawHook cup_draw_presenter = [&](const GameState& state, const SeasonCupDrawEvent& event) { if (!running) return; if (event.phase == SeasonCupDrawPhase::draw) { if (!event.group_stage || event.group_index == 0) group_reveal_skipped = false; if (event.group_stage && group_reveal_skipped) { // SDLFlushEvents still runs before the native overview. SDL_FlushEvents(SDL_MOUSEMOTION, SDL_MOUSEBUTTONUP); return; } } auto view = ui::cup_draw_from_game(state, event, season_exe, season_texts); if (!view.source_eligible) return; ui::CupDrawScreen screen(data, std::move(view)); bool first_draw_frame = true; const auto show_draw = [&] { const auto title = "OpenBMH - cup_draw_" + std::to_string(screen.revealed_count()); present_season(screen.render(), title.c_str()); // DecodeTaxAnimationScript(1) flushes outside script execution (Main_Screen_RuntimeField2=0). // Script 0/1 presentations retain queued input (Main_Screen_RuntimeField2=1). if (first_draw_frame || screen.queue_flush_needed()) SDL_FlushEvents(SDL_MOUSEMOTION, SDL_MOUSEBUTTONUP); first_draw_frame = false; }; if (event.phase == SeasonCupDrawPhase::draw) { // Source ignores the first OriginalMouseSound poll's gameplay result, then // presents the starting scene before its ten option-delay polls. SDL_Event initial; if (quit_confirmation.poll(&initial) && initial.type == SDL_QUIT) { running = false; return; } show_draw(); while (running && screen.advance_step()) { if (screen.present_needed()) show_draw(); wait_promotion_time(Uint32(screen.option_delay_milliseconds())); if (!running) return; if (screen.input_poll_needed()) { SDL_Event input; while (quit_confirmation.poll(&input)) { if (input.type == SDL_QUIT) { running = false; return; } if (input.type == SDL_MOUSEBUTTONDOWN && (input.button.button == SDL_BUTTON_LEFT || input.button.button == SDL_BUTTON_RIGHT)) { screen.source_input(input.button.button == SDL_BUTTON_LEFT ? 2 : 8); break; } } // OriginalMouseSound synthetic left press at its normal poll // boundary; missing transient blocks are not zero values. if ((state.memory.has(::bmh::layout::BalancePlan_BalanceFromGame_RuntimeField) && state.memory.u8(::bmh::layout::BalancePlan_BalanceFromGame_RuntimeField) != 0) || (state.memory.has(::bmh::layout::CareerSession_SportschauSourceOptions_ExecutableField) && state.memory.u8(::bmh::layout::CareerSession_SportschauSourceOptions_ExecutableField) == 0)) screen.source_input(2); } if (screen.held_mouse_check_needed()) { SDL_PumpEvents(); const auto held = SDL_GetMouseState(nullptr, nullptr); screen.source_held_mouse(uint8_t((held & SDL_BUTTON_LMASK ? 1 : 0) | (held & SDL_BUTTON_RMASK ? 2 : 0))); } if (!screen.reveal_aborted()) wait_promotion_time(Uint32(screen.wait_milliseconds())); } if (running && screen.reveal_complete() && !screen.reveal_aborted()) { present_season(screen.render(), "OpenBMH - cup_draw_ack"); wait_season_ack(); } if (event.group_stage && screen.reveal_aborted()) group_reveal_skipped = true; SDL_FlushEvents(SDL_MOUSEMOTION, SDL_MOUSEBUTTONUP); // SDLFlushEvents before native sort return; } present_season(screen.render(), "OpenBMH - cup_overview"); SDL_FlushEvents(SDL_MOUSEMOTION, SDL_MOUSEBUTTONUP); while (running) { SDL_Event input; while (quit_confirmation.poll(&input)) { if (input.type == SDL_QUIT) { running = false; return; } if (input.type != SDL_MOUSEBUTTONDOWN) continue; if (input.button.button == SDL_BUTTON_RIGHT) return; if (input.button.button == SDL_BUTTON_LEFT) { const auto club = screen.hit_test_team(input.button.x, input.button.y); if (club) { auto services=session->live_club_modal_services(revision); (void)present_club_information(services,*club); if (!running) return; // Native category/squad edits belong to the clicked // Source modal. Rebuild the overview from the current // state while retaining its owned sorted round field. auto current = ui::cup_draw_from_game(session->state(), event, season_exe, season_texts); screen = ui::CupDrawScreen(data, std::move(current)); present_season(screen.render(), "OpenBMH - cup_overview"); SDL_FlushEvents(SDL_MOUSEMOTION, SDL_MOUSEBUTTONUP); } } } SDL_Delay(10); } }; auto show_highscore = [&](const GameState& state, bool display) { if (!running) return; const auto options = game_end_options(state); const uint16_t signature = state.memory.u16(::bmh::layout::CareerSession_FormatError_RuntimeField7); if (signature == 0) { // Source GameEndAlternateScoreScreen's alternate branch ignores display: both calls // open the calculator, followed by one presentation for each point. ui::GameEndAlternateScoreScreen screen(ui::load_game_end_alternate_score_assets(data), season_backdrop ? *season_backdrop : flow.render(), options.gradient_text); present_season(screen.render(), "OpenBMH - game_end_calculator"); bool right_cancel = false; while (running && screen.phase() == ui::AlternateScorePhase::Calculator) { SDL_Event event; bool changed = false; while (quit_confirmation.poll(&event)) { if (event.type == SDL_QUIT) { running = false; return; } if (event.type == SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_RIGHT) { right_cancel = true; changed |= screen.cancel(); // Source mouse cancellation event8 } else if (event.type == SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT) { const auto button = screen.button_at(event.button.x, event.button.y); if (button && *button < 15) { present_season(screen.render(button), "OpenBMH - game_end_calculator"); SDL_Delay(4 * 20); // Source DecodeTaxAnimationScript2(4), 50-Hz ticks } changed |= screen.mouse_down(event.button.x, event.button.y); } else if (event.type == SDL_MOUSEMOTION) { changed |= screen.mouse_move(event.motion.x, event.motion.y); } else if (event.type == SDL_MOUSEBUTTONUP && event.button.button == SDL_BUTTON_LEFT) { changed |= screen.mouse_up(); } else if (event.type == SDL_TEXTINPUT) { changed |= screen.text(event.text.text); } else if (event.type == SDL_KEYDOWN) { const auto key = event.key.keysym.sym; if (key == SDLK_RETURN) changed |= screen.key("ENTER"); else if (key == SDLK_BACKSPACE) changed |= screen.key("BACKSPACE"); else if (key == SDLK_SPACE) changed |= screen.key("SPACE"); } if (screen.phase() != ui::AlternateScorePhase::Calculator) break; } if (changed && screen.phase() == ui::AlternateScorePhase::Calculator) present_season(screen.render(), "OpenBMH - game_end_calculator"); SDL_Delay(10); } if (!running) return; if (!screen.accepted_value()) { if (!right_cancel) SDL_Delay(50 * 20); // Source N-key wait; mouse cancel skips it present_season(screen.render(), "OpenBMH - game_end_calculator_cancelled"); } else { while (running && screen.advance_point()) present_season(screen.render(), "OpenBMH - game_end_points"); screen.finish_points(); present_season(screen.render(), "OpenBMH - game_end_points_ack"); wait_season_ack(); } } else { const auto file = highscore_file(save_directory, signature, season_texts[889]); auto scores = make_highscore_projection(state, load_highscore_table(file), HighscoreContext::SeasonBoundary); // The Original stores this table outside the native FBM. Use the // configured writable save base rather than a working-directory path. std::error_code directory_error; fs::create_directories(file.parent_path(), directory_error); if (directory_error || !save_highscore_table(file, scores.rows)) std::fprintf(stderr, "highscore: cannot write %s\n", file.string().c_str()); if (display) { ui::GameEndHighscoreScreen screen(data, std::move(scores), options); present_season(screen.render(), "OpenBMH - game_end_highscore"); wait_season_ack(); } } if (display && running) { ui::GameEndFinalScreen screen(data, options); present_season(screen.render(), "OpenBMH - game_end_final"); wait_season_ack(); } }; std::optional timed_notice_presented_at; std::optional timed_notice_release; auto handle = [&](const ui::FlowResult& r) { pitch_pointer.show({}, renderer); if (r.request == ui::FlowRequest::end_session && !quit_confirmation.confirm()) { flow.reject_desk_action(english_game ? "Quit cancelled." : "Beenden abgebrochen."); dirty = true; return; } if (const auto* desk = flow.desktop()) for (const auto id : desk->take_sound_ids()) app::original_audio_command(playback, id); if (r.request == ui::FlowRequest::kickoff || r.request == ui::FlowRequest::end_session) { // DeskDate clears CareerSession_DispatchStrengths_ExecutableField2 before returning to the match caller. process_timer.stop(); process_timer_owner.reset(); process_timer_frame.reset(); } else if (r.desk_action.kind == ui::DeskRequestKind::open_menu && (r.desk_action.menu_kind == 10 || r.desk_action.menu_kind == 11 || r.desk_action.menu_kind == 19 || r.desk_action.menu_kind == 29)) { // ApplySettingsFile suspends save/load, settings and new-manager waits. process_timer.pause(process_source_seconds()); process_timer_frame.reset(); } if (r.request == ui::FlowRequest::end_session) { // DeskDate's confirmed socket exit tears down the running // session without a calendar turn, RNG draw, or implicit save. running = false; dirty = false; return; } dirty |= r.changed; bool live_skipped = false; uint64_t live_overview_sequence = 0; std::optional outcome_backdrop; auto present_live_lineup = [&](int minute, MatchEngine& engine, std::vector& 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 { 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; 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)); 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; 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()); }; bool left_held = false, left_release_consumed = false, right_held = false; while (running && !closed) { pitch_pointer.show(screen.pointer_cursor(palette), renderer); const Image image = screen.render(); 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_RenderPresent(renderer); 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); 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); } 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; }; using RunningOverviewDispatcher = std::function( const app::CareerSession::LiveOverviewAction&, std::string&, const app::TransferOfferTeamInfoPresenter&)>; const auto present_running_overview = [&](std::optional projection, const GameState& state, uint64_t& live_revision, const RunningOverviewDispatcher& dispatch_overview, const PhaseResultRequest* phase_result) { const int manager = projection->owner.manager_slot; std::unique_ptr table_screen; std::unique_ptr pairings_screen; std::unique_ptr strengths_screen; std::unique_ptr cup_screen; const auto overview_clock_start = std::chrono::steady_clock::now(); const auto overview_source_seconds = [&] { const auto milliseconds = std::chrono::duration_cast( std::chrono::steady_clock::now() - overview_clock_start).count(); return ui::league_pairings_source_seconds(uint64_t(milliseconds)); }; 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(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(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(data, *projection->strengths); } else if (projection->kind == app::CareerSession::LiveOverviewKind::cup_other_games && projection->cup) { cup_screen = std::make_unique(data, *projection->cup); } else { throw FormatError("live overview: Source presenter projection is missing"); } }; 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"; }; 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()); 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_RenderPresent(renderer); if (pairings_screen) pairings_screen->mark_presented_source_seconds(overview_source_seconds()); }; rebuild_screen(); render_overview(); bool closed = false; std::optional down; const auto run_table_range = [&](const Image& backdrop, ui::TableRangeDialogProfile profile) -> ui::TableRangeDialogOutcome { ui::LeagueTableRangeDialog dialog(data, backdrop, std::move(profile)); std::deque keys; Uint32 clock_anchor = SDL_GetTicks(); std::optional outcome; const auto show_dialog = [&] { const Image image = dialog.render(); SDL_SetWindowTitle(window, "OpenBMH - live_table_range"); 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_RenderPresent(renderer); 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; }; std::function 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}); } }; SDL_FlushEvent(SDL_KEYUP); 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); } std::optional 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; } 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; }; ui::LiveScoreReveal live_score_reveal; std::optional live_chance_context; std::unique_ptr reality_field; ui::RealityReporterLayoutState reality_layout; Image reality_pristine, reality_surface; Palette reality_colors; const std::string message = app::serve_flow_request(flow, r, session, data, save_directory, seed, revision, playback, audio_session, music_enabled, [&](int minute, const std::vector& groups, const GameState& state) { 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); for (size_t i = 0; i < pixels.size(); ++i) pixels[i] = palette.argb[live_image.pixels[i]]; SDL_UpdateTexture(texture, nullptr, pixels.data(), 320 * 4); SDL_RenderClear(renderer); SDL_RenderCopy(renderer, texture, nullptr, nullptr); SDL_RenderPresent(renderer); 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)); }, [&](const GameState& state, const TransferOfferListView& offers) -> int { if (!running) return -1; auto view = transfer_view(state, offers, offers.seller_manager); ui::IncomingTransferScreen offer_screen(data, ui::incoming_transfer_decision_from_game(state, view), state.memory.u8(::bmh::layout::TextGradientDisabled) == 0); SDL_SetWindowTitle(window, "OpenBMH - incoming_transfer"); const Uint32 notice_started = SDL_GetTicks(); bool offer_dirty = true; // Keep the original synchronous decision stack suspended here. // Only this modal's input is dispatched; desk actions and saves // cannot run against a partially processed calendar day. while (running) { if (offer_screen.notice_active() && SDL_GetTicks() - notice_started >= 4260) offer_dirty |= offer_screen.dismiss_notice(); if (!offer_screen.notice_active() && offers.offer_count == 0) return -1; if (offer_dirty) { const auto image = offer_screen.render(); outcome_backdrop = image; 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_RenderPresent(renderer); offer_dirty = false; } SDL_Event event; while (quit_confirmation.poll(&event)) { if (event.type == SDL_QUIT) { running = false; return -1; } std::optional answer; if (event.type == SDL_MOUSEBUTTONDOWN && (event.button.button == SDL_BUTTON_LEFT || event.button.button == SDL_BUTTON_RIGHT)) { offer_screen.pointer_down(event.button.button == SDL_BUTTON_RIGHT); } else if (event.type == SDL_MOUSEBUTTONUP && (event.button.button == SDL_BUTTON_LEFT || event.button.button == SDL_BUTTON_RIGHT)) { answer = offer_screen.pointer_up(event.button.x, event.button.y, event.button.button == SDL_BUTTON_RIGHT); offer_dirty = true; } else if (event.type == SDL_KEYDOWN) { if (offer_screen.notice_active()) { offer_dirty |= offer_screen.dismiss_notice(); } else if (event.key.keysym.sym == SDLK_ESCAPE) { answer = offer_screen.key("ESC"); } } if (answer) return *answer; } if (playback.needs_pump()) playback.pump(audio_error); SDL_Delay(10); } return -1; }, [&](const GameState& state, const TransferDecisionEvent& decision) { if (!running) return; if (decision.kind == TransferDecisionEventKind::last_week) { auto view = ui::transfer_last_week_dialog(state, decision); const Image backdrop = outcome_backdrop ? *outcome_backdrop : ui::GameEndTaxDialog(data, view, game_end_options(state)).backdrop(); if (present_pending_dialog(state, std::move(view), backdrop, "OpenBMH - transfer_last_week") == PendingOfferAnswer::unsupported) running = false; return; } auto view = transfer_view(state, decision.offers, decision.viewer_manager); if (decision.kind == TransferDecisionEventKind::confirmation) view.notice_text_address = decision.result_text_address; ui::IncomingTransferScreen decision_screen(data, ui::incoming_transfer_decision_from_game(state, view), state.memory.u8(::bmh::layout::TextGradientDisabled) == 0); const bool confirmation = decision.kind == TransferDecisionEventKind::confirmation; if (confirmation) { const Image backdrop = outcome_backdrop ? *outcome_backdrop : decision_screen.render(); decision_screen.show_confirmation(decision.result_text_address, backdrop); } else { decision_screen.begin_outcome(decision.offers.offer_count, decision.accepted ? decision.selected_bid_index : -1, state.memory.u8(::bmh::layout::OutcomeDelayDisabled)); } SDL_SetWindowTitle(window, confirmation ? "OpenBMH - transfer_confirmation" : "OpenBMH - transfer_evaluation"); const Uint32 started = SDL_GetTicks(); uint64_t rendered_phase = UINT64_MAX; // The observer only presents the engine's settled decision. Keep // calendar/desk/save dispatch suspended until the original modal // input completes; clicks cannot select or reroll a bid here. while (running) { const uint64_t elapsed = Uint32(SDL_GetTicks() - started); const uint64_t phase = confirmation ? 0 : std::min(elapsed / ui::IncomingTransferScreen::outcome_phase_ms, decision_screen.outcome_duration_ms() / ui::IncomingTransferScreen::outcome_phase_ms); if (phase != rendered_phase) { const auto image = decision_screen.render_at_elapsed(elapsed); if (!confirmation) outcome_backdrop = image; 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_RenderPresent(renderer); rendered_phase = phase; } SDL_Event event; while (quit_confirmation.poll(&event)) { if (event.type == SDL_QUIT) { running = false; return; } if (event.type == SDL_MOUSEBUTTONDOWN && (event.button.button == SDL_BUTTON_LEFT || event.button.button == SDL_BUTTON_RIGHT)) decision_screen.pointer_down(event.button.button == SDL_BUTTON_RIGHT); else if (event.type == SDL_MOUSEBUTTONUP && (event.button.button == SDL_BUTTON_LEFT || event.button.button == SDL_BUTTON_RIGHT)) (void)decision_screen.pointer_up(event.button.x, event.button.y, event.button.button == SDL_BUTTON_RIGHT, elapsed); } if (confirmation ? decision_screen.confirmation_dismissed() : decision_screen.outcome_dismissed()) return; SDL_Delay(10); } }, [&](const char* checkpoint, const GameState& state) { if (!running || std::strcmp(checkpoint, "the German entrants (CompetitionWinnerScreen)") != 0) return; // SeasonEntrantsFromGame / CompetitionWinnerScreen: show the three owned Original // projections while the transition is suspended at its checkpoint. // Other season animations remain separate implementation work. for (auto view : ui::season_entrants_from_game(state, season_exe, season_texts)) { ui::SeasonEntrantsScreen entrants_screen(data, std::move(view)); SDL_SetWindowTitle(window, "OpenBMH - season_entrants"); const Image image = entrants_screen.render(); 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_RenderPresent(renderer); bool dismissed = false; while (running && !dismissed) { SDL_Event event; while (quit_confirmation.poll(&event)) { if (event.type == SDL_QUIT) { running = false; return; } if (event.type == SDL_MOUSEBUTTONUP && (event.button.button == SDL_BUTTON_LEFT || event.button.button == SDL_BUTTON_RIGHT)) { dismissed = true; break; } } if (!dismissed) SDL_Delay(10); } } }, tax_presenter, show_highscore, promotion_presenter, cup_draw_presenter, r.request == ui::FlowRequest::kickoff ? make_pending_offer_hooks(flow.render()) : PendingOfferHooks{}, app::PendingOfferEntryPolicy::normal_interactive, (r.request == ui::FlowRequest::kickoff || (r.request == ui::FlowRequest::submenu_action && (std::holds_alternative(r.submenu_action) || std::holds_alternative(r.submenu_action)) )) ? make_market_sale_hooks(flow.render()) : HumanBuyerSaleHooks{}, app::HumanBuyerMarketEntryPolicy::normal_interactive, [&](app::ClubModalServices& services,int team,const Image&) { return present_club_information(services,team) && running; }, [&](app::ClubModalServices& services,const ClubPlayerDetailSelection& selection,const Image& parent) { // Direct1b556 already owns persistent bbcde=1. The shared //ClubPlayerDetailFromGame presenter never restores a temporary club mode here. return present_player_detail(services,selection,parent).has_value() && running; }, [&](const GameState& staged, const ConstructionNotice& notice) { if (!flow.stadium()) throw std::runtime_error("construction notice has no stadium owner"); // The Original payment notices restore the investment detail, // after the tip question has returned, before the outer ACK. const Image backdrop = flow.stadium()->construction_notice_backdrop(); auto view = ui::construction_notice_dialog(staged, season_exe, notice); std::optional effective_options; if (flow.stadium()->state().block_expansion || flow.stadium()->state().quoted_object) { const auto& owner = flow.stadium()->state(); view.compact_dialog_frame = owner.compact_dialog_frame; effective_options = ui::GameEndRenderOptions{owner.plain_background, owner.gradient_text}; } const char* title = notice.kind == ConstructionNoticeKind::InsufficientFunds ? "OpenBMH - stadium_funds_notice" : "OpenBMH - stadium_sponsor_notice"; if (present_pending_dialog(staged, view, backdrop, title, effective_options) == PendingOfferAnswer::unsupported) throw std::runtime_error("construction notice presenter stopped"); }, [&](const GameState& staged, const SeasonTicketCompensationNotice& notice) { if (!flow.stadium()) throw std::runtime_error("compensation notice has no stadium owner"); const Image backdrop = flow.stadium()->construction_notice_backdrop(); auto view = ui::season_ticket_compensation_notice_dialog(staged, season_exe, notice); const auto& owner = flow.stadium()->state(); view.compact_dialog_frame = owner.compact_dialog_frame; if (present_pending_dialog(staged, view, backdrop, "OpenBMH - stadium_ticket_compensation_notice", ui::GameEndRenderOptions{owner.plain_background, owner.gradient_text}) == PendingOfferAnswer::unsupported) throw std::runtime_error("compensation notice presenter stopped"); }, sportschau_presenter, [&](const GameState& staged, const AdvertisingRenewal& renewal, const Image& backdrop) -> app::CareerSession::AdvertisingRenewalPresentation { if (!running) return app::CareerSession::AdvertisingRenewalPresentation::abort; const int manager = int(staged.memory.u8(::bmh::layout::ActiveManager)); if (renewal.status == AdvertisingRenewal::Status::offered) { const auto view = ui::advertising_renewal_question_dialog(staged, manager, renewal); const auto answer = present_pending_dialog(staged, view, backdrop, "OpenBMH - advertising_renewal_question"); if (answer == PendingOfferAnswer::yes) return app::CareerSession::AdvertisingRenewalPresentation::renew; if (answer == PendingOfferAnswer::no) return app::CareerSession::AdvertisingRenewalPresentation::decline; return app::CareerSession::AdvertisingRenewalPresentation::abort; } if (renewal.status == AdvertisingRenewal::Status::declined_by_sponsor) { const auto view = ui::advertising_renewal_notice_dialog(staged, manager, renewal); if (present_pending_dialog(staged, view, backdrop, "OpenBMH - advertising_renewal_notice") == PendingOfferAnswer::yes) return app::CareerSession::AdvertisingRenewalPresentation::acknowledged; } return app::CareerSession::AdvertisingRenewalPresentation::abort; }, poach_player_selector, [&](const GameState& staged,const PoachStart& attempt,const Image& backdrop) { for(const auto& message:attempt.messages) if(present_pending_dialog(staged,ui::poach_notice_from_game(staged,attempt,message),backdrop, "OpenBMH - poach_notice")==PendingOfferAnswer::unsupported) throw FormatError("poach: notice presenter stopped"); }, contract_expiry_presenter, [&](const GameState& staged,ui::TaxDialogProjection view,const Image& backdrop) ->std::optional { if(!running)return {}; const auto answer=present_pending_dialog(staged,std::move(view),backdrop, "OpenBMH - national_friendly_question"); flow.acknowledge_national_friendly_modal_release(); // The synchronous questions already consumed their UP; // do not retain the picker DOWN as a held parent press. press.reset(); if(answer==PendingOfferAnswer::unsupported)return {}; return answer==PendingOfferAnswer::yes; }, loan_return_presenter, loan_return_offer_presenter, [&](int minute, MatchEngine& engine, std::vector& 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) { if (!running) return; bool quit = false; 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); }; 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; std::optional tactics_down; bool source_completed = false; while (running && !closed) { const Image image = screen.render(); 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_RenderPresent(renderer); 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); } 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()); } }; 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'; 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"); SDL_RenderPresent(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"); }; 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"); 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_RenderPresent(renderer); }; 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(); }; const auto show_live_settings = [&](std::optional 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 readme; const auto render_settings = [&] { const Image image = readme ? readme->render() : screen.render(); SDL_SetWindowTitle(window, readme ? "OpenBMH - settings_readme" : "OpenBMH - live_settings"); 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_RenderPresent(renderer); }; render_settings(); 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); const auto render_file = [&] { const Image image = file_screen.render(); SDL_SetWindowTitle(window, "OpenBMH - live_settings_file"); 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_RenderPresent(renderer); }; render_file(); 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)) { 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); } 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(); }; bool closed = false; bool readme_release_barrier = false; std::optional 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; 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( 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(); }; const bool source_phase_start = minute == 1 || (state.indoor ? minute == 21 : (minute == 46 || minute == 91 || minute == 106)); 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(); 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); } } } 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; }, [&](const GameState& staged, ui::TaxDialogProjection view, const Image& backdrop) { if (!running) return false; const bool settings_notice = flow.in_settings() && flow.pending_settings(); const bool shown = present_pending_dialog(staged, std::move(view), backdrop, settings_notice ? "OpenBMH - settings_notice" : "OpenBMH - environment_notice") != PendingOfferAnswer::unsupported; if (settings_notice) { flow.acknowledge_settings_notice_release(); press.reset(); SDL_FlushEvents(SDL_MOUSEMOTION, SDL_MOUSEBUTTONUP); } return shown; }, [&](const LiveMatchEvent& event, MatchEngine& engine, std::vector& 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) { 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."); }, [&](const LiveBallEvent& event, const std::vector& groups, const GameState& state) { 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 present = [&](const Image& image) { 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_RenderPresent(renderer); }; const int count = ui::LiveMatchdayScreen::ball_frame_count(event.displacement); 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)); } }, [&](const LiveChanceEvent& event, const std::vector& groups, const GameState& state) { if (!running || live_skipped) return; const auto frame = 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); 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_RenderPresent(renderer); 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; } 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(); }, [&](const LiveShotEvent& event, const std::vector& groups, const GameState& state) { 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()); for (size_t i = 0; i < pixels.size(); ++i) pixels[i] = shot_colors.argb[frames[index].pixels[i]]; SDL_UpdateTexture(texture, nullptr, pixels.data(), 320 * 4); SDL_RenderClear(renderer); SDL_RenderCopy(renderer, texture, nullptr, nullptr); SDL_RenderPresent(renderer); 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)); } }, [&](const LiveSetPieceEvent& event, const std::vector& groups, const GameState& state) { 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;index0) { 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 }, [&](const LiveBookingEvent& event, const std::vector& groups, const GameState& state) { 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) { for (size_t i=0;i0) { 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)); }, [&](const LiveShootoutEvent& event, const std::vector& groups, const GameState& state) { 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); for (size_t i=0;i0) { 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;i0) SDL_Delay(Uint32(delay)); }, [&](const LiveRealityEvent& event, const std::vector& 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()); for (size_t i=0;i0) 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(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; 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); } 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; }, [&](const PhaseResultRequest& request, const std::vector& groups, const GameState& state) { 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"); }, true); if (message == "career_complete") { running = false; return; } if (!message.empty()) std::fprintf(stderr, "engine: %s\n", message.c_str()); if (session) { const auto autosave_error = session->take_autosave_error(); if (!autosave_error.empty()) std::fprintf(stderr, "autosave: %s\n", autosave_error.c_str()); } // Table requests own their redraw boundary. In particular a // same-league map ACK and a forecast Present ACK retain the frame. if (!flow.in_family_table() || !message.empty()) dirty = true; // DeskDate checks the pending mailbox latch after the normal desk // request has completed. Poll only on the returned, idle desk so // load/weekly/close acknowledgements can open the Source notice // immediately without interrupting another modal or read-only view. if (running && session && flow.desktop() && !flow.desktop()->pending() && !flow.in_preparation_menu() && !flow.in_results_view() && !flow.in_readonly_view() && !flow.in_mailbox() && flow.screen_name() == "desktop") { if (auto mailbox = session->pending_mailbox_notification(revision)) { flow.show_notified_mailbox(std::move(*mailbox)); dirty = true; } } if(!flow.timed_notice_open())timed_notice_presented_at.reset(); SDL_SetWindowTitle(window, ("OpenBMH - " + flow.screen_name()).c_str()); }; const auto present_formation_save_feedback = [&] { for (bool restored : {false, true}) { const auto feedback = flow.pitch_formation_save_feedback(restored); if (!feedback) break; const auto image = process_timer_image(*feedback); for (size_t i = 0; i < pixels.size(); ++i) pixels[i] = palette.argb[image.pixels[i]]; if (SDL_UpdateTexture(texture, nullptr, pixels.data(), 320 * 4) != 0 || SDL_RenderClear(renderer) != 0 || SDL_RenderCopy(renderer, texture, nullptr, nullptr) != 0) throw std::runtime_error(std::string("Formation save renderer: ") + SDL_GetError()); SDL_RenderPresent(renderer); if (!restored) SDL_Delay(ui::PitchScreen::formation_save_flash_ms); } }; const auto service_pitch_hold = [&] { if (!press || press->pitch_hold_attempted || !flow.in_pitch() || press->screen != flow.screen_name() || press->revision != revision) return; const auto ticks = ui::pointer_hold_source_ticks(SDL_GetTicks64()) - press->source_tick; if (!ui::pointer_source_hold_ready(ticks)) return; int window_x=0,window_y=0; if (!(SDL_GetMouseState(&window_x,&window_y) & SDL_BUTTON_LMASK)) return; float x=0,y=0; SDL_RenderWindowToLogical(renderer,window_x,window_y,&x,&y); if (int(x)!=press->x || int(y)!=press->y) { press.reset(); return; } press->pitch_hold_attempted = true; const auto held = flow.pitch_held_left(press->x,press->y,ticks); present_formation_save_feedback(); handle(held); }; const auto pairings_clock_start = std::chrono::steady_clock::now(); const auto pairings_source_seconds = [&] { const auto milliseconds = std::chrono::duration_cast( std::chrono::steady_clock::now() - pairings_clock_start).count(); return ui::league_pairings_source_seconds(uint64_t(milliseconds)); }; const auto balance_source_milliseconds = [&] { return uint64_t(std::chrono::duration_cast( std::chrono::steady_clock::now()-pairings_clock_start).count()); }; // DecodeTaxAnimationScript2 multiplies its argument by 20 before host timer's // millisecond conversion. This is the host unit scale, not a claim // of parity with the Original DOS clock's quantization. const auto family_table_source_units = [&] { return balance_source_milliseconds() / 20; }; const auto mark_family_table_presented = [&] { const auto acknowledged = flow.in_toto_calculator() ? flow.after_toto_present(family_table_source_units()) : flow.after_family_table_present(family_table_source_units()); if (acknowledged.request != ui::FlowRequest::none) handle(acknowledged); else dirty |= acknowledged.changed; }; const auto present_family_table_redraw = [&] { if ((!flow.in_family_table() && flow.screen_name() != "toto") || !dirty) return; const auto image = process_timer_image(flow.render()); for (size_t i = 0; i < pixels.size(); ++i) pixels[i] = palette.argb[image.pixels[i]]; if (SDL_UpdateTexture(texture, nullptr, pixels.data(), 320 * 4) != 0 || SDL_RenderClear(renderer) != 0 || SDL_RenderCopy(renderer, texture, nullptr, nullptr) != 0) throw std::runtime_error(std::string("Table renderer: ") + SDL_GetError()); SDL_RenderPresent(renderer); dirty = false; mark_family_table_presented(); }; struct TableRangeKey { std::string key; ui::StrengthsIdentity identity; int toto_manager = -1; uint64_t toto_revision = 0; }; std::deque table_range_keys; const auto queue_table_range_event = [&](const SDL_Event& event) { if (!flow.in_toto_calculator() && (!flow.in_family_table_range_dialog() || !flow.league_family_identity())) return false; const auto queue = [&](std::string key) { if (flow.in_toto_calculator()) table_range_keys.push_back({std::move(key), {}, flow.toto()->state().manager_slot, flow.toto()->state().revision}); else table_range_keys.push_back({std::move(key), *flow.league_family_identity()}); }; if (event.type == SDL_TEXTINPUT) { const std::string_view text(event.text.text); if (std::all_of(text.begin(), text.end(), [](char c) { return c >= '0' && c <= '9'; })) for (char c : text) queue(std::string(1, c)); return true; } if (event.type != SDL_KEYDOWN) return false; if (event.key.keysym.sym == SDLK_RETURN) queue("ENTER"); else if (event.key.keysym.sym == SDLK_BACKSPACE) queue("BACKSPACE"); else if (event.key.keysym.sym == SDLK_SPACE) queue("SPACE"); // No SDL Escape/right-button origin for Source raw event 8 has // been established for this modal. Unsupported keys stay owned. return true; }; const auto service_family_table = [&] { if (!flow.in_family_table() && flow.screen_name() != "toto") { table_range_keys.clear(); return; } const auto tick = flow.in_toto_calculator() ? flow.tick_toto_source_units(family_table_source_units()) : flow.tick_family_table_source_units(family_table_source_units()); if (tick.request != ui::FlowRequest::none) handle(tick); else dirty |= tick.changed; present_family_table_redraw(); if (!flow.in_family_table_range_dialog() && !flow.in_toto_calculator()) table_range_keys.clear(); while (!table_range_keys.empty() && (flow.family_table_range_input_ready() || flow.toto_calculator_input_ready())) { auto input = std::move(table_range_keys.front()); table_range_keys.pop_front(); if ((input.toto_manager >= 0 && flow.in_toto_calculator() && input.toto_manager == flow.toto()->state().manager_slot && input.toto_revision == flow.toto()->state().revision) || (input.toto_manager < 0 && flow.league_family_identity() && input.identity == *flow.league_family_identity())) { handle(flow.send_key(input.key)); present_family_table_redraw(); } } }; std::optional presented_balance; bool presented_balance_notice=false; const auto present_balance_redraw = [&] { if (!flow.in_balance()) { presented_balance.reset();presented_balance_notice=false; return; } const auto identity=flow.balance()->state().identity; const bool notice=flow.balance()->notice_open(); if(presented_balance&&*presented_balance==identity&¬ice==presented_balance_notice)return; const auto image=process_timer_image(flow.render()); for(size_t i=0;i calculator_release; std::optional calculator_tick_anchor; struct CalculatorKey { std::string key; uint64_t revision = 0, scope = 0, sequence = 0; }; std::deque calculator_keys; const auto queue_calculator_key = [&](std::string key) { const auto& owner = flow.stadium()->state(); calculator_keys.push_back({std::move(key), owner.revision, owner.scope, owner.sequence}); }; const auto queue_calculator_event = [&](const SDL_Event& event) { if (event.type == SDL_TEXTINPUT) { const std::string_view text(event.text.text); if (!std::all_of(text.begin(), text.end(), [](char c) { return c >= '0' && c <= '9'; })) return true; for (const char c : text) queue_calculator_key(std::string(1, c)); return true; } if (event.type != SDL_KEYDOWN) return false; if (event.key.keysym.sym == SDLK_RETURN) queue_calculator_key("ENTER"); else if (event.key.keysym.sym == SDLK_BACKSPACE) queue_calculator_key("BACKSPACE"); else if (event.key.keysym.sym == SDLK_SPACE) queue_calculator_key("SPACE"); // The calculator owns every keyboard event. Unsupported keys, // including Escape, must not reach the outer application shortcut. // Digits arrive separately through SDL_TEXTINPUT. return true; }; const auto mark_stadium_calculator_presented = [&] { if (!flow.in_stadium() || !flow.stadium()->calculator_source_waiting()) { calculator_tick_anchor.reset(); return; } flow.mark_stadium_calculator_presented(); if (!calculator_tick_anchor) calculator_tick_anchor = balance_source_milliseconds(); }; const auto service_stadium_calculator = [&] { if (!flow.in_stadium()) { calculator_release.reset(); calculator_tick_anchor.reset(); calculator_keys.clear(); return; } if (flow.stadium()->calculator_source_waiting() && calculator_tick_anchor) { const uint64_t now = balance_source_milliseconds(); const uint64_t ticks = (now - *calculator_tick_anchor) / 20; if (ticks != 0) { // No wait exceeds fifty ticks, so bound narrowing and keep // the unused remainder for the next physical-clock sample. const unsigned step = unsigned(std::min(ticks, 50)); *calculator_tick_anchor += uint64_t(step) * 20; const auto tick = flow.tick_stadium_calculator_source_ticks(step); if (tick.request != ui::FlowRequest::none) handle(tick); else dirty |= tick.changed; } } if (!flow.in_stadium()) { calculator_release.reset(); calculator_tick_anchor.reset(); calculator_keys.clear(); return; } if (!flow.stadium()->calculator_source_waiting()) { calculator_tick_anchor.reset(); if (calculator_release) { const auto release = *calculator_release; calculator_release.reset(); const auto& owner = flow.stadium()->state(); if (owner.scope == release.scope && owner.sequence == release.sequence && flow.stadium()->calculator_waiting_for_key_release()) handle(flow.click(release.button.x, release.button.y)); press.reset(); } } if (!flow.stadium()->calculator_open()) calculator_keys.clear(); while (!calculator_keys.empty() && !flow.stadium()->calculator_source_waiting() && !flow.stadium()->calculator_waiting_for_key_release() && !flow.stadium()->pending()) { auto input = std::move(calculator_keys.front()); calculator_keys.pop_front(); const auto& owner = flow.stadium()->state(); if (owner.revision == input.revision && owner.scope == input.scope && owner.sequence == input.sequence) handle(flow.send_key(input.key)); } }; std::optional presented_pairings; const auto present_pairings_redraw = [&] { if (!flow.in_league_pairings()) { presented_pairings.reset(); return; } const auto identity = flow.league_pairings()->state().identity; if (presented_pairings && *presented_pairings == identity) return; const auto image = process_timer_image(flow.render()); 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_RenderPresent(renderer); flow.mark_league_pairings_presented_source_seconds(pairings_source_seconds()); presented_pairings = identity; dirty = false; }; const auto service_pairings_timer = [&] { present_pairings_redraw(); const auto tick = flow.tick_league_pairings_source_seconds(pairings_source_seconds()); if (tick.request != ui::FlowRequest::none) { handle(tick); // Move anchors its clock after each accepted full redraw. present_pairings_redraw(); } }; //PresentManagerDialog presents its question before polling2de66. Bind the actual //freshly drawn frame, never an old texture or a preceding modal ACK. using StadiumQuestionFrame = std::array; std::optional presented_stadium_question; const auto stadium_question_frame = [&]() -> std::optional { if (!session || !flow.in_stadium()) return {}; const auto& question=flow.stadium()->state(); if (!question.construction_tip_dialog && !question.periphery_quote_dialog) return {}; const auto& state=flow.stadium()->state(); return StadiumQuestionFrame{session->session_id(),uint64_t(state.manager_slot),state.scope,state.sequence,state.revision}; }; const auto mark_stadium_question_presented = [&] { presented_stadium_question=stadium_question_frame(); }; const auto service_stadium_deadline = [&] { const auto owner=stadium_question_frame(); if (!owner || owner!=presented_stadium_question) return false; if (!session->stadium_tip_deadline_expired() && !poll_process_timer(false,false)) return false; const auto expired = flow.expire_stadium_tip(); if (expired.request == ui::FlowRequest::none) return false; handle(expired); return true; }; const auto service_idle_stadium_deadline = [&] { // OriginalMouseSound/Sample can synthesize event8 on expiry, including idle. // ExpireQuestion's held-button helper must return before57ef7 answers. if (flow.in_stadium() && !flow.stadium()->construction_tip_held()) service_stadium_deadline(); }; using NationalPickerFrame = std::pair; std::optional presented_national_picker; const auto national_picker_frame = [&]() -> std::optional { if (!session || flow.screen_name() != "national_friendly_picker" || !flow.national_friendly_owner()) return {}; return NationalPickerFrame{session->session_id(),*flow.national_friendly_owner()}; }; const auto mark_national_picker_presented = [&] { presented_national_picker=national_picker_frame(); }; using FriendlyPickerFrame = std::array; std::optional presented_friendly_picker; const auto friendly_picker_frame = [&]() -> std::optional { const auto* picker=flow.friendly_opponent_picker(); if (!session || !picker || !flow.desktop()) return {}; const auto& desk=flow.desktop()->state(); return FriendlyPickerFrame{session->session_id(),uint64_t(desk.manager_slot), uint64_t(desk.runtime_club),desk.revision,uint64_t(picker->selected_league())}; }; const auto mark_friendly_picker_presented = [&] { presented_friendly_picker=friendly_picker_frame(); }; using FriendlyCalendarFrame = std::array; std::optional presented_friendly_calendar; const auto friendly_calendar_frame = [&]() -> std::optional { if (!session || !flow.friendly_calendar_quote()) return {}; const auto& quote=*flow.friendly_calendar_quote(); return FriendlyCalendarFrame{session->session_id(),uint64_t(quote.manager_slot), uint64_t(quote.runtime_team),quote.revision,quote.request_id}; }; const auto mark_friendly_calendar_presented = [&] { presented_friendly_calendar=friendly_calendar_frame(); }; using FriendlyQuestionFrame = std::array; std::optional presented_friendly_question; const auto friendly_question_frame = [&]() -> std::optional { const auto* question=flow.friendly_question_screen(); if(!session||!question||!flow.desktop())return {}; const auto& desk=flow.desktop()->state(); return FriendlyQuestionFrame{session->session_id(),uint64_t(desk.manager_slot), uint64_t(desk.runtime_club),desk.revision,uint64_t(question->stage()), uint64_t(question->selected_opponent()),question->quote()?question->quote()->request_id:0, uint64_t(question->active_question()->source_manager_flags)}; }; const auto mark_friendly_question_presented = [&] { presented_friendly_question=friendly_question_frame(); }; const auto service_friendly_question_deadline = [&] { const auto owner=friendly_question_frame(); if(!owner||owner!=presented_friendly_question||!poll_process_timer(false,false))return false; const auto expired=flow.expire_friendly_question(true); if(expired.request==ui::FlowRequest::none&&!expired.changed)return false; handle(expired);return true; }; const auto service_process_timer = [&] { // SDLFlushEvents3's notice owns its wait. Keep the desk clock polling, // but hand its outer expiry back only after this notice restores. if(flow.timed_notice_open()) { poll_process_timer(!dirty,false); return; } if (!session || !flow.desktop()) { process_timer.stop(); process_timer_owner.reset(); process_timer_frame.reset(); return; } if (flow.screen_name() == "desktop") { const auto& desk = flow.desktop()->state(); const ProcessTimerOwner owner{session->session_id(), desk.manager_slot, desk.day_counter}; const auto minutes = session->state().memory.u8(::bmh::layout::CareerSession_DispatchStrengths_ExecutableField); if (!process_timer_owner || *process_timer_owner != owner) { process_timer.start(minutes, process_source_seconds()); process_timer_owner = owner; } else if (process_timer.paused()) { process_timer.resume(minutes, process_source_seconds()); } } // ExpireQuestion's held controls and Source calculator waits own their // release. The outer event8 is serviced after that owner returns. //1e06b paints its initial nation bank before the first2de66 poll. const auto picker_owner=national_picker_frame(); if (picker_owner && picker_owner!=presented_national_picker) return; //50775 paints its accepted league before its first51135/OriginalMouseSound poll. const auto friendly_picker_owner=friendly_picker_frame(); if (!friendly_picker_owner) presented_friendly_picker.reset(); if (friendly_picker_owner && friendly_picker_owner!=presented_friendly_picker) return; //CalendarCell presents the initial calendar before its input loop. const auto calendar_owner=friendly_calendar_frame(); if (calendar_owner && calendar_owner!=presented_friendly_calendar) return; const auto question_owner=stadium_question_frame(); if (question_owner && question_owner!=presented_stadium_question) return; const auto friendly_question_owner=friendly_question_frame(); if(!friendly_question_owner)presented_friendly_question.reset(); if(friendly_question_owner&&friendly_question_owner!=presented_friendly_question)return; if (press || (flow.friendly_question_screen()&&flow.friendly_question_screen()->question_held())) { //ExpireQuestion still polls the clock while holding its button. Only //the timer row advances; the answer and frame ACK stay owned. if (question_owner || friendly_picker_owner || friendly_question_owner) poll_process_timer(!dirty,false); return; } // A clock repaint never re-enters a table/forecast draw or ACK. if (poll_process_timer(!dirty, false)) { int window_x=0,window_y=0; SDL_GetMouseState(&window_x,&window_y); float logical_x=0,logical_y=0; SDL_RenderWindowToLogical(renderer,window_x,window_y,&logical_x,&logical_y); const auto expired = flow.process_timer_expired(int(logical_x),int(logical_y)); if (expired.request != ui::FlowRequest::none || expired.changed) handle(expired); } }; // OpenBMH deviates from the original: display the repository-owned title // at its native resolution until a complete left/right click, without loading balls. { app::StartScreen title_screen(renderer); title_screen.present(); bool opening_confirmed = false; std::optional opening_press; while (running && !opening_confirmed) { SDL_Event opening_event; while (quit_confirmation.poll(&opening_event)) { if (opening_event.type == SDL_QUIT) running = false; if (opening_event.type == SDL_KEYDOWN && opening_event.key.keysym.sym == SDLK_ESCAPE && quit_confirmation.confirm()) running = false; if (opening_event.type == SDL_WINDOWEVENT && (opening_event.window.event == SDL_WINDOWEVENT_EXPOSED || opening_event.window.event == SDL_WINDOWEVENT_SIZE_CHANGED)) title_screen.present(); if (opening_event.type == SDL_WINDOWEVENT && opening_event.window.event == SDL_WINDOWEVENT_FOCUS_LOST) opening_press.reset(); if (opening_event.type == SDL_MOUSEBUTTONDOWN && (opening_event.button.button == SDL_BUTTON_LEFT || opening_event.button.button == SDL_BUTTON_RIGHT)) opening_press = opening_event.button.button; if (opening_event.type == SDL_MOUSEBUTTONUP && opening_press && opening_event.button.button == *opening_press) opening_confirmed = true; } SDL_Delay(10); } } // Restore the indexed game canvas and its logical input mapping. // Opening input must not also change an option on the first setup frame. SDL_FlushEvents(SDL_KEYDOWN, SDL_KEYUP); SDL_FlushEvents(SDL_MOUSEMOTION, SDL_MOUSEBUTTONUP); season_backdrop.reset(); dirty = true; SDL_StartTextInput(); bool filename_input_active = false; std::array setup_button_down{}; while (running) { const bool filename_open = flow.screen_name() == "save_load"; if (filename_open && !filename_input_active) focus_filename_input(renderer); filename_input_active = filename_open; if(timed_notice_presented_at && flow.timed_notice_open() && SDL_GetTicks64()-*timed_notice_presented_at>=70*3*20) handle(flow.expire_timed_notice()); service_process_timer(); if (!running) break; SDL_Event e; while (quit_confirmation.poll(&e)) { if (e.type == SDL_QUIT) { running = false; break; } if (e.type == SDL_WINDOWEVENT) { if (e.window.event == SDL_WINDOWEVENT_FOCUS_LOST) setup_button_down.fill(false); if (e.window.event == SDL_WINDOWEVENT_FOCUS_GAINED) { if (flow.screen_name() == "save_load") focus_filename_input(renderer); else SDL_StartTextInput(); } } // A native picker/window activation can leave an unmatched UP. // Only a press which began on setup may toggle its options. if ((e.type == SDL_MOUSEBUTTONDOWN || e.type == SDL_MOUSEBUTTONUP) && (e.button.button == SDL_BUTTON_LEFT || e.button.button == SDL_BUTTON_RIGHT)) { const size_t button = e.button.button == SDL_BUTTON_LEFT ? 0 : 1; if (e.type == SDL_MOUSEBUTTONDOWN) setup_button_down[button] = flow.screen_name() == "setup"; else { const bool owned = setup_button_down[button]; setup_button_down[button] = false; if (flow.screen_name() == "setup" && !owned) continue; } } if(e.type==SDL_MOUSEBUTTONUP&&timed_notice_release&&e.button.button==*timed_notice_release) { timed_notice_release.reset();continue; } if(flow.timed_notice_open()&&e.type==SDL_MOUSEBUTTONDOWN&& (e.button.button==SDL_BUTTON_LEFT||e.button.button==SDL_BUTTON_RIGHT)) { // PresentManagerDialog consumes DOWN. Do not deliver its release to // the restored caller as a second booking/purchase. timed_notice_release=e.button.button;press.reset(); handle(flow.expire_timed_notice());continue; } if(flow.timed_notice_open()&&(e.type==SDL_KEYDOWN||e.type==SDL_TEXTINPUT))continue; // InLeaguePairings handles a changed league selector before5147b's // timer. Preserve that precedence without moving other inputs. bool selector_consumed = false; if (e.type == SDL_MOUSEBUTTONDOWN && e.button.button == SDL_BUTTON_LEFT && flow.in_league_pairings()) { const auto selection = flow.league_pairings()->selector_event(e.button.x,e.button.y); if (selection && (selection->kind == LeaguePairingsAction::toggle_group || selection->value != flow.league_pairings()->state().source.owner.league)) { handle(flow.pointer_down(e.button.x,e.button.y)); present_pairings_redraw(); selector_consumed = true; } } // Other polled input keeps the Original timer precedence; // held controls remain blocked by release ownership. service_process_timer(); service_pairings_timer(); service_balance_timer(); service_family_table(); service_stadium_calculator(); service_idle_stadium_deadline(); if (queue_table_range_event(e)) { service_family_table(); continue; } if (flow.in_stadium() && flow.stadium()->calculator_source_waiting()) { // DecodeTaxAnimationScript2 delays without consuming keyboard input. Retain // FIFO keys for this accepted calculator owner, including // every digit of one SDL text-input packet. queue_calculator_event(e); if (e.type == SDL_MOUSEBUTTONUP && e.button.button == SDL_BUTTON_LEFT && flow.stadium()->calculator_waiting_for_key_release() && !calculator_release) { const auto& owner = flow.stadium()->state(); calculator_release = CalculatorRelease{e.button, owner.scope, owner.sequence}; } // The Source calculator helper owns input until its wait // completes. SDL_QUIT was serviced above this barrier. continue; } if (flow.in_stadium() && flow.stadium()->calculator_open() && queue_calculator_event(e)) { service_stadium_calculator(); continue; } if (e.type == SDL_KEYDOWN && e.key.keysym.sym == SDLK_ESCAPE && !flow.in_preparation_menu() && !flow.in_results_view() && !flow.in_readonly_view() && quit_confirmation.confirm()) running = false; if (e.type == SDL_MOUSEBUTTONDOWN && e.button.button == SDL_BUTTON_LEFT) press = Press{e.button.x, e.button.y, SDL_GetTicks(), flow.screen_name(), ui::pointer_hold_source_ticks(SDL_GetTicks64()), revision}; if (e.type == SDL_MOUSEBUTTONDOWN && e.button.button == SDL_BUTTON_RIGHT) right_press_screen = flow.screen_name(); if(!selector_consumed&&e.type==SDL_MOUSEBUTTONDOWN&&(flow.desktop()||flow.in_balance()||flow.in_desk_records()||flow.in_achievements()||flow.in_indoor_standings()||flow.in_reschedule_calendar()||flow.in_league_pairings()||flow.in_family_table()||flow.in_toto_calculator()||flow.in_stadium()||flow.in_environment()||flow.in_strengths()||flow.in_top_scorers()||flow.in_opportunities()||flow.in_statistics_menu()||flow.in_statistics_page()||flow.in_analytics()||flow.in_other_games()||flow.in_pitch()||flow.in_settings())&& (e.button.button==SDL_BUTTON_LEFT||e.button.button==SDL_BUTTON_RIGHT)) { handle(flow.pointer_down(e.button.x,e.button.y,e.button.button==SDL_BUTTON_RIGHT)); if (!running) break; if(flow.in_family_table()) { // This path also owns pressed KB6 frames. Upload and // copy must succeed before their Present starts a wait // or commits a staged forecast random stream. present_family_table_redraw(); } else if(flow.in_balance()||flow.in_desk_records()||flow.in_achievements()||flow.in_indoor_standings()||flow.in_reschedule_calendar()||flow.in_league_pairings()||flow.in_stadium()||flow.in_environment()||flow.in_strengths()||flow.in_top_scorers()||flow.in_opportunities()||flow.in_statistics_menu()||flow.in_statistics_page()||flow.in_analytics()||flow.in_other_games()||flow.in_pitch()||flow.in_settings()||flow.friendly_question_screen()) { //48529/ExpireQuestion/67e80 present the held control before waiting //for its release. The existing UP ownership remains intact. const auto image=process_timer_image(flow.render()); for(size_t i=0;isocket_confirmation_armed()) { // SDLSetWindowTitle paints its pressed socket sprite before // DeskDate waits for the physical release. SDL_SetWindowTitle(window, "OpenBMH - desktop"); const auto image=process_timer_image(flow.render()); for(size_t i=0;ix && e.button.y == press->y && press->screen == flow.screen_name() && SDL_GetTicks() - press->time >= 2000; const auto released = held ? flow.hold(e.button.x, e.button.y, 2000) : flow.click(e.button.x, e.button.y, e.button.button == SDL_BUTTON_RIGHT, e.button.clicks >= 2); present_formation_save_feedback(); handle(released); present_desk_record_points(); press.reset(); } if (e.type == SDL_MOUSEMOTION) { if (press && (e.motion.x != press->x || e.motion.y != press->y)) press.reset(); const auto moved = flow.move_action(e.motion.x, e.motion.y); if (moved.request != ui::FlowRequest::none) handle(moved); else dirty |= moved.changed; // BalanceFromGame presents a drag move before sampling the next // keyboard/mouse event, even when both are already queued. present_family_table_redraw(); } if (e.type == SDL_TEXTINPUT) { try { dirty |= flow.text(e.text.text); present_desk_record_points(); } catch (const FormatError& err) { std::fprintf(stderr, "input: %s\n", err.what()); } } if (e.type == SDL_KEYDOWN && flow.screen_name() == "save_load" && e.key.keysym.sym == SDLK_a && (e.key.keysym.mod & (KMOD_CTRL | KMOD_GUI))) { handle(flow.send_key("SELECT_ALL")); continue; } if (e.type == SDL_KEYDOWN && (e.key.keysym.sym == SDLK_RETURN || e.key.keysym.sym == SDLK_BACKSPACE || (flow.screen_name() == "save_load" && (e.key.keysym.sym == SDLK_UP || e.key.keysym.sym == SDLK_DOWN || e.key.keysym.sym == SDLK_PAGEUP || e.key.keysym.sym == SDLK_PAGEDOWN)) || ((flow.in_preparation_menu() || flow.in_results_view() || flow.in_readonly_view()) && e.key.keysym.sym == SDLK_ESCAPE) || ((flow.in_results_view() || flow.in_readonly_view() || flow.screen_name() == "friendly_match") && (e.key.keysym.sym == SDLK_LEFT || e.key.keysym.sym == SDLK_RIGHT || e.key.keysym.sym == SDLK_SPACE)) || ((flow.in_balance() || flow.in_stadium()) && e.key.keysym.sym == SDLK_SPACE) || (flow.desktop() && !flow.in_balance() && e.key.keysym.sym >= SDLK_a && e.key.keysym.sym <= SDLK_z))) { const std::string key = e.key.keysym.sym == SDLK_RETURN ? "ENTER" : e.key.keysym.sym == SDLK_BACKSPACE ? "BACKSPACE" : e.key.keysym.sym == SDLK_ESCAPE ? "ESC" : e.key.keysym.sym == SDLK_LEFT ? "LEFT" : e.key.keysym.sym == SDLK_RIGHT ? "RIGHT" : e.key.keysym.sym == SDLK_SPACE ? "SPACE" : e.key.keysym.sym == SDLK_UP ? "UP" : e.key.keysym.sym == SDLK_DOWN ? "DOWN" : e.key.keysym.sym == SDLK_PAGEUP ? "PAGEUP" : e.key.keysym.sym == SDLK_PAGEDOWN ? "PAGEDOWN" : std::string(1, char('A' + e.key.keysym.sym - SDLK_a)); handle(flow.send_key(key)); present_desk_record_points(); } if (!running) break; } if (!running) break; service_pitch_hold(); if (!running) break; service_process_timer(); service_pairings_timer(); service_balance_timer(); service_family_table(); service_stadium_calculator(); service_idle_stadium_deadline(); if (const auto* desk = flow.desktop()) for (const auto id : desk->take_sound_ids()) app::original_audio_command(playback, id); if (session) playback.set_original_options(app::original_audio_options(session->state(), music_enabled)); if (playback.needs_pump()) { playback.pump(audio_error); if (!audio_error.empty()) std::fprintf(stderr, "audio: %s\n", audio_error.c_str()); } if (flow.in_family_table()) { // Family ACKs belong to a freshly rendered, successfully // copied image. Do not ACK an old texture at the routine // end-of-loop Present after an earlier ACK changed the Flow. present_family_table_redraw(); } else { // A preceding service Present can request the calculator's // restored-underlay frame. This fresh end-of-loop frame owns // its own ACK; an unchanged texture never advances the modal. const bool toto_calculator_redraw = dirty && flow.in_toto_calculator(); const bool stadium_redraw = dirty && flow.in_stadium(); const bool national_picker_redraw = dirty && national_picker_frame().has_value(); const bool friendly_picker_redraw = dirty && friendly_picker_frame().has_value(); const bool friendly_calendar_redraw = dirty && friendly_calendar_frame().has_value(); const bool friendly_question_redraw = dirty && friendly_question_frame().has_value(); const bool source_modal_redraw = toto_calculator_redraw || stadium_redraw || national_picker_redraw || friendly_picker_redraw || friendly_calendar_redraw || friendly_question_redraw; if (dirty) { const auto image = process_timer_image(flow.render()); for (size_t i = 0; i < pixels.size(); ++i) pixels[i] = palette.argb[image.pixels[i]]; if (SDL_UpdateTexture(texture, nullptr, pixels.data(), 320 * 4) != 0 && source_modal_redraw) throw std::runtime_error(std::string("Source modal texture: ") + SDL_GetError()); dirty = false; } pitch_pointer.show(flow.pitch_pointer_cursor(palette), renderer); const int cleared = SDL_RenderClear(renderer); const int copied = SDL_RenderCopy(renderer, texture, nullptr, nullptr); if (source_modal_redraw && (cleared != 0 || copied != 0)) throw std::runtime_error(std::string("Source modal renderer: ") + SDL_GetError()); SDL_RenderPresent(renderer); if(flow.timed_notice_open()&&!timed_notice_presented_at) timed_notice_presented_at=SDL_GetTicks64(); if (stadium_redraw) mark_stadium_question_presented(); if (national_picker_redraw) mark_national_picker_presented(); if (friendly_picker_redraw) mark_friendly_picker_presented(); if (friendly_calendar_redraw) mark_friendly_calendar_presented(); if (friendly_question_redraw) mark_friendly_question_presented(); if (toto_calculator_redraw) mark_family_table_presented(); mark_stadium_calculator_presented(); if(flow.in_balance()) { const auto identity=flow.balance()->state().identity; const bool notice=flow.balance()->notice_open(); flow.mark_balance_presented_source_milliseconds(balance_source_milliseconds()); presented_balance=identity;presented_balance_notice=notice; } } SDL_Delay(10); } SDL_StopTextInput(); pitch_pointer.clear(); SDL_DestroyTexture(texture); SDL_DestroyRenderer(renderer); SDL_DestroyWindow(window); mouse_sound.detach(); // Remove event producers before closing the audio device. playback.shutdown(); return 0; } catch (const std::exception& e) { std::fprintf(stderr, "error: %s\n", e.what()); return 1; } }