Compare commits

...
25 Commits
Author SHA1 Message Date
ClaudeandClaude Fable 5.2 7031f4ff02 Manager record size and table size checks use the named constants
Prepare verified release / draft (push) Waiting to run
108 products of the form size_t(x) * 0xb0c read kManagerRecordSize (the type of
the product is unchanged). The career start and the pairings check their table
sizes against the world layout instead of 168, 138 and 9.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-12 22:37:17 +01:00
ClaudeandClaude 9daf649563 Prepare release 1.0.13
Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-11 15:25:20 +01:00
ClaudeandClaude 9870d90d65 Tests share one check helper; stale references in comments corrected
116 test files had their own identical copy of check(bool, const char*); they
use bmh::test_support::check from src/testing/check.hpp. Seven comments pointed
to documents that no longer exist or named a former author.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-11 14:52:42 +01:00
ClaudeandClaude 205a543b40 Layout constants of the world and league tables named by meaning
Ten constants with generated names (CareerSession_InstallLeagueSizes_RuntimeField*,
CareerSession_DispatchLineup_RuntimeField, CupDraw_FormatError_RuntimeField2/3, ...)
are LeagueClubCount, LeagueEuropeanPlaces, LeagueRelegationPlaces, LeagueNameSuffixes,
PromotionGroupBelowCounts/Leagues, NewcomerClubCount, ForeignCupClubCount and
ManagerRecord0Club/4Club. Values unchanged; the layout reference is regenerated.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-11 12:10:30 +01:00
ClaudeandClaude 33566566ac Split the career session into files by topic
career_session.cpp (9,000 lines) is now eight files: construction and turn,
club dialogs, league family, statistics, transfers, desk, match, management.
Every function moved unchanged. Helpers used by one topic live in its file,
the seven shared ones in the internal header career_session_internal.hpp.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-11 08:57:58 +01:00
ClaudeandClaude 81046f89f2 Name the per-league stride of the results block; document the world layout
kLeagueResultsStride (records.hpp) replaces the literal 0x17C at 17 places, a
static_assert ties the block size to the league count. docs/architecture.md
describes WorldLayout, LeagueSystem and what is still fixed for a larger world.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-11 08:34:41 +01:00
ClaudeandClaude 31ff36fb09 Record sizes in one header; the engine's club count from the world layout
game/records.hpp names the sizes of the manager record, the tactics board, a
board slot and the club record; 58 local copies of these numbers refer to it.
The six local club count constants of the engine (138) are gone, their uses
read world_layout().league_teams.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-11 00:15:40 +01:00
ClaudeandClaude d552c59a77 Team id comparisons ask the world layout
92 comparisons against the raw numbers 138, 168 and 357 in engine, UI and app
read world_layout().league_teams, first_foreign_cup() and no_team(); a team id
written as 0x165 is kNoTeam. Same values, same arithmetic.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-10 23:16:53 +01:00
ClaudeandClaude cb6d3b6035 League system: the league tables of the loaded game as one structure
The mutable globals of schedule.hpp (league sizes, calendar groups, promotion
ladder, European places, league suffixes, newcomers, English competitions) are
members of LeagueSystem in world_layout.hpp, read through league_system() and
written only by the installer of a game version. Values and uses are unchanged.
The size check of set_league_sizes asks the world layout for the league teams.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-10 22:13:40 +01:00
ClaudeandClaude 74d6cde914 World layout: team id ranges and the squad slot table as data
WorldLayout names the dimensions of a game world (league clubs, amateurs,
foreign cup clubs, the pseudo team, national teams, squad slots and pools).
classic_world_layout() holds the numbers of the original; squad_range() and
team_average() ask it instead of literals. A test compares squad_range() with
the former arithmetic for every team id and checks that inconsistent layouts
are refused.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-10 21:19:54 +01:00
ClaudeandClaude 0bcb0d2507 Name the asset viewer openbmh_viewer
On a file system that ignores case the viewer (target openbmh) and the game
(OpenBMH, target openbmh_play) were the same file in the build directory, and
whichever was linked last replaced the other.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-10 21:19:53 +01:00
ClaudeandClaude 8a37be898a Split the window program into files by topic
struct App moves out of main.cpp into app/app.hpp (state and declarations;
the return types are spelled out now, taken from the compiler) and its 94
member functions into
  app_run.cpp         handle() and run(): wiring, title screen, event loop
  app_live.cpp        live match, interventions, event animations, reality mode
  app_transfer.cpp    offers, decisions, market sales, loan returns, poaching
  app_season.cpp      season end and start: tax, promotion, highscore, cup draw
  app_services.cpp    timers and deadlines served between inputs
  app_club.cpp        the club dialogs
  app_sportschau.cpp  the Sportschau
  app_notices.cpp     notices and questions over a screen
main.cpp keeps main(): game data, window, sound (238 lines instead of 4,550).
The function bodies moved unchanged. docs/DIFFERENCES.md is regenerated (a
marker moved to app_run.cpp).

Verified: 211 of 211 tests; careers, UI walk and robot (234 commands)
identical; long robot run (52 kick-offs to April of the season, indoor
tournament included): every desk picture identical.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-10 19:45:58 +01:00
ClaudeandClaude c8dee2c377 App::run: the hook presenters are named members
run() assigned 16 presenter lambdas to the hooks before it showed the title
screen. They are member functions now (present_sportschau_intro,
present_matchday_intro, present_sportschau_replay_step,
present_sportschau_scene, present_competition_winner, present_tax_event,
present_promotion, club_information_dialog, club_player_dialog,
player_detail_dialog, club_statistics_dialog, select_poach_player,
present_cup_draw, ...); run() assigns a forwarding lambda and keeps 437 of
1,240 lines: the wiring, the title screen, the event loop and the tear-down.
The bodies moved unchanged.

Verified: robot (234 commands), UI walk, 9 careers identical; 211 of 211
tests.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-10 18:09:02 +01:00
ClaudeandClaude 99200f1dc8 App::handle: the presenters passed to the controller are named members
handle() was 1,628 lines: the call of serve_flow_request with 22 presenter
lambdas written inline. They are member functions now (present_live_minute,
observe_live_minute, animate_ball / chance / shot / set_piece / booking /
shootout, present_reality, choose_transfer_offer, present_transfer_decision,
present_season_checkpoint, show_club_information, ask_advertising_renewal,
ask_national_friendly, ...), as are its two local helpers
(present_live_lineup, present_running_overview). handle() keeps 111 lines.

handle() is never re-entered (its callers are the service functions and
run(), none of which is reached from inside it), so its ten locals became
members that handle() resets where they were declared. The bodies moved
unchanged.

Verified: robot (234 commands, live match included), UI walk, 9 careers
identical; 211 of 211 tests.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-10 17:59:40 +01:00
ClaudeandClaude 71aeb7cc61 main.cpp: struct App with one member function per presenter
main() held the whole window program in one function of about 4,300 lines:
the state as locals and 53 presenters and services as lambdas capturing
them. Now main() only sets up the game data, the window and the sound (40
statements) and runs App:
- the objects main() created are reference members under their old names,
- the state between the former lambdas are members,
- every former top-level lambda is a member function, in the original order
  (present_season, show_tax, wait_sportschau_ack, present_live_lineup,
  service_family_table, ...),
- App::run() holds the statements that stood between them: wiring of the
  hooks, title screen, event loop, tear-down.
The code inside moved unchanged. Three hook variables that were initialised
with a lambda are assigned in run(); five presenters that are passed on as
values get a forwarding lambda.

This makes the presenters addressable: the next steps move them into files
of their own, which is also the seam for replacing screens one by one.

Verified: robot (234 commands: title, new career, season start, every desk
icon, two matchdays with the live match), UI walk, 9 careers identical;
211 of 211 tests.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-10 17:05:10 +01:00
ClaudeandClaude 2173915d20 app/canvas.hpp: Canvas::show replaces 24 copies of "picture to window"
main.cpp spelled out the same six statements wherever a presenter showed a
picture: convert with the palette, update the texture, clear, copy, present.
They are now canvas.show(image, palette), in the same order and with the
same handling of SDL errors. Presenters that check the SDL calls or update
only a part of the texture keep their own code.

Verified with the robot (234 commands, identical), the UI walk, the careers
and 211 of 211 tests.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-10 16:13:00 +01:00
ClaudeandClaude ff32ef1dbc Robot: play the window program from a script, for regression tests
A test hook for src/app/main.cpp, which the headless tools bypass. With
OPENBMH_ROBOT=<script> and OPENBMH_ROBOT_LOG=<file> (usually with the SDL
dummy video and audio drivers) the game reads clicks and keys from the script
instead of the mouse, waits after each command until the picture has settled
and writes its fingerprint; OPENBMH_ROBOT_SHOTS=<dir> also saves the pictures.
The events go through SDL's queue, so they take the path of real input.

Hooks: app::present() replaces the 31 SDL_RenderPresent calls of main.cpp,
QuitConfirmation::poll() lets the robot queue its next command when no input
is waiting, and a robot run answers the quit question itself. Without the
environment variables nothing changes.

Verified: a script of 234 commands (title, new career, season start
presentations, every desk icon, two matchdays with the live match) gives the
same file in three runs; 211 of 211 tests; careers and UI walk identical.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-10 15:36:08 +01:00
ClaudeandClaude b7f748688c Controller: one named handler per request instead of a 2,000 line function
serve_flow_request was one function of about 2,000 lines with 53 branches.
Its body now lives in FlowRequestServer: the arguments as reference members
under their parameter names and one member function per kind of request
(open_league_table, handle_bank_action, play_matchday, handle_savegame_file,
open_manager_join, ...). serve() asks the handlers in the original order and
keeps the guards between them. The code of every branch moved verbatim; six
lambdas that captured a parameter by name now use an init-capture of the same
object.

This is also the first step towards replacing screens one by one: a request
kind has a name and one place.

Verified: 211 of 211 tests; 9 headless careers and the UI walk (German and
English, about 5,460 steps each) identical.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-10 15:06:07 +01:00
ClaudeandClaude 16b9b24c84 Text encoding moves to formats/text_encoding; app sources built once on MSVC
- json_quote, original_to_utf8 and utf8_to_original lived in ui/manager, the
  manager dialog, although every screen, the console client and the app use
  them. They move byte for byte to formats/text_encoding (namespace bmh);
  ui/manager.hpp keeps them visible as bmh::ui::... .
- The app sources (career session, window/desktop actions, controller) are
  object libraries on MSVC too, compiled with /utf-8 like the game. Before,
  the MSVC build compiled the 9,000 line career_session.cpp again for each of
  about forty tests and tools.

Verified: 211 of 211 tests; 9 headless careers identical; the UI walk
differs only on the stadium screen, as expected from the 96,000 place
limits merged from main (reference re-recorded).

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-10 15:00:15 +01:00
Claude e174f99594 Merge main into foundation (stadium limits, test fixtures) 2026-11-10 14:23:41 +01:00
ClaudeandClaude 3ceb431aa4 Tests: fixtures use the default manager name the dialog offers
other_games_ui_tests and ui_preparation_tests still expected "Nobody"; the
manager dialog offers "OpenBMH", so the attachment check rejected the fixture.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-10 14:23:30 +01:00
ClaudeandClaude a503fff55f Stadium: back to the edition's block limits (Diamond 3.7: 96,000 places)
The extension to 144,000 places of 1.0.3 is withdrawn: the match broadcast of
the original has no room for attendances of 100,000 and more and showed them
wrongly. Limits, unit prices and construction weeks now come from the edition
unchanged (3.7: 8/18/8/14 thousand per block, 30/37/30/25 weeks). A savegame
with a larger stadium keeps its places but cannot extend such a block further.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-10 14:23:29 +01:00
ClaudeandClaude fb3c2fe757 ui/draw.hpp: one place for the pixel loops of fill and copy
67 file-local helpers (fill/rect/copy/copy_region/... in 39 screens) now call
draw::fill, draw::copy_clipped or draw::copy_unclipped. Only the loops moved:
every screen keeps its own wrapper with its bounds check and error text, so
the contracts are unchanged. Eight helpers with special behaviour stay as
they are (bank, season promotion, toto, tax animation, ...).

Verified: 9 headless careers and the scripted UI walk (German and English
data, 38 screens, about 5,460 steps each) give the same fingerprints as
before. ctest: 209 of 211; other_games_ui_tests and ui_preparation_tests
fail the same way without this change.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-10 13:07:24 +01:00
ClaudeandClaude 901f3dec1c Regression net for behaviour-preserving refactoring
- game/digest: fingerprint of the whole game state (saved stream, unsaved
  run-time values, both random generators)
- season_sim: SIM_DIGEST=<file> writes one digest per desk; SIM_LEAGUE picks
  the start league
- tools/ci/compare_digests.py compares two directories of digest files
- ui_walk (tool): replays an input script against the UI flow and the
  production controller without a window, one picture/state fingerprint per step
- openbmh_ui --frames: the same fingerprints for its scripted mode

No change of game behaviour. Reference files live outside the repository.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-10 11:16:52 +01:00
ClaudeandClaude Sonnet 5.5 d9d408069e Indoor kick-off strengths explained: runtime chance weather, not the engine
The six side strengths of an indoor round depend on the chance weather kept
from the last chance of the round before (a runtime value the savegame does
not hold). With WEEK_PREV_WEATHER the kick-off of all eleven recorded rounds
equals the real 3.7. week_check gets that switch plus development helpers for
weather, line-up and formation table; the measurement document is updated.

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-09 22:19:20 +01:00
282 changed files with 14948 additions and 12981 deletions

No files matched your search

+1 -1
View File
@@ -62,4 +62,4 @@ jobs:
GH_TOKEN: ${{ github.token }}
RELEASE_TAG: ${{ github.ref_name }}
run: |
gh release create "$RELEASE_TAG" dist/*.zip dist/SHA256SUMS dist/QA-REPORT.json --draft --verify-tag --title "OpenBMH $RELEASE_TAG" --notes-file docs/release/1.0.12/RELEASE_NOTES.md
gh release create "$RELEASE_TAG" dist/*.zip dist/SHA256SUMS dist/QA-REPORT.json --draft --verify-tag --title "OpenBMH $RELEASE_TAG" --notes-file docs/release/1.0.13/RELEASE_NOTES.md
+62 -21
View File
@@ -1,6 +1,6 @@
# SPDX-License-Identifier: GPL-3.0-only
cmake_minimum_required(VERSION 3.24)
project(OpenBMH VERSION 1.0.12 LANGUAGES CXX C)
project(OpenBMH VERSION 1.0.13 LANGUAGES CXX C)
if(APPLE)
# Enable native languages before dependencies/subdirectories inherit rules.
enable_language(OBJC OBJCXX)
@@ -126,24 +126,38 @@ if(TARGET SDL2::SDL2main)
list(PREPEND BMH_SDL_TARGET SDL2::SDL2main)
endif()
# App sources share objects only within identical compile environments.
# MSVC consumers currently differ in target/source /utf-8 flags; keep that path.
set(BMH_APP_SESSION_SOURCE "${CMAKE_CURRENT_SOURCE_DIR}/src/app/career_session.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/src/app/window_actions.cpp"
"${CMAKE_CURRENT_SOURCE_DIR}/src/app/desktop_actions.cpp")
set(BMH_APP_SESSION_SDL_SOURCE "${BMH_APP_SESSION_SOURCE}")
set(BMH_APP_CONTROLLER_SOURCE "${CMAKE_CURRENT_SOURCE_DIR}/src/app/controller.cpp")
if(NOT MSVC)
add_library(bmh_app_session OBJECT src/app/career_session.cpp src/app/window_actions.cpp src/app/desktop_actions.cpp)
target_link_libraries(bmh_app_session PRIVATE bmhui)
add_library(bmh_app_session_sdl OBJECT src/app/career_session.cpp src/app/window_actions.cpp src/app/desktop_actions.cpp)
target_link_libraries(bmh_app_session_sdl PRIVATE bmhui openbmh_audio ${BMH_SDL_TARGET})
add_library(bmh_app_controller_sdl OBJECT src/app/controller.cpp)
target_link_libraries(bmh_app_controller_sdl PRIVATE bmhui openbmh_audio ${BMH_SDL_TARGET})
set(BMH_APP_SESSION_SOURCE "$<TARGET_OBJECTS:bmh_app_session>")
set(BMH_APP_SESSION_SDL_SOURCE "$<TARGET_OBJECTS:bmh_app_session_sdl>")
set(BMH_APP_CONTROLLER_SOURCE "$<TARGET_OBJECTS:bmh_app_controller_sdl>")
# The app sources (career session, window/desktop actions, controller) are compiled once per
# compile environment and shared as objects by the game and by about forty tests and tools.
# On MSVC they are compiled with /utf-8 like the game itself: their German messages are UTF-8
# string literals. (Until 1.0.12 the MSVC build compiled these sources again for every
# consumer, which cost most of the build time; controller.cpp then got /utf-8 only from
# targets that set it.)
# The career session is defined by topic in career_session*.cpp (the class: src/app/career_session.hpp).
set(BMH_APP_SESSION_SOURCES
src/app/career_session.cpp
src/app/career_session_club.cpp
src/app/career_session_league.cpp
src/app/career_session_statistics.cpp
src/app/career_session_transfer.cpp
src/app/career_session_desk.cpp
src/app/career_session_match.cpp
src/app/career_session_management.cpp
src/app/window_actions.cpp
src/app/desktop_actions.cpp)
add_library(bmh_app_session OBJECT ${BMH_APP_SESSION_SOURCES})
target_link_libraries(bmh_app_session PRIVATE bmhui)
add_library(bmh_app_session_sdl OBJECT ${BMH_APP_SESSION_SOURCES})
target_link_libraries(bmh_app_session_sdl PRIVATE bmhui openbmh_audio ${BMH_SDL_TARGET})
add_library(bmh_app_controller_sdl OBJECT src/app/controller.cpp)
target_link_libraries(bmh_app_controller_sdl PRIVATE bmhui openbmh_audio ${BMH_SDL_TARGET})
if(MSVC)
target_compile_options(bmh_app_session PRIVATE /utf-8)
target_compile_options(bmh_app_session_sdl PRIVATE /utf-8)
target_compile_options(bmh_app_controller_sdl PRIVATE /utf-8)
endif()
set(BMH_APP_SESSION_SOURCE "$<TARGET_OBJECTS:bmh_app_session>")
set(BMH_APP_SESSION_SDL_SOURCE "$<TARGET_OBJECTS:bmh_app_session_sdl>")
set(BMH_APP_CONTROLLER_SOURCE "$<TARGET_OBJECTS:bmh_app_controller_sdl>")
# (before the first subdirectory: tests added there are only registered once testing is on)
enable_testing()
@@ -211,6 +225,7 @@ add_library(bmhcore STATIC
src/formats/vga.cpp
src/formats/font.cpp
src/formats/textd.cpp
src/formats/text_encoding.cpp
src/formats/fbm.cpp
src/formats/le.cpp
src/formats/diamond_image.cpp
@@ -267,6 +282,8 @@ add_library(bmhcore STATIC
src/game/bank_credit.cpp
src/game/career.cpp
src/game/save.cpp
src/game/digest.cpp
src/game/world_layout.cpp
src/game/turn.cpp
src/game/turn_driver.cpp
)
@@ -278,7 +295,11 @@ else()
target_compile_options(bmhcore PRIVATE -Wall -Wextra)
endif()
# The asset viewer of the first milestone (not the game). Its file is named openbmh_viewer: as
# "openbmh" it would be the same file as the game (OpenBMH, target openbmh_play below) on a file
# system that ignores case, and whichever of the two was linked last would win.
add_executable(openbmh src/main.cpp)
set_target_properties(openbmh PROPERTIES OUTPUT_NAME openbmh_viewer)
target_link_libraries(openbmh PRIVATE bmhcore ${BMH_SDL_TARGET})
if(MSVC)
target_compile_options(openbmh PRIVATE /utf-8)
@@ -466,8 +487,18 @@ target_link_libraries(start_screen_tests PRIVATE openbmh_start_screen)
add_test(NAME start_screen_tests COMMAND start_screen_tests)
# The playable program: the shared UI library connected to the engine by src/app.
# The game program: main() sets up data, window and sound; struct App (src/app/app.hpp) is the running
# program, its member functions are defined by topic in the app_*.cpp files.
add_executable(openbmh_play
src/app/main.cpp
src/app/app_run.cpp
src/app/app_services.cpp
src/app/app_season.cpp
src/app/app_sportschau.cpp
src/app/app_transfer.cpp
src/app/app_club.cpp
src/app/app_notices.cpp
src/app/app_live.cpp
${BMH_APP_CONTROLLER_SOURCE}
${BMH_APP_SESSION_SDL_SOURCE})
target_link_libraries(openbmh_play PRIVATE bmhui bmhlaunch_dialog openbmh_audio ${BMH_SDL_TARGET})
@@ -478,9 +509,6 @@ set_target_properties(openbmh_play PROPERTIES WIN32_EXECUTABLE TRUE OUTPUT_NAME
target_include_directories(openbmh_play PRIVATE "${CMAKE_BINARY_DIR}/generated")
if(MSVC)
target_compile_options(openbmh_play PRIVATE /utf-8)
# App sources also compile in headless tests/helpers without target /utf-8.
set_source_files_properties(src/app/career_session.cpp src/app/window_actions.cpp
src/app/desktop_actions.cpp PROPERTIES COMPILE_OPTIONS /utf-8)
endif()
# Development helper: drives the career session like the UI, without a window
@@ -513,6 +541,14 @@ if(MSVC)
target_compile_options(app_controller_tests PRIVATE /utf-8)
endif()
bmh_add_data_test(NAME app_controller_tests COMMAND app_controller_tests "${BMH_DATA}")
# Regression tool (not a test): replays an input script against the UI flow and the controller without a
# window and writes picture/state fingerprints per step (see tests/ui_walk.cpp).
add_executable(ui_walk tests/ui_walk.cpp ${BMH_APP_CONTROLLER_SOURCE} ${BMH_APP_SESSION_SDL_SOURCE})
target_link_libraries(ui_walk PRIVATE bmhui openbmh_audio ${BMH_SDL_TARGET})
if(MSVC)
target_compile_options(ui_walk PRIVATE /utf-8)
endif()
set(BMH_TEST_APP_DELAY_SETTINGS_TESTS_INPUT_1 "" CACHE PATH "External input 1 for app_delay_settings_tests; not distributed")
bmh_add_data_test(NAME app_desktop_input_tests COMMAND app_controller_tests "${BMH_DATA}" --desktop-input-only)
bmh_add_data_test(NAME app_advertising_input_tests COMMAND app_controller_tests "${BMH_DATA}" --advertising-input-only)
@@ -1164,6 +1200,11 @@ add_executable(classic_rules_unit_tests tests/classic_rules_unit_tests.cpp)
target_link_libraries(classic_rules_unit_tests PRIVATE bmhcore)
add_test(NAME classic_rules_unit_tests COMMAND classic_rules_unit_tests)
# The Classic world layout equals the numbers the engine used as literals (no game data needed).
add_executable(world_layout_tests tests/world_layout_tests.cpp)
target_link_libraries(world_layout_tests PRIVATE bmhcore)
add_test(NAME world_layout_tests COMMAND world_layout_tests)
add_executable(season_player_reset_tests tests/season_player_reset_tests.cpp)
target_link_libraries(season_player_reset_tests PRIVATE bmhcore)
add_test(NAME season_player_reset_tests COMMAND season_player_reset_tests)
+2 -2
View File
@@ -1,6 +1,6 @@
# OpenBMH
**Classic-Version: 1.0.12.** Die originalgetreue Linie bleibt in diesem Repository.
**Classic-Version: 1.0.13.** Die originalgetreue Linie bleibt in diesem Repository.
Erweiterte Ligen, die gemeinsame deutsche/englische Karriere und der Dateneditor
werden separat als **[OpenBMH-Extended 1.0 Beta](https://github.com/Weyoune/OpenBMH-extended)** entwickelt.
@@ -30,7 +30,7 @@ In Windows PowerShell, use `.\OpenBMH.exe` and `.\openbmh_cli.exe` instead.
To report a problem, start the game with `-debug`. It then writes `openbmh-debug.log` (timestamped events, errors and refused actions) and `openbmh-stderr.log` into the `debug` sub folder of the save directory, and saves the game there after every match day (`DBG00001.FBM`, `DBG00002.FBM`, ...). Attach the log and the last save to the report.
Use a writable save directory and keep backups of existing games. German editions are the primary compatibility target. **Football Limited / English data support is experimental**; original V2.20 save import and some edition-specific behaviour remain limited. See the [release notes](docs/release/1.0.12/RELEASE_NOTES.md).
Use a writable save directory and keep backups of existing games. German editions are the primary compatibility target. **Football Limited / English data support is experimental**; original V2.20 save import and some edition-specific behaviour remain limited. See the [release notes](docs/release/1.0.13/RELEASE_NOTES.md).
## Features and direction
+12 -12
View File
@@ -61,20 +61,20 @@ The automatic lineup installs the supplied foreign-player rule switch alongside
New careers correct the original all-zero EM qualification placeholders to the original national-team placeholders. Supplied nonzero seeds and restored savegame state are not rewritten by this initialization.
## Stadium extension in1.0.3
## Stadium size: the edition's limits (extension of 1.0.3 withdrawn)
The user-requested stadium extension raises standard A–H maxima to14/24/14/20/
14/24/14/20thousand places (144,000total), keeping larger supplied custom limits
where the saved byte fields can represent them. Original unit prices remain
edition-owned. Each stand's base build period is at least two weeks per1,000
places of its expanded maximum and never shorter than the edition's original
period. Contractor shortening remains unchanged.
The stadium blocks A–H use the limits, unit prices and construction periods of
the supplied edition unchanged. Diamond 3.6/3.7 allows 8/18/8/14 thousand places
per block, twice, so 96,000 places in total; its 14k stands take 25 weeks, the 8k
stands 30 and the 18k stands 37 (original data, not a mistaken timer). Contractor
shortening remains unchanged. The UI validates quotes against the actual edition.
The original Diamond3.6/3.7 table's14k stands really used25weeks versus30weeks
for8k and37weeks for18k. That was original data, not a mistaken timer. Expanded
limits/time policy is an intentional improvement. The UI now validates quotes
against the actual edition and this shared policy rather than hardcoded Diamond
prices and sizes. Existing eight capacity/construction bytes and saves are retained.
Versions 1.0.3 to 1.0.12 raised the standard maxima to 14/24/14/20 thousand
(144,000 in total) with longer construction periods. That extension is withdrawn:
the match broadcast of the original has no room for attendances of 100,000 and
more and showed them wrongly. A savegame whose stadium is already larger than the
edition's limit keeps its places (the capacity bytes are unchanged), but such a
block cannot be extended any further.
## Daily interest at large native balances
OpenBMH deviates from the original: daily debt and deposit interest uses 64-bit
+2 -3
View File
@@ -5,8 +5,8 @@ Generated from source comment markers by `tools/public_release/collect_differenc
See [Compatibility decisions](COMPATIBILITY.md) for the overall policy. These entries
describe deliberate changes; they are not a list of every known compatibility limit.
- [src/app/career_session.cpp](../src/app/career_session.cpp): supports designated set-piece record initialization and validation.
- [src/app/main.cpp](../src/app/main.cpp): display the repository-owned title at its native resolution until a complete left/right click, without loading balls.
- [src/app/app_run.cpp](../src/app/app_run.cpp): display the repository-owned title at its native resolution until a complete left/right click, without loading balls.
- [src/app/career_session_match.cpp](../src/app/career_session_match.cpp): supports designated set-piece record initialization and validation.
- [src/app/quit_confirmation.hpp](../src/app/quit_confirmation.hpp): confirms application exit with a localized native dialog, with cancellation selected by default.
- [src/game/career.cpp](../src/game/career.cpp): skips reserved calendar positions when assigning a joining manager to a club.
- [src/game/career.hpp](../src/game/career.hpp): uses the supported player-generation ranges and excludes reserved calendar positions when assigning managers.
@@ -22,7 +22,6 @@ describe deliberate changes; they are not a list of every known compatibility li
- [src/game/national.cpp](../src/game/national.cpp): a new arrival must not inherit the previous occupant's retirement/refusal/month-processing flags.
- [src/game/season.cpp](../src/game/season.cpp): age/retire each player once, even when a temporary offer row references his club slot or regeneration moves him to a later free-agent slot.
- [src/game/season.cpp](../src/game/season.cpp): initializes the empty EM qualifier seeds with national teams, preventing club zero from entering the EM.
- [src/game/stadium_blocks.cpp](../src/game/stadium_blocks.cpp): allow 144,000 standard places and size-aware construction times while retaining edition-owned unit prices.
- [src/game/state.hpp](../src/game/state.hpp): retains designated set-piece selections in the supported manager-record extension.
- [src/game/week.cpp](../src/game/week.cpp): widen products before annual-rate division so valid native account amounts do not overflow intermediate sums.
- [src/game/week.cpp](../src/game/week.cpp): an unknown history receives a grace month; later losses occur at most once per source month.
+9 -3
View File
@@ -39,9 +39,15 @@ separately, see below). The other two are explained:
## Indoor tournament
All eleven recorded rounds play their 40 minutes with the same random draws as the original. At the kick-off, however,
the six strength values of the side records differ by 1 to 4 points in about half of the rounds (the port is mostly
higher); ordinary matches show no such difference. This is tracked as issue 82. The desk after the round is identical in
All eleven recorded rounds play their 40 minutes with the same random draws as the original. The six strength values
of the side records at the kick-off first differed by 1 to 4 points in about half of the rounds (the port mostly
higher). Cause (issue 82, resolved): the strengths depend on the **chance weather**, a runtime value that the
original keeps from the last chance of the round before (rain above 2 or a temperature below 0 lowers players
whose condition is below their technique). A savegame does not hold it, and the checker starts every turn from a
savegame, so it had rain 0 / temperature 0. With the weather of the previous turn's last chance
(`WEEK_PREV_WEATHER=rain,temperature`, taken from the "last chance weather" line of the previous check) the kick-off
of **all eleven rounds is identical**, bytes 0 to 5 of every side. A running game keeps the weather in memory
like the original, so this was a gap of the check and not of the engine. The desk after the round is identical in
ten of eleven rounds (the eleventh is the tournament end above).
## How to read the "DIFF" lines of the checker
+17
View File
@@ -32,6 +32,23 @@ The current game model combines interpreted vectors with fixed-layout compatibil
Legacy saves serialize blocks in a fixed order and store name pools separately. Runtime UI owners, pending input and frontend capabilities are not additional save fields. See [FBM](formats/FBM.md), [state records](formats/STATE.md) and [RNG](RNG.md).
## World layout
The dimensions of the game world are described in one place, `src/game/world_layout.hpp`, instead of as numbers spread over the engine:
- `WorldLayout` holds the team id ranges (league clubs, amateur clubs, foreign cup clubs without squads, the pseudo team "no club", national teams) and the squad slot table with the player pools behind it.
- `LeagueSystem` holds the league structure of the loaded game: league sizes, calendar groups, promotion ladder, European places and the cup structure. The session installs it from the tables of the game version, so the same engine runs the German and the English data.
- `src/game/records.hpp` names the sizes of the fixed records (manager record, tactics board, club record).
OpenBMH Classic only ever uses `classic_world_layout()`, which returns the numbers of the original; a test compares them and the squad table with the former literals. Code asks `world_layout()` and `league_system()` rather than writing 138 or 168.
This is a parameterisation, not yet a larger world. Still fixed, and to be lifted for an edition with more leagues:
- the number of leagues (`kLeagueCount`) and of calendar groups (eight competition bits),
- the results block (one fixed stride per league, `kLeagueResultsStride`) and the other save blocks sized for the Classic world; the save format is unchanged and a larger world needs a format of its own,
- the id of "no club" as a compile-time constant (`kNoTeam`), five manager records, and some stack tables sized for the Classic club count,
- the per-club tables of the loaded state, whose sizes are checked against the Classic numbers.
## Public interfaces and validation
The [console reference](CLI_CONCEPT/README.md) documents window commands. [protocol.md](protocol.md) describes structured requests, and [CONSOLE_CLIENTS.md](CONSOLE_CLIENTS.md) explains safe client ownership and batching. Prefer shared projections/actions when adding another frontend.
+18 -10
View File
@@ -250,7 +250,7 @@ declarations change. Game text, resort, image and audio fallbacks belong outside
| `CareerSession_DispatchDesktopLayout_RuntimeField2` | `0xa2517` | German-compatible image / runtime field |
| `CareerSession_DispatchLeagueTableControl_RuntimeField` | `0xa454d` | German-compatible image / runtime field |
| `CareerSession_DispatchLeagueTableControl_RuntimeField2` | `0xbb834` | German-compatible image / runtime field |
| `CareerSession_DispatchLineup_RuntimeField` | `0xa2c30` | German-compatible image / runtime field |
| `LeagueClubCount` | `0xa2c30` | German-compatible image / runtime field |
| `CareerSession_DispatchLiveSubstitution_ExecutableField` | `0xa366c` | German-compatible image / runtime field |
| `CareerSession_DispatchLiveTactic_RuntimeField` | `0xa20eb` | German-compatible image / runtime field |
| `CareerSession_DispatchLiveTactic_RuntimeField2` | `0xa20f3` | German-compatible image / runtime field |
@@ -307,12 +307,12 @@ declarations change. Game text, resort, image and audio fallbacks belong outside
| `CareerSession_FormatNumber_TextPointer` | `0xa137e` | German-compatible image / runtime field |
| `CareerSession_InitializeClubModalRuntime_ExecutableField` | `0xa25c0` | German-compatible image / runtime field |
| `CareerSession_InitializeClubModalRuntime_ExecutableFieldUnsigned` | `0xa25c0u` | German-compatible image / runtime field |
| `CareerSession_InstallLeagueSizes_RuntimeField` | `0xa2be9` | German-compatible image / runtime field |
| `CareerSession_InstallLeagueSizes_RuntimeField2` | `0xa2bf2` | German-compatible image / runtime field |
| `CareerSession_InstallLeagueSizes_RuntimeField3` | `0xa2c00` | German-compatible image / runtime field |
| `CareerSession_InstallLeagueSizes_RuntimeField4` | `0xa2c0b` | German-compatible image / runtime field |
| `CareerSession_InstallLeagueSizes_RuntimeField5` | `0xa2c13` | German-compatible image / runtime field |
| `CareerSession_InstallLeagueSizes_RuntimeField6` | `0xa2c34` | German-compatible image / runtime field |
| `LeagueEuropeanPlaces` | `0xa2be9` | German-compatible image / runtime field |
| `LeagueRelegationPlaces` | `0xa2bf2` | German-compatible image / runtime field |
| `LeagueNameSuffixes` | `0xa2c00` | German-compatible image / runtime field |
| `PromotionGroupBelowCounts` | `0xa2c0b` | German-compatible image / runtime field |
| `PromotionGroupBelowLeagues` | `0xa2c13` | German-compatible image / runtime field |
| `NewcomerClubCount` | `0xa2c34` | German-compatible image / runtime field |
| `CareerSession_Int32T_TextPointer` | `0xaeffc` | German-compatible image / runtime field |
| `CareerSession_Int32T_TextPointer2` | `0xaf21c` | German-compatible image / runtime field |
| `CareerSession_Int32T_TextPointer3` | `0xaf228` | German-compatible image / runtime field |
@@ -462,7 +462,7 @@ declarations change. Game text, resort, image and audio fallbacks belong outside
| `ClubKitSelectorsUnsigned` | `0xbb68bu` | German-compatible image / runtime field |
| `ClubPlayerDetail_ClubPlayerDetailFromGame_RuntimeField` | `0xa25bb` | German-compatible image / runtime field |
| `ClubPlayerDetail_ClubPlayerDetailFromGame_RuntimeField2` | `0xa25bf` | German-compatible image / runtime field |
| `ClubPlayerDetail_ClubPlayerDetailFromGame_RuntimeField3` | `0xa2c36` | German-compatible image / runtime field |
| `ForeignCupClubCount` | `0xa2c36` | German-compatible image / runtime field |
| `ClubPlayerDetail_ClubPlayerDetailFromGame_RuntimeField4` | `0xa364a` | German-compatible image / runtime field |
| `ClubPlayerDetail_ClubPlayerDetailRedraw_RuntimeField` | `0xa2c4e` | German-compatible image / runtime field |
| `ClubPlayerDetail_ClubPlayerDetailRedraw_RuntimeField2` | `0xa3c9b` | German-compatible image / runtime field |
@@ -591,8 +591,8 @@ declarations change. Game text, resort, image and audio fallbacks belong outside
| `CupDraw_FormatError_ExecutableField5` | `0xae704` | German-compatible image / runtime field |
| `CupDraw_FormatError_ExecutableField6` | `0xae70c` | German-compatible image / runtime field |
| `CupDraw_FormatError_RuntimeField` | `0xa2547` | German-compatible image / runtime field |
| `CupDraw_FormatError_RuntimeField2` | `0xb6ea8` | German-compatible image / runtime field |
| `CupDraw_FormatError_RuntimeField3` | `0xb9ad8` | German-compatible image / runtime field |
| `ManagerRecord0Club` | `0xb6ea8` | German-compatible image / runtime field |
| `ManagerRecord4Club` | `0xb9ad8` | German-compatible image / runtime field |
| `CupDraw_FormatError_TextPointer` | `0xa1612` | German-compatible image / runtime field |
| `CupDraw_FormatError_TextPointer2` | `0xa1619` | German-compatible image / runtime field |
| `CupDraw_FormatError_TextPointer3` | `0xa161e` | German-compatible image / runtime field |
@@ -893,6 +893,12 @@ declarations change. Game text, resort, image and audio fallbacks belong outside
| `EnglishLayoutTranslation256` | `0x6f2ae` | English image adapter |
| `EnglishLayoutTranslation257` | `0x6f2d4` | English image adapter |
| `EnglishLayoutTranslation258` | `0x6f2e0` | English image adapter |
| `EnglishEnvironmentTileX` | `0x6d230` | English image adapter |
| `EnglishEnvironmentTileY` | `0x6d238` | English image adapter |
| `EnglishEnvironmentYouthColors` | `0x6d240` | English image adapter |
| `EnglishEnvironmentBudgetSteps` | `0x6d244` | English image adapter |
| `EnglishEnvironmentYouthPositionSuffix` | `0x6d24a` | English image adapter |
| `EnglishEnvironmentCostSuffix` | `0x6d24f` | English image adapter |
| `EnglishLayoutTranslation259` | `0x6f2fc` | English image adapter |
| `EnglishLayoutTranslation26` | `0x6bf2c` | English image adapter |
| `EnglishLayoutTranslation260` | `0x6f300` | English image adapter |
@@ -1927,6 +1933,8 @@ declarations change. Game text, resort, image and audio fallbacks belong outside
| `TransferMarket_Rect_TextPointer3` | `0xae148` | German-compatible image / runtime field |
| `TransferMarket_Rect_TextPointer4` | `0xae14c` | German-compatible image / runtime field |
| `TransferMarket_Rect_TextPointer5` | `0xae150` | German-compatible image / runtime field |
| `TransferMarket_SearchRows_RuntimeField` | `0xa20fb` | German-compatible image / runtime field |
| `TransferMarket_SearchButton_TextPointer` | `0xae144` | German-compatible image / runtime field |
| `TransferMarket_Rect_TextPointer6` | `0xaecac` | German-compatible image / runtime field |
| `TransferMarket_Rect_TextPointer7` | `0xaf250` | German-compatible image / runtime field |
| `TransferMarket_Render_TextPointer` | `0xaf264` | German-compatible image / runtime field |
+51
View File
@@ -0,0 +1,51 @@
# OpenBMH Classic 1.0.13
This release returns the stadium to the size of the original and carries a large
internal clean-up. Apart from the stadium the game plays exactly as
[1.0.12](../1.0.12/RELEASE_NOTES.md): the same careers, turn by turn, and the same
pictures. Extended development remains separate in
[OpenBMH-Extended](https://github.com/Weyoune/OpenBMH-extended).
## Stadium: 96,000 places as in the original
- **The block limits are those of the game edition again.** Versions 1.0.3 to 1.0.12
allowed 14/24/14/20 thousand places per block, 144,000 in total. From 100,000
spectators on the live match could not show the attendance correctly: the original
display has room for five digits. The limits are now taken from the game data as
supplied: Diamond 3.7 gives 8/18/8/14 thousand per block, twice, which is 96,000
places. Building times follow the edition as well (30/37/30/25 weeks for a block
built in one go).
- The documented deviation "larger stadium" is gone from
[DIFFERENCES](../../DIFFERENCES.md); [COMPATIBILITY](../../COMPATIBILITY.md)
describes the rule.
## Engine checks against the original
- **Indoor tournament strengths explained.** The team strengths at the kick-off of an
indoor match differed from a recording of the real 3.7 in some turns. The cause is
the weather the original keeps from the last chance of the previous match (rain or
frost lowers players whose condition is below their technique), not the engine. The
comparison tool now carries that weather over, and the turns agree.
## Internal
Nothing in this section changes the game. Every step was compared with the state
before it: nine careers of 110 turns each (state checksum per turn, German and
English data), 86 recorded turns of the real 3.7, a walk through the screens with a
checksum per picture, and the window program played by a script.
- **Smaller files with named functions.** The window program (`main.cpp`, 4,500
lines), the controller's request function (2,000 lines) and the career session
(9,000 lines) are split into files by topic with one named function per presenter
or request.
- **Shared helpers.** The pixel loops of about forty screens (`ui/draw.hpp`), the
text encoding (`formats/text_encoding.hpp`) and the check helper of the tests
exist once instead of as copies.
- **World layout.** The dimensions of the game world (team id ranges, squad slots,
league sizes, promotion ladder, record sizes) are described in one place
(`game/world_layout.hpp`, `game/records.hpp`) instead of as numbers spread over
the engine. Classic uses the numbers of the original; see "World layout" in
[architecture](../../architecture.md).
- **Build.** On Windows the asset viewer no longer overwrites the game in the build
directory (both were `openbmh.exe` to a file system that ignores case), and the
app sources are compiled once instead of once per test.
+369
View File
@@ -0,0 +1,369 @@
// SPDX-License-Identifier: GPL-3.0-only
#pragma once
// struct App: the running window program (see the comment on the class). Internal header of the game
// program: included by src/app/main.cpp and the app_*.cpp files that define the member functions.
#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 [<game>] [--seed <Watcom seed>] [--save-directory <directory>] [--mute] [--volume <0..1>] [--music] [--live-frame-ms <0..1000>]
// <game> (also as --data <game>): 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 <SDL.h>
#include <algorithm>
#include <array>
#include <chrono>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cctype>
#include <deque>
#include <filesystem>
#include <memory>
#include <optional>
#include <stdexcept>
#include <string>
#include <vector>
#include "app/canvas.hpp"
#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/debug_log.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"
// (this internal header is only included by the files of the game program; they share these two)
namespace fs = std::filesystem;
using namespace bmh;
// 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.
// Moves the platform text-input rectangle over the save-file name field (logical canvas
// coordinates 106,209 to 262,219 converted to window pixels) and restarts text input.
// Called when an in-game filename field gains focus.
inline 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();
}
// The running game program: everything main() does after the window is set up.
//
// main() used to hold all of this in one function of about 4,300 lines: the state of the window
// program as locals and every presenter (season end, Sportschau, tax, promotion, cup draw, club
// dialogs, live match, ...) as a lambda capturing them. App holds the same things as members: the
// objects main() created (as references under their old names), the state, one member function per
// former lambda in the original order, and run() with the statements that stood between them (the
// wiring of the hooks, the title screen, the event loop, the tear-down). The code inside moved
// unchanged.
//
// The member functions are defined by topic:
// app_services.cpp the timers and deadlines the event loop serves between inputs (process timer, table, balance, pairings, stadium, friendly match pickers)
// app_season.cpp season end and season start (season pictures, contract expiry, tax, promotion, highscore, entrants, cup draw)
// app_sportschau.cpp the Sportschau (intro, replay scenes, fixtures, winner, awards, team info) and its waits
// app_transfer.cpp transfers (incoming offers, decisions, pending offers, market sales, loan returns, poaching)
// app_club.cpp the club dialogs (club information, player list, player detail, statistics)
// app_notices.cpp notices and questions over a screen (construction, season tickets, advertising renewal, national friendly, environment)
// app_live.cpp the live match (minute display, the observer with its interventions, the event animations, reality mode, phase results)
// app_run.cpp handle() - one request through the controller - and run() - wiring, title screen, event loop, tear-down
struct App { fs::path& data;
fs::path& save_directory;
uint32_t& seed;
bool& music_enabled;
int& live_frame_ms;
bool& live_frame_ms_explicit;
bool& english_game;
const Palette& palette;
ui::StartupFlow& flow;
std::unique_ptr<app::CareerSession>& session;
uint64_t& revision;
openbmh::audio::Playback& playback;
std::string& audio_error;
std::optional<uint64_t>& audio_session;
SDL_Window*& window;
SDL_Renderer*& renderer;
SDL_Texture*& texture;
app::PitchPointer& pitch_pointer;
std::vector<uint32_t>& pixels;
app::Canvas& canvas;
ui::LiveMatchdayScreen& live_screen;
ui::RealityReporterPanel& reality_reporter;
ui::SportschauIntro& sportschau_intro;
ui::MatchdayIntro& matchday_intro;
ui::SportschauEleven& sportschau_eleven;
ui::SportschauTeamInfo& sportschau_team_info;
ui::CompetitionWinnerScreen& competition_winner;
const LeImage& season_exe;
app::QuitConfirmation& quit_confirmation;
app::OriginalMouseSound& mouse_sound;
const TextDb& season_texts;
const std::chrono::steady_clock::time_point& process_clock_origin;
auto process_source_seconds() -> uint64_t;
ui::ProcessTimer process_timer;
// Identifies which session/manager/day a process timer belongs to.
struct ProcessTimerOwner {
uint64_t session;
int manager;
uint32_t day;
bool operator==(const ProcessTimerOwner&) const = default;
};
std::optional<ProcessTimerOwner> process_timer_owner;
std::optional<ui::ProcessTimer::Sample> process_timer_frame;
auto process_timer_image(Image image) -> bmh::Image;
auto poll_process_timer(bool update_texture, bool present) -> bool;
// `running` ends every loop below; `dirty` requests a redraw of the flow screen.
bool running = true, dirty = true;
// Remembers the current left mouse press (position, time, screen, source tick, revision)
// so the matching release can be judged against it later.
struct Press {
int x, y;
uint32_t time;
std::string screen;
uint64_t source_tick, revision;
bool pitch_hold_attempted = false;
};
std::optional<Press> press;
std::optional<std::string> right_press_screen;
auto transfer_view(const GameState& state, const TransferOfferListView& offers, int viewer_manager) -> bmh::ui::IncomingTransferDecisionView;
std::optional<Image> season_backdrop;
auto present_season(const Image& image, const char* title, const Palette* palette_override = nullptr) -> void;
auto present_desk_record_points() -> void;
auto contract_expiry_presenter(GameState& staged, WatcomRandom& random, int manager, int expired_row) -> int;
auto game_end_options(const GameState& state) -> bmh::ui::GameEndRenderOptions;
auto wait_season_ack() -> void;
auto wait_sportschau_ack() -> void;
auto source_tick_wait(unsigned ticks) -> void;
auto wait_source_retraces(unsigned count) -> void;
// --- Sportschau (results show) presenters: the engine calls these hooks synchronously. ---
SportschauPresentationHooks sportschau_presenter;
auto sportschau_context(const GameState& state) -> bmh::ui::SportschauReportContext;
std::optional<ui::SportschauMatchReport> sportschau_replay_screen;
size_t sportschau_step_index = 0;
auto show_tax(const GameState& state, const SeasonTaxEvent& event) -> bool;
// Hooks for the season tax events: question via show_tax, notices and the animation below.
SeasonTaxHooks tax_presenter;
auto wait_promotion_time(Uint32 milliseconds) -> void;
// Presents the promotion/relegation table animation (39 steps) unless the manager's
// animation-skip flag is set.
SeasonPromotionHook promotion_presenter;
auto present_pending_dialog(const GameState& state, ui::TaxDialogProjection view, const Image& backdrop, const char* title, std::optional<ui::GameEndRenderOptions> effective_options = {}) -> PendingOfferAnswer;
auto loan_return_presenter(GameState& state, WatcomRandom&, int manager, const std::string& question) -> int;
auto make_pending_offer_hooks(Image backdrop) -> bmh::PendingOfferHooks;
auto make_market_sale_hooks(Image backdrop) -> bmh::HumanBuyerSaleHooks;
// Forward declarations: the club, player and statistics presenters call each other, so
// they are assigned further below.
std::function<bool(app::ClubModalServices&, int)> present_club_information;
std::function<std::optional<bool>(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;
// Assigned to the genuine Source submodal presenters below before the
// controller advances a new career or annual transition.
std::function<bool(app::ClubModalServices&, const ui::ClubInfoRequest&, const Image&)> present_club_player;
std::function<void(app::ClubModalServices&, int, const Image&)> present_club_statistics;
bool poach_selection_active=false;
std::optional<ClubPlayerDetailSelection> poach_card_selection;
// Selector the engine calls while the player chooses a player to poach: shows league table
// pages, the range dialog, club info and player cards in nested modal loops. Returns the
// chosen player, or std::nullopt when closed or the process timer expired.
app::CareerSession::PoachPlayerSelector poach_player_selector;
// 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;
// Presents a cup draw: the reveal animation (draw phase) or the overview of a round.
// In the overview a left click on a club opens its club info, a right click leaves.
SeasonCupDrawHook cup_draw_presenter;
auto show_highscore(const GameState& state, bool display) -> void;
std::optional<Uint64> timed_notice_presented_at;
std::optional<Uint8> timed_notice_release;
// --- the request in service (state of App::handle and of the presenters it passes on) ---
// handle() is never re-entered: every presenter below runs inside one handle() call.
bool live_skipped;
uint64_t live_overview_sequence;
std::optional<Image> outcome_backdrop;
auto present_live_lineup(int minute, MatchEngine& engine, std::vector<MatchGroup>& groups, GameState& state, uint64_t& live_revision, int selected_team, int selected_opponent, const app::LiveLineupDispatcher& dispatch, const app::LiveTacticsDispatcher& dispatch_tactic, const app::LivePitchDispatcher& dispatch_pitch, const app::LiveInterventionScopeDispatcher& dispatch_scope, bool live_skipped, bool event_origin) -> bool;
// Callback type through which the overview screen asks the engine for its actions.
using RunningOverviewDispatcher = std::function<std::optional<app::CareerSession::LiveOverviewDispatch>(
const app::CareerSession::LiveOverviewAction&, std::string&,
const app::TransferOfferTeamInfoPresenter&)>;
auto present_running_overview(std::optional<app::CareerSession::LiveOverviewProjection> projection, const GameState& state, uint64_t& live_revision, const RunningOverviewDispatcher& dispatch_overview, const PhaseResultRequest* phase_result) -> bool;
// State used by the live-match presenters below.
ui::LiveScoreReveal live_score_reveal;
std::optional<ui::LiveChanceProjection> live_chance_context;
std::unique_ptr<ui::RealityFieldScreen> reality_field;
ui::RealityReporterLayoutState reality_layout;
Image reality_pristine, reality_surface;
Palette reality_colors;
auto present_live_minute(int minute, const std::vector<MatchGroup>& groups, const GameState& state) -> void;
auto choose_transfer_offer(const GameState& state, const TransferOfferListView& offers) -> int;
auto present_transfer_decision(const GameState& state, const TransferDecisionEvent& decision) -> void;
auto present_season_checkpoint(const char* checkpoint, const GameState& state) -> void;
auto show_club_information(app::ClubModalServices& services,int team,const Image&) -> bool;
auto show_player_detail(app::ClubModalServices& services,const ClubPlayerDetailSelection& selection,const Image& parent) -> bool;
auto present_construction_notice(const GameState& staged, const ConstructionNotice& notice) -> void;
auto present_ticket_compensation_notice(const GameState& staged, const SeasonTicketCompensationNotice& notice) -> void;
auto ask_advertising_renewal(const GameState& staged, const AdvertisingRenewal& renewal, const Image& backdrop) -> app::CareerSession::AdvertisingRenewalPresentation;
auto present_poach_notices(const GameState& staged,const PoachStart& attempt,const Image& backdrop) -> void;
auto ask_national_friendly(const GameState& staged,ui::TaxDialogProjection view,const Image& backdrop) -> std::optional<bool>;
auto observe_live_minute(int minute, MatchEngine& engine, std::vector<MatchGroup>& groups, GameState& state, uint64_t& live_revision, const app::LiveLineupDispatcher& dispatch, const app::LiveTacticsDispatcher& dispatch_tactic, const app::LivePitchDispatcher& dispatch_pitch, const app::LiveInterventionScopeDispatcher& dispatch_scope) -> void;
auto present_environment_notice(const GameState& staged, ui::TaxDialogProjection view, const Image& backdrop) -> bool;
auto present_live_event_lineup(const LiveMatchEvent& event, MatchEngine& engine, std::vector<MatchGroup>& groups, GameState& state, uint64_t& live_revision, const app::LiveLineupDispatcher& dispatch, const app::LiveTacticsDispatcher& dispatch_tactic, const app::LivePitchDispatcher& dispatch_pitch, const app::LiveInterventionScopeDispatcher& dispatch_scope) -> void;
auto animate_ball(const LiveBallEvent& event, const std::vector<MatchGroup>& groups, const GameState& state) -> void;
auto animate_chance(const LiveChanceEvent& event, const std::vector<MatchGroup>& groups, const GameState& state) -> void;
auto animate_shot(const LiveShotEvent& event, const std::vector<MatchGroup>& groups, const GameState& state) -> void;
auto animate_set_piece(const LiveSetPieceEvent& event, const std::vector<MatchGroup>& groups, const GameState& state) -> void;
auto animate_booking(const LiveBookingEvent& event, const std::vector<MatchGroup>& groups, const GameState& state) -> void;
auto animate_shootout(const LiveShootoutEvent& event, const std::vector<MatchGroup>& groups, const GameState& state) -> void;
auto present_reality(const LiveRealityEvent& event, const std::vector<MatchGroup>& groups, const GameState& state) -> bool;
auto present_phase_result(const PhaseResultRequest& request, const std::vector<MatchGroup>& groups, const GameState& state) -> void;
auto handle(const ui::FlowResult& r) -> void;
auto present_formation_save_feedback() -> void;
auto service_pitch_hold() -> void;
const std::chrono::steady_clock::time_point pairings_clock_start = std::chrono::steady_clock::now();
auto pairings_source_seconds() -> uint64_t;
auto balance_source_milliseconds() -> uint64_t;
auto family_table_source_units() -> uint64_t;
auto mark_family_table_presented() -> void;
auto present_family_table_redraw() -> void;
// A key typed for the table range dialog or toto calculator, tagged with its owner so
// that keys for a screen that has since changed are dropped.
struct TableRangeKey {
std::string key;
ui::StrengthsIdentity identity;
int toto_manager = -1;
uint64_t toto_revision = 0;
};
std::deque<TableRangeKey> table_range_keys;
auto queue_table_range_event(const SDL_Event& event) -> bool;
auto service_family_table() -> void;
// Which balance screen state was last presented (to avoid redrawing identical frames).
std::optional<ui::BalanceIdentity> presented_balance;
bool presented_balance_notice=false;
auto present_balance_redraw() -> void;
auto service_balance_timer() -> void;
// KB6 waits start after the pressed/final calculator image reaches SDL.
// Keep a matching physical UP until the four-tick press is over; N's
// last calculator frame stays visible through its fifty-tick wait.
// Pending release of a button pressed on the stadium calculator.
struct CalculatorRelease {
SDL_MouseButtonEvent button;
uint64_t scope = 0, sequence = 0;
};
std::optional<CalculatorRelease> calculator_release;
std::optional<uint64_t> calculator_tick_anchor;
// A calculator key tagged with the owner state it was typed for.
struct CalculatorKey {
std::string key;
uint64_t revision = 0, scope = 0, sequence = 0;
};
std::deque<CalculatorKey> calculator_keys;
auto queue_calculator_key(std::string key) -> void;
auto queue_calculator_event(const SDL_Event& event) -> bool;
auto mark_stadium_calculator_presented() -> void;
auto service_stadium_calculator() -> void;
// Which pairings page was last presented (to avoid redrawing identical frames).
std::optional<ui::LeaguePairingsIdentity> presented_pairings;
auto present_pairings_redraw() -> void;
auto service_pairings_timer() -> void;
//PresentManagerDialog presents its question before polling2de66. Bind the actual
//freshly drawn frame, never an old texture or a preceding modal ACK.
// Frame identities: each tuple names the owner state (session, manager, scope, sequence,
// revision, ...) of a modal question that was actually drawn. A process-timer deadline
// is applied only to a frame that has been presented, never to a stale one.
using StadiumQuestionFrame = std::array<uint64_t,5>;
std::optional<StadiumQuestionFrame> presented_stadium_question;
auto stadium_question_frame() -> std::optional<StadiumQuestionFrame>;
auto mark_stadium_question_presented() -> void;
auto service_stadium_deadline() -> bool;
auto service_idle_stadium_deadline() -> void;
// Same idea for the national friendly picker.
using NationalPickerFrame = std::pair<uint64_t,ui::NationalFriendlyUiOwner>;
std::optional<NationalPickerFrame> presented_national_picker;
auto national_picker_frame() -> std::optional<NationalPickerFrame>;
auto mark_national_picker_presented() -> void;
using FriendlyPickerFrame = std::array<uint64_t,5>;
std::optional<FriendlyPickerFrame> presented_friendly_picker;
auto friendly_picker_frame() -> std::optional<FriendlyPickerFrame>;
auto mark_friendly_picker_presented() -> void;
// Same idea for the friendly match calendar.
using FriendlyCalendarFrame = std::array<uint64_t,5>;
std::optional<FriendlyCalendarFrame> presented_friendly_calendar;
auto friendly_calendar_frame() -> std::optional<FriendlyCalendarFrame>;
auto mark_friendly_calendar_presented() -> void;
// Same idea for the friendly match question.
using FriendlyQuestionFrame = std::array<uint64_t,8>;
std::optional<FriendlyQuestionFrame> presented_friendly_question;
auto friendly_question_frame() -> std::optional<FriendlyQuestionFrame>;
auto mark_friendly_question_presented() -> void;
auto service_friendly_question_deadline() -> bool;
auto service_process_timer() -> void;
// filename_input_active: the save/load filename field already has focus.
// setup_button_down: [0] left, [1] right button pressed while on the setup screen.
bool filename_input_active = false;
std::array<bool, 2> setup_button_down{};
auto present_sportschau_intro(const GameState&, const SportschauIntroView&) -> void;
auto present_matchday_intro(const GameState&, const MatchdayIntroView& view) -> void;
auto present_sportschau_replay_step(const GameState& state, const SportschauFixtureView& fixture, const SportschauReportStep& step) -> bool;
auto present_sportschau_scene(const GameState& state, const SportschauFixtureView& fixture, const SportschauSceneView& scene) -> void;
auto present_sportschau_fixture(const GameState& state, const SportschauFixtureView& fixture) -> void;
auto present_competition_winner(const GameState& state, const CompetitionWinnerView& view) -> void;
auto present_sportschau_awards(const GameState& state, const SportschauAwardsView& view) -> void;
auto present_sportschau_team_info(const GameState& state, const SportschauTeamInfoView& view) -> void;
auto present_tax_event(const GameState& state, const SeasonTaxEvent& event) -> void;
auto present_promotion(const GameState& state, const SeasonPromotionEvent& event) -> void;
auto club_information_dialog(app::ClubModalServices& services, int team) -> bool;
auto club_player_dialog(app::ClubModalServices& services, const ui::ClubInfoRequest& selected, const Image& parent_image) -> bool;
auto player_detail_dialog(app::ClubModalServices& services,const ClubPlayerDetailSelection& selection,const Image& parent_image) -> std::optional<bool>;
auto club_statistics_dialog(app::ClubModalServices& services, int team, const Image& parent_frame) -> void;
auto select_poach_player(app::CareerSession& staged,app::ClubModalServices&,int manager, uint64_t& selection_revision,const Image& transfer_backdrop) -> std::optional<ClubPlayerDetailSelection>;
auto present_cup_draw(const GameState& state, const SeasonCupDrawEvent& event) -> void;
auto run() -> int;
};
+339
View File
@@ -0,0 +1,339 @@
// SPDX-License-Identifier: GPL-3.0-only
// App: the club dialogs (club information, player list, player detail, statistics).
// (moved out of main.cpp unchanged; the class is declared in app/app.hpp)
#include "app/app.hpp"
// Callback: club information screen (true if the program is still running).
auto App::show_club_information(app::ClubModalServices& services,int team,const Image&) -> bool {
return present_club_information(services,team) && running;
}
// Next callback: player detail card.
auto App::show_player_detail(app::ClubModalServices& services,const ClubPlayerDetailSelection& selection,const Image& parent) -> bool {
// 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;
}
// Modal club information screen for `team`. Returns true when it was left normally (or
// the process timer expired), false when the program is quitting.
auto App::club_information_dialog(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.
// The child loop consumes the matching release itself.
press.reset();
ui::ClubInfoView selected_view = ui::ClubInfoView::data_a;
std::unique_ptr<ui::ClubInfoScreen> club_screen;
// Rebuilds the club screen from the current game state.
const auto redraw = [&] {
std::string error;
ClubInfoEntry snapshot;
if (team == kNoTeam || team < season_exe.u16(::bmh::layout::LeagueClubCount)) {
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<ui::ClubInfoScreen>(data, std::move(projection));
};
// Presents the club screen; the window title encodes the view state.
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);
// True when the process timer ran out and no button is currently held down.
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<ui::ClubInfoScreen>(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;
}
// Opens the player detail card for a row chosen in the club list. The runtime input mode
// byte is switched for the card and restored afterwards (RAII helper below).
auto App::club_player_dialog(app::ClubModalServices& services, const ui::ClubInfoRequest& selected, const Image& parent_image) -> bool {
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);
// Restores the saved runtime byte when the card is left, including by exception.
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);
}
// Modal player detail card. Returns the card's close-parent flag, or std::nullopt when
// the program is quitting.
auto App::player_detail_dialog(app::ClubModalServices& services,const ClubPlayerDetailSelection& selection,const Image& parent_image) -> std::optional<bool> {
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;
// Asks the engine to redraw the player's data and projects it for the card.
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);
// Presents the card; the window title encodes selection and statistics state.
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());
};
// Waits until the left button is up, but only if the engine recorded a long hold before
// the card opened.
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();
// Source tick at which a left button hold began (for the card's hold shortcut).
std::optional<uint64_t> 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());
// Executes a request coming from the card. A returned value means the card is left
// (true/false = close the parent screens too).
const auto apply_request = [&](ui::ClubPlayerDetailRequest request) -> std::optional<bool> {
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;
};
// Applies the process-timer deadline to the card unless a mouse release is still awaited.
const auto expire_card = [&]() -> std::optional<bool> {
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();
}
// While the button is held, report the elapsed source ticks to the card; forget the hold
// when the physical button is up.
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;
}
// Modal team statistics screen with a mode toggle; leaves on close, right press or timer.
auto App::club_statistics_dialog(app::ClubModalServices& services, int team, const Image& parent_frame) -> void {
if (!running) return;
auto mode = ui::TeamStatisticsMode::combined;
std::unique_ptr<ui::TeamStatisticsScreen> statistics;
// Rebuilds the statistics screen for the current mode.
const auto rebuild = [&] {
auto projection = ui::team_statistics_from_game(services.state(), team, mode,
season_exe, season_texts);
statistics = std::make_unique<ui::TeamStatisticsScreen>(data,
std::move(projection), parent_frame);
};
// Presents the statistics screen; the window title encodes team, mode and pressed button.
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);
// True when the process timer ran out and no button is currently held down.
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;
// A right press leaves at once without waiting for its release.
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);
}
}
+1325
View File
File diff suppressed because it is too large. Load diff
+88
View File
@@ -0,0 +1,88 @@
// SPDX-License-Identifier: GPL-3.0-only
// App: notices and questions over a screen (construction, season tickets, advertising renewal, national friendly, environment).
// (moved out of main.cpp unchanged; the class is declared in app/app.hpp)
#include "app/app.hpp"
// Next callback: stadium construction payment notice, shown over the investment detail.
auto App::present_construction_notice(const GameState& staged, const ConstructionNotice& notice) -> void {
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<ui::GameEndRenderOptions> 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");
}
// Next callback: season ticket compensation notice.
auto App::present_ticket_compensation_notice(const GameState& staged, const SeasonTicketCompensationNotice& notice) -> void {
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");
}
// Callback: advertising contract renewal. A question gives renew/decline; a sponsor's
// refusal is a notice that gives acknowledged; anything else aborts.
auto App::ask_advertising_renewal(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;
}
// Callback: national friendly question. Returns yes/no, or std::nullopt when unsupported
// or the program is quitting.
auto App::ask_national_friendly(const GameState& staged,ui::TaxDialogProjection view,const Image& backdrop) -> std::optional<bool> {
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;
}
// Next callback: environment/settings notice dialog. Returns false when the program is
// quitting or the dialog could not be shown.
auto App::present_environment_notice(const GameState& staged, ui::TaxDialogProjection view, const Image& backdrop) -> bool {
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;
}
+565
View File
@@ -0,0 +1,565 @@
// SPDX-License-Identifier: GPL-3.0-only
// App: handle() - one request through the controller - and run() - wiring, title screen, event loop, tear-down.
// (moved out of main.cpp unchanged; the class is declared in app/app.hpp)
#include "app/app.hpp"
// =====================================================================================
// Handling FlowResults (requests from the UI flow)
// =====================================================================================
// Called by the main loop for every ui::FlowResult. It handles quitting and the process
// timer, then passes the request to app::serve_flow_request() together with the
// presenter lambdas defined inside, which the engine may call back synchronously.
auto App::handle(const ui::FlowResult& r) -> void {
pitch_pointer.show({}, renderer);
// A quit request must be confirmed by the player; otherwise the desk reports it as cancelled.
if (r.request == ui::FlowRequest::end_session && !quit_confirmation.confirm()) {
flow.reject_desk_action(english_game ? "Quit cancelled." : "Beenden abgebrochen.");
dirty = true;
return;
}
// Play the sounds the desk queued during this action.
if (const auto* desk = flow.desktop())
for (const auto id : desk->take_sound_ids()) app::original_audio_command(playback, id);
// Process timer: kickoff and quitting stop it; opening the menus 10, 11, 19 and 29
// (save/load, settings, new manager) pauses it.
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();
}
// Confirmed quit: end the program at once, without advancing the calendar or saving.
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;
live_skipped = false; // (a member now; fresh for every request like the former local)
live_overview_sequence = 0; // (a member now; fresh for every request like the former local)
outcome_backdrop = std::optional<Image>{}; // (a member now; fresh for every request like the former local)
// State used by the live-match presenters below.
live_score_reveal = ui::LiveScoreReveal{}; // (a member now; fresh for every request like the former local)
live_chance_context = std::optional<ui::LiveChanceProjection>{}; // (a member now; fresh for every request like the former local)
reality_field.reset(); // (a member now; fresh for every request like the former local)
reality_layout = ui::RealityReporterLayoutState{}; // (a member now; fresh for every request like the former local)
reality_pristine = Image{}; reality_surface = Image{}; // (a member now; fresh for every request like the former local)
reality_colors = Palette{}; // (a member now; fresh for every request like the former local)
// Hand the flow result to the controller. The arguments after the audio ones are the
// presenter callbacks the engine may call synchronously (live frame, incoming transfers,
// transfer decisions, season checkpoints, tax, highscore, promotion, cup draw, offers,
// club/player screens, notices, poaching, contracts, ...). The returned message is
// printed to stderr by the caller; "career_complete" ends the program.
const std::string message = app::serve_flow_request(flow, r, session, data, save_directory, seed, revision,
playback, audio_session, music_enabled,
[this](auto&&... a) -> decltype(auto) { return present_live_minute(std::forward<decltype(a)>(a)...); },
[this](auto&&... a) -> decltype(auto) { return choose_transfer_offer(std::forward<decltype(a)>(a)...); },
[this](auto&&... a) -> decltype(auto) { return present_transfer_decision(std::forward<decltype(a)>(a)...); },
[this](auto&&... a) -> decltype(auto) { return present_season_checkpoint(std::forward<decltype(a)>(a)...); },
// Further callbacks: tax, highscore, promotion and cup draw presenters (defined above).
tax_presenter, [this](auto&&... a) -> decltype(auto) { return show_highscore(std::forward<decltype(a)>(a)...); }, promotion_presenter, cup_draw_presenter,
// Pending-offer hooks exist only for kickoff; market sale hooks for kickoff and for
// transfer market / outgoing transfer submenu actions.
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<ui::TransferMarketRequest>(r.submenu_action) ||
std::holds_alternative<ui::OutgoingTransferRequest>(r.submenu_action))
)) ? make_market_sale_hooks(flow.render()) : HumanBuyerSaleHooks{},
app::HumanBuyerMarketEntryPolicy::normal_interactive,
[this](auto&&... a) -> decltype(auto) { return show_club_information(std::forward<decltype(a)>(a)...); },
[this](auto&&... a) -> decltype(auto) { return show_player_detail(std::forward<decltype(a)>(a)...); },
[this](auto&&... a) -> decltype(auto) { return present_construction_notice(std::forward<decltype(a)>(a)...); },
[this](auto&&... a) -> decltype(auto) { return present_ticket_compensation_notice(std::forward<decltype(a)>(a)...); }, sportschau_presenter,
[this](auto&&... a) -> decltype(auto) { return ask_advertising_renewal(std::forward<decltype(a)>(a)...); }, poach_player_selector,
[this](auto&&... a) -> decltype(auto) { return present_poach_notices(std::forward<decltype(a)>(a)...); }, [this](auto&&... a) -> decltype(auto) { return contract_expiry_presenter(std::forward<decltype(a)>(a)...); },
[this](auto&&... a) -> decltype(auto) { return ask_national_friendly(std::forward<decltype(a)>(a)...); },
// The loan-return presenters (defined above), then the live match observer.
[this](auto&&... a) -> decltype(auto) { return loan_return_presenter(std::forward<decltype(a)>(a)...); }, [this](auto&&... a) -> decltype(auto) { return loan_return_offer_presenter(std::forward<decltype(a)>(a)...); },
[this](auto&&... a) -> decltype(auto) { return observe_live_minute(std::forward<decltype(a)>(a)...); },
[this](auto&&... a) -> decltype(auto) { return present_environment_notice(std::forward<decltype(a)>(a)...); },
[this](auto&&... a) -> decltype(auto) { return present_live_event_lineup(std::forward<decltype(a)>(a)...); },
[this](auto&&... a) -> decltype(auto) { return animate_ball(std::forward<decltype(a)>(a)...); },
[this](auto&&... a) -> decltype(auto) { return animate_chance(std::forward<decltype(a)>(a)...); },
[this](auto&&... a) -> decltype(auto) { return animate_shot(std::forward<decltype(a)>(a)...); },
[this](auto&&... a) -> decltype(auto) { return animate_set_piece(std::forward<decltype(a)>(a)...); },
[this](auto&&... a) -> decltype(auto) { return animate_booking(std::forward<decltype(a)>(a)...); },
[this](auto&&... a) -> decltype(auto) { return animate_shootout(std::forward<decltype(a)>(a)...); },
[this](auto&&... a) -> decltype(auto) { return present_reality(std::forward<decltype(a)>(a)...); },
[this](auto&&... a) -> decltype(auto) { return present_phase_result(std::forward<decltype(a)>(a)...); }, true);
// In -debug mode every request and its outcome is logged.
if (app::debug::enabled()) app::debug::log("request " + std::to_string(int(r.request)) + (message.empty() ? std::string(" ok") : " -> " + message));
// The controller reports the end of the career by this message: leave the main loop.
if (message == "career_complete") { running = false; return; }
if (!message.empty()) std::fprintf(stderr, "engine: %s\n", message.c_str());
// Autosave problems are reported but do not stop the game.
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;
}
}
// Forget the presentation time once no timed notice is open.
if(!flow.timed_notice_open())timed_notice_presented_at.reset();
SDL_SetWindowTitle(window, ("OpenBMH - " + flow.screen_name()).c_str());
}
// The statements of the former main(): hook wiring, title screen, event loop and tear-down.
auto App::run() -> int {
sportschau_presenter.intro = [this](auto&&... a) -> decltype(auto) { return present_sportschau_intro(std::forward<decltype(a)>(a)...); };
sportschau_presenter.kickoff = [this](auto&&... a) -> decltype(auto) { return present_matchday_intro(std::forward<decltype(a)>(a)...); };
sportschau_presenter.replay.step = [this](auto&&... a) -> decltype(auto) { return present_sportschau_replay_step(std::forward<decltype(a)>(a)...); };
sportschau_presenter.replay.scene = [this](auto&&... a) -> decltype(auto) { return present_sportschau_scene(std::forward<decltype(a)>(a)...); };
sportschau_presenter.fixture = [this](auto&&... a) -> decltype(auto) { return present_sportschau_fixture(std::forward<decltype(a)>(a)...); };
sportschau_presenter.winner = [this](auto&&... a) -> decltype(auto) { return present_competition_winner(std::forward<decltype(a)>(a)...); };
sportschau_presenter.awards = [this](auto&&... a) -> decltype(auto) { return present_sportschau_awards(std::forward<decltype(a)>(a)...); };
sportschau_presenter.team_info = [this](auto&&... a) -> decltype(auto) { return present_sportschau_team_info(std::forward<decltype(a)>(a)...); };
tax_presenter.choose = [this](auto&&... a) -> decltype(auto) { return show_tax(std::forward<decltype(a)>(a)...); };
tax_presenter.observe = [this](auto&&... a) -> decltype(auto) { return present_tax_event(std::forward<decltype(a)>(a)...); };
promotion_presenter = [this](auto&&... a) -> decltype(auto) { return present_promotion(std::forward<decltype(a)>(a)...); };
present_club_information = [this](auto&&... a) -> decltype(auto) { return club_information_dialog(std::forward<decltype(a)>(a)...); };
present_club_player = [this](auto&&... a) -> decltype(auto) { return club_player_dialog(std::forward<decltype(a)>(a)...); };
present_player_detail = [this](auto&&... a) -> decltype(auto) { return player_detail_dialog(std::forward<decltype(a)>(a)...); };
present_club_statistics = [this](auto&&... a) -> decltype(auto) { return club_statistics_dialog(std::forward<decltype(a)>(a)...); };
poach_player_selector = [this](auto&&... a) -> decltype(auto) { return select_poach_player(std::forward<decltype(a)>(a)...); };
cup_draw_presenter = [this](auto&&... a) -> decltype(auto) { return present_cup_draw(std::forward<decltype(a)>(a)...); };
// =====================================================================================
// Opening screen
// =====================================================================================
// 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<Uint8> opening_press;
// Only a complete click confirms: press and release of the same button. Losing focus
// forgets the press; expose and resize events redraw the title picture.
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;
// Text input stays on for the whole session so SDL_TEXTINPUT events arrive.
SDL_StartTextInput();
// =====================================================================================
// Main event loop
// =====================================================================================
// Each pass: keep the filename field focused on the save/load screen, expire timed
// notices, service the timers, then drain the SDL event queue through
// quit_confirmation.poll(). SDL_QUIT ends the loop. Mouse down, up and motion, text and
// key events are translated into StartupFlow calls (pointer_down, click or hold,
// move_action, text, send_key); every FlowResult is passed to handle(), which serves
// the request. After the queue is empty the loop services holds and timers again, plays
// queued sounds, pumps audio, redraws the 320x240 canvas if dirty, presents it and
// sleeps 10 ms.
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;
// A timed notice closes by itself after 70*3*20 ms.
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;
}
// Losing focus forgets the pressed setup buttons; regaining it restores text input.
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;
}
}
// Swallow the release of the press that dismissed a timed notice.
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;
}
// Keyboard input is ignored while a timed notice is open.
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();
// Keys for the table range dialog or toto calculator are queued, not dispatched at once.
if (queue_table_range_event(e)) {
service_family_table();
continue;
}
// While the stadium calculator is in a timed wait, its keys are queued and its release
// is remembered; no other input is processed (release barrier).
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;
}
// The open calculator owns all keyboard input.
if (flow.in_stadium() && flow.stadium()->calculator_open() && queue_calculator_event(e)) {
service_stadium_calculator();
continue;
}
// ESC asks to quit (after confirmation) unless it is a close key in a menu or view.
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;
// Remember the left press so its release can be judged as a click or a 2 second hold.
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};
// Remember where the right press began, to detect releases without a matching press.
if (e.type == SDL_MOUSEBUTTONDOWN && e.button.button == SDL_BUTTON_RIGHT)
right_press_screen = flow.screen_name();
// Buttons without a lasting state look pressed while the mouse button is held (bank, offer editor,
// lineup, pitch). The pitch runs its action at the press itself, so the pressed look is held briefly.
if (e.type == SDL_MOUSEBUTTONDOWN && e.button.button == SDL_BUTTON_LEFT &&
flow.press_hold(e.button.x, e.button.y)) {
const auto image = process_timer_image(flow.render());
canvas.show(image, palette);
dirty = false;
if (flow.in_pitch()) SDL_Delay(90);
}
// Screens that react to the press itself get pointer_down() now.
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();
// Screens with held controls are redrawn at once, so the pressed state is visible before
// the release arrives.
} 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;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("Held controls renderer: ")+SDL_GetError());
app::present(renderer);
mark_stadium_question_presented();
mark_national_picker_presented();
mark_friendly_picker_presented();
mark_friendly_calendar_presented();
mark_friendly_question_presented();
if(flow.in_balance())flow.mark_balance_presented_source_milliseconds(balance_source_milliseconds());
mark_stadium_calculator_presented();
dirty=false;
} else if (flow.desktop() && flow.desktop()->socket_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());
canvas.show(image, palette);
dirty=false;
}
}
if (e.type == SDL_MOUSEBUTTONDOWN && e.button.button == SDL_BUTTON_RIGHT &&
flow.file_info_press(e.button.x, e.button.y)) {
// InfoPress→Centered paints immediately and waits for mouse UP.
// Present before polling a queued release, which restores the list.
const auto image = process_timer_image(flow.render());
canvas.show(image, palette);
dirty = false;
}
// Mouse release. Order: an expired question that owns this release, then right-button
// releases whose press was consumed elsewhere (orphaned releases), then click or hold.
if (e.type == SDL_MOUSEBUTTONUP && (e.button.button == SDL_BUTTON_LEFT || e.button.button == SDL_BUTTON_RIGHT)) {
if(e.button.button==SDL_BUTTON_LEFT&&service_friendly_question_deadline()) {
press.reset();continue; // The expired question owns this UP, not its returned calendar/desk.
}
if (e.button.button == SDL_BUTTON_LEFT && service_stadium_deadline()) {
// The release belongs to the expired question, never
// to the newly accepted stadium scene underneath it.
press.reset();
continue;
}
if (e.button.button == SDL_BUTTON_RIGHT) {
// ClubInfoFromGame consumes the right press and clears CareerSession_BeginFriendlyOpponentTable_ExecutableField2
// before returning. Its release is not another Source8
// cancel event in the parent OpenTransferEditor input loop.
// owned: the right press began on this same screen.
const bool owned = right_press_screen && *right_press_screen == flow.screen_name();
const bool source_wait_release = flow.source_mouse_wait_release_pending();
// Menu6's right DOWN closes1e06b immediately. Its real
// UP must still consume the existing national barrier.
const bool national_picker_release = right_press_screen &&
*right_press_screen == "national_friendly_picker";
right_press_screen.reset();
if (!owned && flow.settings_readme_release_pending()) {
handle(flow.click(e.button.x, e.button.y, true));
press.reset();
continue;
}
if (!owned && (source_wait_release || national_picker_release)) {
handle(flow.click(e.button.x, e.button.y, true));
press.reset();
continue;
}
if (!owned) { flow.consume_orphaned_pitch_release(); continue; }
}
// A left release is a hold (2000 ms or more, same position, same screen) only on screens
// that support it; everywhere else it is a click.
const bool held = e.button.button == SDL_BUTTON_LEFT && !flow.in_pitch() && !flow.friendly_question_screen() && !flow.friendly_question_release_pending() && !flow.in_family_table() && !flow.in_balance() && !flow.in_desk_records() && !flow.in_achievements() && !flow.in_indoor_standings() && !flow.in_reschedule_calendar() && !flow.in_top_scorers() && !flow.in_opportunities() && !flow.in_statistics_menu() && !flow.in_statistics_page() && !flow.in_analytics() && !flow.in_other_games() && press && e.button.x == press->x && 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)
// clicks >= 2 reports a double click.
: flow.click(e.button.x, e.button.y, e.button.button == SDL_BUTTON_RIGHT, e.button.clicks >= 2);
present_formation_save_feedback();
// JA of the manager confirmation is shown pushed in briefly before the
// (possibly slow) next step starts, as in the original.
if (flow.screen_name() == "manager_accepted") {
present_season(flow.render(), "OpenBMH - manager_accepted");
SDL_Delay(150);
}
handle(released);
present_desk_record_points();
press.reset();
}
// Moving away from the pressed position cancels the hold candidate.
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();
}
// Typed characters go to the flow; a FormatError only produces a message.
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());
}
}
// Ctrl/Cmd+A selects all in the filename field.
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;
}
// Only keys the current screen type uses are forwarded to the flow (by name); on the
// desktop the letters A-Z are shortcuts.
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;
}
// Queue drained: service holds, timers and sounds, then draw.
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);
// Keep the audio options in step with the game's settings.
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());
}
// Present the frame. Tables redraw through their own path so that their acknowledgement
// is tied to a freshly drawn frame.
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;
}
// Update the custom pitch cursor, then present the canvas texture.
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());
app::present(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;
}
}
// Limit the loop to roughly 100 passes per second.
SDL_Delay(10);
}
// =====================================================================================
// Shutdown
// =====================================================================================
// Stop text input, release the SDL objects, detach the mouse sound and close audio.
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;
}
+491
View File
@@ -0,0 +1,491 @@
// SPDX-License-Identifier: GPL-3.0-only
// App: season end and season start (season pictures, contract expiry, tax, promotion, highscore, entrants, cup draw).
// (moved out of main.cpp unchanged; the class is declared in app/app.hpp)
#include "app/app.hpp"
// Paints a 320x240 indexed image through the palette into the texture and presents it.
// Also sets the window title and remembers the image as the backdrop for later dialogs.
auto App::present_season(const Image& image, const char* title,
const Palette* palette_override) -> void {
SDL_SetWindowTitle(window, title);
season_backdrop = image;
const Palette& frame_palette = palette_override ? *palette_override : palette;
const Image painted = process_timer_image(image);
canvas.show(painted, frame_palette);
}
// Plays the highscore point animation of the desk, one rendered frame per step, if active.
auto App::present_desk_record_points() -> void {
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;
}
// Modal contracts screen shown when a player's contract expires. Runs its own event loop
// and applies the player's contract actions to a staged copy of the game state.
// Returns 1 if the expired player was renewed, 0 if not, -2 on quit or error (the staged
// state and random generator are then restored).
auto App::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;
// Modal sub-loop: polls events itself instead of returning to the main loop.
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;
}
// Clicks act on button release; a button held down is drawn pressed meanwhile.
if (event.type == SDL_MOUSEBUTTONDOWN && event.button.button == SDL_BUTTON_LEFT) {
if (screen.press(event.button.x, event.button.y)) {
present_season(screen.render(), "OpenBMH - contracts");
}
} else 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);
changed = true; // also ends a pressed look that did not lead to a change
} 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");
}
// The screen asks for an engine action (quote, offer, bonuses, insurance); it is validated
// and executed on the staged state, then acknowledged to the screen. Any exception rolls
// the staged state back.
if (const ui::ContractRequest* pending = screen.pending()) {
const ui::ContractRequest request = *pending;
const auto old_game = staged;
const auto old_random = random;
try {
// Reject requests that do not belong to the current club or row range.
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] ||
// Stale quote, wrong row or implausibly high salary: refuse.
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;
}
// Keep audio streaming while idle, then yield the CPU briefly.
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;
}
}
// Reads the plain-background and text-gradient switches for the end-of-season dialogs.
auto App::game_end_options(const GameState& state) -> bmh::ui::GameEndRenderOptions {
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};
}
// Blocks until a fresh left or right mouse press (pending mouse events are flushed first)
// or quit.
auto App::wait_season_ack() -> void {
// 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);
}
}
// Modal dialog for the season tax event (question, notice or outcome). Returns true if the
// player answered Yes. A button counts only when pressed and released on the same button.
auto App::show_tax(const GameState& state, const SeasonTaxEvent& event) -> bool {
if (!running) return false;
const size_t base = size_t(event.manager_slot) * kManagerRecordSize;
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<Image>{});
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;
// Modal sub-loop (own event polling).
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;
}
// Waits without consuming gameplay input; only a quit request is handled.
auto App::wait_promotion_time(Uint32 milliseconds) -> void {
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);
}
}
// End-of-game highscore presentation: an interactive calculator when the signature is 0,
// otherwise the table is updated on disk and shown when `display` is set; ends with the
// final screen.
auto App::show_highscore(const GameState& state, bool display) -> void {
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();
}
}
// Callback at season-transition checkpoints; only the one for the German entrants does
// anything: it shows the entrant screens, each closed by a mouse release.
auto App::present_season_checkpoint(const char* checkpoint, const GameState& state) -> void {
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();
canvas.show(image, palette);
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);
}
}
}
auto App::present_tax_event(const GameState& state, const SeasonTaxEvent& event) -> void {
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 App::present_promotion(const GameState& state, const SeasonPromotionEvent& event) -> void {
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 App::present_cup_draw(const GameState& state, const SeasonCupDrawEvent& event) -> void {
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;
// Presents the current draw frame; the first frame or flagged steps flush queued mouse events.
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);
}
}
+446
View File
@@ -0,0 +1,446 @@
// SPDX-License-Identifier: GPL-3.0-only
// App: the timers and deadlines the event loop serves between inputs (process timer, table, balance, pairings, stadium, friendly match pickers).
// (moved out of main.cpp unchanged; the class is declared in app/app.hpp)
#include "app/app.hpp"
// Seconds since this process started; the time source for the process timer.
auto App::process_source_seconds() -> uint64_t {
return uint64_t(std::chrono::duration_cast<std::chrono::seconds>(
std::chrono::steady_clock::now()-process_clock_origin).count());
}
// Returns the image with the process timer bar painted on it while the timer runs.
auto App::process_timer_image(Image image) -> bmh::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.
// Samples the process timer. When the bar changed and update_texture is set, only the
// top pixel row of the texture is refreshed (and presented if `present`). Returns true
// once the timer has expired.
auto App::poll_process_timer(bool update_texture, bool present) -> bool {
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);
app::present(renderer);
}
}
return sample && sample->expired;
}
// Flashes the formation-saved feedback image, then shows the restored screen.
auto App::present_formation_save_feedback() -> void {
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());
app::present(renderer);
if (!restored) SDL_Delay(ui::PitchScreen::formation_save_flash_ms);
}
}
// Called every loop pass. If the left button has been held long enough on the pitch
// screen at the position where it was pressed, triggers the hold action once.
auto App::service_pitch_hold() -> void {
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);
}
// Seconds since the loop started in the pairings screen's source units.
auto App::pairings_source_seconds() -> uint64_t {
const auto milliseconds = std::chrono::duration_cast<std::chrono::milliseconds>(
std::chrono::steady_clock::now() - pairings_clock_start).count();
return ui::league_pairings_source_seconds(uint64_t(milliseconds));
}
// Milliseconds since the same clock started; the base for the table, balance and
// calculator timers below.
auto App::balance_source_milliseconds() -> uint64_t {
return uint64_t(std::chrono::duration_cast<std::chrono::milliseconds>(
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.
// Elapsed time in 20 ms source units.
auto App::family_table_source_units() -> uint64_t {
return balance_source_milliseconds() / 20;
}
// Tells the flow the table frame has reached the screen; it may answer with a request.
auto App::mark_family_table_presented() -> void {
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;
}
// Redraws the league table or toto screen when dirty, then marks it as presented.
auto App::present_family_table_redraw() -> void {
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());
app::present(renderer);
dirty = false;
mark_family_table_presented();
}
// Collects typed digits, ENTER, BACKSPACE and SPACE for those screens. Returns true when
// the event belongs to them (unsupported keys are swallowed too).
auto App::queue_table_range_event(const SDL_Event& event) -> bool {
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;
}
// Called every loop pass while a table or toto screen is open: advances its timers,
// redraws, and feeds queued keys whenever the screen is ready for input.
auto App::service_family_table() -> void {
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();
}
}
}
// Presents the balance screen only when its identity or notice state changed.
auto App::present_balance_redraw() -> void {
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&&notice==presented_balance_notice)return;
const auto image=process_timer_image(flow.render());
canvas.show(image, palette);
flow.mark_balance_presented_source_milliseconds(balance_source_milliseconds());
presented_balance=identity;presented_balance_notice=notice;dirty=false;
}
// Called every loop pass: advances the balance screen's millisecond timer.
auto App::service_balance_timer() -> void {
present_balance_redraw();
const auto tick=flow.tick_balance_source_milliseconds(balance_source_milliseconds());
if(tick.request!=ui::FlowRequest::none){handle(tick);present_balance_redraw();}
else if(tick.changed){dirty=true;presented_balance.reset();}
}
// Queues a key for the current stadium calculator owner.
auto App::queue_calculator_key(std::string key) -> void {
const auto& owner = flow.stadium()->state();
calculator_keys.push_back({std::move(key), owner.revision, owner.scope, owner.sequence});
}
// Collects typed digits, ENTER, BACKSPACE and SPACE for the stadium calculator; returns
// true when the event is consumed.
auto App::queue_calculator_event(const SDL_Event& event) -> bool {
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;
}
// Starts the calculator's wait clock once its frame has reached the screen.
auto App::mark_stadium_calculator_presented() -> void {
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();
}
// Called every loop pass while the stadium screen is open: converts elapsed time into
// source ticks for the calculator's waits and feeds queued keys.
auto App::service_stadium_calculator() -> void {
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<uint64_t>(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();
// The remembered release is delivered only if the calculator owner is unchanged and still
// waits for the key release.
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));
}
}
// Presents the league pairings screen when its page identity changed.
auto App::present_pairings_redraw() -> void {
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());
canvas.show(image, palette);
flow.mark_league_pairings_presented_source_seconds(pairings_source_seconds());
presented_pairings = identity;
dirty = false;
}
// Called every loop pass: advances the pairings screen's second timer.
auto App::service_pairings_timer() -> void {
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();
}
}
// Identity of the stadium tip/quote question currently open, if any.
auto App::stadium_question_frame() -> std::optional<StadiumQuestionFrame> {
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};
}
// Records the current stadium question frame as presented.
auto App::mark_stadium_question_presented() -> void { presented_stadium_question=stadium_question_frame(); }
// If the presented stadium question has expired, hands the expiry to the flow. Returns
// true when it did.
auto App::service_stadium_deadline() -> bool {
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;
}
// Same check from the idle path, but not while the question's button is being held.
auto App::service_idle_stadium_deadline() -> void {
// 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();
}
auto App::national_picker_frame() -> std::optional<NationalPickerFrame> {
if (!session || flow.screen_name() != "national_friendly_picker" || !flow.national_friendly_owner()) return {};
return NationalPickerFrame{session->session_id(),*flow.national_friendly_owner()};
}
auto App::mark_national_picker_presented() -> void { presented_national_picker=national_picker_frame(); }
// Identity of the friendly opponent picker currently open, if any.
auto App::friendly_picker_frame() -> std::optional<FriendlyPickerFrame> {
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())};
}
auto App::mark_friendly_picker_presented() -> void { presented_friendly_picker=friendly_picker_frame(); }
auto App::friendly_calendar_frame() -> std::optional<FriendlyCalendarFrame> {
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};
}
auto App::mark_friendly_calendar_presented() -> void { presented_friendly_calendar=friendly_calendar_frame(); }
auto App::friendly_question_frame() -> std::optional<FriendlyQuestionFrame> {
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)};
}
auto App::mark_friendly_question_presented() -> void { presented_friendly_question=friendly_question_frame(); }
// If the presented friendly question has expired, hands the expiry to the flow. Returns
// true when it did.
auto App::service_friendly_question_deadline() -> bool {
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;
}
// Called every loop pass and before each event. On the desktop it starts or resumes the
// process timer for the current session/manager/day and polls it. It does nothing until
// the modal frames above have been presented and while a button is held. On expiry the
// flow is told with the current logical mouse position.
auto App::service_process_timer() -> void {
// 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);
}
}
+236
View File
@@ -0,0 +1,236 @@
// SPDX-License-Identifier: GPL-3.0-only
// App: the Sportschau (intro, replay scenes, fixtures, winner, awards, team info) and its waits.
// (moved out of main.cpp unchanged; the class is declared in app/app.hpp)
#include "app/app.hpp"
// Same acknowledgement wait as above, used by the Sportschau screens.
auto App::wait_sportschau_ack() -> void {
// 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);
}
}
// Waits `ticks` units of 20 ms; only a window close request interrupts it.
auto App::source_tick_wait(unsigned ticks) -> void {
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
}
}
// Waits `count` original-display refresh periods using the high-resolution counter so
// the pacing is the same on 60/120/144 Hz monitors; only a close request interrupts it.
auto App::wait_source_retraces(unsigned count) -> void {
// 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);
}
}
}
// Builds the render options (panel background, gradient text) for Sportschau screens.
auto App::sportschau_context(const GameState& state) -> bmh::ui::SportschauReportContext {
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;
}
// --- presenters the engine calls through hooks (wired in run()): Sportschau, tax, promotion, the club
// dialogs, the poach selection and the cup draw ---
// Plays the Sportschau intro animation frames with fanfare, then waits for a click.
auto App::present_sportschau_intro(const GameState&, const SportschauIntroView&) -> void {
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();
}
// Shows the matchday intro screen for a fixed time; a left click skips it.
auto App::present_matchday_intro(const GameState&, const MatchdayIntroView& view) -> void {
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.
// 36 ticks of the DOS BIOS timer (1193182 Hz / 65536) converted to milliseconds.
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);
}
// Shows one step of the report replay (log entries growing minute by minute).
// Returns true when the replay should stop (quit) or be skipped by a left click.
auto App::present_sportschau_replay_step(const GameState& state,
const SportschauFixtureView& fixture, const SportschauReportStep& step) -> bool {
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;
// Only minute pauses accept input; other steps just look for a close request.
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;
}
// Plays one highlight (header, optional set piece, shot animation) of the replay, using
// the memory-driven delays, then restores the report screen.
auto App::present_sportschau_scene(const GameState& state,
const SportschauFixtureView& fixture, const SportschauSceneView& scene) -> void {
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);
// Waits a configured number of ticks read from the game memory row (small values halved).
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());
}
// Shows the full match report of a fixture and waits for acknowledgement.
auto App::present_sportschau_fixture(const GameState& state, const SportschauFixtureView& fixture) -> void {
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();
}
// Shows the competition winner screen.
auto App::present_competition_winner(const GameState& state, const CompetitionWinnerView& view) -> void {
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.
}
// Shows the team-of-the-matchday (eleven) screen.
auto App::present_sportschau_awards(const GameState& state, const SportschauAwardsView& view) -> void {
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();
}
// Shows the team information screen.
auto App::present_sportschau_team_info(const GameState& state, const SportschauTeamInfoView& view) -> void {
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();
}
+652
View File
@@ -0,0 +1,652 @@
// SPDX-License-Identifier: GPL-3.0-only
// App: transfers (incoming offers, decisions, pending offers, market sales, loan returns, poaching).
// (moved out of main.cpp unchanged; the class is declared in app/app.hpp)
#include "app/app.hpp"
// Converts the engine's transfer offer list into the UI's IncomingTransferDecisionView.
auto App::transfer_view(const GameState& state, const TransferOfferListView& offers, int viewer_manager) -> bmh::ui::IncomingTransferDecisionView {
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;
}
// Shows a yes/no/acknowledge dialog over a backdrop and runs a modal loop until answered.
// Questions are bound to the process timer (expiry answers No); timed notices close
// after 70*3*20 ms. Returns `unsupported` when the program is quitting.
auto App::present_pending_dialog(const GameState& state, ui::TaxDialogProjection view,
const Image& backdrop, const char* title,
std::optional<ui::GameEndRenderOptions> 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;
}
// Asks whether a loaned player should be returned. Returns 1 yes, 0 no, -1 cancelled.
auto App::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;
}
// Builds the hooks that present pending transfer/contract offers over the given backdrop.
auto App::make_pending_offer_hooks(Image backdrop) -> bmh::PendingOfferHooks {
auto pending_backdrop = std::make_shared<Image>(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");
};
// Lets the player pick one of the incoming transfer bids (modal; reacts to mouse press).
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<int> 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");
};
// Shows a program-error screen and waits for a left or right press; throws on quit.
hooks.program_error = [&, pending_backdrop](const GameState& staged, uint16_t code) {
ui::ProgramErrorScreen screen(data,code,game_end_options(staged));
// The modal loop owns the input now: drop any press recorded by the main loop.
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;
}
// Builds the hooks for transfer-market sales to a human buyer (only notices are shown).
auto App::make_market_sale_hooks(Image backdrop) -> bmh::HumanBuyerSaleHooks {
auto market_backdrop = std::make_shared<Image>(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");
};
// PresentManagerDialog yes/no question: poaching asks the selling manager whether the offered fee is
// fine and the buyer whether he pays the fee the DFB sets. Without this hook the engine refuses a poaching
// offer (the ANGEBOT button of the Abwerben dialog then does nothing).
hooks.confirm = [&, market_backdrop](const GameState& staged, int manager, const std::string& text) {
const auto answer = present_pending_dialog(staged, ui::loan_return_question_dialog(staged, manager, text),
*market_backdrop, "OpenBMH - transfer_market_question");
if (answer == PendingOfferAnswer::unsupported) throw std::runtime_error("transfer market presenter stopped");
return answer == PendingOfferAnswer::yes;
};
return hooks;
}
// Modal offer editor for a returned loan player. Returns -1 if unsupported or quitting,
// 0 if cancelled, 1 once the offer was submitted/closed.
auto App::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 {
// Only valid for manager slots 0..3 and list entries 40..43; anything else is unsupported.
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,
// clicks > 1 tells the screen it is a double click.
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();
}
}
// Keep audio streaming while idle, then yield the CPU briefly.
if (playback.needs_pump()) playback.pump(audio_error);
SDL_Delay(10);
}
(void)backdrop;
return -1;
}
// Callback for an incoming transfer offer: modal decision screen. Returns the chosen bid
// index, or -1 for decline, nothing to choose or quit.
auto App::choose_transfer_offer(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) {
// The introductory notice disappears after 4260 ms or on any key.
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;
canvas.show(image, palette);
offer_dirty = false;
}
SDL_Event event;
while (quit_confirmation.poll(&event)) {
if (event.type == SDL_QUIT) { running = false; return -1; }
std::optional<int> 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;
}
// Callback that presents a transfer decision already settled by the engine: last-week
// dialog, confirmation, or the animated evaluation of the bids. Clicks cannot change it.
auto App::present_transfer_decision(const GameState& state, const TransferDecisionEvent& decision) -> void {
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;
canvas.show(image, palette);
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);
// OK of the confirmation looks pressed while the mouse button is held
if (event.button.button == SDL_BUTTON_LEFT && confirmation &&
decision_screen.press(event.button.x, event.button.y))
rendered_phase = UINT64_MAX;
} 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()) rendered_phase = UINT64_MAX;
}
}
if (confirmation ? decision_screen.confirmation_dismissed() : decision_screen.outcome_dismissed()) return;
SDL_Delay(10);
}
}
// Callback: shows the poaching attempt's notices one after another.
auto App::present_poach_notices(const GameState& staged,const PoachStart& attempt,const Image& backdrop) -> void {
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");
}
auto App::select_poach_player(app::CareerSession& staged,app::ClubModalServices&,int manager,
uint64_t& selection_revision,const Image& transfer_backdrop) -> std::optional<ClubPlayerDetailSelection> {
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);
// Local variant of present_season that throws if an SDL render call fails.
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<pixels.size();++i)pixels[i]=palette.argb[painted.pixels[i]];
if(SDL_UpdateTexture(texture,nullptr,pixels.data(),320*4)!=0 ||
SDL_RenderClear(renderer)!=0 || SDL_RenderCopy(renderer,texture,nullptr,nullptr)!=0)
throw FormatError(std::string("poach renderer: ")+SDL_GetError());
app::present(renderer);
};
std::unique_ptr<ui::LeagueTableScreen> table;
// Rebuilds the league table screen from the current engine page.
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<ui::LeagueTableScreen>(data,std::move(tables),page->identity.league,
ui::LeagueTableScreen::FamilyMode{page->identity,1});
};
// Presents the table; a freshly forecast page is acknowledged to the engine once shown.
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.
}
};
// Modal table range dialog. Digit, ENTER, BACKSPACE and SPACE keys are queued and fed to
// the dialog only while it is ready for input; returns its accept/cancel outcome.
const auto run_range=[&](Image backdrop,ui::TableRangeDialogProfile profile)
-> ui::TableRangeDialogOutcome {
ui::LeagueTableRangeDialog dialog(data,std::move(backdrop),std::move(profile));
std::deque<std::string> keys;
Uint32 clock_anchor=SDL_GetTicks();
std::optional<ui::TableRangeDialogOutcome> 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;
}
// Feed the dialog whole 20 ms source units elapsed since the last anchor.
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};
// When the process timer runs out and no table action or release is pending, closes the
// selection as if the close control had been used. Returns true if it did.
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");
}
+39
View File
@@ -0,0 +1,39 @@
// SPDX-License-Identifier: GPL-3.0-only
// The game picture on the window: the 320x240 canvas of palette indices is converted with a palette,
// uploaded to the streaming texture and shown.
//
// src/app/main.cpp repeated these six statements at about twenty places (every presenter that shows
// a picture). Canvas::show() is that sequence, in the same order and with the same disregard of SDL
// errors as the copies had; presenters that check the SDL calls or update only a part of the texture
// keep their own code. The members are the window objects main() creates; the pixel buffer stays
// main()'s vector, because a few presenters fill parts of it themselves.
#pragma once
#include <SDL.h>
#include <cstddef>
#include <cstdint>
#include <vector>
#include "app/robot.hpp"
#include "formats/palette.hpp"
#include "formats/vga.hpp"
namespace bmh::app {
struct Canvas {
SDL_Renderer* renderer;
SDL_Texture* texture;
std::vector<uint32_t>& pixels; // 320 * 240 ARGB values
// Converts the picture with the palette, uploads it and shows it (clear, copy, present).
void show(const Image& image, const Palette& palette) {
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);
present(renderer);
}
};
} // namespace bmh::app
+26 -7572
View File
File diff suppressed because it is too large. Load diff
+193
View File
@@ -0,0 +1,193 @@
// SPDX-License-Identifier: GPL-3.0-only
// CareerSession: the club information dialogs (club, player list, player detail) and their services.
// (moved out of career_session.cpp unchanged; the class is declared in app/career_session.hpp)
#include "app/career_session_internal.hpp"
namespace bmh::app {
// Club-information modal family (enter, change category, player redraw, national action,
// pending offers): each member refuses to run while another modal owner is open and clears
// 'error' first. The ones that change state work on copies and assign them back only after
// success.
// Enter: opens the club info entry for 'team'; nullopt plus 'error' on an invalid team.
std::optional<ClubInfoEntry> CareerSession::enter_club_information(int team, std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return std::nullopt; }
error.clear();
try { return prepare_club_info_entry(g_, team); }
catch (const std::invalid_argument& e) { error = e.what(); return std::nullopt; }
}
// Switches the club info category for 'team'; nullopt plus 'error' when it is invalid.
std::optional<uint8_t> CareerSession::change_club_information_category(int team, int requested,
std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return std::nullopt; }
error.clear();
try { return set_club_info_category(g_, team, requested); }
catch (const std::invalid_argument& e) { error = e.what(); return std::nullopt; }
}
// Redraws a player detail card; random generators advance only if the redraw succeeded.
std::optional<ClubPlayerDetailRedraw> CareerSession::redraw_club_player_detail(
const ClubPlayerDetailSelection& selection, std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return std::nullopt; }
error.clear();
auto next_game = game_;
auto next_rand = rand_;
try {
auto redraw = club_player_detail_redraw(g_, selection, exe_, next_game, next_rand);
game_ = next_game;
rand_ = next_rand;
return redraw;
} catch (const std::invalid_argument& e) {
error = e.what();
return std::nullopt;
}
}
// Applies the national-team add/remove action of a player card on a staged copy; the copy is
// committed only when the engine reports no reason. Returns whether the action was applied.
std::optional<bool> CareerSession::dispatch_club_player_national_action(
const ClubPlayerDetailSelection& selection, std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return std::nullopt; }
error.clear();
auto next_state = g_;
auto next_rand = rand_;
MinuteReport report;
try {
const bool applied = club_player_detail_national_action(next_state, selection, next_rand, report);
if (!report.reason.empty()) { error = report.reason; return std::nullopt; }
g_ = std::move(next_state);
rand_ = next_rand;
return applied; // Source still refreshes the lineup when an add finds a full squad.
} catch (const std::invalid_argument& e) {
error = e.what();
return std::nullopt;
}
}
// Processes the pending transfer offers of a player card. Rejects a stale revision or a nested
// pending-offer/market dispatch, works on copies and commits them when at least one offer was
// processed. The revision is bumped here unless a calendar advance is active: then the outer
// driver publishes the revision when it returns.
std::optional<PendingOfferResult> CareerSession::dispatch_club_player_pending_offers(
const ClubPlayerDetailSelection& selection, uint64_t expected_revision,
const PendingOfferHooks& hooks, uint64_t& revision, std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return std::nullopt; }
error.clear();
if (expected_revision != revision || pending_offer_dispatch_active_ || market_dispatch_active_ ||
revision == std::numeric_limits<uint64_t>::max()) {
error = "pending offer: stale or nested player-card action";
return std::nullopt;
}
auto next_state = g_;
auto next_game = game_;
auto next_rand = rand_;
pending_offer_dispatch_active_ = true;
struct Reset { bool& active; ~Reset() { active = false; } } reset{pending_offer_dispatch_active_};
MinuteReport report;
try {
const auto result = process_player_card_pending_offers(
next_state, selection, next_game, next_rand, pending_hooks_for_dispatch(hooks), report);
if (report.unsupported || !result.completed) {
error = report.reason.empty() ? "pending offer: manual decision incomplete" : report.reason;
return std::nullopt;
}
if (result.processed != 0) {
g_ = std::move(next_state);
game_ = next_game;
rand_ = next_rand;
// A nested cup modal belongs to the current calendar transaction;
// its outer driver publishes that revision when advancement returns.
if (!calendar_advance_active_) ++revision;
}
return result;
} catch (const std::exception& e) {
error = e.what();
return std::nullopt;
}
}
// Seeds the process-only byte map used by the club modals with their start values from the
// executable; these values are never written to a save.
void CareerSession::initialize_club_modal_runtime() {
// Setup clears the boot-only dialog mode before either creating or loading
// a career. This process flag is deliberately absent from native saves.
club_modal_runtime_.emplace(layout::CompactDialogFrame, 0);
// LE object4 has bb cdd/de/e1 in its zero-initialized virtual tail;
// CareerSession_InitializeClubModalRuntime_ExecutableField is file-backed zero. These are explicit process-start values,
// carried by this runtime owner across modal entry/return, not FBM bytes.
for(uint32_t address:{::bmh::layout::CareerSession_DispatchTransferOffer_ExecutableFieldUnsigned,::bmh::layout::CareerSession_DispatchPoachUi_ExecutableFieldUnsigned,::bmh::layout::CareerSession_DispatchTransferOffer_ExecutableField2Unsigned,::bmh::layout::CareerSession_InitializeClubModalRuntime_ExecutableFieldUnsigned})
club_modal_runtime_.emplace(address,exe_.u8(address));
}
// Collects the executable bytes and rating tables the Sportschau screen reads.
SportschauSourceOptions CareerSession::sportschau_source_options() const {
return {source_runtime_byte(g_, club_modal_runtime_, exe_, ::bmh::layout::CareerSession_SportschauSourceOptions_ExecutableField),
source_runtime_byte(g_, club_modal_runtime_, exe_, ::bmh::layout::CareerSession_DispatchTransferOffer_ExecutableField2), exe_.u16(::bmh::layout::TeamsWithSquads),
sportschau_rating_tables(exe_)};
}
// Builds the service callbacks of the club modal on a given (staged) state, generators and
// runtime byte map, so the modal can run on a copy and be committed or dropped by the caller.
ClubModalServices CareerSession::staged_club_modal_services(GameState& state,
GameRandom& game,WatcomRandom& rand,std::map<uint32_t,uint8_t>& runtime) {
ClubModalServices services;
auto* g=&state; auto* gr=&game; auto* wr=&rand; auto* bytes=&runtime;
services.state=[g]() -> GameState& { return *g; };
services.enter_club=[g](int team) { return prepare_club_info_entry(*g,team); };
services.change_category=[g](int team,int category) { return set_club_info_category(*g,team,category); };
services.redraw_player=[this,g,gr,wr](const ClubPlayerDetailSelection& selection) {
auto next_game=*gr; auto next_rand=*wr;
auto result=club_player_detail_redraw(*g,selection,exe_,next_game,next_rand);
*gr=next_game; *wr=next_rand; return result;
};
services.national_action=[g,wr](const ClubPlayerDetailSelection& selection) {
auto next=*g; auto next_rand=*wr; MinuteReport report;
const bool applied=club_player_detail_national_action(next,selection,next_rand,report);
if(!report.reason.empty())throw FormatError(report.reason);
*g=std::move(next); *wr=next_rand; return applied;
};
services.pending_offers=[this,g,gr,wr](const ClubPlayerDetailSelection& selection,const PendingOfferHooks& hooks) {
auto next=*g; auto next_game=*gr; auto next_rand=*wr; MinuteReport report;
auto result=process_player_card_pending_offers(next,selection,next_game,next_rand,
pending_hooks_for_dispatch(hooks),report);
if(report.unsupported||!result.completed)
throw FormatError(report.reason.empty()?"TeamInfo: nested pending decision incomplete":report.reason);
*g=std::move(next); *gr=next_game; *wr=next_rand; return result;
};
services.runtime_byte=[this,g,bytes](uint32_t address) {
if(g->memory.has(address))return g->memory.u8(address);
if(const auto at=bytes->find(address);at!=bytes->end())return at->second;
// Explicit original initialization supplies the transient input owner.
// Never serialize an absent BSS byte or infer Native absence as zero.
return exe_.u8(address);
};
services.set_runtime_byte=[g,bytes](uint32_t address,uint8_t value) {
if(g->memory.has(address))g->memory.set8(address,value);
else (*bytes)[address]=value;
};
return services;
}
// Same services bound to the live state (non-transactional); pending offers go through
// dispatch_club_player_pending_offers. Throws when another modal owner is open.
ClubModalServices CareerSession::live_club_modal_services(uint64_t& revision) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) throw FormatError("strengths_active");
auto services=staged_club_modal_services(g_,game_,rand_,club_modal_runtime_);
services.transactional=false;
// Existing cup/club caller keeps its separately owned pending transaction.
services.pending_offers=[this,&revision](const ClubPlayerDetailSelection& selection,const PendingOfferHooks& hooks) {
std::string error;
auto result=dispatch_club_player_pending_offers(selection,revision,hooks,revision,error);
if(!result)throw FormatError(error);
return *result;
};
return services;
}
} // namespace bmh::app
File diff suppressed because it is too large. Load diff
+164
View File
@@ -0,0 +1,164 @@
// SPDX-License-Identifier: GPL-3.0-only
#pragma once
// Internal header of the career session: the includes and the helper functions that more than one of the
// career_session*.cpp files uses. Included only by those files (the helpers have internal linkage).
#include "formats/native_save_version.hpp"
#include "formats/badge_policy.hpp"
#include "game/calendar.hpp"
#include "formats/executable_layout.hpp"
#include "app/career_session.hpp"
#include "formats/league_visibility.hpp"
#include <stdexcept>
#include <system_error>
#include <algorithm>
#include <array>
#include <atomic>
#include <cctype>
#include <bit>
#include <fstream>
#include <limits>
#include <utility>
#include "formats/binary.hpp"
#include "formats/fbm.hpp"
#include "formats/savestate.hpp"
#include "game/career.hpp"
#include "game/cup.hpp"
#include "game/driver.hpp"
#include "game/desk.hpp"
#include "game/desk_actions.hpp"
#include "game/match.hpp"
#include "game/messages.hpp"
#include "game/prediction.hpp"
#include "game/schedule.hpp"
#include "game/bank_credit.hpp"
#include "game/matchday_setup.hpp"
#include "game/matchday.hpp"
#include "game/lineup.hpp"
#include "game/month.hpp"
#include "game/national.hpp"
#include "game/schedule.hpp"
#include "game/table.hpp"
#include "game/table_forecast.hpp"
#include "game/save.hpp"
#include "game/season.hpp"
#include "game/turn.hpp"
#include "game/week.hpp"
#include "game/weekly.hpp"
#include "ui/desk_state.hpp"
#include "ui/league_table.hpp"
#include "ui/other_games_state.hpp"
#include "ui/manager.hpp"
#include "ui/pending_offer.hpp"
#include "ui/training.hpp"
namespace bmh::app {
namespace {
// Reads one byte of the executable's data at 'address': from the game's memory image when the
// address is mapped there, else from the runtime override map, else from the loaded EXE.
uint8_t source_runtime_byte(const GameState& state,const std::map<uint32_t,uint8_t>& runtime,
const LeImage& exe,uint32_t address) {
if(state.memory.has(address))return state.memory.u8(address);
const auto found=runtime.find(address);return found==runtime.end()?exe.u8(address):found->second;
}
// Writes one byte to the memory image when the address is mapped there, otherwise into the
// runtime override map (the EXE image itself is never modified).
void source_runtime_set_byte(GameState& state,std::map<uint32_t,uint8_t>& runtime,
uint32_t address,uint8_t value) {
if(state.memory.has(address))state.memory.set8(address,value);
else runtime[address]=value;
}
// Little-endian 32-bit read built from four source_runtime_byte reads.
uint32_t source_runtime_u32(const GameState& state,const std::map<uint32_t,uint8_t>& runtime,
const LeImage& exe,uint32_t address) {
return uint32_t(source_runtime_byte(state,runtime,exe,address)) |
uint32_t(source_runtime_byte(state,runtime,exe,address+1))<<8 |
uint32_t(source_runtime_byte(state,runtime,exe,address+2))<<16 |
uint32_t(source_runtime_byte(state,runtime,exe,address+3))<<24;
}
// Writes the process scratch bytes (league, group, date pieces, strength sums) that the
// original leaves behind after drawing the pairings page, so later reads see the same values.
// Bytes go to the memory image when mapped there, else to the runtime map.
void pairings_runtime_draw(GameState& g,std::map<uint32_t,uint8_t>& runtime,
const ui::LeaguePairingsState& page,const LeImage& exe) {
const auto put=[&](uint32_t at,uint8_t v) {
if(g.memory.has(at))g.memory.set8(at,v);else runtime[at]=v;
};
const uint32_t tip_preference=::bmh::layout::CareerSession_CloseLeagueFamily_ExecutableField+uint32_t(page.identity.manager);
const bool computer_tip=page.source.owner.computer_tip_active;
if(computer_tip)put(tip_preference,uint8_t(g.memory.u8(tip_preference)|0x10));
// Actual5147b entry/input globals; these are process bytes, not invented FBM blocks.
put(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_RuntimeField2,uint8_t(page.identity.league));put(::bmh::layout::CareerSession_AdvertisingSessionUnchanged_ExecutableField,page.source.owner.league_group);
put(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField,0);put(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField2,0);
const auto date=[&](uint32_t counter) {
if(counter==0xffff)return; //21258's Wettbewerb-gesperrt branch changes no date scratch.
const auto d=ui::desk_date(counter,exe);
int cycle=3;uint32_t n=counter;
while(n>uint32_t(364+(cycle==4))) {if(cycle==4){cycle=0;--n;}n-=365;++cycle;}
put(::bmh::layout::CareerSession_PairingsRuntimeDraw_ExecutableField,uint8_t(28+(cycle==4)));
put(::bmh::layout::CareerSession_PairingsRuntimeDraw_ExecutableField4,uint8_t(d.day));put(::bmh::layout::CareerSession_PairingsRuntimeDraw_ExecutableField5,uint8_t(d.month));put(::bmh::layout::CareerSession_PairingsRuntimeDraw_ExecutableField6,uint8_t(d.weekday));
put(::bmh::layout::CareerSession_PairingsRuntimeDraw_ExecutableField2,uint8_t(d.year));put(::bmh::layout::CareerSession_PairingsRuntimeDraw_ExecutableField3,uint8_t(d.year>>8));
};
const bool selected_filter=page.source.owner.filter_active&&page.source.owner.filter_team>=0;
if(!selected_filter&&!page.source.owner.postponed_active)
date(page.source.match_date); //333f3 is absent in selected Mode4 and Mode8.
for(const auto& row:page.source.rows) {
if(row.scheduled_date)date(*row.scheduled_date);
else if(row.postponed_date)date(*row.postponed_date);
const uint8_t displayed=row.computer_tip_result.value_or(row.raw_result);
// In local28's referee phase, exact CC rows skip both 68164 calls.
// Preserve prior scratch when every row takes that branch; a mixed
// page leaves the last ordinary away-row value, in Source draw order.
if(page.source.owner.active_phase&&displayed==0xcc)continue;
//68164's final17295 call on the away team leaves Source CareerSession_FormatError_ExecutableField3.
const auto strength=team_average(g,row.away.runtime_team,0x1ff);
put(::bmh::layout::CareerSession_FormatError_ExecutableField3,uint8_t(strength.best_half_sum));put(::bmh::layout::CareerSession_FormatError_ExecutableField4,uint8_t(strength.best_half_sum>>8));
}
// Move clears its one-redraw local38 bit after the forecast has
// been projected. The returned page retains the pressed Original button.
if(computer_tip)put(tip_preference,uint8_t(g.memory.u8(tip_preference)&0xef));
}
// Compares the runtime-only fields of two states (callbacks by target type); used to check the
// strengths view left the game unchanged.
bool same_strengths_runtime_state(const GameState& a,const GameState& b) {
const auto same_callback=[](const auto& lhs,const auto& rhs) {
return bool(lhs)==bool(rhs)&&(!lhs||lhs.target_type()==rhs.target_type());
};
return a.indoor==b.indoor&&a.currency_suffix==b.currency_suffix&&a.level==b.level&&
a.chance_rain==b.chance_rain&&a.chance_temperature==b.chance_temperature&&
a.last_shooter==b.last_shooter&&a.last_pick_quality==b.last_pick_quality&&
a.live_scene==b.live_scene&&a.reality==b.reality&&a.live_matches==b.live_matches&&a.list_toggle==b.list_toggle&&
a.lineups_frozen==b.lineups_frozen&&a.texts==b.texts&&a.date==b.date&&
a.season_start==b.season_start&&a.development_balance==b.development_balance&&
a.trend_rotation==b.trend_rotation&&a.season==b.season&&a.transfer_notice_suppressed==b.transfer_notice_suppressed&&
a.offer_answer==b.offer_answer&&a.pools_open==b.pools_open&&a.autosave_months==b.autosave_months&&
a.autosave_month==b.autosave_month&&same_callback(a.contract_screen,b.contract_screen)&&
same_callback(a.loan_return_screen,b.loan_return_screen)&&
same_callback(a.loan_return_offer_screen,b.loan_return_offer_screen)&&
same_callback(a.transfer_decision,b.transfer_decision)&&
same_callback(a.transfer_offer_selector,b.transfer_offer_selector)&&
same_callback(a.transfer_decision_observer,b.transfer_decision_observer);
}
// Reinterprets the low byte of 'value' as a signed byte.
int8_t source_byte(int value) { return static_cast<int8_t>(uint8_t(value)); }
// True when a table request carries no stray fields (no target child, team, row or dialog reply;
// league id only if the selector variant is allowed) and the expected control index.
bool canonical_table_envelope(const ui::LeagueFamilyRequest& request,int control_index=-1,
bool allow_selector_league=false) {
return request.target_child==0&&request.runtime_team==-1&&request.expected_club_identity==-1&&
request.table_row_index==-1&&(allow_selector_league||request.league_id==-1)&&
request.control_index==control_index&&
!request.table_dialog_reply;
}
} // namespace
} // namespace bmh::app
File diff suppressed because it is too large. Load diff
+803
View File
@@ -0,0 +1,803 @@
// SPDX-License-Identifier: GPL-3.0-only
// CareerSession: club management: training, training camp, bank, stadium, toto.
// (moved out of career_session.cpp unchanged; the class is declared in app/career_session.hpp)
#include "app/career_session_internal.hpp"
namespace bmh::app {
namespace {
constexpr uint8_t kBlockSeat = 1;
constexpr uint8_t kBlockRoof = 2;
constexpr uint8_t kBlockFeatures = kBlockSeat | kBlockRoof;
// True for the stadium requests that belong to the block-expansion dialog (select, total,
// feature toggle, cancel, confirm, answer tip).
bool is_block_expansion_action(ui::StadiumRequestKind kind) {
return kind == ui::StadiumRequestKind::expansion_select ||
kind == ui::StadiumRequestKind::expansion_set_total ||
kind == ui::StadiumRequestKind::expansion_toggle_feature ||
kind == ui::StadiumRequestKind::expansion_cancel ||
kind == ui::StadiumRequestKind::expansion_confirm ||
kind == ui::StadiumRequestKind::expansion_answer_tip;
}
} // namespace
// Training group: one request changes the types, areas, automation byte or one player's
// intensity or focus of the active manager. The request carries the desired result; it is
// validated against the current projection (stale manager, plan limits, expected values), applied
// on a staged copy and committed with revision plus one. Manual edits clear the matching
// assistant flag and never draw random numbers; initialize and enabling automation run the
// automatic training. Returns false with a short error code in 'error' otherwise.
bool CareerSession::dispatch_training(const ui::TrainingRequest& request, uint64_t& revision,
std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return false; }
const int active = int(g_.memory.u8(::bmh::layout::ActiveManager));
if (request.manager_slot != active || request.manager_slot < 0 || request.manager_slot > 3 ||
size_t(request.manager_slot) >= g_.manager_teams.size() ||
request.runtime_club != g_.manager_teams[size_t(request.manager_slot)] || request.revision != revision) {
error = "stale_manager_or_revision";
return false;
}
try {
const ui::TrainingState current = ui::training_from_game(g_, exe_, revision);
if (current.manager_slot != request.manager_slot || current.runtime_club != request.runtime_club) {
error = "stale_manager_or_revision";
return false;
}
const size_t slot = size_t(request.manager_slot);
const size_t rec = slot * 0xb0c;
const size_t option_at = slot * 5 + 4;
if (g_.manager_records.size() < rec + 0xb0c || g_.manager_options.size() <= option_at) {
error = "invalid_training_state";
return false;
}
auto valid_plan = [](const std::array<uint8_t, 4>& types, const std::array<uint8_t, 9>& areas) {
int type_sum = 0, fitness = 0, skills = 0;
for (uint8_t value : types) { if (value < 1 || value > 3) return false; type_sum += value; }
for (size_t i = 0; i < areas.size(); ++i) {
const uint8_t value = areas[i];
if (value < 1 || value > 3) return false;
if (i < 2) fitness += value; else skills += value;
}
return type_sum <= 8 && fitness <= 4 && skills <= 18;
};
if (!valid_plan(request.desired_types, request.desired_areas)) {
error = "invalid_training_plan";
return false;
}
ui::TrainingRequestKind kind = request.kind;
auto types = current.types;
auto areas = current.areas;
uint8_t automation = current.automation;
bool run_automatic = false;
// NeedsInitialization initializes an uninitialized screen via Initialize;
// the four subordinate toggles exist only while the global flag is on.
// NeedsInitialization2 calls that same deterministic routine after an enabled
// automation toggle. Manual field edits only write their field and clear
// the matching assistant flag; they do not run training or draw RNG.
switch (kind) {
case ui::TrainingRequestKind::initialize:
if (!current.needs_initialization() || request.index != -1 || request.value != -1 ||
request.player_id != -1 || request.desired_types != types || request.desired_areas != areas ||
request.desired_automation != 0x9f) {
error = "invalid_training_initialization";
return false;
}
automation = 0x9f;
run_automatic = true;
break;
case ui::TrainingRequestKind::set_type:
if (current.needs_initialization() || request.index < 0 || request.index >= int(types.size()) ||
request.value < 1 || request.value > 3 || request.player_id != -1 ||
request.value == types[size_t(request.index)]) {
error = "invalid_training_type";
return false;
}
types[size_t(request.index)] = uint8_t(request.value);
automation = uint8_t(automation & ~uint8_t(1u << 1));
break;
case ui::TrainingRequestKind::set_area:
if (current.needs_initialization() || request.index < 0 || request.index >= int(areas.size()) ||
request.value < 1 || request.value > 3 || request.player_id != -1 ||
request.value == areas[size_t(request.index)]) {
error = "invalid_training_area";
return false;
}
areas[size_t(request.index)] = uint8_t(request.value);
automation = uint8_t(automation & ~uint8_t(1u << 2));
break;
case ui::TrainingRequestKind::set_player_intensity:
case ui::TrainingRequestKind::set_player_focus: {
if (current.needs_initialization() || request.index < 0 || request.index >= current.squad_capacity ||
request.player_id < 0 || request.player_id > 0x0ffe) {
error = "invalid_training_player";
return false;
}
const auto player = std::find_if(current.players.begin(), current.players.end(), [&](const auto& p) {
return p.row == request.index && p.player_id == request.player_id;
});
const SquadRange squad = squad_range(request.runtime_club);
if (player == current.players.end() || squad.count != size_t(current.squad_capacity) ||
squad.first + size_t(request.index) >= g_.squad_slots.size() ||
(g_.squad_slots[squad.first + size_t(request.index)] & 0x0fff) != request.player_id) {
error = "stale_training_player";
return false;
}
if (kind == ui::TrainingRequestKind::set_player_intensity) {
if (request.value < 1 || request.value > 3 || request.value == player->intensity) {
error = "invalid_training_intensity";
return false;
}
automation = uint8_t(automation & ~uint8_t(1u << 3));
} else if (request.value < 0 || request.value > 7 || request.value != (player->focus + 1) % 8) {
error = "invalid_training_focus";
return false;
}
break;
}
case ui::TrainingRequestKind::set_automation: {
if (current.needs_initialization() || request.index < 0 || request.index > 4 ||
(request.value != 0 && request.value != 1) || request.player_id != -1) {
error = "invalid_training_automation";
return false;
}
if (request.index != 0 && !(current.automation & 1)) {
error = "training_automation_group_hidden";
return false;
}
const uint8_t mask = uint8_t(1u << request.index);
automation = uint8_t(automation ^ mask);
if (((automation & mask) != 0) != (request.value != 0)) {
error = "stale_training_automation";
return false;
}
run_automatic = (automation & 1) != 0;
break;
}
case ui::TrainingRequestKind::none:
default:
error = "unsupported_training_request";
return false;
}
if (request.desired_types != types || request.desired_areas != areas ||
request.desired_automation != automation) {
error = "stale_training_projection";
return false;
}
GameState staged = g_;
std::copy(types.begin(), types.end(), staged.manager_records.begin() + rec + 0xc5);
std::copy(areas.begin(), areas.end(), staged.manager_records.begin() + rec + 0xc9);
staged.manager_options[option_at] = automation;
if (kind == ui::TrainingRequestKind::set_player_intensity ||
kind == ui::TrainingRequestKind::set_player_focus) {
const size_t board = slot * 0x840 + size_t(request.index) * 0x58 + 0x0a;
if (board >= staged.tactics.size()) {
error = "invalid_training_board";
return false;
}
if (kind == ui::TrainingRequestKind::set_player_intensity)
staged.tactics[board] = uint8_t((staged.tactics[board] & 0xfc) | request.value);
else
staged.tactics[board] = uint8_t((staged.tactics[board] & 0x03) | (request.value << 2));
}
if (run_automatic) auto_training(staged, request.manager_slot);
g_ = std::move(staged);
++revision;
error.clear();
return true;
} catch (const std::exception&) {
error = "invalid_training_state";
return false;
}
}
// Training camp group: set_focus changes the four focus bytes of the active manager (an unchanged
// or invalid focus is refused); book books a resort for the week after checking the focus the UI
// saw, the weekly/visit limits and the funds (the booking draws random numbers). Refused while a
// modal owner is open or when the manager slot, club or revision is stale; revision plus one on
// success, short error codes in 'error' otherwise.
bool CareerSession::dispatch_training_camp(const ui::TrainingCampRequest& request, uint64_t& revision,
std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return false; }
if (request.manager_slot < 0 || size_t(request.manager_slot) >= g_.manager_teams.size() ||
request.manager_slot != int(g_.memory.u8(::bmh::layout::ActiveManager)) ||
request.runtime_club != g_.manager_teams[size_t(request.manager_slot)] || request.revision != revision) {
error = "stale_manager_or_revision";
return false;
}
const size_t rec = size_t(request.manager_slot) * kManagerRecordSize;
if (request.kind == ui::TrainingCampRequestKind::set_focus) {
const std::array<uint8_t, 4> current{
g_.manager_records.at(rec + 0xc1), g_.manager_records.at(rec + 0xc2),
g_.manager_records.at(rec + 0xc3), g_.manager_records.at(rec + 0xc4)};
if (request.focus == current) {
error = "focus_unchanged";
return false;
}
if (!set_training_camp_focus(g_, request.manager_slot, request.focus)) {
error = "invalid_focus_request";
return false;
}
++revision;
return true;
}
if (request.kind == ui::TrainingCampRequestKind::book) {
if (request.resort < 0 || request.resort >= kTrainingCampResorts) {
error = "invalid_resort";
return false;
}
const std::array<uint8_t, 4> current{
g_.manager_records.at(rec + 0xc1), g_.manager_records.at(rec + 0xc2),
g_.manager_records.at(rec + 0xc3), g_.manager_records.at(rec + 0xc4)};
if (request.focus != current) {
error = "stale_focus";
return false;
}
switch (training_camp_booking_block(g_, request.manager_slot)) {
case TrainingCampBookingBlock::booked_this_week: error = "booked_this_week"; return false;
case TrainingCampBookingBlock::visit_limit: error = "visit_limit"; return false;
case TrainingCampBookingBlock::invalid_request: error = "invalid_request"; return false;
case TrainingCampBookingBlock::none: break;
}
if (!book_training_camp(g_, request.manager_slot, request.resort, rand_)) {
error = "insufficient_funds";
return false;
}
++revision;
return true;
}
error = "unsupported_training_camp_request";
return false;
}
// Bank group: deposit moves, share and fund trades, stock tips and bank credit. Needs the active
// manager, club and current revision and no modal owner open. Every branch validates amounts and
// counts against the manager record and the stock/fund blocks, then applies the change to the
// live state and bumps the revision once. The notices of the last property purchase or credit
// refund are kept for the next projection. Returns false with a short error code otherwise.
bool CareerSession::dispatch_bank(const ui::BankRequest& request, uint64_t& revision, std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return false; }
error.clear();
if (revision == std::numeric_limits<uint64_t>::max()) {
error = "revision_exhausted"; return false;
}
const int active = int(g_.memory.u8(::bmh::layout::ActiveManager));
if (request.manager_slot != active ||
request.manager_slot < 0 || size_t(request.manager_slot) >= g_.manager_teams.size() ||
request.runtime_club != g_.manager_teams[size_t(request.manager_slot)] || request.revision != revision) {
error = "stale_manager_or_revision"; return false;
}
const size_t rec = size_t(request.manager_slot) * kManagerRecordSize;
std::optional<ui::BankState::PropertyNotice> property_notice;
std::optional<ui::BankState::CreditNotice> credit_notice;
const auto read_signed = [&](size_t offset) {
const uint32_t v = uint32_t(g_.manager_records.at(rec + offset)) |
uint32_t(g_.manager_records.at(rec + offset + 1)) << 8 |
uint32_t(g_.manager_records.at(rec + offset + 2)) << 16 |
uint32_t(g_.manager_records.at(rec + offset + 3)) << 24;
return int32_t(v);
};
if (request.kind == ui::BankRequestKind::move_to_deposit) {
if (!request.amount || request.asset_index != -1 || request.count != 0 ||
int64_t(request.amount > 0 ? request.amount : -int64_t(request.amount)) > 99999999) {
error = "invalid_amount"; return false;
}
const int64_t available = request.amount > 0 ? read_signed(0x314) : read_signed(0x318);
if (available < 0 || int64_t(request.amount > 0 ? request.amount : -int64_t(request.amount)) > available) {
error = "amount_unavailable"; return false;
}
move_to_deposit(g_, request.manager_slot, request.amount);
} else if (request.kind == ui::BankRequestKind::buy_shares || request.kind == ui::BankRequestKind::sell_shares ||
request.kind == ui::BankRequestKind::stock_tip) {
if (request.asset_index < 0 || request.asset_index >= kStocks ||
g_.stocks.size() < size_t(kStocks) * 0x5c) { error = "invalid_stock"; return false; }
const size_t at = size_t(request.asset_index) * 0x5c;
const int price = int(uint16_t(g_.stocks.at(at + 0x4e) | uint16_t(g_.stocks.at(at + 0x4f)) << 8));
if (request.kind == ui::BankRequestKind::buy_shares) {
if (request.count <= 0 || request.count > 9999 || price <= 0 ||
request.count > max_shares_to_buy(g_, request.manager_slot, request.asset_index)) {
error = "invalid_share_count"; return false;
}
const int64_t raw = int64_t(price) * request.count;
const int64_t total = raw + raw * 15 / 1000;
if (total > int64_t(read_signed(0x314)) + read_signed(0x31c)) {
error = "insufficient_funds"; return false;
}
if (!buy_shares(g_, request.manager_slot, request.asset_index, request.count)) {
error = "investment_limit"; return false;
}
} else if (request.kind == ui::BankRequestKind::sell_shares) {
const size_t held_at = at + 0x50 + size_t(request.manager_slot) * 2;
const int held = int(uint16_t(g_.stocks.at(held_at) | uint16_t(g_.stocks.at(held_at + 1)) << 8));
if (request.count <= 0 || request.count > held) { error = "invalid_share_count"; return false; }
sell_shares(g_, request.manager_slot, request.asset_index, request.count);
} else {
if (request.count != 0 || request.amount != 0) { error = "invalid_tip_request"; return false; }
last_stock_tip_ = stock_tip(g_, request.manager_slot, request.asset_index, rand_);
}
} else if (request.kind == ui::BankRequestKind::buy_fund || request.kind == ui::BankRequestKind::sell_fund) {
if (request.amount != 0 || request.asset_index < 0 || request.asset_index >= kFunds || request.count <= 0 || request.count > 10 ||
g_.memory.u32(::bmh::layout::FundBlock + uint32_t(request.asset_index) * 0x1c) == 0) {
error = "invalid_fund_request"; return false;
}
const uint32_t fund_at = ::bmh::layout::FundBlock + uint32_t(request.asset_index) * 0x1c;
const uint16_t held = g_.memory.u16(fund_at + 0x14 + uint32_t(request.manager_slot) * 2);
if (request.kind == ui::BankRequestKind::buy_fund) {
if (request.count > max_fund_units(g_, request.manager_slot, request.asset_index)) {
error = "invalid_fund_count"; return false;
}
const int32_t additional_cost = buy_fund_units(g_, request.manager_slot, request.asset_index, request.count, game_);
if (request.asset_index != 0) {
const std::string text = message_text(g_, ::bmh::layout::CareerSession_Int32T_TextPointer2) + format_number(g_, additional_cost, 0x101) +
message_text(g_, ::bmh::layout::CareerSession_Int32T_TextPointer);
property_notice = ui::BankState::PropertyNotice{request.asset_index, additional_cost, ui::original_to_utf8(text)};
}
} else {
if (request.count > held) { error = "invalid_fund_count"; return false; }
sell_fund_units(g_, request.manager_slot, request.asset_index, request.count);
}
} else if (request.kind == ui::BankRequestKind::bank_credit) {
if (request.amount != 0 || request.asset_index != -1 || request.count != 0 || request.credit_edits.empty()) {
error = "invalid_credit_request"; return false;
}
if (request.credit_counterparty != 0) {
// Source case 5 scans configured human managers, excluding the borrower.
// A runtime national-manager entry is not an additional human lender.
const int configured = int(g_.memory.u8(::bmh::layout::ManagerCount));
if (request.credit_counterparty < 1 || request.credit_counterparty > 4) {
error = "invalid_credit_request"; return false;
}
const int lender = request.credit_counterparty - 1;
if (configured < 1 || configured > 4 || request.manager_slot >= configured ||
lender < 0 || lender >= configured || lender == request.manager_slot) {
error = "invalid_credit_request"; return false;
}
}
const auto result = commit_bank_credit(g_, exe_, request.manager_slot,
request.expected_credit, request.credit_edits, request.accept_credit_fees, request.credit_counterparty);
if (result.status != BankCreditStatus::accepted) {
error = result.status == BankCreditStatus::no_change ? "credit_no_change" :
result.status == BankCreditStatus::stale_request ? "stale_credit_request" :
result.status == BankCreditStatus::confirmation_required ? "credit_confirmation_required" :
"invalid_credit_request";
return false;
}
if (result.refund != 0) {
// "Die Bank" (CareerSession_Int32T_TextPointer3) or, in case 5, the lender's name (record +0xa8)
const int lender = request.credit_counterparty - 1;
std::string who = message_text(g_, ::bmh::layout::CareerSession_Int32T_TextPointer3);
if (lender >= 0) {
who.clear();
for (size_t i = 0; i < 26; ++i) {
const uint8_t ch = g_.manager_records.at(size_t(lender) * kManagerRecordSize + 0xa8 + i);
if (!ch) break;
who += char(ch);
}
}
const std::string text = who + message_text(g_, ::bmh::layout::CareerSession_Int32T_TextPointer4) +
format_number(g_, result.refund, 0x101) + message_text(g_, ::bmh::layout::CareerSession_Int32T_TextPointer5);
credit_notice = ui::BankState::CreditNotice{result.refund, ui::original_to_utf8(text)};
}
} else {
error = "unsupported_bank_request"; return false;
}
last_property_notice_ = std::move(property_notice);
last_credit_notice_ = std::move(credit_notice);
++revision;
return true;
}
// True when a construction tip dialog is open and the process timer (when running) has no time
// left; read-only.
bool CareerSession::stadium_tip_deadline_expired() const {
if (!stadium_.opened || (!stadium_.tip &&
(!stadium_.block_expansion || !stadium_.block_expansion->tip))) return false;
const auto byte = [this](uint32_t address) {
if (g_.memory.has(address)) return g_.memory.u8(address);
const auto found = club_modal_runtime_.find(address);
return found == club_modal_runtime_.end() ? exe_.u8(address) : found->second;
};
const auto word = [&byte](uint32_t address) {
uint32_t value = 0;
for (unsigned i = 0; i < 4; ++i) value |= uint32_t(byte(address + i)) << (8 * i);
return value;
};
return word(::bmh::layout::CareerSession_DispatchStrengths_ExecutableField2) != 0 && int32_t(word(::bmh::layout::CareerSession_FormatError_ExecutableField2)) < 1;
}
// Stadium group: an owner (stadium_) is opened with a scope id and every later request must echo
// scope and sequence, the manager, club, stable club identity, game mode and revision. All
// actions (data page, periphery quote/build, block expansion editor with its tip, investments)
// run inside the apply lambda below; on failure the stadium checkpoint is restored, on success
// revision, sequence and the owner's revision advance. Exceptions restore the checkpoint and
// the revision and are rethrown. Short error codes in 'error' otherwise.
// Older periphery callers send no scope envelope; a compatibility step fills it in for their four
// original operations only.
bool CareerSession::dispatch_stadium(const ui::StadiumRequest& supplied_request, uint64_t& revision, std::string& error,
const ConstructionNoticeHook& notice_presenter,
const SeasonTicketCompensationNoticeHook& compensation_presenter) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return false; }
const int active = int(g_.memory.u8(::bmh::layout::ActiveManager));
auto request = supplied_request;
// Existing CLI periphery callers predate the UI scope envelope. Restrict
// this compatibility adapter to their four original operations and an
// entirely absent envelope; investments and close remain strictly owned.
const bool legacy_periphery = !request.stable_club_identity && request.scope == 0 && request.sequence == 0 &&
(request.kind == ui::StadiumRequestKind::open || request.kind == ui::StadiumRequestKind::quote_periphery ||
request.kind == ui::StadiumRequestKind::decline_periphery || request.kind == ui::StadiumRequestKind::build_periphery);
if (legacy_periphery && active >= 0 && active <= 3 && size_t(active) < g_.manager_teams.size() &&
request.runtime_club >= 0 && size_t(request.runtime_club) < g_.club_ids.size()) {
request.stable_club_identity = int(g_.club_ids[size_t(request.runtime_club)]);
if (request.kind != ui::StadiumRequestKind::open) {
request.scope = stadium_.scope; request.sequence = stadium_.sequence;
}
}
const bool block_action = is_block_expansion_action(request.kind);
if (!block_action && (request.block_slot != -1 || request.block_total_places != 0 ||
request.block_features != 0 || request.expected_block_quote)) {
error = "unexpected_block_expansion_fields"; return false;
}
if (request.manager_slot != active || active < 0 || active > 3 ||
size_t(active) >= g_.manager_teams.size() || request.runtime_club != g_.manager_teams[size_t(active)] ||
request.runtime_club < 0 || request.runtime_club >= 357 ||
size_t(request.runtime_club) >= g_.club_ids.size() ||
request.stable_club_identity != std::optional<int>(int(g_.club_ids[size_t(request.runtime_club)])) ||
request.revision != revision || revision == UINT64_MAX || !g_.memory.has(::bmh::layout::GameMode)) {
error = "stale_manager_or_revision"; return false;
}
const size_t record = size_t(active) * kManagerRecordSize;
if (record + 0xb0c > g_.manager_records.size() ||
(int(g_.manager_records[record + 0x290]) | int(g_.manager_records[record + 0x291]) << 8) != request.runtime_club) {
error = "invalid_stadium_owner"; return false;
}
const int mode = g_.memory.u8(::bmh::layout::GameMode);
if (mode < 1 || mode > 3) { error = "invalid_stadium_mode"; return false; }
if (request.kind == ui::StadiumRequestKind::open) {
const bool legacy_reentry = legacy_periphery && !stadium_.data_open && !stadium_.investment && !stadium_.tip &&
!stadium_.block_expansion;
if ((stadium_.opened && !legacy_reentry) || request.scope != 0 || request.sequence != 0 || request.object != -1 ||
request.option != -1 || request.price != 0 || request.accept_tip || next_stadium_scope_ == UINT64_MAX) {
error = "invalid_stadium_open"; return false;
}
} else if (!stadium_.opened || stadium_.manager != active || stadium_.club != request.runtime_club ||
stadium_.stable_club != *request.stable_club_identity || stadium_.mode != mode ||
stadium_.revision != revision || request.scope != stadium_.scope ||
request.sequence != stadium_.sequence || stadium_.sequence == UINT64_MAX) {
error = "stale_stadium_scope"; return false;
}
auto before = stadium_checkpoint();
const uint64_t before_revision = revision;
try {
// Performs the validated stadium action and returns true on success; 'invalid' records the
// reason and returns false.
const auto apply = [&]() -> bool {
const auto invalid = [&error](const char* reason) { error = reason; return false; };
const auto plain = [&request](int object = -1) {
return request.object == object && request.option == -1 && request.price == 0 && !request.accept_tip;
};
const auto clear_investment = [this] {
stadium_.investment.reset(); stadium_.selection_status.reset(); stadium_.option.reset(); stadium_.tip.reset();
stadium_.option_index = -1; stadium_.text_variant = -1;
};
StadiumInvestmentConstants constants;
for (unsigned i = 0; i < 8; ++i) {
constants.price[i] = exe_.u32(::bmh::layout::CareerSession_DispatchStadium_RuntimeField + i * 4);
constants.weeks[i] = exe_.u8(::bmh::layout::CareerSession_DispatchStadium_RuntimeField2 + (14 + i) * 5);
}
const auto options = [&](StadiumInvestment investment) {
return stadium_investment_options_source(g_, active, investment, stadium_.price_percent, constants);
};
const auto selected_valid = [&]() {
if (!stadium_.investment || !stadium_.option || stadium_.option_index < 0) return false;
const auto current = options(*stadium_.investment);
return size_t(stadium_.option_index) < current.size() &&
current[size_t(stadium_.option_index)] == *stadium_.option;
};
if (request.kind == ui::StadiumRequestKind::open) {
StadiumRuntime opened;
opened.opened = true; opened.manager = active; opened.club = request.runtime_club;
opened.stable_club = *request.stable_club_identity; opened.mode = mode;
opened.scope = next_stadium_scope_++;
opened.price_percent = construction_price_percent(g_, active, game_);
if (opened.price_percent < 1 || opened.price_percent > 427) return invalid("invalid_stadium_discount");
stadium_ = std::move(opened);
return true;
}
if (request.kind == ui::StadiumRequestKind::close) {
if (stadium_.data_open || !plain() || stadium_.investment || stadium_.periphery_quote || stadium_.tip ||
stadium_.block_expansion)
return invalid("invalid_stadium_close");
stadium_.opened = false; stadium_.periphery_quote.reset(); clear_investment();
stadium_.feedback.clear(); return true;
}
const bool data_action = request.kind == ui::StadiumRequestKind::open_data ||
request.kind == ui::StadiumRequestKind::toggle_data_curve ||
request.kind == ui::StadiumRequestKind::toggle_data_scale ||
request.kind == ui::StadiumRequestKind::set_data_ticket_price ||
request.kind == ui::StadiumRequestKind::close_data;
if (data_action) {
if (stadium_.investment || stadium_.periphery_quote || stadium_.tip || stadium_.block_expansion ||
request.option != -1 || request.price != 0 || request.accept_tip)
return invalid("invalid_stadium_data_context");
if (request.kind == ui::StadiumRequestKind::open_data) {
if (stadium_.data_open || request.object != -1) return invalid("invalid_stadium_data_open");
const uint32_t flags_at = ::bmh::layout::Flags + uint32_t(active) * 3 + 1;
if (!g_.memory.has(flags_at)) return invalid("missing_stadium_data_flags");
stadium_.data_flags = g_.memory.u8(flags_at);
// Build the pure projection before accepting modal ownership.
(void)ui::stadium_data_from_game(g_, exe_, active, stadium_.data_flags);
stadium_.data_open = true;
} else {
if (!stadium_.data_open) return invalid("stadium_data_not_open");
if (request.kind == ui::StadiumRequestKind::toggle_data_curve) {
if (request.object < 0 || request.object > 5) return invalid("invalid_stadium_data_curve");
stadium_.data_flags ^= uint8_t(1u << request.object);
} else if (request.kind == ui::StadiumRequestKind::toggle_data_scale) {
if (request.object < 0 || request.object > 1) return invalid("invalid_stadium_data_scale");
stadium_.data_flags ^= 0xc0; // Either ABS or REL button toggles both Source bits.
} else if (request.kind == ui::StadiumRequestKind::set_data_ticket_price) {
if (request.object < 10 || request.object > 25) return invalid("invalid_stadium_data_ticket");
g_.manager_records[record + 0x26e] = uint8_t(request.object);
(void)ui::stadium_data_from_game(g_, exe_, active, stadium_.data_flags);
} else {
if (request.object != -1) return invalid("invalid_stadium_data_close");
g_.memory.set8(::bmh::layout::Flags + uint32_t(active) * 3 + 1, stadium_.data_flags);
stadium_.data_open = false;
}
}
stadium_.feedback.clear();
return true;
}
if (stadium_.data_open) return invalid("stadium_data_active");
if (mode == 1 && !legacy_periphery &&
(request.kind == ui::StadiumRequestKind::quote_periphery ||
request.kind == ui::StadiumRequestKind::build_periphery ||
request.kind == ui::StadiumRequestKind::decline_periphery))
return invalid("stadium_periphery_disabled");
if (request.kind == ui::StadiumRequestKind::quote_periphery) {
if (stadium_.investment || stadium_.periphery_quote || stadium_.block_expansion || request.object < 0 ||
request.object >= 14 || !plain(request.object)) return invalid("invalid_periphery_offer");
const size_t object = size_t(request.object);
const uint8_t level = g_.manager_records[record + object];
if (g_.manager_records[record + 0x1e + object] != 0 || (object == 0 ? level >= 0xab : level != 0))
return invalid("periphery_unavailable");
const int32_t price = periphery_offer(g_, request.object, game_);
if (price <= 0) return invalid("invalid_periphery_price");
stadium_.periphery_quote = std::make_pair(request.object, price);
stadium_.feedback.clear(); return true;
}
if (request.kind == ui::StadiumRequestKind::decline_periphery ||
request.kind == ui::StadiumRequestKind::build_periphery) {
if (stadium_.investment || stadium_.block_expansion || !stadium_.periphery_quote ||
request.option != -1 || request.accept_tip ||
request.object != stadium_.periphery_quote->first || request.price != stadium_.periphery_quote->second)
return invalid("stale_periphery_offer");
if (request.kind == ui::StadiumRequestKind::build_periphery) {
const size_t object = size_t(request.object);
const uint8_t level = g_.manager_records[record + object];
if (g_.manager_records[record + 0x1e + object] != 0 || (object == 0 ? level >= 0xab : level != 0))
return invalid("periphery_unavailable");
// ConstructionPricePercent consumes this genuine JA even when PayConstruction's
// payment fails. The Source presenter runs before the quote
// is cleared; payment/sponsor effects are not rolled back.
const bool built = build_periphery(g_, active, request.object,
uint32_t(request.price), rand_, notice_presenter);
stadium_.feedback = built || notice_presenter ? std::string{} : message_text(g_, ::bmh::layout::Advertising_FormatError_TextPointer18);
}
stadium_.periphery_quote.reset();
if (request.kind == ui::StadiumRequestKind::decline_periphery) stadium_.feedback.clear();
return true;
}
// A–H uses its own quote/commit domain and remains available in
// Source mode 1, where facilities are disabled. All request fields
// outside the typed block envelope must stay neutral.
if (block_action) {
if (request.object != -1 || request.option != -1 || request.price != 0 ||
(request.kind != ui::StadiumRequestKind::expansion_answer_tip && request.accept_tip))
return invalid("invalid_block_expansion_envelope");
const auto block_constants=stadium_block_expansion_constants(exe_);
const auto quote_block = [&](StadiumBlockSlot slot, uint32_t total, uint8_t features) {
return quote_stadium_block_expansion(g_, active, slot, total, features,
stadium_.price_percent, block_constants);
};
if (request.kind == ui::StadiumRequestKind::expansion_select) {
if (stadium_.investment || stadium_.periphery_quote || stadium_.block_expansion ||
request.block_slot < 0 || request.block_slot >= 8 || request.block_total_places != 0 ||
request.block_features != 0 || request.expected_block_quote)
return invalid("invalid_block_expansion_selection");
const auto slot = static_cast<StadiumBlockSlot>(request.block_slot);
const uint8_t raw = g_.manager_records.at(record + 0x44 + size_t(request.block_slot));
const uint32_t current = uint32_t(g_.manager_records.at(record + 0x4c + size_t(request.block_slot))) * 1000;
auto quote = quote_block(slot, current, uint8_t(raw & kBlockFeatures));
if (!quote) return invalid("block_expansion_unavailable");
StadiumRuntime::BlockExpansion draft;
draft.quote = *quote;
draft.total_target_places = current;
draft.desired_features = uint8_t(raw & kBlockFeatures);
game_.set_seed(int32_t(g_.memory.u32(::bmh::layout::CareerSession_Invalid_RuntimeField2)));
draft.header_text_variant = game_.range(3, 10); // Front, once on editor entry.
stadium_.block_expansion = std::move(draft);
stadium_.feedback.clear();
return true;
}
if (!stadium_.block_expansion || stadium_.investment || stadium_.periphery_quote ||
request.block_slot < 0 || request.block_slot >= 8 ||
request.block_slot != int(stadium_.block_expansion->quote.slot) ||
!request.expected_block_quote || *request.expected_block_quote != stadium_.block_expansion->quote)
return invalid("stale_block_expansion_quote");
auto& draft = *stadium_.block_expansion;
if (draft.tip) {
const auto& tip = *draft.tip;
const bool valid_tip = tip.decision == StandBlockOfferDecision::Pending &&
tip.base_price == draft.quote.base_price && tip.base_days == draft.quote.base_weeks &&
tip.price == tip.base_price && tip.percent >= 6 && tip.percent <= 14 &&
tip.offered_price == uint32_t(uint64_t(tip.base_price) * uint32_t(100 + tip.percent) / 100);
if (!valid_tip) return invalid("stale_block_expansion_tip");
}
auto fresh = quote_block(draft.quote.slot, draft.total_target_places, draft.desired_features);
if (!fresh || *fresh != draft.quote)
return invalid("block_expansion_source_changed");
const auto matches_draft = [&] {
return request.block_total_places == draft.total_target_places &&
request.block_features == draft.desired_features;
};
switch (request.kind) {
case ui::StadiumRequestKind::expansion_set_total: {
if (draft.tip || request.block_features != draft.desired_features)
return invalid("stale_block_expansion_draft");
auto next_quote = quote_block(draft.quote.slot, request.block_total_places, draft.desired_features);
if (!next_quote) return invalid("invalid_block_expansion_total");
draft.total_target_places = request.block_total_places;
draft.quote = *next_quote;
stadium_.feedback.clear();
return true;
}
case ui::StadiumRequestKind::expansion_toggle_feature: {
const uint8_t changed = uint8_t(request.block_features ^ draft.desired_features);
if (draft.tip || request.block_total_places != draft.total_target_places ||
(request.block_features & uint8_t(~kBlockFeatures)) != 0 ||
(changed != kBlockSeat && changed != kBlockRoof) ||
(request.block_features & uint8_t(draft.quote.current_raw_flags & kBlockFeatures)) !=
uint8_t(draft.quote.current_raw_flags & kBlockFeatures))
return invalid("invalid_block_expansion_feature");
auto next_quote = quote_block(draft.quote.slot, draft.total_target_places, request.block_features);
if (!next_quote) return invalid("invalid_block_expansion_feature");
draft.desired_features = request.block_features;
draft.quote = *next_quote;
stadium_.feedback.clear();
return true;
}
case ui::StadiumRequestKind::expansion_cancel:
if (draft.tip || !matches_draft()) return invalid("stale_block_expansion_cancel");
stadium_.block_expansion.reset();
stadium_.feedback.clear();
return true;
case ui::StadiumRequestKind::expansion_confirm: {
if (draft.tip || !matches_draft()) return invalid("stale_block_expansion_confirm");
if (draft.quote.base_price == 0) {
stadium_.block_expansion.reset();
stadium_.feedback.clear();
return true;
}
auto tip = prepare_stand_block_offer(draft.quote.base_price, draft.quote.base_weeks, rand_);
if (tip.offered_price > uint32_t(INT32_MAX))
return invalid("block_expansion_tip_price_overflow");
draft.tip = tip;
stadium_.feedback.clear();
return true;
}
case ui::StadiumRequestKind::expansion_answer_tip: {
if (!draft.tip || !matches_draft() || request.accept_tip &&
uint64_t(draft.tip->base_price) * uint32_t(100 + draft.tip->percent) >
uint64_t(INT32_MAX))
return invalid("invalid_block_expansion_tip_answer");
StandBlockOffer resolved = *draft.tip;
resolve_stand_block_offer(resolved, request.accept_tip, rand_);
const bool built = build_stadium_block_expansion(g_, active, draft.quote.slot,
block_constants, draft.quote, resolved, rand_, notice_presenter, compensation_presenter);
stadium_.block_expansion.reset();
stadium_.feedback = built || notice_presenter ? std::string{} : message_text(g_, ::bmh::layout::Advertising_FormatError_TextPointer18);
return true;
}
default:
return invalid("unsupported_block_expansion_request");
}
}
if (mode == 1) return invalid("stadium_investments_disabled");
if (request.kind == ui::StadiumRequestKind::select_investment) {
if (stadium_.investment || stadium_.periphery_quote || stadium_.block_expansion || request.object < 0 ||
request.object >= 8 || !plain(request.object)) return invalid("invalid_investment_selection");
const auto investment = static_cast<StadiumInvestment>(request.object);
const auto current = options(investment);
if (current.empty()) return invalid("investment_unavailable");
game_.set_seed(int32_t(g_.memory.u32(::bmh::layout::CareerSession_Invalid_RuntimeField2)));
stadium_.text_variant = game_.range(3, 10); // Front: exactly once at dialog entry.
stadium_.investment = investment; stadium_.selection_status = current.front().current_status;
stadium_.option_index = -1; stadium_.option.reset(); // Source iVar5=-1 until an explicit tier click.
stadium_.feedback.clear(); return true;
}
if (request.kind == ui::StadiumRequestKind::cancel_investment) {
if (!stadium_.investment || stadium_.tip || !plain(int(*stadium_.investment)))
return invalid("stale_investment_selection");
clear_investment(); stadium_.feedback.clear(); return true; // Initial Abbruch precedes W(6,14).
}
if (request.kind == ui::StadiumRequestKind::select_investment_option) {
if (!stadium_.investment || stadium_.tip || request.object != int(*stadium_.investment) ||
request.option < 0 || request.accept_tip || !stadium_.selection_status ||
g_.manager_records[record + 0x3c + size_t(*stadium_.investment)] != *stadium_.selection_status)
return invalid("stale_investment_selection");
const auto current = options(*stadium_.investment);
if (size_t(request.option) >= current.size() || request.price != int32_t(current[size_t(request.option)].base_price))
return invalid("stale_investment_price");
stadium_.option_index = request.option; stadium_.option = current[size_t(request.option)];
return true; // Pure tier choice: neither Source generator advances.
}
if (request.kind == ui::StadiumRequestKind::confirm_investment) {
if (stadium_.tip || !selected_valid() || request.object != int(*stadium_.investment) ||
request.option != stadium_.option_index || request.accept_tip ||
request.price != int32_t(stadium_.option->base_price)) return invalid("stale_investment_selection");
stadium_.tip = prepare_stand_block_offer(stadium_.option->base_price, stadium_.option->base_weeks, rand_);
if (stadium_.tip->offered_price > uint32_t(INT32_MAX)) return invalid("invalid_investment_tip_price");
return true;
}
if (request.kind == ui::StadiumRequestKind::answer_construction_tip) {
if (!stadium_.tip || !selected_valid() || request.object != int(*stadium_.investment) ||
request.option != stadium_.option_index || request.price != int32_t(request.accept_tip ?
stadium_.tip->offered_price : stadium_.tip->base_price)) return invalid("stale_construction_tip");
auto resolved = *stadium_.tip;
resolve_stand_block_offer(resolved, request.accept_tip, rand_);
const bool built = build_stadium_investment_source(g_, active, *stadium_.investment,
stadium_.price_percent, constants, *stadium_.option, resolved, rand_, notice_presenter);
// A genuine PayConstruction/BookMoney2 refusal consumes the answer and
// retains the sponsor share clearing and Source W draws.
// Interactive callers have already shown Source's timed funds
// notice; headless legacy callers retain their text feedback.
clear_investment();
stadium_.feedback = built || notice_presenter ? std::string{} : message_text(g_, ::bmh::layout::Advertising_FormatError_TextPointer18);
return true;
}
return invalid("unsupported_stadium_request");
};
if (!apply()) { restore_stadium_checkpoint(std::move(before)); return false; }
++revision; ++stadium_.sequence; stadium_.revision = revision;
error.clear(); return true;
} catch (...) {
restore_stadium_checkpoint(std::move(before)); revision = before_revision; throw;
}
}
// Submits a pools coupon for the active manager; only valid when the coupon has eleven matches.
// Revision plus one; false with a short error code otherwise.
bool CareerSession::dispatch_toto(const ui::TotoRequest& request, uint64_t& revision, std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return false; }
const int active = int(g_.memory.u8(::bmh::layout::ActiveManager));
if (request.kind != ui::TotoRequestKind::submit || request.manager_slot != active || request.manager_slot < 0 ||
size_t(request.manager_slot) >= g_.manager_teams.size() ||
request.runtime_club != g_.manager_teams[size_t(request.manager_slot)] || request.revision != revision) {
error = "stale_manager_or_revision"; return false;
}
if (g_.memory.u8(::bmh::layout::CareerSession_DispatchToto_RuntimeField) != 11) { error = "toto_coupon_requires_eleven_matches"; return false; }
if (!submit_pools_coupon(g_, request.manager_slot, request.stake, request.tips)) {
error = "invalid_toto_coupon"; return false;
}
++revision;
return true;
}
} // namespace bmh::app
File diff suppressed because it is too large. Load diff
File diff suppressed because it is too large. Load diff
+669
View File
@@ -0,0 +1,669 @@
// SPDX-License-Identifier: GPL-3.0-only
// CareerSession: transfers: offer editor, poaching, transfer market.
// (moved out of career_session.cpp unchanged; the class is declared in app/career_session.hpp)
#include "app/career_session_internal.hpp"
namespace bmh::app {
namespace {
// Transfer editor / market group (helpers first). Projects the engine's transfer offer editor
// owner into the UI state: the quote fields, calculator profiles and, unless the editor is
// closed, the incoming-offer decision panel read from the four offer rows of the market list.
ui::OutgoingTransferEditorState transfer_offer_projection(const GameState& game,
const TransferOfferEditorState& owner, uint64_t revision, bool gradient) {
ui::OutgoingTransferEditorState out;
const auto& request = owner.request;
out.manager_slot = request.manager; out.runtime_club = request.runtime_club;
out.revision = revision; out.list_entry = request.list_entry; out.source_slot = request.source_slot;
out.player = request.expected_player;
out.seller = request.expected_seller_word == 0xffff ? 0x0fff : request.expected_seller_word & 0x7fff;
out.bid_slot = owner.bid_slot; out.source_mode = owner.mode;
out.editable = owner.editable; out.closed = owner.closed; out.quote_loan = owner.quote_loan;
out.initial_action_loan = request.loan;
out.gradient_text = gradient;
out.fee = owner.fee; out.monthly_salary = owner.salary; out.duration_years = owner.years;
out.bonuses = owner.bonuses;
const auto copy_profile = [](const TransferOfferInputProfile& p) {
return ui::OutgoingTransferCalculatorProfile{p.supported, p.currency, p.minimum, p.maximum,
p.initial, p.source_text_address, p.presets};
};
for (size_t n = 0; n < 2; ++n) out.money_calculators[n] = copy_profile(owner.money_profiles[n]);
for (size_t n = 0; n < 8; ++n) out.mode3_calculators[n] = copy_profile(owner.mode3_profiles[n]);
if (owner.closed) return out; // No modal is constructed after Source cleanup.
ui::IncomingTransferDecisionView view;
view.source_outgoing_editor_context = true;
view.valid = true; view.list_entry = request.list_entry; view.player = out.player;
view.seller = out.seller; view.seller_manager = out.seller == 0x0fff ? -1 : game.manager_of(out.seller);
view.viewer_manager = request.manager;
view.asking_fee = owner.asking_fee; view.asking_monthly_salary = owner.asking_salary;
view.quoted_fee = owner.quoted_fee; view.quoted_monthly_salary = owner.quoted_salary;
view.quoted_years = owner.years;
const uint32_t list = ::bmh::layout::EditorList + uint32_t(request.list_entry) * 0x58;
for (uint32_t n = 0; n < 4; ++n) {
auto& row = view.offers[n];
const auto buyer = game.memory.u16(list + n * 2);
row.bid_index = int(n); row.present = buyer != 0xffff;
row.buyer = row.present ? int(buyer) : -1;
row.buyer_manager = row.present ? game.manager_of(row.buyer) : -1;
row.fee = game.memory.u32(list + 0x1c + n * 4);
row.monthly_salary = game.memory.u32(list + 0x0c + n * 4);
const auto raw_term = game.memory.u8(list + 0x34 + n);
row.loan = (raw_term & 0x80) != 0; row.contract_months = raw_term & 0x7f;
row.eligible = row.present;
for (uint32_t k = 0; k < 7; ++k) row.bonuses[k] = game.memory.u8(list + 0x38 + n * 7 + k);
}
out.panel = ui::incoming_transfer_decision_from_game(game, view);
return out;
}
} // namespace
// Public wrapper so other code (loan return offers) can reuse the editor projection.
ui::OutgoingTransferEditorState loan_return_offer_editor_projection(
const GameState& game, const TransferOfferEditorState& owner, uint64_t revision, bool gradient) {
return transfer_offer_projection(game, owner, revision, gradient);
}
// Maps a UI field edit onto the engine's transfer offer editor edit and returns the new owner.
TransferOfferEditorState edit_transfer_offer_from_ui(GameState& game,
const TransferOfferEditorState& owner, const ui::OutgoingTransferRequest& request,
GameRandom& game_random, WatcomRandom& watcom_random) {
return edit_transfer_offer_editor_source(game, owner,
{TransferOfferEditorField(uint8_t(request.field)), request.value, request.accepted},
game_random, watcom_random);
}
// Transfer market request family (open offer, poach, editor events, quote preview, market
// actions): each entry validates the request revision, the active manager slot and the manager's
// club, refuses nested modals (market_dispatch_active_ and the other owners), works on copies of
// the state and both random generators and commits them only on success. The revision is
// advanced only where something observable changed. Failures return an empty optional and an
// error text.
// Opens the buyer's offer editor for a marked market row after checking the row identity
// against the market list in memory; the editor owner and its revision are stored on success.
std::optional<CareerSession::TransferOfferEditorDispatch> CareerSession::open_transfer_offer(
const ui::TransferMarketRequest& request, uint64_t& revision, std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return std::nullopt; }
error.clear();
if (request.kind != ui::TransferMarketRequestKind::open_offer || transfer_offer_editor_ ||
market_dispatch_active_ || pending_offer_dispatch_active_ || calendar_advance_active_ ||
request.revision != revision || revision == std::numeric_limits<uint64_t>::max() ||
request.manager_slot < 0 || request.manager_slot >= 4 ||
size_t(request.manager_slot) >= g_.manager_teams.size() ||
!g_.memory.has(::bmh::layout::ActiveManager) || g_.memory.u8(::bmh::layout::ActiveManager) != request.manager_slot ||
request.runtime_club != g_.manager_teams[size_t(request.manager_slot)] ||
request.bid.manager != request.manager_slot || request.bid.list_entry < 0 || request.bid.list_entry >= 40 ||
request.bid.source_slot != 2928 + request.bid.list_entry || request.selected_players.size() > 1) {
error = "transfer offer: stale, nested or unsupported marked opening";
return std::nullopt;
}
const uint32_t list = ::bmh::layout::EditorList + uint32_t(request.bid.list_entry) * 0x58;
if (!g_.memory.has(list + 0x57)) { error = "transfer offer: missing Native list row"; return std::nullopt; }
const uint16_t seller_word = g_.memory.u16(list + 8);
if (!request.selected_players.empty()) {
const auto& selected = request.selected_players.front();
const int seller = seller_word == 0xffff ? -1 : int(seller_word & 0x7fff);
if (selected.squad_row != -1 || selected.source_slot != request.bid.source_slot ||
selected.list_entry != request.bid.list_entry || selected.player != request.bid.player ||
selected.seller != seller) {
error = "transfer offer: selected row does not match the Native market identity";
return std::nullopt;
}
}
int bid_slot = -1;
for (int n = 0; n < 4; ++n) {
const auto buyer = g_.memory.u16(list + uint32_t(n) * 2);
if (buyer == 0xffff || buyer == request.runtime_club) { bid_slot = n; break; }
}
const TransferOfferEditorRequest input{request.manager_slot, request.runtime_club, request.bid.list_entry,
request.bid.source_slot, request.bid.player, seller_word, bid_slot, request.offer_is_loan};
auto next_state = g_; auto next_game = game_; auto next_rand = rand_;
market_dispatch_active_ = true;
struct Reset { bool& active; ~Reset() { active = false; } } reset{market_dispatch_active_};
try {
auto owner = open_transfer_offer_editor_source(next_state, input, next_game, next_rand);
if (!owner.supported) { error = owner.reason; return std::nullopt; }
// Opening has Source G-seeding/G92..108 even for a full read-only list.
const auto next_revision = revision + 1;
TransferOfferEditorDispatch result;
result.preparation = preparation_projection(next_state, next_revision);
result.editor = transfer_offer_projection(next_state, owner, next_revision, result.preparation.desktop.gradient_text);
ui::OutgoingTransferScreen validate(data_directory_, result.editor);
g_ = std::move(next_state); game_ = next_game; rand_ = next_rand;
transfer_offer_editor_ = std::move(owner); transfer_offer_revision_ = next_revision; revision = next_revision;
return result;
} catch (const std::exception& e) { error = e.what(); return std::nullopt; }
}
// Starts a poaching attempt for a squad slot: the attempt draws random numbers, so the revision
// advances whenever the result is not invalid; a ready attempt also opens the offer editor on
// the special poach row and remembers the attempt in poach_.
std::optional<CareerSession::PoachDispatch> CareerSession::open_poach(
int manager_slot, int squad_slot, uint64_t& revision, std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return std::nullopt; }
error.clear();
if (transfer_offer_editor_ || market_dispatch_active_ || pending_offer_dispatch_active_ || calendar_advance_active_ ||
revision == std::numeric_limits<uint64_t>::max() || manager_slot < 0 || manager_slot >= 4 ||
size_t(manager_slot) >= g_.manager_teams.size() || !g_.memory.has(::bmh::layout::ActiveManager) ||
g_.memory.u8(::bmh::layout::ActiveManager) != manager_slot) {
error = "poach: stale, nested or unsupported opening";
return std::nullopt;
}
auto next_state = g_; auto next_game = game_; auto next_rand = rand_;
market_dispatch_active_ = true;
struct Reset { bool& active; ~Reset() { active = false; } } reset{market_dispatch_active_};
try {
PoachDispatch result;
result.start = start_poach(next_state, manager_slot, squad_slot, next_rand);
if (result.start.status == PoachStatus::ready) {
const int row = 0x28 + result.start.offer_row;
const TransferOfferEditorRequest input{manager_slot, g_.manager_teams[size_t(manager_slot)], row, 2928 + row,
result.start.player, next_state.memory.u16(::bmh::layout::EditorList + uint32_t(row) * 0x58 + 8), 0, false, true};
auto owner = open_transfer_offer_editor_source(next_state, input, next_game, next_rand);
if (!owner.supported) { error = owner.reason; return std::nullopt; }
const auto next_revision = revision + 1;
TransferOfferEditorDispatch editor;
editor.preparation = preparation_projection(next_state, next_revision);
editor.editor = transfer_offer_projection(next_state, owner, next_revision, editor.preparation.desktop.gradient_text);
result.editor = std::move(editor);
transfer_offer_editor_ = std::move(owner);
transfer_offer_revision_ = next_revision;
poach_ = result.start;
revision = next_revision;
} else if (result.start.status != PoachStatus::invalid) {
++revision; // draws, and "Transfermarkt überlastet" counts the attempt
}
g_ = std::move(next_state); game_ = next_game; rand_ = next_rand;
return result;
} catch (const std::exception& e) { error = e.what(); return std::nullopt; }
}
// Closes the table opened only to choose a poach target: needs an unchanged table owner, then
// restores the display word and drops the family owner without a family close. False with
// 'error' if stale.
bool CareerSession::close_poach_table_selection(const ui::LeagueFamilyRequest& request,std::string& error) {
error.clear();
if(!poach_table_selection_ || request.kind!=ui::LeagueFamilyRequestKind::close || request.from_child!=1 ||
!canonical_table_envelope(request) || !league_family_owner_ || league_family_owner_->child!=1 ||
league_family_owner_->identity!=request.identity || !league_family_owner_->table ||
league_family_owner_->table->phase!=TableDispatchPhase::ready ||
save_stream(g_)!=league_family_owner_->native || club_modal_runtime_!=league_family_owner_->runtime ||
game_.seed()!=league_family_owner_->game_seed || game_.calls()!=league_family_owner_->game_calls ||
rand_.seed()!=league_family_owner_->rand_seed || rand_.calls()!=league_family_owner_->rand_calls) {
error="poach: stale Table selection close";return false;
}
const uint32_t at=::bmh::layout::LeagueTableDisplayModes+uint32_t(request.identity.manager)*2;
uint16_t word=uint16_t(g_.memory.u16(at)&0x0f7f);
if(source_runtime_byte(g_,club_modal_runtime_,exe_,::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField)!=0)word|=0x80;
g_.memory.set16(at,word);
if(g_.memory.has(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField2))g_.memory.set8(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField2,0);else club_modal_runtime_[::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField2]=0;
// FriendlyMatchScreen returns directly to19c1c. No21213 family close.
league_family_owner_.reset();return true;
}
// Poach flow driven by UI callbacks: checks the request is a pristine open_poach request of the
// current revision (320x240 backdrop, nothing else open), then reports attempts-used or
// transfer-ban notices, or lets the player pick a squad player in a table on a cloned session
// and opens the poach from that choice. The UI acknowledges through 'accept'; any failure,
// including a session changed by the acknowledgement, restores the checkpoint and revision.
bool CareerSession::dispatch_poach_ui(const ui::TransferMarketRequest& request,
const Image& backdrop, const PoachPlayerSelector& select, const PoachUiAccept& accept,
uint64_t& revision, std::string& error) {
error.clear();
if (!accept || request.kind!=ui::TransferMarketRequestKind::open_poach ||
!g_.memory.has(::bmh::layout::GameMode) || g_.memory.u8(::bmh::layout::GameMode)!=3 ||
request.revision!=revision || revision==UINT64_MAX || request.manager_slot<0 || request.manager_slot>3 ||
!g_.memory.has(::bmh::layout::ActiveManager) || g_.memory.u8(::bmh::layout::ActiveManager)!=request.manager_slot ||
size_t(request.manager_slot)>=g_.manager_teams.size() ||
request.runtime_club!=g_.manager_teams[size_t(request.manager_slot)] ||
request.bid.manager!=request.manager_slot || request.bid.list_entry!=-1 || request.bid.player!=-1 ||
request.bid.source_slot!=-1 || request.bid.fee!=0 || request.bid.annual_salary!=0 ||
request.bid.contract_years!=1 || request.bid.poach || std::any_of(request.bid.bonuses.begin(),request.bid.bonuses.end(),
[](uint32_t n){return n!=0;}) || request.squad_row!=-1 || request.expected_player!=-1 ||
request.preview_source_slot!=-1 || request.preview_seller!=-1 || request.preview_is_purchase ||
request.preview_is_loan || !request.selected_players.empty() ||
backdrop.width!=320 || backdrop.height!=240 || advertising_renewal_dispatch_active_ || pending_offer_dispatch_active_ || market_dispatch_active_ ||
calendar_advance_active_ || transfer_offer_editor_ || poach_ || manager_join_ || contract_quote_ ||
league_family_owner_ || league_pairings_draft_ || strengths_owner_ || top_scorers_owner_ ||
other_games_owner_ || balance_draft_ || stadium_.opened ||
(turn_driver_.stage!=TurnDriver::Stage::MatchdayDesks && turn_driver_.stage!=TurnDriver::Stage::SeasonEndDesk)) {
error="poach: stale or competing selection";return false;
}
const auto checkpoint=advertising_session_checkpoint(revision);
try {
const int manager=request.manager_slot;
const size_t record=size_t(manager)*kManagerRecordSize;
PoachDispatch result;
result.start.manager=manager;
// These three notices precede the Table modal in Reset.
if (record+0x8c0>g_.manager_records.size()) throw FormatError("poach: missing manager record");
const bool attempts_used=(g_.manager_records[record+0x8be] |
uint16_t(g_.manager_records[record+0x8bf])<<8)!=0xffff;
if(attempts_used) {
result.start.status=PoachStatus::attempts_used;
result.start.messages.push_back(message_text(g_,::bmh::layout::CareerSession_DispatchPoachUi_TextPointer2));
} else if(g_.manager_records[record+0x220]>>5==1) {
result.start.status=PoachStatus::transfer_ban;
result.start.messages.push_back(message_text(g_,::bmh::layout::CareerSession_DispatchPoachUi_TextPointer));
} else if(request.offer_is_loan) {
auto services=staged_club_modal_services(g_,game_,rand_,club_modal_runtime_);
services.set_runtime_byte(::bmh::layout::CareerSession_AdvertisingSessionUnchanged_ExecutableField,0);
services.set_runtime_byte(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_RuntimeField2,g_.manager_records[record+0x210]);
services.set_runtime_byte(::bmh::layout::CareerSession_DispatchPoachUi_ExecutableField,2);
result.start.messages.push_back(message_text(g_,::bmh::layout::CareerSession_DispatchPoachUi_TextPointer3));
} else {
if(!select) throw FormatError("poach: Source player selection presenter unavailable");
// The cloned Session owns the existing50775 controls implementation.
// begin_league_family(child1) itself does not call53435; only the
// host Table owner is reused, never prepare/close-family effects.
CareerSession staged=*this;
staged.poach_table_selection_=true;
uint64_t selection_revision=revision;
auto services=staged.staged_club_modal_services(staged.g_,staged.game_,staged.rand_,staged.club_modal_runtime_);
services.set_runtime_byte(::bmh::layout::CareerSession_AdvertisingSessionUnchanged_ExecutableField,0);
services.set_runtime_byte(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_RuntimeField2,g_.manager_records[record+0x210]);
services.set_runtime_byte(::bmh::layout::CareerSession_DispatchPoachUi_ExecutableField,2);
services.set_runtime_byte(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField,0);services.set_runtime_byte(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField2,0);
//50775 control7 toggles this existing BSS byte. Materialize its
// actual current value in the staged runtime, including when it
// was read from the executable rather than persisted in Native.
services.set_runtime_byte(::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField,services.runtime_byte(::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField));
auto entry=staged.strengths_open_request(selection_revision);
if(!entry)throw FormatError("poach: missing Table selection identity");
entry->identity.league=g_.manager_records[record+0x210];entry->identity.league_group=0;
if(!staged.begin_league_family(entry->identity,1,selection_revision,error))throw FormatError(error);
market_dispatch_active_=true;
const auto live_baseline=advertising_session_checkpoint(revision);
const auto selection=select(staged,services,manager,selection_revision,backdrop);
if(!advertising_session_unchanged(live_baseline,revision))
throw FormatError("poach: selection changed the live session");
auto& next=staged.g_;
if(next.date!=g_.date || next.manager_teams!=g_.manager_teams ||
!next.memory.has(::bmh::layout::ActiveManager) || next.memory.u8(::bmh::layout::ActiveManager)!=manager)
throw FormatError("poach: selection changed its manager/calendar context");
market_dispatch_active_=false;
int slot=-1;
if(selection) {
if(selection->origin!=ClubPlayerDetailOrigin::squad || selection->human_loan_index!=-1)
throw FormatError("poach: selection is not an ordinary squad row");
const auto player=club_player_detail_context(next,*selection);
slot=player.source_slot;
if(slot<0 || slot>=0xb70 || slot_team(slot)!=selection->runtime_team ||
(next.squad_slots.at(size_t(slot))&0xfff)!=selection->player_id)
throw FormatError("poach: stale player selection");
}
// Preserve actual Table/ClubInfo/card effects, including a cancelled
// selection. No LeagueScreenShown entry and no family-close RNG stir.
g_=std::move(next);game_=staged.game_;rand_=staged.rand_;club_modal_runtime_=std::move(staged.club_modal_runtime_);
if(selection) {
auto opened=open_poach(manager,slot,revision,error);
if(!opened) throw FormatError(error);
result=std::move(*opened);
}
if(revision==checkpoint.revision) ++revision;
}
const auto accepted_baseline=advertising_session_checkpoint(revision);
accept(result,preparation_projection(revision));
if(!advertising_session_unchanged(accepted_baseline,revision))
throw FormatError("poach: UI acknowledgement changed the session");
return true;
} catch(const std::exception& e) {
restore_advertising_session_checkpoint(checkpoint);revision=checkpoint.revision;
error=e.what();return false;
}
}
// Applies one editor event (field quote change, submit, cancel, team info, player info) to the
// open offer editor: identity and quote must match the owner and the posted row must equal the
// single field change. Runs on copies; the revision rises only if state, runtime bytes or a
// random generator actually changed. A closing editor ends a poach attempt and clears the owner.
std::optional<CareerSession::TransferOfferEditorDispatch> CareerSession::dispatch_transfer_offer(
const ui::OutgoingTransferRequest& request, const HumanBuyerSaleHooks& presenters,
uint64_t& revision, std::string& error,
const TransferOfferTeamInfoPresenter& team_info,
const TransferOfferPlayerInfoPresenter& player_info) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return std::nullopt; }
error.clear();
if (!transfer_offer_editor_ || market_dispatch_active_ || pending_offer_dispatch_active_ || calendar_advance_active_ ||
request.identity.revision != revision || transfer_offer_revision_ != revision ||
revision == std::numeric_limits<uint64_t>::max()) {
error = "transfer offer: stale or nested editor event"; return std::nullopt;
}
const auto& current = *transfer_offer_editor_;
const auto& id = request.identity;
const int seller = current.request.expected_seller_word == 0xffff ? 0x0fff : current.request.expected_seller_word & 0x7fff;
if (id.manager_slot != current.request.manager || id.runtime_club != current.request.runtime_club ||
id.list_entry != current.request.list_entry || id.source_slot != current.request.source_slot ||
id.player != current.request.expected_player || id.seller != seller || id.bid_slot != current.bid_slot ||
request.quoted_fee != current.quoted_fee || request.quoted_monthly_salary != current.quoted_salary ||
request.quoted_years != current.years) {
error = "transfer offer: mismatched editor identity or quote"; return std::nullopt;
}
uint32_t fee = current.fee, salary = current.salary;
uint8_t years = current.years; auto bonuses = current.bonuses;
bool quote_loan = current.quote_loan;
const unsigned field = unsigned(request.field);
if (request.kind == ui::OutgoingTransferRequestKind::quote_change) {
if (field > unsigned(ui::OutgoingTransferField::quote_loan)) {
error = "transfer offer: invalid editor field"; return std::nullopt;
}
if (request.accepted) {
if (field == 0) fee = request.value;
else if (field == 1) salary = request.value;
else if (field == 2) years = uint8_t(request.value);
else if (field < 10) bonuses[field - 3] = uint8_t(field < 6 ? request.value : request.value / 5);
else quote_loan = !quote_loan;
}
} else if (request.kind != ui::OutgoingTransferRequestKind::submit && request.kind != ui::OutgoingTransferRequestKind::cancel &&
request.kind != ui::OutgoingTransferRequestKind::team_info &&
request.kind != ui::OutgoingTransferRequestKind::player_info) {
error = "transfer offer: unsupported editor event"; return std::nullopt;
}
if (request.fee != fee || request.monthly_salary != salary || request.duration_years != years ||
request.bonuses != bonuses || request.quote_loan != quote_loan) {
error = "transfer offer: posted row differs from the single Source field event"; return std::nullopt;
}
if(request.kind==ui::OutgoingTransferRequestKind::team_info&&!team_info) {
error="transfer offer: TeamInfo presenter unavailable"; return std::nullopt;
}
if(request.kind==ui::OutgoingTransferRequestKind::player_info&&!player_info) {
error="transfer offer: PlayerInfo presenter unavailable"; return std::nullopt;
}
auto next_state = g_; auto next_game = game_; auto next_rand = rand_;
auto next_runtime=club_modal_runtime_;
auto owner = current; TransferActionResult action;
auto hooks = presenters;
switch (turn_driver_.transfer_allocator_context) {
case PendingOfferAllocatorGate::zero: hooks.allocator_gate = HumanBuyerSaleAllocatorGate::zero; break;
case PendingOfferAllocatorGate::blocked: hooks.allocator_gate = HumanBuyerSaleAllocatorGate::blocked; break;
default: hooks.allocator_gate = HumanBuyerSaleAllocatorGate::unsupported; break;
}
hooks.direct_mode = HumanBuyerSaleDirectMode::ordinary_ai_purchase;
hooks.before_accounts = {}; hooks.after_paid_accounts = {};
market_dispatch_active_ = true;
struct Reset { bool& active; ~Reset() { active = false; } } reset{market_dispatch_active_};
try {
if (request.kind == ui::OutgoingTransferRequestKind::quote_change) {
owner = edit_transfer_offer_from_ui(next_state, current, request, next_game, next_rand);
} else if (request.kind == ui::OutgoingTransferRequestKind::cancel) {
owner = cancel_transfer_offer_editor_source(next_state, current);
} else if(request.kind==ui::OutgoingTransferRequestKind::team_info) {
// Validate the complete old Native row before any modal effect.
const auto validation=cancel_transfer_offer_editor_source(next_state,current);
if(!validation.supported) {error=validation.reason;return std::nullopt;}
auto services=staged_club_modal_services(next_state,next_game,next_rand,next_runtime);
const auto parent=transfer_offer_projection(next_state,current,revision,
next_state.memory.u8(::bmh::layout::TextGradientDisabled)==0);
const Image backdrop=ui::OutgoingTransferScreen(data_directory_,parent).render();
if(!team_info(services,current.request.runtime_club,backdrop)) {
error="transfer offer: TeamInfo presenter stopped";return std::nullopt;
}
owner=resume_transfer_offer_team_info_source(next_state,current,next_rand);
} else if(request.kind==ui::OutgoingTransferRequestKind::player_info) {
const auto selection=transfer_offer_player_info_selection_source(next_state,current);
auto services=staged_club_modal_services(next_state,next_game,next_rand,next_runtime);
const auto parent=transfer_offer_projection(next_state,current,revision,
next_state.memory.u8(::bmh::layout::TextGradientDisabled)==0);
const Image backdrop=ui::OutgoingTransferScreen(data_directory_,parent).render();
services.set_runtime_byte(::bmh::layout::CareerSession_DispatchPoachUi_ExecutableField,1); // Source direct entry persists, unlike4f548.
if(!player_info(services,selection,backdrop)) {
error="transfer offer: PlayerInfo presenter stopped";return std::nullopt;
}
owner=resume_transfer_offer_player_info_source(next_state,current,
services.runtime_byte(::bmh::layout::CareerSession_DispatchTransferOffer_ExecutableField),services.runtime_byte(::bmh::layout::CareerSession_DispatchTransferOffer_ExecutableField2),next_rand);
} else {
MinuteReport report;
auto submitted = submit_transfer_offer_editor_source(next_state, current, next_rand, hooks, report);
owner = std::move(submitted.editor); action = submitted.action;
if (report.unsupported) { error = report.reason; return std::nullopt; }
}
if (!owner.supported) { error = owner.reason; return std::nullopt; }
// a poaching editor that closes frees its special row and counts the attempt (Reset)
if (owner.closed && poach_) finish_poach(next_state, *poach_);
const bool changed = save_stream(next_state) != save_stream(g_) || next_runtime != club_modal_runtime_ ||
next_game.seed() != game_.seed() || next_game.calls() != game_.calls() ||
next_rand.seed() != rand_.seed() || next_rand.calls() != rand_.calls();
const auto next_revision = revision + uint64_t(changed);
TransferOfferEditorDispatch result;
result.preparation = preparation_projection(next_state, next_revision);
result.editor = transfer_offer_projection(next_state, owner, next_revision, result.preparation.desktop.gradient_text);
result.action = action;
if (!owner.closed) { ui::OutgoingTransferScreen validate(data_directory_, result.editor); }
g_ = std::move(next_state); game_ = next_game; rand_ = next_rand;
club_modal_runtime_=std::move(next_runtime);
if (owner.closed) { transfer_offer_editor_.reset(); poach_.reset(); } else transfer_offer_editor_ = std::move(owner);
transfer_offer_revision_ = next_revision; revision = next_revision;
return result;
} catch (const std::exception& e) { error = e.what(); return std::nullopt; }
}
// Quotes a purchase, lender snapshot or squad row preview (the listing identity is re-checked)
// using a copy of the W random stream; the stream and revision are updated only if the quote
// and its projection both succeed.
std::optional<CareerSession::TransferMarketPreviewDispatch> CareerSession::preview_transfer_market(
const ui::TransferMarketRequest& request, uint64_t& revision, std::string& error) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return std::nullopt; }
error.clear();
if (request.kind != ui::TransferMarketRequestKind::preview_quote ||
transfer_offer_editor_ || market_dispatch_active_ || pending_offer_dispatch_active_ || calendar_advance_active_ ||
request.revision != revision || revision == std::numeric_limits<uint64_t>::max() ||
request.manager_slot < 0 || request.manager_slot >= 4 ||
size_t(request.manager_slot) >= g_.manager_teams.size() ||
!g_.memory.has(::bmh::layout::ActiveManager) || g_.memory.u8(::bmh::layout::ActiveManager) != request.manager_slot ||
request.runtime_club != g_.manager_teams[size_t(request.manager_slot)]) {
error = "transfer market: stale or nested preview";
return std::nullopt;
}
if (request.preview_is_purchase) {
if (request.preview_snapshot_index != -1 || request.squad_row != -1 || request.bid.manager != request.manager_slot ||
request.bid.list_entry < 0 || request.bid.list_entry >= 40 ||
request.bid.source_slot != request.preview_source_slot ||
request.preview_source_slot != 0xb70 + request.bid.list_entry ||
request.bid.player != request.expected_player) {
error = "transfer market: mismatched preview listing identity";
return std::nullopt;
}
} else if (request.preview_snapshot_index >= 0) {
const auto identity = transfer_market_snapshot_preview(g_, request.manager_slot,
request.runtime_club, request.preview_snapshot_index);
if (!identity || identity->displayed_row != request.squad_row || identity->player != request.expected_player ||
identity->source_slot != request.preview_source_slot || request.preview_seller != request.runtime_club) {
error = "transfer market: mismatched lender snapshot identity";
return std::nullopt;
}
} else {
const auto range = squad_range(request.runtime_club);
if (request.preview_snapshot_index != -1 || request.squad_row < 0 || size_t(request.squad_row) >= range.count ||
request.preview_source_slot != int(range.first + size_t(request.squad_row)) ||
request.preview_seller != request.runtime_club) {
error = "transfer market: mismatched preview roster identity";
return std::nullopt;
}
}
auto next_rand = rand_;
market_dispatch_active_ = true;
struct Reset { bool& active; ~Reset() { active = false; } } reset{market_dispatch_active_};
try {
const TransferMarketPreviewRequest input{request.manager_slot, request.runtime_club,
request.preview_source_slot, request.expected_player, request.preview_seller,
request.preview_is_purchase, request.preview_is_loan, request.preview_snapshot_index};
const auto result = quote_transfer_market_preview_source(g_, input, next_rand);
if (!result.supported) {
error = result.reason.empty() ? "transfer market: unsupported Source preview" : result.reason;
return std::nullopt;
}
const bool changed = next_rand.seed() != rand_.seed() || next_rand.calls() != rand_.calls();
const auto next_revision = revision + uint64_t(changed);
TransferMarketPreviewDispatch dispatch;
dispatch.preparation = preparation_projection(next_revision);
if (!dispatch.preparation.transfer_market)
throw FormatError("transfer market: preview has no ordinary projection");
dispatch.quote = {request.manager_slot, request.runtime_club, request.preview_source_slot,
request.expected_player, request.preview_seller, next_revision,
result.delta, result.projected_balance, request.preview_is_purchase, request.preview_is_loan, request.preview_snapshot_index};
// Projection construction can throw. Keep the live W stream and revision
// unchanged until both the Source result and the projection are valid.
rand_ = next_rand;
revision = next_revision;
return dispatch;
} catch (const std::exception& e) {
error = e.what();
return std::nullopt;
}
}
// Direct market actions of a human manager: review offers, submit a bid, list a player. Needs
// a request of the current revision for the active manager's club; loans and marked batches are
// not accepted here. The allocator gate comes from the turn driver, never from the presenter.
// The staged copy is committed (revision plus one) only if something changed.
std::optional<TransferActionResult> CareerSession::dispatch_transfer_market(
const ui::TransferMarketRequest& request, const HumanBuyerSaleHooks& presenters,
uint64_t& revision, std::string& error,
const std::function<int(const GameState&, const TransferOfferListView&)>& review) {
if (balance_draft_ || balance_dispatch_active_ || strengths_owner_ || strengths_dispatch_active_ ||
top_scorers_owner_ || top_scorers_dispatch_active_ || stadium_.block_expansion || other_games_owner_ || other_games_dispatch_active_) { error = "strengths_active"; return std::nullopt; }
error.clear();
if (transfer_offer_editor_ || market_dispatch_active_ || pending_offer_dispatch_active_ || calendar_advance_active_ ||
request.revision != revision || revision == std::numeric_limits<uint64_t>::max() ||
request.manager_slot < 0 || request.manager_slot >= 4 ||
size_t(request.manager_slot) >= g_.manager_teams.size() ||
!g_.memory.has(::bmh::layout::ActiveManager) || g_.memory.u8(::bmh::layout::ActiveManager) != request.manager_slot ||
request.runtime_club != g_.manager_teams[size_t(request.manager_slot)]) {
error = "transfer market: stale or nested request";
return std::nullopt;
}
if (request.kind == ui::TransferMarketRequestKind::review_offers) {
if (!review || request.bid.manager != request.manager_slot || request.bid.list_entry < 0 ||
request.bid.list_entry >= 40 || request.bid.source_slot != 0xb70 + request.bid.list_entry ||
request.squad_row != -1 || !request.selected_players.empty()) {
error = "transfer market: invalid offer review"; return std::nullopt;
}
const auto view = project_transfer_offer_list(g_, request.bid.list_entry);
if (!view.valid || view.player != request.bid.player || view.seller != request.runtime_club ||
view.seller_manager != request.manager_slot) {
error = "transfer market: stale seller listing"; return std::nullopt;
}
} else if (request.kind == ui::TransferMarketRequestKind::submit_bid) {
if (request.bid.manager != request.manager_slot || request.squad_row != -1 ||
request.expected_player != -1 ||
std::any_of(request.bid.bonuses.begin(), request.bid.bonuses.end(),
[](uint32_t value) { return value > 255; })) {
error = "transfer market: invalid buyer request";
return std::nullopt;
}
} else if (request.kind == ui::TransferMarketRequestKind::list_player) {
const auto range = squad_range(request.runtime_club);
if (request.squad_row < 0 || size_t(request.squad_row) >= range.count ||
range.first + size_t(request.squad_row) >= g_.squad_slots.size() ||
request.expected_player < 0 || request.expected_player >= 0xfff ||
(g_.squad_slots[range.first + size_t(request.squad_row)] & 0xfff) != request.expected_player) {
error = "transfer market: stale seller row";
return std::nullopt;
}
} else {
error = "transfer market: unsupported action";
return std::nullopt;
}
// Reset sends an owned marked player through the same Size2
// listing for both VER-KAUFEN and VER-LEIHEN. Only a buyer's OpenTransferEditor
// offer owns the actual loan term; listing does not create a loan record.
if ((request.offer_is_loan && request.kind != ui::TransferMarketRequestKind::list_player) ||
request.selected_players.size() > 1) {
error = "transfer market: this caller does not own buyer loan or marked batch processing";
return std::nullopt;
}
if (!request.selected_players.empty()) {
const auto& selected = request.selected_players.front();
const bool matches = request.kind == ui::TransferMarketRequestKind::list_player
? selected.squad_row == request.squad_row && selected.player == request.expected_player &&
selected.seller == request.runtime_club &&
selected.source_slot == int(squad_range(request.runtime_club).first + size_t(request.squad_row))
: selected.list_entry == request.bid.list_entry && selected.source_slot == request.bid.source_slot &&
selected.player == request.bid.player && selected.squad_row == -1;
if (!matches) {
error = "transfer market: mismatched marked selection";
return std::nullopt;
}
}
auto next_state = g_;
auto next_game = game_;
auto next_rand = rand_;
auto hooks = presenters;
// A presenter cannot supply the allocator gate or insert the special
// pending caller's severance/ACK/news sequence into a direct purchase.
switch (turn_driver_.transfer_allocator_context) {
case PendingOfferAllocatorGate::zero: hooks.allocator_gate = HumanBuyerSaleAllocatorGate::zero; break;
case PendingOfferAllocatorGate::blocked: hooks.allocator_gate = HumanBuyerSaleAllocatorGate::blocked; break;
default: hooks.allocator_gate = HumanBuyerSaleAllocatorGate::unsupported; break;
}
// Reset -> OpenTransferEditor establishes DeskActions_EditorFail_RuntimeField2=0 at LAB1b67e before
// resolving the AI seller. This explicitly selected App entry supplies
// that transient ownership; a missing FBM byte is never the observation.
hooks.direct_mode = HumanBuyerSaleDirectMode::ordinary_ai_purchase;
hooks.before_accounts = {};
hooks.after_paid_accounts = {};
market_dispatch_active_ = true;
struct Reset { bool& active; ~Reset() { active = false; } } reset{market_dispatch_active_};
MinuteReport report;
try {
const auto before = save_stream(g_);
TransferActionResult result;
if (request.kind == ui::TransferMarketRequestKind::review_offers) {
const auto view = project_transfer_offer_list(next_state, request.bid.list_entry);
result.player = view.player; result.list_entry = view.list_entry;
result.status = TransferActionStatus::pending;
// VERKAUFEN on a listed player: "Wollen Sie <name> vom Transfermarkt holen?". Yes frees the list
// slot (the player stays in the squad), no goes on to the offers.
bool withdrawn = false;
if (request.ask_withdraw && hooks.confirm) {
const std::string question = message_text(next_state, ::bmh::layout::TransferMarket_WithdrawQuestion_TextPointer) +
next_state.player_name(view.player) +
message_text(next_state, ::bmh::layout::TransferMarket_WithdrawQuestion_TextPointer2);
if (hooks.confirm(next_state, request.manager_slot, question)) {
next_state.squad_slots.at(0xb70u + size_t(view.list_entry)) = 0xfff;
withdrawn = true;
}
}
const int selected = !withdrawn && view.offer_count ? review(next_state, view) : -1;
if (selected != -1) {
auto allocator = TransferAllocatorContext::unsupported;
if (turn_driver_.transfer_allocator_context == PendingOfferAllocatorGate::zero)
allocator = TransferAllocatorContext::zero;
else if (turn_driver_.transfer_allocator_context == PendingOfferAllocatorGate::blocked)
allocator = TransferAllocatorContext::blocked;
result = accept_manager_transfer_offer(next_state, request.manager_slot,
view.list_entry, view.player, selected, next_rand, report, allocator);
}
} else if (request.kind == ui::TransferMarketRequestKind::list_player)
result = list_manager_player(next_state, request.manager_slot, request.squad_row, next_rand, report);
else
result = submit_transfer_bid_source_human_buyer(next_state, request.bid, next_rand, hooks, report);
if (report.unsupported || result.status == TransferActionStatus::unsupported) {
error = report.reason.empty() ? "transfer market: unsupported Source sale" : report.reason;
return std::nullopt;
}
const bool changed = save_stream(next_state) != before ||
next_rand.seed() != rand_.seed() || next_rand.calls() != rand_.calls() ||
next_game.seed() != game_.seed() || next_game.calls() != game_.calls();
if (changed) {
// Pure projections reject inconsistent squad/board/training state
// before any staged notice effects become live.
(void)ui::preparation_from_game(next_state, exe_, revision + 1);
g_ = std::move(next_state);
game_ = next_game;
rand_ = next_rand;
++revision;
}
return result;
} catch (const std::exception& e) {
error = e.what();
return std::nullopt;
}
}
} // namespace bmh::app
+476 -156
View File
File diff suppressed because it is too large. Load diff
+12 -4226
View File
File diff suppressed because it is too large. Load diff
+11
View File
@@ -10,6 +10,8 @@
#include <functional>
#include <utility>
#include "app/robot.hpp"
namespace bmh::app {
// OpenBMH deviates from the original: confirms application exit with a localized native dialog, with cancellation selected by default.
@@ -47,6 +49,15 @@ public:
while (SDL_PollEvent(event)) {
if (event->type != SDL_QUIT || confirm()) return 1;
}
// No input waiting: a robot run (app/robot.hpp, inactive in normal play) may queue the
// events of its next script command now.
Robot& robot = Robot::instance();
if (robot.active()) {
robot.idle();
while (SDL_PollEvent(event)) {
if (event->type != SDL_QUIT || confirm()) return 1;
}
}
return 0;
}
+253
View File
@@ -0,0 +1,253 @@
// SPDX-License-Identifier: GPL-3.0-only
// The robot: a test hook that plays the real game program from an input script, without a person.
//
// Purpose. The window program (src/app/main.cpp) owns the SDL loop, the modal presentation loops
// and the timers; the headless tools (ui_walk, season_sim) bypass all of that. The robot covers it:
// started with
//
// OPENBMH_ROBOT=<script file> OPENBMH_ROBOT_LOG=<output file>
//
// (usually together with SDL_VIDEODRIVER=dummy and SDL_AUDIODRIVER=dummy, so that no window and no
// sound device are needed), the program reads the script instead of waiting for the mouse. After
// every command the robot waits until the picture has stopped changing and writes one line
//
// <number> <command> -> <fingerprint of the settled picture> [unsettled]
//
// A refactoring of the window program must reproduce that file. Without the two environment
// variables the robot is inactive and costs one branch per frame and per empty event poll.
//
// How it hooks in (both hooks are called on the UI thread only):
// - present(renderer) replaces SDL_RenderPresent in main.cpp: the robot reads the rendered
// picture back and remembers its fingerprint;
// - QuitConfirmation::poll calls idle() when SDL has no event: once the picture is settled the
// robot pushes the events of the next command into SDL's queue (so they take exactly the path
// of real input, including SDL's conversion to the 320x240 logical coordinates).
//
// Script: one command per line, '#' starts a comment. Coordinates are the game's 320x240 units.
// left X Y | right X Y a click (press, 120 ms, release)
// key NAME RETURN, ESCAPE, BACKSPACE, SPACE or one letter/digit
// text T typed text
// wait MS nothing for MS milliseconds (then the settled picture is logged)
// quit closes the program (the quit question is answered with yes)
// OPENBMH_ROBOT_SHOTS=<directory> additionally saves the settled picture of every command as a BMP.
// The time a command may take to settle is limited (OPENBMH_ROBOT_TIMEOUT_MS, default 15000); a
// screen that keeps animating is logged as "unsettled" with the picture shown at that moment.
#pragma once
#include <SDL.h>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <sstream>
#include <string>
#include <vector>
namespace bmh::app {
class Robot {
public:
static Robot& instance() {
static Robot robot;
return robot;
}
bool active() const { return active_; }
// Reads the environment; called once the window exists.
void start(SDL_Window* window) {
const char* script = std::getenv("OPENBMH_ROBOT");
const char* log = std::getenv("OPENBMH_ROBOT_LOG");
if (!script || !log) return;
std::ifstream in(script);
if (!in) { std::fprintf(stderr, "robot: cannot read %s\n", script); return; }
std::string line;
while (std::getline(in, line)) {
if (!line.empty() && line.back() == '\r') line.pop_back();
const auto first = line.find_first_not_of(" \t");
if (first == std::string::npos || line[first] == '#') continue;
commands_.push_back(line.substr(first));
}
log_ = std::fopen(log, "wb");
if (!log_) { std::fprintf(stderr, "robot: cannot write %s\n", log); return; }
if (const char* settle = std::getenv("OPENBMH_ROBOT_SETTLE_MS")) settle_ms_ = Uint32(std::atoi(settle));
if (const char* timeout = std::getenv("OPENBMH_ROBOT_TIMEOUT_MS")) timeout_ms_ = Uint32(std::atoi(timeout));
if (const char* shots = std::getenv("OPENBMH_ROBOT_SHOTS")) shots_ = shots;
window_ = window;
active_ = true;
last_change_ = command_time_ = SDL_GetTicks();
}
// A picture is about to be shown: fingerprint it (FNV-1a over the rendered ARGB pixels).
void frame(SDL_Renderer* renderer) {
if (!active_) return;
int w = 0, h = 0;
if (SDL_GetRendererOutputSize(renderer, &w, &h) != 0 || w <= 0 || h <= 0) return;
pixels_.resize(size_t(w) * size_t(h) * 4);
width_ = w, height_ = h;
if (SDL_RenderReadPixels(renderer, nullptr, SDL_PIXELFORMAT_ARGB8888, pixels_.data(), w * 4) != 0) return;
uint64_t hash = 0xcbf29ce484222325ull;
for (uint8_t byte : pixels_) hash = (hash ^ byte) * 0x100000001b3ull;
if (hash != picture_) {
picture_ = hash;
++pictures_;
last_change_ = SDL_GetTicks();
}
}
// SDL has no event: issue the release of a click, or the next command once the picture is settled.
void idle() {
if (!active_) return;
const Uint32 now = SDL_GetTicks();
if (release_pending_) {
if (now - command_time_ < 120) return;
push_button(SDL_MOUSEBUTTONUP, release_button_);
release_pending_ = false;
last_change_ = now; // (the release may change the picture: settle again from here)
return;
}
if (now < wait_until_) return;
const bool settled = now - last_change_ >= settle_ms_ && now - command_time_ >= settle_ms_;
const bool timed_out = now - command_time_ >= timeout_ms_;
if (!settled && !timed_out) return;
// the previous command is done: log it with the picture now on screen
if (issued_ > 0 && !logged_) {
// (the number of pictures in between depends on the clock and is not written)
// A picture that was still changing at the time limit (a running live match, an animation) depends
// on the clock: only the fact is written, not its fingerprint.
if (settled) std::fprintf(log_, "%zu %s -> %016llx\n", issued_, commands_[issued_ - 1].c_str(), static_cast<unsigned long long>(picture_));
else std::fprintf(log_, "%zu %s -> unsettled\n", issued_, commands_[issued_ - 1].c_str());
std::fflush(log_);
save_shot();
logged_ = true;
}
if (issued_ >= commands_.size()) {
if (!finished_) { finished_ = true; std::fclose(log_); log_ = nullptr; }
return;
}
issue(commands_[issued_++]);
logged_ = false;
pictures_ = 0;
command_time_ = last_change_ = SDL_GetTicks();
}
// The quit question of a robot run is answered with "quit".
static int confirm_quit(const SDL_MessageBoxData*, int* selected) {
if (selected) *selected = 1;
return 0;
}
private:
// OPENBMH_ROBOT_SHOTS=<directory>: the settled picture of every command as <number>.bmp (for
// writing scripts and for looking at a run; not needed for the comparison).
void save_shot() {
if (shots_.empty() || pixels_.empty()) return;
SDL_Surface* surface = SDL_CreateRGBSurfaceWithFormatFrom(pixels_.data(), width_, height_, 32, width_ * 4,
SDL_PIXELFORMAT_ARGB8888);
if (!surface) return;
char name[32];
std::snprintf(name, sizeof name, "/%04zu.bmp", issued_);
SDL_SaveBMP(surface, (shots_ + name).c_str());
SDL_FreeSurface(surface);
}
void push_button(Uint32 type, Uint8 button) {
SDL_Event e{};
e.type = type;
e.button.windowID = SDL_GetWindowID(window_);
e.button.button = button;
e.button.state = type == SDL_MOUSEBUTTONDOWN ? SDL_PRESSED : SDL_RELEASED;
e.button.clicks = 1;
e.button.x = window_x_;
e.button.y = window_y_;
SDL_PushEvent(&e);
}
void push_motion() {
SDL_Event e{};
e.type = SDL_MOUSEMOTION;
e.motion.windowID = SDL_GetWindowID(window_);
e.motion.x = window_x_;
e.motion.y = window_y_;
SDL_PushEvent(&e);
}
void push_key(SDL_Keycode key) {
for (const Uint32 type : {Uint32(SDL_KEYDOWN), Uint32(SDL_KEYUP)}) {
SDL_Event e{};
e.type = type;
e.key.windowID = SDL_GetWindowID(window_);
e.key.state = type == SDL_KEYDOWN ? SDL_PRESSED : SDL_RELEASED;
e.key.keysym.sym = key;
e.key.keysym.scancode = SDL_GetScancodeFromKey(key);
SDL_PushEvent(&e);
}
}
void issue(const std::string& command) {
std::istringstream row(command);
std::string name;
row >> name;
if (name == "left" || name == "right") {
int x = 0, y = 0;
row >> x >> y;
// the middle of the logical pixel in window coordinates (SDL converts back)
int w = 960, h = 720;
SDL_GetWindowSize(window_, &w, &h);
window_x_ = x * w / 320 + w / 640;
window_y_ = y * h / 240 + h / 480;
// (the warp moves SDL's own pointer state too, which the program reads in a few places, and
// queues the motion event)
SDL_WarpMouseInWindow(window_, window_x_, window_y_);
release_button_ = name == "left" ? SDL_BUTTON_LEFT : SDL_BUTTON_RIGHT;
push_button(SDL_MOUSEBUTTONDOWN, release_button_);
release_pending_ = true;
} else if (name == "key") {
std::string key;
row >> key;
SDL_Keycode code = SDLK_UNKNOWN;
if (key == "RETURN" || key == "ENTER") code = SDLK_RETURN;
else if (key == "ESCAPE" || key == "ESC") code = SDLK_ESCAPE;
else if (key == "BACKSPACE") code = SDLK_BACKSPACE;
else if (key == "SPACE") code = SDLK_SPACE;
else if (key.size() == 1) code = SDL_Keycode(key[0] >= 'A' && key[0] <= 'Z' ? key[0] - 'A' + 'a' : key[0]);
if (code != SDLK_UNKNOWN) push_key(code);
} else if (name == "text") {
std::string text;
std::getline(row, text);
if (!text.empty() && text[0] == ' ') text.erase(0, 1);
SDL_Event e{};
e.type = SDL_TEXTINPUT;
e.text.windowID = SDL_GetWindowID(window_);
SDL_strlcpy(e.text.text, text.c_str(), sizeof(e.text.text));
SDL_PushEvent(&e);
} else if (name == "wait") {
int ms = 0;
row >> ms;
wait_until_ = SDL_GetTicks() + Uint32(ms > 0 ? ms : 0);
} else if (name == "quit") {
SDL_Event e{};
e.type = SDL_QUIT;
SDL_PushEvent(&e);
}
}
bool active_ = false, release_pending_ = false, logged_ = true, finished_ = false;
SDL_Window* window_ = nullptr;
std::FILE* log_ = nullptr;
std::vector<std::string> commands_;
std::vector<uint8_t> pixels_;
size_t issued_ = 0;
uint64_t picture_ = 0;
unsigned pictures_ = 0;
Uint32 last_change_ = 0, command_time_ = 0, wait_until_ = 0;
Uint32 settle_ms_ = 400, timeout_ms_ = 15000;
int window_x_ = 0, window_y_ = 0, width_ = 0, height_ = 0;
std::string shots_;
Uint8 release_button_ = SDL_BUTTON_LEFT;
};
// Shows the rendered picture (SDL_RenderPresent), letting the robot see it first.
inline void present(SDL_Renderer* renderer) {
Robot& robot = Robot::instance();
if (robot.active()) robot.frame(renderer);
SDL_RenderPresent(renderer);
}
} // namespace bmh::app
+1 -1
View File
@@ -427,7 +427,7 @@ void Console::finish_kickoff(const ui::DeskState& before, const TurnAdvanceResul
name = ui::league_table_from_game(session_->state(), active_slot(), *group.league_id).league_name;
// (the indoor tournament, 0xb, has a runtime name: TEXTD only holds the placeholder
// "...xxx"; the projection already carries the name frozen for these results)
else if (group.cup_id && *group.cup_id >= 0 && *group.cup_id < 13 && (*group.cup_id != 0xb || bmh::kEnglishCompetitions))
else if (group.cup_id && *group.cup_id >= 0 && *group.cup_id < 13 && (*group.cup_id != 0xb || bmh::league_system().english_competitions))
name = text(kCompetitionNames + *group.cup_id);
if (group.matches.empty()) continue;
emit('i', name + ":");
+2 -2
View File
@@ -36,7 +36,7 @@ constexpr int kHighscorePrefix = 889; // the high score file prefix ("high/h.")
void Console::register_info_commands() {
// --- TopScorers (05-information 7, menu 20) -------------------------------------------
// Codex's read-only port of TopScorersFromGame (game/top_scorers.hpp): the best ten of the own
// The read-only port of TopScorersFromGame (game/top_scorers.hpp): the best ten of the own
// league by goals, assists or both (one point each), for the whole league or only the
// managers' clubs. No state changes and no random draws, so the console reads it directly.
struct ScorerView {
@@ -133,7 +133,7 @@ void Console::register_info_commands() {
if (window_ == "Fixtures" && pairings_) fixtures_action(LeaguePairingsAction::close);
std::string error;
ClubInfoEntry entry;
if (team < int(exe_.u16(::bmh::layout::CareerSession_DispatchLineup_RuntimeField))) { // league teams get the entry step (as the app does)
if (team < int(exe_.u16(::bmh::layout::LeagueClubCount))) { // league teams get the entry step (as the app does)
const auto prepared = session_->enter_club_information(team, error);
if (!prepared) fail("E_RULE", "club information: " + error);
entry = *prepared;
+1 -1
View File
@@ -166,7 +166,7 @@ void Console::register_squad_commands() {
});
// Moving a player, the formations and the automatic weights: the requests the SDL pitch
// screen builds (src/ui/pitch.cpp click / save_formation), dispatched through
// CareerSession::dispatch_pitch (PitchScreen pitch branch, Codex's source port).
// CareerSession::dispatch_pitch (PitchScreen pitch branch, the source port).
auto pitch_context = [this] {
const auto p = prep();
if (!p.pitch || !p.pitch->indoor.has_value()) fail("E_ENGINE_GAP", "no pitch mode projection");
+1 -1
View File
@@ -90,7 +90,7 @@ Json mailbox_record(const ui::MailboxState& m) {
} // namespace
// --- Advice and Scoreboard (for agents that learn: docs/CLI_CONCEPT/16-playbook.md) -------
// --- Advice and Scoreboard (for agents that learn: docs/CLI_CONCEPT/10-agenten-und-tests.md) -------
// Advice names what needs a decision now, from the engine's own data; it judges nothing
// the player could not see on his screens, it only collects it. Scoreboard compares the
// human managers. Both read only.
+1 -1
View File
@@ -459,7 +459,7 @@ void Console::register_transfer_commands() {
Arg a;
a.text = number;
const auto id = to_int(a);
if (!id || *id < 0 || *id >= 138) fail("E_BAD_ARGUMENT", "club is club:<n> (ListPoachClubs)");
if (!id || *id < 0 || *id >= world_layout().league_teams) fail("E_BAD_ARGUMENT", "club is club:<n> (ListPoachClubs)");
return int(*id);
};
Param club = detail::text("club");
+10 -10
View File
@@ -231,7 +231,7 @@ inline constexpr auto CareerSession_DispatchDesktopLayout_RuntimeField = 0xa250e
inline constexpr auto CareerSession_DispatchDesktopLayout_RuntimeField2 = 0xa2517;
inline constexpr auto CareerSession_DispatchLeagueTableControl_RuntimeField = 0xa454d;
inline constexpr auto CareerSession_DispatchLeagueTableControl_RuntimeField2 = 0xbb834;
inline constexpr auto CareerSession_DispatchLineup_RuntimeField = 0xa2c30;
inline constexpr auto LeagueClubCount = 0xa2c30;
inline constexpr auto CareerSession_DispatchLiveSubstitution_ExecutableField = 0xa366c;
inline constexpr auto CareerSession_DispatchLiveTactic_RuntimeField = 0xa20eb;
inline constexpr auto CareerSession_DispatchLiveTactic_RuntimeField2 = 0xa20f3;
@@ -288,12 +288,12 @@ inline constexpr auto CareerSession_FormatNumber_ExecutableField2 = 0xa1380;
inline constexpr auto CareerSession_FormatNumber_TextPointer = 0xa137e;
inline constexpr auto CareerSession_InitializeClubModalRuntime_ExecutableField = 0xa25c0;
inline constexpr auto CareerSession_InitializeClubModalRuntime_ExecutableFieldUnsigned = 0xa25c0u;
inline constexpr auto CareerSession_InstallLeagueSizes_RuntimeField = 0xa2be9;
inline constexpr auto CareerSession_InstallLeagueSizes_RuntimeField2 = 0xa2bf2;
inline constexpr auto CareerSession_InstallLeagueSizes_RuntimeField3 = 0xa2c00;
inline constexpr auto CareerSession_InstallLeagueSizes_RuntimeField4 = 0xa2c0b;
inline constexpr auto CareerSession_InstallLeagueSizes_RuntimeField5 = 0xa2c13;
inline constexpr auto CareerSession_InstallLeagueSizes_RuntimeField6 = 0xa2c34;
inline constexpr auto LeagueEuropeanPlaces = 0xa2be9;
inline constexpr auto LeagueRelegationPlaces = 0xa2bf2;
inline constexpr auto LeagueNameSuffixes = 0xa2c00;
inline constexpr auto PromotionGroupBelowCounts = 0xa2c0b;
inline constexpr auto PromotionGroupBelowLeagues = 0xa2c13;
inline constexpr auto NewcomerClubCount = 0xa2c34;
inline constexpr auto CareerSession_Int32T_TextPointer = 0xaeffc;
inline constexpr auto CareerSession_Int32T_TextPointer2 = 0xaf21c;
inline constexpr auto CareerSession_Int32T_TextPointer3 = 0xaf228;
@@ -443,7 +443,7 @@ inline constexpr auto ClubKitSelectors = 0xbb68b;
inline constexpr auto ClubKitSelectorsUnsigned = 0xbb68bu;
inline constexpr auto ClubPlayerDetail_ClubPlayerDetailFromGame_RuntimeField = 0xa25bb;
inline constexpr auto ClubPlayerDetail_ClubPlayerDetailFromGame_RuntimeField2 = 0xa25bf;
inline constexpr auto ClubPlayerDetail_ClubPlayerDetailFromGame_RuntimeField3 = 0xa2c36;
inline constexpr auto ForeignCupClubCount = 0xa2c36;
inline constexpr auto ClubPlayerDetail_ClubPlayerDetailFromGame_RuntimeField4 = 0xa364a;
inline constexpr auto ClubPlayerDetail_ClubPlayerDetailRedraw_RuntimeField = 0xa2c4e;
inline constexpr auto ClubPlayerDetail_ClubPlayerDetailRedraw_RuntimeField2 = 0xa3c9b;
@@ -572,8 +572,8 @@ inline constexpr auto CupDraw_FormatError_ExecutableField4 = 0xae6dc;
inline constexpr auto CupDraw_FormatError_ExecutableField5 = 0xae704;
inline constexpr auto CupDraw_FormatError_ExecutableField6 = 0xae70c;
inline constexpr auto CupDraw_FormatError_RuntimeField = 0xa2547;
inline constexpr auto CupDraw_FormatError_RuntimeField2 = 0xb6ea8;
inline constexpr auto CupDraw_FormatError_RuntimeField3 = 0xb9ad8;
inline constexpr auto ManagerRecord0Club = 0xb6ea8;
inline constexpr auto ManagerRecord4Club = 0xb9ad8;
inline constexpr auto CupDraw_FormatError_TextPointer = 0xa1612;
inline constexpr auto CupDraw_FormatError_TextPointer2 = 0xa1619;
inline constexpr auto CupDraw_FormatError_TextPointer3 = 0xa161e;
+3 -3
View File
@@ -30,8 +30,8 @@ struct BlockDef {
// Sizes marked with a Count depend on the master database:
// Clubs = CareerSession_DataDirectory_RuntimeField (419) Players = CareerSession_DataDirectory_RuntimeField3 (2574)
// N42 = CareerSession_DataDirectory_RuntimeField2 (168) N66 = CareerSession_DataDirectory_RuntimeField4 (3096)
// Teams = CareerSession_DispatchLineup_RuntimeField (138, teams in league play)
// TeamsPlusCups = CareerSession_DispatchLineup_RuntimeField + CareerSession_InstallLeagueSizes_RuntimeField6 (138 + 30)
// Teams = LeagueClubCount (138, teams in league play)
// TeamsPlusCups = LeagueClubCount + NewcomerClubCount (138 + 30)
constexpr BlockDef kBlocks[] = {
{::bmh::layout::Cup_AdvanceCup_RuntimeField3, false, 1, Count::None, 0, false}, {::bmh::layout::LiveMatchday_FormatError_RuntimeField14, false, 6, Count::None, 0, false},
{::bmh::layout::ManagerRecords, false, 0x373c, Count::None, 0, false}, // 5 manager records of 0xB0C bytes
@@ -110,7 +110,7 @@ constexpr BlockDef kBlocks[] = {
SaveState::SaveState(const Bytes& stream, const DbCounts& c) : stream_(stream) {
// Teams in league play and cup-only teams are not part of DbCounts yet;
// these are the V2.24 values (CareerSession_DispatchLineup_RuntimeField, CareerSession_InstallLeagueSizes_RuntimeField6).
// these are the V2.24 values (LeagueClubCount, NewcomerClubCount).
constexpr uint32_t kTeams = 138, kCupTeams = 30;
size_t pos = 0;
uint32_t last_pointer = 0;
+57
View File
@@ -0,0 +1,57 @@
// SPDX-License-Identifier: GPL-3.0-only
// Text encoding helpers: see text_encoding.hpp.
#include "formats/text_encoding.hpp"
#include <array>
#include <iomanip>
#include <sstream>
#include "formats/binary.hpp"
namespace bmh {
namespace {
// The seven German letters and the ISO 646-DE bytes that stand for them, in the same order.
constexpr std::array<std::string_view, 7> german = {"Ä", "Ö", "Ü", "ä", "ö", "ü", "ß"};
constexpr std::string_view original_german = "[\\]{|}~";
} // namespace
std::string json_quote(std::string_view value) {
std::ostringstream s; s << '"';
for (unsigned char c : value) {
if (c == '"' || c == '\\') s << '\\' << c;
else if (c < 32) s << "\\u" << std::hex << std::setw(4) << std::setfill('0') << int(c) << std::dec;
else s << c;
}
s << '"'; return s.str();
}
std::string original_to_utf8(std::string_view value) {
std::string out;
for (char c : value) {
auto i = original_german.find(c);
if (i != std::string_view::npos) out += german[i];
else if (static_cast<unsigned char>(c) < 128) out += c;
else out += "�"; // Unsupported original byte remains visibly unknown.
}
return out;
}
std::string utf8_to_original(std::string_view value) {
std::string out;
for (size_t i = 0; i < value.size();) {
bool found = false;
for (size_t j = 0; j < german.size(); ++j)
if (value.substr(i, german[j].size()) == german[j]) {
out += original_german[j]; i += german[j].size(); found = true; break;
}
if (found) continue;
const unsigned char c = value[i++];
if (c >= 128) throw FormatError("manager name: unsupported UTF-8 character");
out += char(c);
}
return out;
}
} // namespace bmh
+28
View File
@@ -0,0 +1,28 @@
// SPDX-License-Identifier: GPL-3.0-only
#pragma once
// Text encoding of the original game and of the JSON the front ends emit.
//
// The original stores German text in ISO 646-DE: the seven bytes [ \ ] { | } ~ stand for
// Ä Ö Ü ä ö ü ß, everything else is ASCII. The engine and the screens keep text in that original
// encoding (the bitmap fonts are indexed by it); UTF-8 is used only where text leaves the program
// (JSON state, console, window titles) or enters it (typed names).
//
// These functions lived in ui/manager.hpp until 1.0.12, although nearly every screen, the console
// client and the app use them; ui/manager.hpp still makes them visible as bmh::ui::... .
#include <string>
#include <string_view>
namespace bmh {
// A JSON string literal (with the quotes) for UTF-8 text: escapes '"', '\' and control characters.
std::string json_quote(std::string_view utf8);
// Original (ISO 646-DE) bytes -> UTF-8. A byte above 127 is not part of the original encoding
// and becomes U+FFFD, so that it stays visible.
std::string original_to_utf8(std::string_view original);
// UTF-8 -> original bytes; throws FormatError for a character the original cannot store.
std::string utf8_to_original(std::string_view utf8);
} // namespace bmh
+1 -1
View File
@@ -21,7 +21,7 @@ namespace bmh {
namespace {
constexpr size_t kRecordSize = 0xb0c;
constexpr size_t kRecordSize = kManagerRecordSize;
constexpr uint32_t kPlanTicketPrice = ::bmh::layout::PlanTicketPrice; // one byte per manager
// BalancePlanRuntimeField: months left in the business year by calendar month (July: 12, June: 1)
constexpr int8_t kMonthsLeft[13] = {0, 6, 5, 4, 3, 2, 1, 12, 11, 10, 9, 8, 7};
+1 -1
View File
@@ -20,7 +20,7 @@
namespace bmh {
namespace {
constexpr uint32_t kLoans = ::bmh::layout::Loans;
constexpr size_t kRecord = 0xb0c;
constexpr size_t kRecord = kManagerRecordSize;
int32_t signed_word(uint32_t v) { return std::bit_cast<int32_t>(v); }
uint32_t word(int32_t v) { return std::bit_cast<uint32_t>(v); }
int32_t add(int32_t a, int32_t b) { return signed_word(word(a) + word(b)); }
+15 -15
View File
@@ -24,10 +24,9 @@ constexpr size_t kTailFrom = 2928 + 40;
constexpr size_t kTailTo = 2972; // CareerRuntimeField2
constexpr size_t kExtraSlots = 3096; // CareerSession_DataDirectory_RuntimeField4: 54 extra players from here
constexpr size_t kSquadSlots = 3096 + 54;
constexpr int kLeagueTeams = 138; // CareerSession_DispatchLineup_RuntimeField
// LeagueSizes: clubs per league; LeagueStrengthRanges: (minimum, maximum) strength per league.
// (the clubs per league are kLeagueSizes, schedule.hpp)
// (the clubs per league are league_system().sizes, schedule.hpp)
int kLeagueStrength[9][2] = {{71, 93}, {49, 71}, {28, 49}, {28, 49}, {10, 28},
{85, 95}, {90, 95}, {75, 95}, {80, 95}};
@@ -85,11 +84,11 @@ void startup_players(GameState& g, GameRandom& game, WatcomRandom& rand) {
generate_player(g, int16_t(g.squad_slots.at(kExtraSlots + i)), int16_t(level), game, rand);
}
int previous = 0, index = -1; // local_18, local_1c
for (int team = 0; team < kLeagueTeams; team++) {
for (int team = 0; team < world_layout().league_teams; team++) {
const int league = team_league(team);
index = league == previous ? index + 1 : 0;
previous = league;
const uint32_t count = uint32_t(kLeagueSizes[league]);
const uint32_t count = uint32_t(league_system().sizes[league]);
const uint32_t range = uint32_t(kLeagueStrength[league][1] - kLeagueStrength[league][0]);
const int level = int16_t(int((count - uint32_t(index)) * range * 100) / int(count) / 100) + kLeagueStrength[league][0];
const SquadRange r = squad_range(team);
@@ -208,7 +207,7 @@ void new_career_markets_and_moods(GameState& g, GameRandom& game, WatcomRandom&
if (g.texts) {
auto name = [&](int record, uint32_t pointer) {
const std::string& t = (*g.texts)[(pointer - ::bmh::layout::TextPointerTable) / 4];
const size_t at = size_t(record) * 0xb0c + 0xa8;
const size_t at = size_t(record) * kManagerRecordSize + 0xa8;
for (size_t i = 0; i <= t.size(); i++) g.manager_records.at(at + i) = i < t.size() ? uint8_t(t[i]) : 0;
};
name(first, ::bmh::layout::Career_NewCareerMarketsAndMoods_ExecutableField);
@@ -256,7 +255,7 @@ namespace bmh {
namespace {
constexpr size_t kRecord = 0xb0c;
constexpr size_t kRecord = kManagerRecordSize;
uint16_t team_of(const GameState& g, int m) {
const size_t at = size_t(m) * kRecord + 0x290;
@@ -269,7 +268,7 @@ bool human_club(const GameState& g, int team) {
const int managers = g.memory.u8(::bmh::layout::ManagerCount);
for (int m = 0; m < managers; m++)
if (team_of(g, m) == uint16_t(team)) return true;
return team_of(g, 0) == 0x165 && team_of(g, 4) == uint16_t(team);
return team_of(g, 0) == kNoTeam && team_of(g, 4) == uint16_t(team);
}
// OpenBMH deviates from the original: skips reserved calendar positions when assigning a joining manager to a club.
@@ -351,7 +350,7 @@ void put32(std::vector<uint8_t>& v, size_t o, uint32_t x) {
// CareerAddManager2(team, mode): condition and technique of every player of a league club around
// a level of its league (mode 0 random W(min, max), 1 min + 3, 2 the middle + 1, 3 max - 3).
void set_club_strength(GameState& g, int team, int mode, WatcomRandom& rand) {
if (team >= kLeagueTeams) return;
if (team >= world_layout().league_teams) return;
const int league = team_league(team);
const int lo = kLeagueStrength[league][0], hi = kLeagueStrength[league][1];
int level = mode;
@@ -439,20 +438,21 @@ void career_managers_begin(GameState& g, bool adding) {
bool career_add_manager(GameState& g, const LeImage& exe, int m, const CareerManager& choice, bool adding,
GameRandom& game, WatcomRandom& rand, MinuteReport& report) {
// Reject malformed requests before changing records or consuming either RNG.
const size_t clubs = size_t(world_layout().first_foreign_cup()); // clubs with records (Classic: 168)
if (!g.memory.has(::bmh::layout::ManagerCount) || m < 0 || m >= 4 ||
g.memory.u8(::bmh::layout::ManagerCount) > 4 || m >= g.memory.u8(::bmh::layout::ManagerCount) ||
size_t(m) >= g.manager_teams.size() || g.manager_records.size() < 5 * kRecord ||
choice.team < 0 || choice.team >= 168 || size_t(choice.team) >= g.club_ids.size() ||
choice.team < 0 || choice.team >= world_layout().first_foreign_cup() || size_t(choice.team) >= g.club_ids.size() ||
choice.league < 0 || choice.league > 4 || choice.strength < 0 || choice.strength > 2 ||
choice.portrait < 0 || choice.portrait > 11 || choice.name.size() > 24 ||
g.tactics.size() < size_t(m + 1) * 0x840 ||
g.manager_ratings.size() < size_t(m + 1) * 0x3c ||
g.manager_results.size() < g.manager_teams.size() * 0x690 ||
g.squad_slots.size() < kSquadSlots || g.club_ids.size() < 168 ||
g.team_morale.size() < 168 || g.team_flags.size() < 168 ||
g.club_heap_bc.size() < 168 * 2 || g.club_heap_78.size() < 168 * 2 ||
g.club_heap_b8.size() < 168 || g.position_history.size() < 138 * 0x1a ||
(!g.club_table.empty() && g.club_table.size() < 168 * 0x4a) ||
g.squad_slots.size() < kSquadSlots || g.club_ids.size() < clubs ||
g.team_morale.size() < clubs || g.team_flags.size() < clubs ||
g.club_heap_bc.size() < clubs * 2 || g.club_heap_78.size() < clubs * 2 ||
g.club_heap_b8.size() < clubs || g.position_history.size() < size_t(world_layout().league_teams) * 0x1a ||
(!g.club_table.empty() && g.club_table.size() < clubs * kClubRecordSize) ||
g.player_bonus.size() < g.players.size() || g.player_cards.size() < g.players.size() ||
!exe.contains(::bmh::layout::Career_CareerAddManager_ExecutableField) || !exe.contains(::bmh::layout::Career_BuildStadium_RuntimeField3 + 0x15 * 5) ||
!exe.contains(::bmh::layout::Career_BuildStadium_RuntimeField + 4 * 0x17 + 0x15)) {
@@ -665,7 +665,7 @@ void english_competition_blocks(StaticMemory& mem) {
}
void competition_pointers(StaticMemory& mem, const LeImage& exe) {
if (kEnglishCompetitions) {
if (league_system().english_competitions) {
competition_pointers_english(mem, exe);
return;
}
+1 -1
View File
@@ -72,7 +72,7 @@ GameState startup_state(const LeImage& exe, const Database& db, const Bytes& m3_
// the leagues, cups and tournaments.
void competition_pointers(StaticMemory& mem, const LeImage& exe);
// The memory of the English-only competitions (Football Limited, kEnglishCompetitions):
// The memory of the English-only competitions (Football Limited, league_system().english_competitions):
// blocks at their English addresses, which no German address uses. FA Cup results (67
// matches) and fields (68 clubs: the 20 Premier League clubs, the 48 of the qualifying
// stage, the proper rounds), the League Cup (44 clubs, three entries) and entry 35.
+2 -2
View File
@@ -8,7 +8,7 @@
#include <stdexcept>
namespace bmh {
ClubInfoEntry prepare_club_info_entry(GameState& g, int team) {
if (team < 0 || (team >= 138 && team != kNoTeam))
if (team < 0 || (team >= world_layout().league_teams && team != kNoTeam))
throw std::invalid_argument("club info: team has no squad");
const SquadRange range = squad_range(team);
if (range.first > g.squad_slots.size() || range.count > g.squad_slots.size() - range.first)
@@ -55,7 +55,7 @@ uint8_t set_club_info_category(GameState& g, int team, int requested) {
if (manager_count > 4 || manager_count > g.manager_teams.size())
throw std::invalid_argument("club info: truncated manager teams");
const bool national = !g.manager_teams.empty() && g.manager_teams.front() == kNoTeam;
constexpr size_t national_club = 4 * 0xb0c + 0x290;
constexpr size_t national_club = 4 * kManagerRecordSize + 0x290;
if (national && g.manager_records.size() < national_club + 2)
throw std::invalid_argument("club info: truncated national manager record");
// FindManagerForClub matches the first ManagerCount teams, irrespective of manager name,
+2 -2
View File
@@ -19,7 +19,7 @@
namespace bmh {
namespace {
constexpr size_t kRecord = 0xb0c, kBoard = 0x840, kBoardRow = 0x58;
constexpr size_t kRecord = kManagerRecordSize, kBoard = kTacticsBoardSize, kBoardRow = kTacticsBoardSlotSize;
uint16_t record_word(const GameState& g, size_t manager, size_t offset) {
const size_t at = manager * kRecord + offset;
@@ -78,7 +78,7 @@ ClubPlayerDetailContext club_player_detail_context(const GameState& g, const Clu
out.primary_club = -1;
} else {
if (s.rendered_row < 0 || s.rendered_row >= 24 || s.runtime_team < 0 ||
(s.runtime_team >= 138 && s.runtime_team != kNoTeam))
(s.runtime_team >= world_layout().league_teams && s.runtime_team != kNoTeam))
throw std::invalid_argument("player detail: invalid runtime club");
const auto range = squad_range(s.runtime_team);
if (range.first + range.count > g.squad_slots.size()) throw std::invalid_argument("player detail: truncated squad");
+9 -9
View File
@@ -138,7 +138,7 @@ void store_replays(GameState& g, int day) {
if (mem.u16(at) != day) continue;
const uint16_t r = mem.u16(kReplayResults + uint32_t(k++) * 2);
const uint8_t result = uint8_t(((r >> 5) << 4) | (r & 0xf));
g.results.at(size_t(mem.u8(at + 4)) + size_t(mem.u8(at + 2)) * 10 + size_t(mem.u8(at + 3)) * 0x17C) = result;
g.results.at(size_t(mem.u8(at + 4)) + size_t(mem.u8(at + 2)) * 10 + size_t(mem.u8(at + 3)) * kLeagueResultsStride) = result;
mem.set16(at, 0);
}
remove_competition(mem, 9);
@@ -352,7 +352,7 @@ void setup_cup_groups(GameState& g, int id, std::vector<MatchGroup>& groups, Min
grp.desc.at(1) = flags;
// competition 11 is the German indoor tournament; in the English game the same entry
// is the League Cup ("Koka Kola Cup"), an ordinary cup on grass (EN Put32)
if (type == 0xb && !kEnglishCompetitions) g.indoor = true;
if (type == 0xb && !league_system().english_competitions) g.indoor = true;
put32(grp.desc, 0xcc, e);
// the first leg of a two-legged knockout tie is never decided on the day
if ((flags & 5) == 5 && mem.u8(e + 0x1d) % 2 == 0) grp.desc.at(1) &= 0xF7;
@@ -443,7 +443,7 @@ void national_tournament_end(GameState& g) {
if (coach) book_money(g, 0, -400000, true, true);
for (int i = 0; i < 4; i++) {
if (teams[i] == kNoTeam && coach) book_money(g, 0, -kPremium[i], true, true);
// (0x8a + 0x1e + 0xbd = 0x165: CareerSession_DispatchLineup_RuntimeField + CareerSession_InstallLeagueSizes_RuntimeField6 + ClubPlayerDetail_ClubPlayerDetailFromGame_RuntimeField3)
// (0x8a + 0x1e + 0xbd = 0x165: LeagueClubCount + NewcomerClubCount + ForeignCupClubCount)
if (mem.has(::bmh::layout::Placements)) mem.set8(::bmh::layout::Placements + uint32_t(i), uint8_t((teams[i] - kNoTeam) | 0x80));
}
}
@@ -539,7 +539,7 @@ void advance_cup(GameState& g, int id, WatcomRandom& rand, MinuteReport& report,
if (type == 9) return store_replays(g, g.season_day());
// EndCompetition(type), re-added at the next preparation; the English Put32 keeps its
// League Cup (type 0xb) running like the other cups
if (type == 0xb && !kEnglishCompetitions) remove_competition(mem, type);
if (type == 0xb && !league_system().english_competitions) remove_competition(mem, type);
if (type == 10) {
// the friendlies: off the running list, the day's calendar entry masked with 0xffe
// (0x4001 becomes 0) and no teams left in today's entry (CupRuntimeField2)
@@ -596,7 +596,7 @@ void advance_cup(GameState& g, int id, WatcomRandom& rand, MinuteReport& report,
for (uint16_t t : winners) {
const int manager = g.manager_of(t);
if (manager < 0) continue;
const size_t at = size_t(manager) * 0xB0C + 0xda + size_t(std::min(g.season, 0x31)) * 3 + (type > 0 ? 2 : 1);
const size_t at = size_t(manager) * kManagerRecordSize + 0xda + size_t(std::min(g.season, 0x31)) * 3 + (type > 0 ? 2 : 1);
g.manager_records.at(at) = uint8_t(g.manager_records.at(at) + 1);
}
if (cup_round(mem, entry) == mem.u8(e + 0x1b)) {
@@ -622,7 +622,7 @@ void advance_cup(GameState& g, int id, WatcomRandom& rand, MinuteReport& report,
if (mem.u8(::bmh::layout::Cup_AdvanceCup_RuntimeField) == 0 && mem.has(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField2)) mem.set8(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField2, 0);
const int manager = g.manager_of(winners[0]);
if (manager >= 0 && type >= 0 && type < 4) {
const size_t at = size_t(manager) * 0xB0C + (type == 0 ? 0x8a6 : 0x8a8);
const size_t at = size_t(manager) * kManagerRecordSize + (type == 0 ? 0x8a6 : 0x8a8);
const uint16_t n = uint16_t(g.manager_records.at(at) | g.manager_records.at(at + 1) << 8);
g.manager_records.at(at) = uint8_t(n + 1), g.manager_records.at(at + 1) = uint8_t((n + 1) >> 8);
}
@@ -642,8 +642,8 @@ void advance_cup(GameState& g, int id, WatcomRandom& rand, MinuteReport& report,
if (mem.u8(e + 0x17) != 0 && winners.size() > 1)
mem.set16(cup_entry_address(mem.u8(e + 0x17)) + 0x22, winners[1]);
// (the indoor tournament only: the English League Cup has no Masters; its winner
// would go to EN CupRuntimeField6 for Europe - not ported, see docs/fltd.md)
if (type != 0xb || kEnglishCompetitions) return;
// would go to EN CupRuntimeField6 for Europe - not ported)
if (type != 0xb || league_system().english_competitions) return;
// the indoor tournament: the four places (CupRuntimeField7 picks them from the list
// champion..fourth) earn points for the Masters (CupRuntimeField8 x strength class
// Cup_AdvanceCup_RuntimeField3, clubs of the first two leagues only), then the next tournament is
@@ -673,7 +673,7 @@ void advance_cup(GameState& g, int id, WatcomRandom& rand, MinuteReport& report,
static constexpr uint8_t kPlacePoints[5] = {0, 6, 4, 2, 1}; // CupRuntimeField8
for (int i = 0; i < 4 && size_t(kPlaceOrder[i]) < winners.size(); i++) { // Uint32T
const int team = winners[kPlaceOrder[i]];
if (team < kLeagueSizes[0] + kLeagueSizes[1]) {
if (team < league_system().sizes[0] + league_system().sizes[1]) {
const uint32_t at = ::bmh::layout::Cup_AdvanceCup_ExecutableField + uint32_t(team) * 2;
mem.set16(at, uint16_t(mem.u16(at) + kPlacePoints[i + 1] * mem.u8(::bmh::layout::Cup_AdvanceCup_RuntimeField3)));
}
+3 -3
View File
@@ -22,7 +22,7 @@ namespace bmh {
namespace {
constexpr size_t kRecord = 0xB0C;
constexpr size_t kRecord = kManagerRecordSize;
// DeskRuntimeField: which of the 0x36 desk buttons exist, for the pseudo club 0x165 and per
// game mode (GameMode; the table for mode m starts at DeskRuntimeField + m * 0x36).
@@ -79,7 +79,7 @@ void enter_desk(GameState& g, int manager, GameRandom& game, WatcomRandom& rand,
uint8_t v = uint8_t(g.memory.u8(at) & 0xf);
// EN AlwaysHidesRecordIndoorTableIncluding always hides record 10 (IndoorTable), including
// Modus III. DE HasNoEquivalentCondition has no equivalent condition.
if ((kEnglishCompetitions && b == 10) ||
if ((league_system().english_competitions && b == 10) ||
(team == kNoTeam && kButtons[b] == 0) || (mode < 3 && kButtons[mode * 0x36 + b] == 0) ||
(b == 0x16 && mode2 == 1 && g.date < 0x16e))
v |= 0x10;
@@ -110,7 +110,7 @@ void enter_desk(GameState& g, int manager, GameRandom& game, WatcomRandom& rand,
// (<goal>. Platz) nicht erreicht haben." Reached: (4 - league) * 50000 per place better
// than the goal plus one (the third divisions count as the second), booked as income.
std::vector<uint8_t>& r = g.manager_records;
const size_t rec = size_t(manager) * 0xB0C;
const size_t rec = size_t(manager) * kManagerRecordSize;
const int goal = r.at(rec + 0x176);
if (g.memory.has(::bmh::layout::CareerSession_RuntimeError_RuntimeField4) && g.memory.u8(::bmh::layout::CareerSession_RuntimeError_RuntimeField4) != 0 && goal != 0) {
const int place = int16_t(table_position(g, team)) + 1; // TablePosition
+13 -13
View File
@@ -33,7 +33,7 @@ void wr32(std::vector<uint8_t>& v, size_t o, int32_t x) {
}
// Manager record (ManagerRecords + manager * 0xb0c) offsets used here.
constexpr size_t kRecordSize = 0xb0c;
constexpr size_t kRecordSize = kManagerRecordSize;
constexpr size_t kTeam = 0x290; // club of the manager (low byte used)
constexpr size_t kFocus = 0xc1; // four training camp sliders 0..15
constexpr size_t kStays = 0x21f; // bits 0-6 stays, bit 7 "in a camp this week"
@@ -75,7 +75,7 @@ FriendlyBookingQuote make_friendly_quote(const GameState& g, int manager, int op
return out;
}
const int own_team = g.manager_teams[size_t(manager)];
if (own_team < 0 || own_team >= 168 || opponent < 0 || opponent >= 168 || opponent == own_team) {
if (own_team < 0 || own_team >= world_layout().first_foreign_cup() || opponent < 0 || opponent >= world_layout().first_foreign_cup() || opponent == own_team) {
out.status = FriendlyQuoteStatus::invalid_opponent;
return out;
}
@@ -101,7 +101,7 @@ int national_opponent_manager(const GameState& g, const NationalFriendlyOwner& o
// FindManagerForClub's second lookup: spare manager record 4 represents the
// Bundestrainer's own association only for the first human national coach.
if (owner.manager == 0 && !g.manager_teams.empty() && g.manager_teams[0] == kNoTeam &&
g.memory.has(::bmh::layout::DeskActions_NationalOpponentManager_RuntimeField) && int(g.memory.u16(::bmh::layout::CupDraw_FormatError_RuntimeField3)) == opponent &&
g.memory.has(::bmh::layout::DeskActions_NationalOpponentManager_RuntimeField) && int(g.memory.u16(::bmh::layout::ManagerRecord4Club)) == opponent &&
5 * kRecordSize <= g.manager_records.size()) return 4;
return -1;
}
@@ -637,7 +637,7 @@ TransferActionResult submit_transfer_bid_impl(GameState& g, const TransferBidReq
const bool source_direct_candidate = source_hooks && seller_manager < 0 &&
fee_pct >= 110 && salary_pct >= g.memory.u8(entry + 0x55);
if (source_direct_candidate) {
if (request.list_entry >= 40 || seller < 0 || (seller >= 0x8a && seller != 0x0fff) || seller == buyer ||
if (request.list_entry >= 40 || seller < 0 || (seller >= world_layout().league_teams && seller != 0x0fff) || seller == buyer ||
request.manager < 0 || size_t(request.manager) >= g.manager_teams.size() ||
!g.memory.has(::bmh::layout::ActiveManager) || g.memory.u8(::bmh::layout::ActiveManager) != request.manager ||
source_hooks->direct_mode != HumanBuyerSaleDirectMode::ordinary_ai_purchase ||
@@ -803,7 +803,7 @@ TransferActionResult submit_transfer_bid_source_impl(GameState& g, const Transfe
// ordinary settlement already removes players using that actual range.
// Higher club IDs have no ordinary squad; do not invent their settlement
// or let ReleasePlayer reach its missing-player/internal-error21 boundary.
if (seller != 0x0fff && seller >= 138) {
if (seller != 0x0fff && seller >= world_layout().league_teams) {
report.fail(kOrdinarySellerBoundary);
out.status = TransferActionStatus::unsupported;
out.player = player; out.list_entry = request.list_entry;
@@ -1022,7 +1022,7 @@ TransferActionResult submit_transfer_bid_source_impl(GameState& g, const Transfe
std::optional<TransferMarketSnapshotPreview> transfer_market_snapshot_preview(
const GameState& g,int manager,int runtime_club,int index) {
if(manager<0||manager>=4||size_t(manager)>=g.manager_teams.size()||
g.manager_teams[size_t(manager)]!=runtime_club||runtime_club<0||runtime_club>=138||index<0||index>=12)
g.manager_teams[size_t(manager)]!=runtime_club||runtime_club<0||runtime_club>=world_layout().league_teams||index<0||index>=12)
return std::nullopt;
const auto owner=squad_range(runtime_club);
int count=0,ordinal=-1;
@@ -1049,7 +1049,7 @@ std::optional<TransferMarketSnapshotPreview> transfer_market_snapshot_preview(
// Require exactly one genuine ledger and its authenticated owner.
if(borrower!=-1||int(loan>>12&0x3ff)!=runtime_club)return std::nullopt;
borrower=int(loan>>22&0x3ff);
if(borrower<0||borrower>=138||borrower==runtime_club)return std::nullopt;
if(borrower<0||borrower>=world_layout().league_teams||borrower==runtime_club)return std::nullopt;
}
if(borrower<0)return std::nullopt;
const auto range=squad_range(borrower);
@@ -1104,7 +1104,7 @@ TransferMarketPreviewResult quote_transfer_market_preview_source(
// with the unchanged42307 formula; do not synthesize a Native slot.
} else {
if(request.snapshot_index!=-1)return unsupported("market preview: invalid snapshot index");
if(request.seller!=request.runtime_club||request.runtime_club>=138)
if(request.seller!=request.runtime_club||request.runtime_club>=world_layout().league_teams)
return unsupported("market preview: outgoing club is not an ordinary owned squad");
const auto range=squad_range(request.runtime_club);
if(range.count==0||range.first+range.count>g.squad_slots.size()||
@@ -1146,7 +1146,7 @@ int editor_slot(const GameState& g,const TransferOfferEditorRequest& r) {
std::string editor_identity(const GameState& g,const TransferOfferEditorRequest& r) {
if(r.manager<0||r.manager>=4||size_t(r.manager)>=g.manager_teams.size()||
!g.memory.has(::bmh::layout::ActiveManager)||g.memory.u8(::bmh::layout::ActiveManager)!=r.manager||
g.manager_teams[size_t(r.manager)]!=r.runtime_club||r.runtime_club<0||r.runtime_club>=138)
g.manager_teams[size_t(r.manager)]!=r.runtime_club||r.runtime_club<0||r.runtime_club>=world_layout().league_teams)
return "OpenTransferEditor: stale ordinary manager/team";
const size_t record=size_t(r.manager)*kRecordSize;
if(record+kRecordSize>g.manager_records.size()||
@@ -1172,7 +1172,7 @@ std::string editor_identity(const GameState& g,const TransferOfferEditorRequest&
const int seller=int(r.expected_seller_word&0x7fff);
if(r.expected_seller_word==0xffff||seller==r.runtime_club)
return "OpenTransferEditor: targeted/invalid seller is outside ordinary editor";
if(seller!=0x0fff&&seller>=138)return kOrdinarySellerBoundary;
if(seller!=0x0fff&&seller>=world_layout().league_teams)return kOrdinarySellerBoundary;
// OpenTransferEditor: the original refuses a loan from a free agent (seller 0x0fff) with the message
// DeskActionsRuntimeField6 (SDLFlushEvents3) - a rule of the game, not a gap: the code names it
if(r.loan&&r.expected_seller_word==0x0fff)return "free_agent_loan_refused";
@@ -1815,7 +1815,7 @@ void move_to_deposit(GameState& g, int manager, int32_t amount) {
}
void open_lineup_screen(GameState& g, int manager) {
uint8_t* rec = &g.manager_records.at(size_t(manager) * 0xb0c);
uint8_t* rec = &g.manager_records.at(size_t(manager) * kManagerRecordSize);
if ((rec[0xb0a] | rec[0xb0b] << 8) == 0x3253) return;
for (int i = 0; i < 4; i++) rec[0xafc + i] = 0;
rec[0xb08] = 0, rec[0xb09] = 0, rec[0xb0a] = 0x53, rec[0xb0b] = 0x32;
@@ -1827,7 +1827,7 @@ namespace bmh {
bool submit_pools_coupon(GameState& g, int manager, uint32_t stake,
const std::array<uint8_t, 11>& tips) {
constexpr size_t kRecord = 0xb0c;
constexpr size_t kRecord = kManagerRecordSize;
constexpr uint32_t kCoupon = ::bmh::layout::Coupon;
constexpr uint32_t kCouponBytes = 5 * 0x14;
if (manager < 0 || size_t(manager) >= g.manager_teams.size() ||
@@ -1849,7 +1849,7 @@ bool submit_pools_coupon(GameState& g, int manager, uint32_t stake,
namespace bmh {
namespace {
constexpr size_t kAdRecord = 0xb0c;
constexpr size_t kAdRecord = kManagerRecordSize;
constexpr size_t kAdPool = 0x8cc;
constexpr size_t kAdContracts = 0xa34;
constexpr size_t kAdContractBytes = 0x0c;
+59
View File
@@ -0,0 +1,59 @@
// SPDX-License-Identifier: GPL-3.0-only
// state_digest: see digest.hpp.
#include "game/digest.hpp"
#include "game/save.hpp"
namespace bmh {
namespace {
// FNV-1a, 64 bit: simple, stable across platforms and compilers (no std::hash).
struct Fnv {
uint64_t value = 0xcbf29ce484222325ull;
void byte(uint8_t b) { value = (value ^ b) * 0x100000001b3ull; }
// (integers are fed byte by byte, least significant first, so the result does not depend on
// the byte order of the machine)
void u64(uint64_t v) {
for (int i = 0; i < 8; i++) byte(uint8_t(v >> (i * 8)));
}
void i64(int64_t v) { u64(uint64_t(v)); }
};
} // namespace
uint64_t state_digest(const GameState& g, int32_t game_seed, uint32_t rand_seed) {
Fnv h;
// 1. everything that is saved, in the block order of the original
const Bytes stream = save_stream(g);
h.u64(stream.size());
for (uint8_t b : stream) h.byte(b);
// 2. the run-time values a savegame does not hold (GameState members marked "not saved")
h.i64(g.indoor);
h.i64(g.level);
h.i64(g.chance_rain);
h.i64(g.chance_temperature);
h.i64(g.last_shooter);
h.i64(g.last_pick_quality);
h.i64(g.live_scene);
h.u64(g.live_matches.size());
for (int team : g.live_matches) h.i64(team);
for (uint16_t home : g.sportschau_homes) h.u64(home);
for (uint8_t priority : g.sportschau_priorities) h.u64(priority);
h.i64(g.sportschau_selection_available);
h.i64(g.list_toggle);
h.i64(g.lineups_frozen);
h.i64(g.pools_open);
h.i64(g.autosave_months);
h.i64(g.autosave_month);
h.u64(g.date);
h.u64(g.season_start);
h.i64(g.season);
h.i64(g.development_balance);
h.i64(g.trend_rotation);
// 3. both random generators
h.i64(game_seed);
h.u64(rand_seed);
return h.value;
}
} // namespace bmh
+26
View File
@@ -0,0 +1,26 @@
// SPDX-License-Identifier: GPL-3.0-only
#pragma once
// A fingerprint of the complete game state, for behaviour-preserving refactoring.
//
// Two runs of the same career must produce the same digest after every turn. The digest covers
// - everything a savegame holds (the decrypted stream of save_stream: all state blocks and the
// four name pools), and
// - the run-time values that are not saved but steer later draws (the chance weather, the last
// shooter, the transfer list toggle, the autosave counters, ...).
// The states of the two random generators are passed in by the caller, because they do not belong
// to GameState.
//
// It is a regression tool only: the value has no meaning of its own and may change whenever the
// engine's behaviour is changed on purpose (then the reference files are simply recorded again).
#include <cstdint>
#include "game/state.hpp"
namespace bmh {
// FNV-1a (64 bit) over the saved stream and the unsaved run-time values of `g`, the game
// generator's seed and the Watcom generator's seed.
uint64_t state_digest(const GameState& g, int32_t game_seed, uint32_t rand_seed);
} // namespace bmh
+1 -1
View File
@@ -32,7 +32,7 @@ bool legacy_academy(const GameState& g, int manager) {
return value == 1500000 || value == 1000000 || value == 580000 || value == 280000;
}
uint32_t academy_paid(const GameState& g, int manager) {
const auto at = size_t(manager) * 0xb0c + 0x880;
const auto at = size_t(manager) * kManagerRecordSize + 0x880;
return uint32_t(g.manager_records.at(at)) | uint32_t(g.manager_records.at(at + 1)) << 8 |
uint32_t(g.manager_records.at(at + 2)) << 16 | uint32_t(g.manager_records.at(at + 3)) << 24;
}
+2 -2
View File
@@ -16,7 +16,7 @@
namespace bmh {
namespace {
constexpr size_t kRecord = 0xb0c;
constexpr size_t kRecord = kManagerRecordSize;
// OpenBMH deviates from the original: reads the supported edition-specific high-score format from the loaded image.
// supported rule profile executable HighscoreRuntimeField..a5144, verified against the installed LE image.
constexpr std::array<uint8_t, 8> kHistoryWeights{3, 5, 4, 30, 20, 10, 5, 40};
@@ -86,7 +86,7 @@ HighscoreScore highscore_score(const GameState& g, int manager, HighscoreContext
HighscoreScore result;
const int team = g.manager_teams.at(size_t(manager));
if (team == kNoTeam) {
// CareerSession_DispatchLineup_RuntimeField+CareerSession_InstallLeagueSizes_RuntimeField6+ClubPlayerDetail_ClubPlayerDetailFromGame_RuntimeField3 == kNoTeam in the supported Original database;
// LeagueClubCount+NewcomerClubCount+ForeignCupClubCount == kNoTeam in the supported Original database;
// national honours store (team-kNoTeam)|0x80, so Germany's index is0.
for (uint32_t year = 0; year < 20; ++year)
for (uint32_t place = 0; place < 4; ++place) {
+7 -7
View File
@@ -113,7 +113,7 @@ void validate(const GameState& g,const LeaguePairingsOwner& o) {
require(o.supported&&!o.closed&&o.manager>=0&&o.manager<4&&
size_t(o.manager)<g.manager_teams.size()&&g.memory.has(::bmh::layout::ActiveManager)&&
g.memory.u8(::bmh::layout::ActiveManager)==o.manager&&g.manager_teams[size_t(o.manager)]==o.runtime_club&&
(national||(o.runtime_club>=0&&o.runtime_club<138))&&
(national||(o.runtime_club>=0&&o.runtime_club<world_layout().league_teams))&&
size_t(o.runtime_club)<g.club_ids.size()&&
g.club_ids[size_t(o.runtime_club)]==o.club_identity,
"pairings: stale or unsupported manager identity");
@@ -129,12 +129,12 @@ void validate(const GameState& g,const LeaguePairingsOwner& o) {
(g.memory.u8(::bmh::layout::CareerSession_CloseLeagueFamily_ExecutableField+uint32_t(o.manager))&0x0f)==8)&&
g.memory.has(::bmh::layout::LeagueTableDisplayModes+uint32_t(o.manager)*2+1),
"pairings: missing preferences or unsupported saved list mode");
require(g.results.size()>=kResultsSize&&g.club_ids.size()>=138&&g.league_rounds.size()>=9&&
require(g.results.size()>=kResultsSize&&g.club_ids.size()>=size_t(world_layout().league_teams)&&g.league_rounds.size()>=size_t(kLeagueCount)&&
g.memory.has(::bmh::layout::Postponed+0xef)&&g.memory.has(::bmh::layout::CompetitionCalendar+365*2+1),
"pairings: incomplete Native schedule");
const auto selection_valid=[&](int team,int identity) {
return team<0 ? team>=-2&&identity==-1 :
team<138&&team_league(team)==o.league&&g.club_ids.at(size_t(team))==identity;
team<world_layout().league_teams&&team_league(team)==o.league&&g.club_ids.at(size_t(team))==identity;
};
require(selection_valid(o.search_first,o.search_first_identity)&&
selection_valid(o.search_second,o.search_second_identity)&&
@@ -186,7 +186,7 @@ void validate(const GameState& g,const LeaguePairingsOwner& o) {
o.filter_offset>=0&&o.filter_offset%10==0&&o.filter_team>=-2,
"pairings: invalid Source club-filter mode");
if(o.filter_team>=0) {
require(o.filter_team<138&&team_league(o.filter_team)==o.league&&
require(o.filter_team<world_layout().league_teams&&team_league(o.filter_team)==o.league&&
g.club_ids.at(size_t(o.filter_team))==o.filter_identity&&
(o.filter_offset==0||o.filter_offset<filtered_fixture_count(o.league,o.filter_team)),
"pairings: stale or out-of-range filtered club");
@@ -320,7 +320,7 @@ LeaguePairingsOwner open_league_pairings_source(GameState& g,int manager,const L
require(manager>=0&&manager<4&&size_t(manager)<g.manager_teams.size(),"pairings: unsupported manager");
LeaguePairingsOwner out;out.manager=manager;out.runtime_club=g.manager_teams[size_t(manager)];
const bool national=out.runtime_club==kNoTeam;
require((national||(out.runtime_club>=0&&out.runtime_club<138))&&
require((national||(out.runtime_club>=0&&out.runtime_club<world_layout().league_teams))&&
size_t(out.runtime_club)<g.club_ids.size(),"pairings: unsupported or unowned manager");
out.club_identity=g.club_ids[size_t(out.runtime_club)];
// TeamLeague2 maps the Original national runtime team 0x165 to league 0.
@@ -373,9 +373,9 @@ LeaguePairingsOwner edit_league_pairings_source(GameState& g,const LeaguePairing
require(g.memory.has(::bmh::layout::CalendarState_FormatError_RuntimeField2)&&g.memory.u8(::bmh::layout::CalendarState_FormatError_RuntimeField2)==0,
"pairings: secondary leagues disabled");
out.league_group^=1;
require(size_t(out.manager)*0xb0c+0x210<g.manager_records.size(),
require(size_t(out.manager)*kManagerRecordSize+0x210<g.manager_records.size(),
"pairings: missing manager league preference");
out.league=out.league_group?5:g.manager_records.at(size_t(out.manager)*0xb0c+0x210);
out.league=out.league_group?5:g.manager_records.at(size_t(out.manager)*kManagerRecordSize+0x210);
require(out.league>=0&&out.league<9,"pairings: invalid manager league preference");
[[fallthrough]];
case LeaguePairingsAction::select_league:
+9 -10
View File
@@ -27,9 +27,8 @@ constexpr int8_t kTypeBySlot[24] = {2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 0, 1, 2, 2,
constexpr int16_t kUnavailable = -32000; // 0x8300
constexpr int kMismatchWeight = 0x40; // local_54 for computer teams
constexpr size_t kManagerRecordSize = 0xB0C;
constexpr size_t kManagerBoardSize = 0x840;
constexpr size_t kBoardRowSize = 0x58;
constexpr size_t kManagerBoardSize = kTacticsBoardSize;
constexpr size_t kBoardRowSize = kTacticsBoardSlotSize;
constexpr size_t kFormationManagerSize = 0x160;
constexpr size_t kNativeFormationBlockSize = 0x580;
@@ -42,7 +41,7 @@ uint8_t formation_byte(const GameState& g, size_t index) {
}
bool pitch_context_valid(const GameState& g, int manager, int team) {
if (manager < 0 || manager > 3 || team < 0 || team >= 138 || g.lineups_frozen ||
if (manager < 0 || manager > 3 || team < 0 || team >= world_layout().league_teams || g.lineups_frozen ||
!g.memory.has(::bmh::layout::ActiveManager) || !g.memory.has(::bmh::layout::GameMode) ||
g.memory.u8(::bmh::layout::ActiveManager) != manager || g.memory.u8(::bmh::layout::GameMode) < 1 || g.memory.u8(::bmh::layout::GameMode) > 3 ||
size_t(manager) >= g.manager_teams.size() || g.manager_teams[size_t(manager)] != team ||
@@ -331,7 +330,7 @@ void install_lineup_rules(const LeImage& exe) {
}
static void auto_lineup_impl(GameState& g, int team, int mode, int manager) {
if (team >= 138 && team != kNoTeam) return; // teams without squads
if (team >= world_layout().league_teams && team != kNoTeam) return; // teams without squads
if (g.lineups_frozen) return; // LineupRuntimeField (the season change)
const bool improve_from_reserves = (mode & 0x80) != 0;
mode &= 0x7F;
@@ -369,7 +368,7 @@ static void auto_lineup_impl(GameState& g, int team, int mode, int manager) {
g.club_heap_78[club_word + 1] = uint8_t(badge_word >> 8);
formation = 0;
set = manager;
const uint8_t style = g.manager_records.at(size_t(manager) * 0xB0C + 0x288);
const uint8_t style = g.manager_records.at(size_t(manager) * kManagerRecordSize + 0x288);
weight = 1 << ((style & 3) + 4);
familiarity = (style >> 4) & 3;
if (g.level >= 6) detail = (style >> 2) & 3;
@@ -448,7 +447,7 @@ static void auto_lineup_impl(GameState& g, int team, int mode, int manager) {
if (option == -1) throw std::invalid_argument("auto_lineup: invalid human formation option");
formation = option;
set = manager;
const uint8_t style = g.manager_records.at(size_t(manager) * 0xB0C + 0x288); // assistant settings
const uint8_t style = g.manager_records.at(size_t(manager) * kManagerRecordSize + 0x288); // assistant settings
weight = 1 << ((style & 3) + 4);
familiarity = (style >> 4) & 3;
if (g.level >= 6) detail = (style >> 2) & 3;
@@ -650,7 +649,7 @@ void auto_lineup(GameState& g, int team, int mode) {
}
void auto_lineup_parked_club_source(GameState& g, int team, int mode) {
constexpr size_t record = 4*0xb0c+0x290;
constexpr size_t record = 4 * kManagerRecordSize+0x290;
if (team<0 || team>=138 || g.manager_teams.size()!=1 || g.manager_teams[0]!=kNoTeam ||
!g.memory.has(::bmh::layout::CoachActive) || g.memory.u8(::bmh::layout::CoachActive)==0 ||
!g.memory.has(::bmh::layout::ManagerCount) || g.memory.u8(::bmh::layout::ManagerCount)!=1 ||
@@ -687,7 +686,7 @@ void quicksort_by_key(int16_t* items, uint32_t* keys, int count, bool ascending)
}
bool substitute(GameState& g, int team, int off, int mode, WatcomRandom& rand) {
if (!(team < 138 || team == kNoTeam)) return false;
if (!(team < world_layout().league_teams || team == kNoTeam)) return false;
const int manager = g.manager_of(team);
int used = g.team_flags.at(team) >> 5 & 7; // substitutions so far
if (mode == 10) {
@@ -789,7 +788,7 @@ bool substitute(GameState& g, int team, int off, int mode, WatcomRandom& rand) {
// human teams: the re-sort uses a formation after the attitude (mode / 2 for the
// tactical changes, else the manager's setting, record +0xd2): option byte 0 is set
// to 4 - attitude for the call and restored afterwards
int attitude = mode < 9 ? mode >> 1 : int8_t(g.manager_records.at(size_t(manager) * 0xB0C + 0xd2)); // (mode as clamped above)
int attitude = mode < 9 ? mode >> 1 : int8_t(g.manager_records.at(size_t(manager) * kManagerRecordSize + 0xd2)); // (mode as clamped above)
if (attitude > 3) attitude = 3;
uint8_t& option = g.manager_options.at(size_t(manager) * 5);
const uint8_t saved = option;
+1 -1
View File
@@ -20,7 +20,7 @@ uint32_t key(int team, int player) {
}
int manager_team(const GameState& g, int manager) {
if (manager >= 0 && size_t(manager) < g.manager_teams.size()) return g.manager_teams[size_t(manager)];
const size_t at = size_t(manager) * 0xb0c + 0x290;
const size_t at = size_t(manager) * kManagerRecordSize + 0x290;
if (manager < 0 || manager > 4 || at + 1 >= g.manager_records.size())
throw FormatError("long career: invalid manager");
return int(g.manager_records[at] | uint16_t(g.manager_records[at + 1]) << 8);
+5 -5
View File
@@ -30,7 +30,7 @@ constexpr int8_t kRegionTemperature[48] = {0, -1, 5, 0, 0, 5, 0, -1, -5, -4,
constexpr uint8_t kLeagueCrowd[10] = {27, 12, 7, 7, 3, 27, 27, 27, 27, 27};
// First league that counts as a regional league (LeaguePairings_LeaguePairingsConstants_RuntimeField).
constexpr int kFirstRegionalLeague = 5;
// Number of cup-only teams before the amateur blocks (CareerSession_InstallLeagueSizes_RuntimeField6).
// Number of cup-only teams before the amateur blocks (NewcomerClubCount).
constexpr int kCupTeams = 30;
int clamp(int v, int lo, int hi) { return v < lo ? lo : v > hi ? hi : v; }
@@ -81,7 +81,7 @@ int team_region(int team) {
if (team == kNoTeam) return 0;
int t = team;
for (int league = 0; league < kLeagueCount; league++) {
t -= kLeagueSizes[league];
t -= league_system().sizes[league];
if (t < 0) return league >= kFirstRegionalLeague ? league - kFirstRegionalLeague + 1 : 0;
}
if (t - kCupTeams >= 0) return (t - kCupTeams) / 7 - kFirstRegionalLeague + 10;
@@ -112,7 +112,7 @@ void rate_side(GameState& g, const MatchSetup& m, int side, int previous6, Watco
int base = kLeagueCrowd[league < 10 ? league : 9] * 1000;
if (unsigned(rand.range(base + 3000, base + 6000)) < unsigned(m.spectators)) {
// a human manager's side with record +0x289 set suffers more from a full house
modifier -= manager >= 0 && g.manager_records.at(size_t(manager) * 0xB0C + 0x289) != 0 ? 9 : 6;
modifier -= manager >= 0 && g.manager_records.at(size_t(manager) * kManagerRecordSize + 0x289) != 0 ? 9 : 6;
}
}
modifier = clamp(int8_t(modifier), -10, 10);
@@ -141,7 +141,7 @@ void rate_side(GameState& g, const MatchSetup& m, int side, int previous6, Watco
} else {
// human teams: record +0xd9 (signed) * 5 plus a constant 110, scaled to 0-100. Diamond 3.7: the
// condition/technique balance r[6] no longer enters (before: d9 * 5 + r[6]).
const int8_t d9 = int8_t(g.manager_records.at(size_t(manager) * 0xB0C + 0xd9));
const int8_t d9 = int8_t(g.manager_records.at(size_t(manager) * kManagerRecordSize + 0xd9));
r[7] = uint8_t((d9 * 5 + 110) * 100 / 0xFF);
}
}
@@ -162,7 +162,7 @@ std::array<SideRecord, 2> build_side_records(GameState& g, const MatchSetup& m,
// state; OpenBMH uses a cleared record (0) as a deterministic stand-in.
const int manager = g.manager_of(side ? m.away : m.home);
if (manager >= 0 && !g.manager_option(manager, 2))
r.b[8] = g.manager_records.at(size_t(manager) * 0xB0C + 0xd2); // the manager's own setting
r.b[8] = g.manager_records.at(size_t(manager) * kManagerRecordSize + 0xd2); // the manager's own setting
else
r.b[8] = uint8_t(initial_attitude(r, rec[1 - side], side, m.match_index, rand));
}
+14 -14
View File
@@ -84,7 +84,7 @@ MinuteReport MatchEngine::minute(int minute, int last_minute, int stoppage) {
// Human teams use the places on their tactics board, also for the player's value.
int MatchEngine::pick_player(int team, int mode, int exclude, MinuteReport& report, int preset) {
mode &= 0x7F; // 0x80 = reuse the squad of the previous call, same team here
if (team >= 138 && team != kNoTeam) return 0xFFF; // clubs without squad: nobody, no draws
if (team >= world_layout().league_teams && team != kNoTeam) return 0xFFF; // clubs without squad: nobody, no draws
SquadRange range = squad_range(team);
if (range.count == 0) return 0xFFF;
RatingContext ctx{state.chance_rain, state.chance_temperature};
@@ -320,7 +320,7 @@ void MatchEngine::set_piece_animation(int kind, int distance, int side, int grou
int MatchEngine::designated_slot(int team, int offset, int exclude) const {
int manager = state.manager_of(team);
if (manager < 0 || state.manager_records.empty()) return -1;
const uint8_t* rec = state.manager_records.data() + size_t(manager) * 0xB0C;
const uint8_t* rec = state.manager_records.data() + size_t(manager) * kManagerRecordSize;
auto u16 = [&](int at) { return int(rec[at] | rec[at + 1] << 8); };
if (u16(0xb0a) != 0x3253) return -1;
int id = u16(offset);
@@ -473,8 +473,8 @@ int injure_player(GameState& g, int slot, int type, bool match, int manager, Wat
// duration * (doctor / 100 - 5) / 8; a poor doctor makes it longer. The cut is limited
// only for the heavy injuries: types 20-25 by 4 matchdays, types 26-27 by 6, types 28-30
// by 8; lighter types have no limit (the duration is cut to 0 at the lowest).
const int doctor = int16_t(g.manager_records.at(size_t(manager) * 0xB0C + 0x8ae) |
g.manager_records.at(size_t(manager) * 0xB0C + 0x8af) << 8);
const int doctor = int16_t(g.manager_records.at(size_t(manager) * kManagerRecordSize + 0x8ae) |
g.manager_records.at(size_t(manager) * kManagerRecordSize + 0x8af) << 8);
// (the / 8 is Watcom's SAR/SHL/SBB idiom: (x + 7) >> 3 for negative x)
const int x = duration * (doctor / 100 - 5);
int cut = (x + (x < 0 ? 7 : 0)) >> 3;
@@ -532,9 +532,9 @@ ForcedMatchEvent MatchEngine::event_impl(MatchGroup& g, int m, int s, int minute
int opp_team = g.fixtures.at(m * 2 + 1 - s); // MatchEngineRuntimeField11
// Small-squad teams (id >= 90) only half of the time; teams without squads never. The
// national team (0x165, squad nominated on the national team days) only while manager
// slot 0 holds it (CupDraw_FormatError_RuntimeField2 == 0x165: a Bundestrainer's match).
// slot 0 holds it (ManagerRecord0Club == 0x165: a Bundestrainer's match).
if (!(team < 90 || rand.range(0, 1) == 0)) return result;
if (!(team < 138 || team == kNoTeam)) return result;
if (!(team < world_layout().league_teams || team == kNoTeam)) return result;
if (team == kNoTeam && (state.manager_teams.empty() || state.manager_teams[0] != kNoTeam)) return result;
const int manager = state.manager_of(team); // FindManagerForClub, local_6c
const bool human = manager >= 0;
@@ -703,7 +703,7 @@ ForcedMatchEvent MatchEngine::event_impl(MatchGroup& g, int m, int s, int minute
}
if (human) {
const int bucket = std::min(minute, 0x59) / 5;
state.manager_records.at(size_t(manager) * 0xB0C + 0x1ae + size_t(bucket) + size_t((kind == 1) + 2) * 0x12)++;
state.manager_records.at(size_t(manager) * kManagerRecordSize + 0x1ae + size_t(bucket) + size_t((kind == 1) + 2) * 0x12)++;
}
}
@@ -761,7 +761,7 @@ void MatchEngine::side(MatchGroup& g, int m, int& s, int minute, int& own_att, i
report.fail("attitude of a human team needs the manager records (savegame)");
return;
}
own[8] = state.manager_records.at(size_t(manager) * 0xB0C + 0xd2);
own[8] = state.manager_records.at(size_t(manager) * kManagerRecordSize + 0xd2);
return;
}
int home = 0, away = 0;
@@ -854,7 +854,7 @@ void MatchEngine::side(MatchGroup& g, int m, int& s, int minute, int& own_att, i
return;
}
const auto& exe = *reality_rules;
if (team < exe.u16(::bmh::layout::CareerSession_DispatchLineup_RuntimeField) && opp_team < exe.u16(::bmh::layout::CareerSession_DispatchLineup_RuntimeField)) {
if (team < exe.u16(::bmh::layout::LeagueClubCount) && opp_team < exe.u16(::bmh::layout::LeagueClubCount)) {
const int displacement = (1 - s * 2) * rand.range(21, 45);
if (live_ball && button(::bmh::layout::MatchEngine_Side_ExecutableField3) == 0)
live_ball({minute, show_group, m, displacement});
@@ -955,7 +955,7 @@ void MatchEngine::side(MatchGroup& g, int m, int& s, int minute, int& own_att, i
}
// Goalkeeper of the opponent: the player in squad slot 0 if the formation puts it in goal.
if (!reality_played && (opp_team < 168 || opp_team == kNoTeam)) {
if (!reality_played && (opp_team < world_layout().first_foreign_cup() || opp_team == kNoTeam)) {
int x = 0, y = 0;
state.formation_position(opp_team, 0, x, y);
if (x == 0 && y == 4) keeper = state.squad_slots.at(squad_range(opp_team).first) & 0x0FFF;
@@ -990,7 +990,7 @@ void MatchEngine::side(MatchGroup& g, int m, int& s, int minute, int& own_att, i
deflected = game.range(0, 5) == 0;
}
if (kind == 0) {
if (team >= 168 && team != kNoTeam) {
if (team >= world_layout().first_foreign_cup() && team != kNoTeam) {
// clubs without squad: the attack rating (TeamRating, profile 3), drawn
RatingContext drawn;
drawn.rand = &rand;
@@ -1000,7 +1000,7 @@ void MatchEngine::side(MatchGroup& g, int m, int& s, int minute, int& own_att, i
}
}
if (keeper == 0xFFF) {
if (opp_team >= 168 && opp_team != kNoTeam) {
if (opp_team >= world_layout().first_foreign_cup() && opp_team != kNoTeam) {
// clubs without squad: the goalkeeping rating (profile 0), drawn
RatingContext drawn;
drawn.rand = &rand;
@@ -1077,7 +1077,7 @@ void MatchEngine::side(MatchGroup& g, int m, int& s, int minute, int& own_att, i
const size_t bucket = size_t(std::min(minute, 0x59) / 5);
for (int t : {opp_team, team}) {
const int mgr = state.manager_of(t);
if (mgr >= 0) state.manager_records.at(size_t(mgr) * 0xB0C + 0x1c0 + bucket)++;
if (mgr >= 0) state.manager_records.at(size_t(mgr) * kManagerRecordSize + 0x1c0 + bucket)++;
}
}
@@ -1207,7 +1207,7 @@ void MatchEngine::penalty_shootout(MatchGroup& g, int m, MinuteReport& report) {
const int side = order[k];
const int team = pair[side];
int player = 0xFFF;
if (team < 138 || team == kNoTeam) {
if (team < world_layout().league_teams || team == kNoTeam) {
// a player who has not taken a penalty yet (after 100 tries the list restarts)
int tries = 0;
bool fresh;
+15 -15
View File
@@ -28,13 +28,13 @@ namespace {
constexpr uint8_t kCompetitionClass[24] = {0, 1, 2, 2, 2, 3, 3, 3, 3, 255, 0, 255,
4, 255, 255, 255, 255, 255, 255, 1, 0, 0, 0, 0};
// Clubs per league (LeagueSizes): five leagues of 18, four regional leagues of 12.
// (the clubs per league are kLeagueSizes, schedule.hpp)
// (the clubs per league are league_system().sizes, schedule.hpp)
// Three points for a win in every league (CareerSession_BeginFriendlyOpponentTable_RuntimeField, index 9 = "no league" reads the
// following table byte 18, also non-zero).
constexpr bool kThreePoints[10] = {true, true, true, true, true, true, true, true, true, true};
constexpr size_t kClubRecord = 0x4a;
constexpr size_t kManagerRecord = 0xB0C;
constexpr size_t kBoard = 0x840, kBoardSlot = 0x58;
constexpr size_t kClubRecord = kClubRecordSize;
constexpr size_t kManagerRecord = kManagerRecordSize;
constexpr size_t kBoard = kTacticsBoardSize, kBoardSlot = kTacticsBoardSlotSize;
uint32_t rd32(const std::vector<uint8_t>& v, size_t o) {
return uint32_t(v.at(o) | v.at(o + 1) << 8 | v.at(o + 2) << 16 | uint32_t(v.at(o + 3)) << 24);
@@ -55,7 +55,7 @@ int league_of(int team) {
if (team > 0x164) return 0;
int end = 0;
for (int l = 0; l < 9; l++) {
end += kLeagueSizes[l];
end += league_system().sizes[l];
if (team < end) return l;
}
return 9;
@@ -135,7 +135,7 @@ SportschauFixtureView sportschau_fixture_view(const GameState& state, const Matc
if (team >= 0 && size_t(team) * 2 + 1 < state.club_heap_78.size())
badge_word = uint16_t(state.club_heap_78[size_t(team) * 2] |
uint16_t(state.club_heap_78[size_t(team) * 2 + 1]) << 8);
if (team >= 0 && team < 0xa8) {
if (team >= 0 && team < world_layout().first_foreign_cup()) {
requires_font_fit = true;
if (state.memory.has(::bmh::layout::ClubShortNameOffsets + uint32_t(team))) {
const uint8_t source = state.memory.u8(::bmh::layout::ClubShortNameOffsets + uint32_t(team));
@@ -313,7 +313,7 @@ void update_club_table(GameState& g, int home, int away, int hg, int ag) {
auto add16 = [&](size_t o, int v) { wr16(g.club_table, o, uint16_t(rd16(g.club_table, o) + v)); };
// Only the first league and the regional leagues keep points in this table (the
// condition tests the home club only).
const bool league = home < kLeagueSizes[0] || (home >= 90 && home < 138);
const bool league = home < league_system().sizes[0] || (home >= world_layout().domestic_teams && home < world_layout().league_teams);
const int win_points = kThreePoints[league_of(home)] ? 3 : 2;
if (league) {
add16(H + 0x20, hg);
@@ -415,7 +415,7 @@ void develop_players(GameState& g, const MatchGroup& grp, int m, GameRandom& gam
const int type = grp.desc.at(0);
for (int side = 0; side < 2; side++) {
const int team = grp.fixtures.at(m * 2 + side);
if (!(team < 168 || team == kNoTeam)) continue;
if (!(team < world_layout().first_foreign_cup() || team == kNoTeam)) continue;
const uint8_t cls = (type == 0xb && team == kNoTeam) ? 3 : uint8_t(competition_class(type));
const int manager = g.manager_of(team);
const SquadRange range = squad_range(team);
@@ -597,7 +597,7 @@ bool league_screen_shown(const std::vector<uint8_t>& buttons, int param_1, int p
int table_position(const GameState& g, int team) {
if (team >= 138) return 2;
if (team >= world_layout().league_teams) return 2;
int league = league_of(team);
int rounds = league < int(g.league_rounds.size()) ? g.league_rounds[league] : 0;
if (rounds == 0) return -1;
@@ -672,13 +672,13 @@ void manager_match_record(GameState& g, const MatchGroup& grp, int m, int home_g
rating += int16_t(add);
} else {
int league = league_of(g.manager_teams[k]);
int size = league < 9 ? kLeagueSizes[league] : 0;
int size = league < 9 ? league_system().sizes[league] : 0;
rating += (size - table_position(g, g.manager_teams[k])) * 4;
}
rating = std::clamp(int16_t(rating), int16_t(0), int16_t(200));
rate_manager(g, int(k), rating, 0);
}
if (opp < 0xa8) {
if (opp < world_layout().first_foreign_cup()) {
size_t at = k * 0x690 + size_t(opp) * 10 + (side == 1 ? 5 : 0);
std::copy_backward(g.manager_results.begin() + at, g.manager_results.begin() + at + 4,
g.manager_results.begin() + at + 5);
@@ -710,15 +710,15 @@ static void store_strength_history(GameState& g, int manager) {
}
g.manager_records.at(rec + 0x222 + n) = uint8_t(team_average(g, team, 0xFF).value);
int pos = table_position(g, team);
if (pos == -1) pos = (kLeagueSizes[g.manager_records.at(rec + 0x210)] - 1) >> 1;
if (pos == -1) pos = (league_system().sizes[g.manager_records.at(rec + 0x210)] - 1) >> 1;
g.manager_records.at(rec + 0x248 + n) = uint8_t(pos);
}
void advance_league_rounds(GameState& g, uint32_t competitions, WatcomRandom& rand, MinuteReport& report,
const CompetitionWinnerHook& winner) {
// CalendarFirstLeague / CalendarLeagueCounts: first league and league count of competition bits 0-7
const uint8_t* kFirst = kGroupLeague; // (schedule.hpp: the groups of the loaded game)
const uint8_t* kCount = kGroupLeagues;
const uint8_t* kFirst = league_system().group_first; // (schedule.hpp: the groups of the loaded game)
const uint8_t* kCount = league_system().group_count;
for (int bit = 0; bit < 19; bit++) {
if (!(competitions >> bit & 1)) continue;
if (bit >= 5) {
@@ -762,7 +762,7 @@ void advance_league_rounds(GameState& g, uint32_t competitions, WatcomRandom& ra
if (c + 1 == end && g.league_rounds.at(2) == league_matchdays(2)) {
uint32_t n = 0;
for (int l = 2; l < 4; l++)
for (int team = league_first_team(l); team < league_first_team(l) + kLeagueSizes[l]; team++) {
for (int team = league_first_team(l); team < league_first_team(l) + league_system().sizes[l]; team++) {
const uint8_t pos = uint8_t(table_position(g, team));
if (pos != 0 && pos < 3) g.memory.set16(::bmh::layout::Teams + n++ * 2, uint16_t(team));
}
+25 -27
View File
@@ -30,18 +30,17 @@ namespace bmh {
namespace {
constexpr size_t kManagerRecord = 0xB0C;
constexpr size_t kManagerRecord = kManagerRecordSize;
constexpr size_t kDescriptorSize = 0xD0;
// Competition class per descriptor type (MatchEngineRuntimeField9): which card counters apply.
constexpr uint8_t kCompetitionClass[24] = {0, 1, 2, 2, 2, 3, 3, 3, 3, 255, 0, 255,
4, 255, 255, 255, 255, 255, 255, 1, 0, 0, 0, 0};
// League groups per competition bit 0-4 (CalendarFirstLeague first league, CalendarLeagueCounts count;
// the arrays are indexed with the bit for bits 0-3 and with 4..7 for bit 4).
// (kGroupLeague / kGroupLeagues: schedule.hpp, the calendar groups of the loaded game)
// (league_system().group_first / league_system().group_count: schedule.hpp, the calendar groups of the loaded game)
// Crowd interest per descriptor type (MatchdaySetupRuntimeField).
constexpr uint8_t kTypeInterest[24] = {5, 5, 10, 15, 12, 10, 5, 10, 5, 10, 5, 31, 10, 10, 10, 0, 0, 1, 0, 0, 0, 12, 0, 0};
// Number of clubs taking part in league play (CareerSession_DispatchLineup_RuntimeField).
constexpr int kLeagueClubCount = 0x8a;
// Number of clubs taking part in league play (LeagueClubCount).
// Squad slots checked by the driver (CareerRuntimeField).
constexpr size_t kSquadSlotCount = 0xb70;
@@ -288,7 +287,7 @@ bool schedule_replay(GameState& g, int day, int league, int m, int slot, int rou
g.memory.set8(at + 2, uint8_t(round));
g.memory.set8(at + 3, uint8_t(league));
g.memory.set8(at + 4, uint8_t(m));
g.results.at(size_t(m) + size_t(round) * 10 + size_t(league) * 0x17C) = kPostponedMark;
g.results.at(size_t(m) + size_t(round) * 10 + size_t(league) * kLeagueResultsStride) = kPostponedMark;
g.memory.set8(kCalendar + uint32_t(date) * 2 + 1, g.memory.u8(kCalendar + uint32_t(date) * 2 + 1) | 0x40);
return true;
}
@@ -312,8 +311,8 @@ void winter_postponements(GameState& g, int day, int league, GameRandom& game, W
if (count == 0) return;
for (int slot = 0; slot < kPostponedEntries; slot++) {
if (g.memory.u16(kPostponed + uint32_t(slot) * 6) != 0) continue;
const int m = rand.range(0, kLeagueSizes[league] / 2 - 1);
if ((g.results.at(size_t(m) + size_t(round) * 10 + size_t(league) * 0x17C) & 0xcf) == 0xcc &&
const int m = rand.range(0, league_system().sizes[league] / 2 - 1);
if ((g.results.at(size_t(m) + size_t(round) * 10 + size_t(league) * kLeagueResultsStride) & 0xcf) == 0xcc &&
schedule_replay(g, day, league, m, slot, round, game)) {
count--;
break;
@@ -385,7 +384,7 @@ void indoor_tournament_draw(GameState& g, GameRandom& game, WatcomRandom& rand)
if (guest != 0) mem.set16(kTeams, uint16_t(rand.range(90, 137)));
int count = guest != 0;
int n = rand.range(5, 7);
uint8_t lo = 0, hi = uint8_t(kLeagueSizes[0]);
uint8_t lo = 0, hi = uint8_t(league_system().sizes[0]);
uint32_t previous;
do {
for (int s = 0; s < n; s++) {
@@ -415,8 +414,8 @@ void indoor_tournament_draw(GameState& g, GameRandom& game, WatcomRandom& rand)
n = 8 - count;
previous = hi;
lo = hi;
hi = uint8_t(hi + kLeagueSizes[1]);
} while (previous < uint32_t(kLeagueSizes[0] + kLeagueSizes[1]));
hi = uint8_t(hi + league_system().sizes[1]);
} while (previous < uint32_t(league_system().sizes[0] + league_system().sizes[1]));
std::string title;
for (size_t i = 3; i < g.tournament_name.size() && g.tournament_name[i]; i++) title.push_back(char(g.tournament_name[i]));
for (uint32_t k = 0; k < 8; k++) {
@@ -438,7 +437,7 @@ void indoor_tournament_draw(GameState& g, GameRandom& game, WatcomRandom& rand)
for (uint32_t k = 0; k < 8; k++) {
const int t = mem.u16(kTeams + k * 2);
const int league = t > 0x164 ? 0 : team_league(t); // TeamLeague2
if (league < 2) sum += (0x26 - table_position(g, t)) - kLeagueSizes[0] * league;
if (league < 2) sum += (0x26 - table_position(g, t)) - league_system().sizes[0] * league;
else if (league < 5) sum += 1;
else sum += 0x19;
}
@@ -450,14 +449,14 @@ uint32_t day_competitions(const GameState& g, uint16_t entry) {
if (g.memory.u8(::bmh::layout::CalendarState_FormatError_RuntimeField2) != 0) v = entry & 0x7fef;
// (German: the indoor option off removes the indoor days; the English CycleManagerOptions2 has no
// such test - its 0x4002 days are the League Cup)
if (!kEnglishCompetitions && g.memory.u8(::bmh::layout::CalendarState_FormatError_RuntimeField) != 0 && v == 0x4002) v = 0;
if (!league_system().english_competitions && g.memory.u8(::bmh::layout::CalendarState_FormatError_RuntimeField) != 0 && v == 0x4002) v = 0;
if ((v & 0x4001) == 0x4001) v = (v & 0xff0) | 0x8000;
if (v == 0x4002) v = 0x10000;
if (v == 0x4004) v = 0x40000;
if (v == 0x4006) v = (g.memory.u8(::bmh::layout::CompetitionSelection) & 2) ? 0x800000 : 0;
// the international tournament of the year (bits 9-12) turns with the season; the English
// CycleManagerOptions2 counts from 1995 and adds 3 ((season + 3) % 4) to stay in step
if (v & 0x1e00) v &= 1u << (0xc - (g.season + (kEnglishCompetitions ? 3 : 0)) % 4);
if (v & 0x1e00) v &= 1u << (0xc - (g.season + (league_system().english_competitions ? 3 : 0)) % 4);
return v;
}
@@ -511,7 +510,7 @@ bool matchday_needs_manager_desks(const GameState& g, uint16_t calendar_entry,
const uint32_t competition = rd32(group.desc, 0xcc);
for (size_t fixture = 0; fixture < size_t(group.matches()); ++fixture) {
if (competition < 0x14) {
const size_t result = size_t(competition) * 0x17c +
const size_t result = size_t(competition) * kLeagueResultsStride +
size_t(g.league_rounds.at(competition)) * 10 + fixture;
if (g.results.at(result) != 0xcc) continue;
} else if (int8_t(mem.u8(competition + 0x18) + 5) >= 0x1e) {
@@ -568,18 +567,18 @@ std::vector<MatchGroup> setup_matchday(GameState& g, uint32_t competitions, cons
const int from = bit, to = bit < 4 ? bit + 1 : 8;
for (int k = from; k < to; k++) {
// FixturesFromGenerateFixtures(k)
for (int league = kGroupLeague[k]; league < kGroupLeague[k] + kGroupLeagues[k]; league++) {
for (int league = league_system().group_first[k]; league < league_system().group_first[k] + league_system().group_count[k]; league++) {
turn_step = "setup: winter postponements";
winter_postponements(g, ctx.season_day, league, game, rand);
const int round = g.league_rounds.at(size_t(league));
const int size = kLeagueSizes[league];
const int size = league_system().sizes[league];
MatchGroup grp;
grp.desc = group_descriptor(g, groups.size());
for (const Fixture& f : generate_fixtures(league_table_teams(league), round + 1, league_matchdays(league) / 2, league_first_team(league))) {
grp.fixtures.push_back(f.home);
grp.fixtures.push_back(f.away);
}
const size_t at = size_t(league) * 0x17C + size_t(round) * 10;
const size_t at = size_t(league) * kLeagueResultsStride + size_t(round) * 10;
for (int m = 0; m < size / 2; m++) {
uint8_t& r = g.results.at(at + size_t(m));
if ((r & 0xCF) == 0xCE) r = 0xCD; // postponed -> to be replayed later
@@ -613,7 +612,7 @@ std::vector<MatchGroup> setup_matchday(GameState& g, uint32_t competitions, cons
}
}
}
for (int team = 0; team < kLeagueClubCount; team++)
for (int team = 0; team < world_layout().league_teams; team++)
if (g.team_flags.at(size_t(team)) & 1) auto_lineup(g, team, 100);
turn_step = "setup: options";
cycle_manager_options(g);
@@ -664,7 +663,7 @@ int attendance(GameState& g, int home, int away, int bits, int temperature, int
}
}
const int home_manager = g.manager_of(home), away_manager = g.manager_of(away); // local_20, local_14
const size_t rec = size_t(home_manager) * 0xB0C; // EDI / puVar10: the home manager's record
const size_t rec = size_t(home_manager) * kManagerRecordSize; // EDI / puVar10: the home manager's record
auto r8 = [&](size_t off) { return int(g.manager_records.at(rec + off)); };
auto r16 = [&](size_t off) { return int(g.manager_records.at(rec + off) | g.manager_records.at(rec + off + 1) << 8); };
auto r32 = [&](size_t off) { return int32_t(rd32(g.manager_records, rec + off)); };
@@ -852,7 +851,7 @@ int attendance(GameState& g, int home, int away, int bits, int temperature, int
if (away_manager >= 0 && (bits & 0x180)) {
// a shared gate (cups, bits 7/8): the human away club gets the same half and counts
// the match in its attendance statistics (no catering, no records)
const size_t away_rec = size_t(away_manager) * 0xB0C;
const size_t away_rec = size_t(away_manager) * kManagerRecordSize;
auto& m = g.manager_records;
if ((m.at(away_rec + 0x290) | m.at(away_rec + 0x291) << 8) != kNoTeam) {
book_money(g, away_manager, -income, true);
@@ -892,8 +891,7 @@ bool select_live_match(GameState& g, int home, int away) {
// record +0x8ac / 16 + 40.
void man_marking(GameState& g, int own_manager, int own, int other_manager, int other, int chance, int rate,
WatcomRandom& rand) {
constexpr int kLeagueTeams = 138; // CareerSession_DispatchLineup_RuntimeField
if (g.indoor || own >= kLeagueTeams || other >= kLeagueTeams || (own_manager < 0 && other_manager < 0)) return;
if (g.indoor || own >= world_layout().league_teams || other >= world_layout().league_teams || (own_manager < 0 && other_manager < 0)) return;
if (other_manager >= 0)
for (size_t s = 0; s < 24; s++) {
const size_t at = size_t(other_manager) * 0x840 + s * 0x58 + 0x46;
@@ -905,7 +903,7 @@ void man_marking(GameState& g, int own_manager, int own, int other_manager, int
const size_t at = size_t(own_manager) * 0x840 + s * 0x58 + 0x44;
g.tactics.at(at) = 0xFF, g.tactics.at(at + 1) = 0x0F;
}
const size_t rec = size_t(own_manager) * 0xB0C + 0x8ac;
const size_t rec = size_t(own_manager) * kManagerRecordSize + 0x8ac;
rate = uint8_t((int16_t(g.manager_records.at(rec) | g.manager_records.at(rec + 1) << 8) >> 4) + 0x28);
}
bool marking[24] = {}; // local_70: own slots already marking
@@ -1008,7 +1006,7 @@ void kick_off(GameState& g, std::vector<MatchGroup>& groups, const MatchdayConte
grp.cup_results.assign(size_t(n), 0);
} else {
grp.results.assign(size_t(n), 0);
const size_t at = size_t(league) * 0x17C + size_t(g.league_rounds.at(size_t(league))) * 10;
const size_t at = size_t(league) * kLeagueResultsStride + size_t(g.league_rounds.at(size_t(league))) * 10;
for (int m = 0; m < n; m++) {
uint8_t& r = g.results.at(at + size_t(m));
if (r == 0xCC)
@@ -1035,7 +1033,7 @@ void kick_off(GameState& g, std::vector<MatchGroup>& groups, const MatchdayConte
man_marking(g, own_manager, t, other_manager, opponent, 0x32, rate, rand);
}
const TeamAverage fit = team_average(g, t, 0x1f1, &rand);
if ((t < kLeagueClubCount || t == kNoTeam) && (fit.players & 0xFF) < 8) {
if ((t < world_layout().league_teams || t == kNoTeam) && (fit.players & 0xFF) < 8) {
// FinishEvent sets this fixture's local void bit and BuildSideRecords writes
// the awarded 0:2/2:0 score before continuing to the next fixture.
forfeit_side = side;
@@ -1055,7 +1053,7 @@ void kick_off(GameState& g, std::vector<MatchGroup>& groups, const MatchdayConte
const int home_goals = forfeit_side == 0 ? 0 : 2;
const int away_goals = forfeit_side == 0 ? 2 : 0;
if (grp.desc.at(0) == 0) {
const size_t at = size_t(league) * 0x17C +
const size_t at = size_t(league) * kLeagueResultsStride +
size_t(g.league_rounds.at(size_t(league))) * 10 + size_t(m);
const uint8_t score = uint8_t((home_goals << 4) | away_goals);
g.results.at(at) = score;
@@ -1151,7 +1149,7 @@ namespace {
void raw_score(const GameState& g, const MatchGroup& grp, int m, int& home, int& away) {
if (grp.desc.at(0) == 0) {
const int league = int(le32(grp.desc, 0xcc));
const uint8_t r = g.results.at(size_t(league) * 0x17C + size_t(g.league_rounds.at(size_t(league))) * 10 + size_t(m));
const uint8_t r = g.results.at(size_t(league) * kLeagueResultsStride + size_t(g.league_rounds.at(size_t(league))) * 10 + size_t(m));
home = r >> 4, away = r & 0xF;
} else {
const uint16_t r = grp.cup_results.at(size_t(m));
+6 -6
View File
@@ -191,12 +191,12 @@ std::string format_number_wide(const GameState& g, int64_t value, int flags) {
std::string format_amount(const GameState& g, int32_t value) { return format_number(g, value, 0x101); }
void install_message_texts(const LeImage& exe) {
kContractEndsSoonText = exe.cstring(kEnglishCompetitions ? ::bmh::layout::EnglishContractExpiryWarningText : ::bmh::layout::ContractExpiryWarningText);
kMastersQualificationText = kEnglishCompetitions ? "Masters entry confirmed. Your participation bonus has been credited." : exe.cstring(::bmh::layout::MastersQualificationText);
kMastersWinnerText = kEnglishCompetitions ? "Masters title won. Your prize money has been credited." : exe.cstring(::bmh::layout::MastersWinnerText);
kIndoorInvitationText = kEnglishCompetitions ? "Indoor event entry bonus credited for " : exe.cstring(::bmh::layout::IndoorInvitationText);
kChampionshipBonusText = kEnglishCompetitions ? "League title bonus credited." : exe.cstring(::bmh::layout::ChampionshipBonusText);
kFriendlyPayerPrefixText = kEnglishCompetitions ? "Your share: " : exe.cstring(::bmh::layout::NationalFriendlyPayerPrefixText);
kContractEndsSoonText = exe.cstring(league_system().english_competitions ? ::bmh::layout::EnglishContractExpiryWarningText : ::bmh::layout::ContractExpiryWarningText);
kMastersQualificationText = league_system().english_competitions ? "Masters entry confirmed. Your participation bonus has been credited." : exe.cstring(::bmh::layout::MastersQualificationText);
kMastersWinnerText = league_system().english_competitions ? "Masters title won. Your prize money has been credited." : exe.cstring(::bmh::layout::MastersWinnerText);
kIndoorInvitationText = league_system().english_competitions ? "Indoor event entry bonus credited for " : exe.cstring(::bmh::layout::IndoorInvitationText);
kChampionshipBonusText = league_system().english_competitions ? "League title bonus credited." : exe.cstring(::bmh::layout::ChampionshipBonusText);
kFriendlyPayerPrefixText = league_system().english_competitions ? "Your share: " : exe.cstring(::bmh::layout::NationalFriendlyPayerPrefixText);
}
} // namespace bmh
+6 -7
View File
@@ -33,9 +33,9 @@ namespace bmh {
namespace {
constexpr size_t kRecord = 0xB0C; // manager record
constexpr size_t kBoard = 0x840; // tactics board of a manager
constexpr size_t kBoardSlot = 0x58;
constexpr size_t kRecord = kManagerRecordSize; // manager record
constexpr size_t kBoard = kTacticsBoardSize; // tactics board of a manager
constexpr size_t kBoardSlot = kTacticsBoardSlotSize;
constexpr uint32_t kTransferList = ::bmh::layout::EditorList;
constexpr uint32_t kListEntry = 0x58;
constexpr int kPoolFirst = 0xb70; // CareerRuntimeField: the transfer list (40 slots + 4)
@@ -43,7 +43,6 @@ constexpr int kFreeAgents = 0xb9c; // CareerRuntimeField2: free agents (80
constexpr int kForeignAgents = 0xbec; // MonthRuntimeField: foreign free agents (20 slots)
constexpr int kPoolEnd = 0xc00; // LargeSquadClubCount
constexpr int kBigSquadClubs = 90; // TeamsWithSquads
constexpr int kLeagueClubs = 0x8a; // CareerSession_DispatchLineup_RuntimeField
// MonthRuntimeField2: development steps by strength / 10; the ten bytes after it (PlayerCard_PlayerCardMarketValue_RuntimeField)
// are the extra value above 500 points.
@@ -215,7 +214,7 @@ void list_club_player(GameState& g, int first, int last, WatcomRandom& rand, Min
n++;
}
}
int pick = 0x8a; // sVar11
int pick = world_layout().league_teams; // sVar11
int slot = -1; // unaff_EDI: the slot tried last
if (n != 0) {
quicksort_by_key(teams, keys, n);
@@ -237,7 +236,7 @@ void list_club_player(GameState& g, int first, int last, WatcomRandom& rand, Min
}
// (when no club had a fitting player the slot tried last is listed all the same)
}
if (pick < 0x8a) {
if (pick < world_layout().league_teams) {
list_player(g, slot, rand, report);
return;
}
@@ -303,7 +302,7 @@ void new_list_entries(GameState& g, WatcomRandom& rand, MinuteReport& report) {
while (left-- != 0 && !report.unsupported) list_club_player(g, 0, kBigSquadClubs, rand, report);
break;
case 3:
while (left-- != 0 && !report.unsupported) list_club_player(g, kBigSquadClubs, kLeagueClubs, rand, report);
while (left-- != 0 && !report.unsupported) list_club_player(g, kBigSquadClubs, world_layout().league_teams, rand, report);
break;
}
}
+4 -4
View File
@@ -19,9 +19,9 @@ namespace bmh {
namespace {
constexpr size_t kManagerRecord = 0xb0c;
constexpr size_t kBoard = 0x840; // one manager's tactics board (24 x 0x58)
constexpr size_t kBoardSlot = 0x58;
constexpr size_t kManagerRecord = kManagerRecordSize;
constexpr size_t kBoard = kTacticsBoardSize; // one manager's tactics board (24 x 0x58)
constexpr size_t kBoardSlot = kTacticsBoardSlotSize;
constexpr uint32_t kDesktops = ::bmh::layout::Desktops; // desktop layouts, 0x360 per manager slot
constexpr size_t kDesktop = 0x360;
constexpr size_t kPoolSlots = 0xb70; // CareerRuntimeField: the clubs' squads end here
@@ -205,7 +205,7 @@ void national_coach_take_over(GameState& g, int active_manager, uint16_t source_
set_manager_count(g, 1);
swap_manager_slots(g, 4, 0); // SwapManagerSlots(4, 0)
uint8_t* coach = &g.manager_records.at(0);
coach[0x290] = uint8_t(kNoTeam & 0xff), coach[0x291] = uint8_t(kNoTeam >> 8); // CupDraw_FormatError_RuntimeField2 = 0x165
coach[0x290] = uint8_t(kNoTeam & 0xff), coach[0x291] = uint8_t(kNoTeam >> 8); // ManagerRecord0Club = 0x165
coach[0x218] = g.manager_records.at(4 * kManagerRecord + 0x218); // NationalRuntimeField2 = NationalRuntimeField3
g.manager_teams.at(0) = kNoTeam;
auto_lineup(g, kNoTeam, 0xe4); // Int2(0x165, 0xe4)
+1 -1
View File
@@ -54,7 +54,7 @@ void national_coach_take_over(GameState& g, int active_manager, uint16_t source_
// NationalCoachHandBack: with CoachActive set the slots change places again, the number of managers
// is restored from OriginalManagerCount and CoachActive cleared.
void national_coach_hand_back(GameState& g);
// CupDraw_FormatError_RuntimeField2 == 0x165: slot 0 manages the national team.
// ManagerRecord0Club == 0x165: slot 0 manages the national team.
bool national_coach_active(const GameState& g);
// NationalCoachAfterLoad (saving and loading): the savegame holds the slots swapped back with
// CoachActive still 1; afterwards (and so after loading) SwapManagerSlots2 takes over again.
+4 -4
View File
@@ -153,20 +153,20 @@ OtherGamesRow make_row(const GameState& game, int home, int away, uint16_t resul
OtherGamesClubMetadata source_metadata(const GameState& game, int team) {
OtherGamesClubMetadata out;
bool manager_owned = game.manager_of(team) >= 0;
constexpr size_t kNationalOriginalClub = 4 * 0xb0c + 0x290;
constexpr size_t kNationalOriginalClub = 4 * kManagerRecordSize + 0x290;
if (!manager_owned && !game.manager_teams.empty() && game.manager_teams[0] == kNoTeam &&
game.manager_records.size() >= kNationalOriginalClub + 2) {
const int original_club = int(uint16_t(game.manager_records[kNationalOriginalClub] |
uint16_t(game.manager_records[kNationalOriginalClub + 1]) << 8));
manager_owned = original_club == team;
}
if (team >= 168 && !manager_owned) {
const size_t at = size_t(team - 168);
if (team >= world_layout().first_foreign_cup() && !manager_owned) {
const size_t at = size_t(team - world_layout().first_foreign_cup());
if (at >= game.foreign_strength.size()) invalid("missing Source foreign-strength byte");
out.foreign_strength = game.foreign_strength[at];
return out;
}
if (team >= 168 && team != kNoTeam)
if (team >= world_layout().first_foreign_cup() && team != kNoTeam)
invalid("manager-controlled foreign-club row needs live TeamRating W-generator context");
constexpr std::array<uint16_t, 5> kFlags{0x0f1, 0x0f2, 0x0f4, 0x0f8, 0x0ff};
for (size_t i = 0; i < kFlags.size(); ++i)
+1 -1
View File
@@ -16,7 +16,7 @@ namespace bmh {
namespace {
constexpr size_t kRecordSize = 0xb0c;
constexpr size_t kRecordSize = kManagerRecordSize;
constexpr size_t kAttempts = 0x8b6; // five player ids, 0xffff free
constexpr uint32_t kTransferList = ::bmh::layout::EditorList; // 44 rows of 0x58 bytes
constexpr uint32_t kListRow = 0x58;
+10 -11
View File
@@ -18,14 +18,13 @@ namespace bmh {
namespace {
constexpr size_t kRecord = 0xB0C; // manager record
constexpr size_t kBoard = 0x840; // tactics board of a manager
constexpr size_t kBoardSlot = 0x58; // one slot of the board
constexpr size_t kRecord = kManagerRecordSize; // manager record
constexpr size_t kBoard = kTacticsBoardSize; // tactics board of a manager
constexpr size_t kBoardSlot = kTacticsBoardSlotSize; // one slot of the board
// Static league tables of V2.24 (not part of the savegame):
// (European places per league, CareerSession_InstallLeagueSizes_RuntimeField, are kLeagueEurope of the loaded game; league 0 uses 4)
// (the relegation places per league, CareerSession_InstallLeagueSizes_RuntimeField2, are kLeagueRelegation of the loaded game)
constexpr int kLeagueTeams = 138; // CareerSession_DispatchLineup_RuntimeField: clubs in the league system
// (European places per league, LeagueEuropeanPlaces, are league_system().europe of the loaded game; league 0 uses 4)
// (the relegation places per league, LeagueRelegationPlaces, are league_system().relegation of the loaded game)
// Text of a pointer variable of the text table TextPointerTable.
} // namespace
@@ -41,11 +40,11 @@ int table_prediction(GameState& g, int team, int mode, std::array<uint8_t, 24>&
// (Fill would refresh the desk warning flags PredictionRuntimeField.. here; they are
// run-time only and not needed by the game logic.)
const size_t rec = size_t(manager) * kRecord;
const int size = kLeagueSizes[league]; // local_2c
const int size = league_system().sizes[league]; // local_2c
if (size_word) *size_word = size; // (stored as a word, see the header)
if (team >= kLeagueTeams) return 9;
if (team >= world_layout().league_teams) return 9;
const int pos = team - league_first_team(league); // local_24
const int target[3] = {0, league == 0 ? 4 : kLeagueEurope[league], size - kLeagueRelegation[league]};
const int target[3] = {0, league == 0 ? 4 : league_system().europe[league], size - league_system().relegation[league]};
int from = 0; // local_10
if (mode > 3) {
@@ -147,7 +146,7 @@ static uint32_t season_bonus_impl(GameState& g, int manager, int team, int board
if (league == 0 && rank == 0) amount = pay_bonus(g, manager, board_slot, 3, pay);
if (amount == 0 && rank < 5) amount = pay_bonus(g, manager, board_slot, 4, pay);
if (amount == 0 && rank < 10) amount = pay_bonus(g, manager, board_slot, 5, pay);
if (amount == 0 && league < kLeagueCount && rank < kLeagueSizes[league] - kLeagueRelegation[league])
if (amount == 0 && league < kLeagueCount && rank < league_system().sizes[league] - league_system().relegation[league])
amount = pay_bonus(g, manager, board_slot, 6, pay);
return amount;
}
@@ -201,7 +200,7 @@ uint32_t expected_bonus_parked_club_source(GameState& g, int rank, int board_slo
board_slot<0 || board_slot>=24 || g.tactics.size()<5*kBoard)
throw std::invalid_argument("expected_bonus: invalid FindManagerForClub parked club context");
const int team=int(g.manager_records[team_at]) | int(g.manager_records[team_at+1])<<8;
if(team<0 || team>=kLeagueTeams)
if(team<0 || team>=world_layout().league_teams)
throw std::invalid_argument("expected_bonus: parked record4 has no ordinary club");
return expected_bonus_impl(g,4,team,rank,board_slot,player,fitness);
}
+3 -3
View File
@@ -126,7 +126,7 @@ int human_correction(GameState& g, RatingContext& ctx, int manager, int rank, in
} // namespace
int team_rating(GameState& g, int team, const RatingProfile& profile, RatingContext& ctx, int* keeper) {
if (team >= 168 && team != kNoTeam) {
if (team >= world_layout().first_foreign_cup() && team != kNoTeam) {
// Clubs without squad: per group a random value around the level of the club
// (ForeignClubStrength bits 5-7 -> RatingRuntimeField2), +2 if the group's strength bit is set
// (bit 3, 3, 2, 1 for goal, defence, midfield, attack: RatingRuntimeField3) and a style
@@ -135,7 +135,7 @@ int team_rating(GameState& g, int team, const RatingProfile& profile, RatingCont
static const uint8_t kStrongBit[4] = {3, 3, 2, 1};
static const int8_t kStyle[8] = {0, 6, 0, -6, 0, -6, 0, 6};
if (!ctx.rand) throw std::invalid_argument("team_rating: a team without squad needs the Watcom generator");
const uint8_t s = g.foreign_strength.at(size_t(team - 168));
const uint8_t s = g.foreign_strength.at(size_t(team - world_layout().first_foreign_cup()));
int16_t total = 0;
for (int i = 0; i < 4; i++) {
const int level = kLevel[s >> 5];
@@ -151,7 +151,7 @@ int team_rating(GameState& g, int team, const RatingProfile& profile, RatingCont
const int manager = team == kNoTeam ? -1 : g.manager_of(team); // local_5a
int rank = 0; // local_5e
if (manager >= 0) {
const size_t rec = size_t(manager) * 0xB0C;
const size_t rec = size_t(manager) * kManagerRecordSize;
const int league = g.manager_records.at(rec + 0x210);
const int mode = (league < int(g.league_rounds.size()) && g.league_rounds[size_t(league)] > 9) + 1;
std::array<uint8_t, 24> buf;
+2 -2
View File
@@ -54,7 +54,7 @@ void validate(const GameState& state, const std::array<int,2>& teams, int side,
if (range.first+range.count > state.squad_slots.size() || range.count < 11)
throw FormatError("Reality setup: truncated squad");
const int m = manager(state,team);
if (m >= 0 && (state.manager_records.size() < size_t(m)*0xb0c+0xd9 ||
if (m >= 0 && (state.manager_records.size() < size_t(m)*kManagerRecordSize+0xd9 ||
state.tactics.size() < size_t(m+1)*0x840))
throw FormatError("Reality setup: truncated manager/board");
for (const auto& p : positions[size_t(s)])
@@ -110,7 +110,7 @@ void initialize_reality(GameState& state, const std::array<int,2>& teams, int at
for (int option = 0; option < 7; ++option)
setup.tactics[size_t(side)][size_t(option)] = uint8_t(m < 0 ?
rand.range(0,exe.u8(::bmh::layout::RealitySetup_InitializeReality_RuntimeFieldUnsigned+uint32_t(option))) :
state.manager_records.at(size_t(m)*0xb0c+0xd2+size_t(option)));
state.manager_records.at(size_t(m)*kManagerRecordSize+0xd2+size_t(option)));
}
setup.grid.reset_occupancy(); // SizeT2 clears only the two occupancy planes.
for (int pass = 0; pass < 2; ++pass) {
+23
View File
@@ -0,0 +1,23 @@
// SPDX-License-Identifier: GPL-3.0-only
#pragma once
// Sizes of the fixed records of the original game state, in bytes. Until 1.0.12 every file that walks
// these records kept its own copy of the numbers; they are named here once. The values are those of
// the original (the save file is built from these records), so they are constants, not part of the
// world layout: a world with more managers or clubs has more records, not larger ones.
#include <cstddef>
namespace bmh {
// One manager record (five of them: managers 0-3 and the spare record 4 the national coach swaps with).
constexpr size_t kManagerRecordSize = 0xB0C;
// The tactics board inside a manager record: 24 slots of kTacticsBoardSlotSize bytes.
constexpr size_t kTacticsBoardSize = 0x840;
constexpr size_t kTacticsBoardSlotSize = 0x58;
// The league record of a club (*ClubSeasonRecords), one per club with league records.
constexpr size_t kClubRecordSize = 0x4a;
// One league's part of the results block (LeagueResults, schedule.hpp): 38 matchdays x 10 matches,
// whatever the size of the league.
constexpr size_t kLeagueResultsStride = 0x17C;
} // namespace bmh
+8 -8
View File
@@ -30,13 +30,13 @@ constexpr int kWinterBreakFirst = 0x96, kWinterBreakLast = 0xc8;
// target inside 0x15 .. 0x11e.
constexpr int kLastReplayDay = 0x11e, kFirstDayAfter = 0x15;
constexpr uint8_t kRescheduledMark = 0xce; // param_5 = -0x32
constexpr size_t kRecordSize = 0xb0c;
constexpr size_t kRecordSize = kManagerRecordSize;
constexpr size_t kFloodlights = 0x0e; // manager record byte (RescheduleRuntimeField)
// LeagueCalendarBits: calendar bit of a league (the two leagues 2 and 3 share bit 2, the four
// leagues of 12 clubs bit 4; compare kGroupLeague in matchday_setup.cpp).
// (kLeagueBit: schedule.hpp, set from the groups of the loaded game; 0xff = not played)
// leagues of 12 clubs bit 4; compare league_system().group_first in matchday_setup.cpp).
// (league_system().calendar_bit: schedule.hpp, set from the groups of the loaded game; 0xff = not played)
size_t result_at(int league, int round, int match) { return size_t(match) + size_t(round) * 10 + size_t(league) * 0x17c; }
size_t result_at(int league, int round, int match) { return size_t(match) + size_t(round) * 10 + size_t(league) * kLeagueResultsStride; }
bool memory_ok(const GameState& g) {
return g.memory.has(kCalendar + kCalendarDays * 2 - 1) &&
@@ -89,7 +89,7 @@ int team_replay_on(const GameState& g, int day, int team, int league) {
// (bit 15) when it is free (0, 0x4001 or a calendar event 0x1c0), neither it nor its two
// neighbours conflict for the club (the neighbours before it may already be marked), the
// day after it lies in 0x15 .. 0x11e and it is not in the winter break. The national team
// (manager 0 coaching team 0x165) also checks the club of the Bundestrainer, CupDraw_FormatError_RuntimeField3.
// (manager 0 coaching team 0x165) also checks the club of the Bundestrainer, ManagerRecord4Club.
std::vector<uint16_t> marked_calendar(const GameState& g, int team) {
std::vector<uint16_t> cal(kCalendarDays);
for (int d = 0; d < kCalendarDays; d++) cal[size_t(d)] = g.memory.u16(kCalendar + uint32_t(d) * 2);
@@ -102,7 +102,7 @@ std::vector<uint16_t> marked_calendar(const GameState& g, int team) {
bool ok = true;
for (int i = std::max(0, d - 1); i <= std::min(kCalendarDays - 1, d + 1); i++) {
if (day_conflict(g, team, -1, cal[size_t(i)], i)) ok = false;
if (national && day_conflict(g, int16_t(g.memory.u16(::bmh::layout::CupDraw_FormatError_RuntimeField3)), -1, cal[size_t(i)], i)) ok = false;
if (national && day_conflict(g, int16_t(g.memory.u16(::bmh::layout::ManagerRecord4Club)), -1, cal[size_t(i)], i)) ok = false;
}
if (d + 1 > kLastReplayDay || d + 1 < kFirstDayAfter) ok = false;
if (d >= kWinterBreakFirst && d <= kWinterBreakLast) ok = false;
@@ -122,14 +122,14 @@ std::vector<LeagueMatchRef> reschedulable_matches(const GameState& g, int manage
// The screen only reacts to the calendar bit of the club's league for bits 0-3
// (local_34 == bit); CalendarCell derives local_34 as league - (league > 2).
const int screen_bit = league > 2 ? league - 1 : league;
if (screen_bit > 3 || kLeagueBit[league] != screen_bit) return out;
if (screen_bit > 3 || league_system().calendar_bit[league] != screen_bit) return out;
// DaysIntoSeason, the day of the season; its saved copy in g.memory is only the load day
const int today = g.season_day();
const int matchdays = league_matchdays(league);
int round = -1;
for (int day = 0; day < kCalendarDays; day++) {
const uint32_t comps = day_competitions(g, g.memory.u16(kCalendar + uint32_t(day) * 2));
if (kLeagueBit[league] > 7 || !((comps >> kLeagueBit[league]) & 1)) continue;
if (league_system().calendar_bit[league] > 7 || !((comps >> league_system().calendar_bit[league]) & 1)) continue;
++round; // local_58 - 1: the league days up to this one
if (day <= today || round == 0 || round + 2 >= matchdays) continue;
const std::vector<Fixture> fixtures = round_fixtures(league, round);
+2 -2
View File
@@ -153,9 +153,9 @@ Bytes save_header(const GameState& g) {
for (size_t i = 0; i < 11; i++) h.push_back(i < date.size() ? uint8_t(date[i]) : 0);
Bytes list(0xa0, 0);
for (int m = 0; m < managers && m < 4; m++) {
const size_t rec = size_t(m) * 0xb0c;
const size_t rec = size_t(m) * kManagerRecordSize;
const int team = int16_t(g.manager_records.at(rec + 0x290) | g.manager_records.at(rec + 0x291) << 8);
const bool national = team == 0x165;
const bool national = team == kNoTeam;
const size_t at = size_t(m) * 0x28;
list[at] = national ? 0x1e : g.manager_records.at(rec + 0x210); // (0x1e: high byte of the loop word)
list[at + 1] = national ? 1 : 0;
+9 -9
View File
@@ -96,14 +96,14 @@ void install_fixture_tables(const LeImage& exe) {
int league_first_team(int league) {
int first = 0;
for (int l = 0; l < league; l++) first += kLeagueSizes[l];
for (int l = 0; l < league; l++) first += league_system().sizes[l];
return first;
}
int team_league(int team) {
int end = 0;
for (int l = 0; l < kLeagueCount; l++) {
end += kLeagueSizes[l];
end += league_system().sizes[l];
if (team < end) return l;
}
return kLeagueCount;
@@ -128,18 +128,18 @@ std::vector<Fixture> generate_fixtures(int teams, int matchday, int rounds, int
return out;
}
int league_table_teams(int league) { return league < 5 ? kLeagueSizes[0] : kLeagueSizes[5]; }
int league_table_teams(int league) { return league < 5 ? league_system().sizes[0] : league_system().sizes[5]; }
void set_league_sizes(const uint8_t (&sizes)[kLeagueCount]) {
int total = 0;
for (int l = 0; l < kLeagueCount; l++) total += sizes[l];
const auto has_table = [](int teams) { return teams == 20 || teams == 18 || teams == 16 || teams == 12; };
if (total != 138 || !has_table(sizes[0]) || !has_table(sizes[5]))
throw std::invalid_argument("league sizes do not describe 138 league teams with fixture tables");
if (total != world_layout().league_teams || !has_table(sizes[0]) || !has_table(sizes[5]))
throw std::invalid_argument("league sizes do not describe the league teams of the world with fixture tables");
for (int l = 0; l < kLeagueCount; l++)
if (sizes[l] < 2 || sizes[l] > (l < 5 ? sizes[0] : sizes[5]))
throw std::invalid_argument("a league is larger than its fixture table");
for (int l = 0; l < kLeagueCount; l++) kLeagueSizes[l] = sizes[l];
for (int l = 0; l < kLeagueCount; l++) installed_league_system().sizes[l] = sizes[l];
}
void set_league_groups(const uint8_t (&first)[8], const uint8_t (&count)[8]) {
@@ -150,12 +150,12 @@ void set_league_groups(const uint8_t (&first)[8], const uint8_t (&count)[8]) {
// (bits 4-7 are the four international leagues, all on calendar bit 4)
for (int l = first[b]; l < first[b] + count[b]; l++) bit[l] = uint8_t(b < 4 ? b : 4);
}
for (int b = 0; b < 8; b++) kGroupLeague[b] = first[b], kGroupLeagues[b] = count[b];
for (int l = 0; l < kLeagueCount; l++) kLeagueBit[l] = bit[l];
for (int b = 0; b < 8; b++) installed_league_system().group_first[b] = first[b], installed_league_system().group_count[b] = count[b];
for (int l = 0; l < kLeagueCount; l++) installed_league_system().calendar_bit[l] = bit[l];
}
std::vector<Fixture> league_fixtures(int league, int matchday) {
const int teams = kLeagueSizes[league];
const int teams = league_system().sizes[league];
return generate_fixtures(league_table_teams(league), matchday, teams - 1, league_first_team(league));
}
+14 -46
View File
@@ -29,6 +29,9 @@
#include <string>
#include <vector>
#include "game/records.hpp"
#include "game/world_layout.hpp"
namespace bmh {
class LeImage;
@@ -40,55 +43,18 @@ using FixtureTableCache = std::map<int, std::vector<std::string>>;
void set_fixture_tables(FixtureTableCache tables);
void install_fixture_tables(const LeImage& exe);
// Number of teams per league, LeagueSizes of the loaded game: the German versions have 5
// leagues of 18 and 4 of 12; the English Football Limited 20 20 20 20 10 and the same four
// international leagues of 12 (both 138 league teams, so the squad layout is the same).
// The German sizes are the default; set_league_sizes() installs those of the loaded game
// (app::CareerSession does it from the EXE table). One game per process.
constexpr int kLeagueCount = 9;
inline uint8_t kLeagueSizes[kLeagueCount] = {18, 18, 18, 18, 18, 12, 12, 12, 12};
// The league structure of the loaded game (sizes, calendar groups, promotion ladder, cup structure)
// is league_system() of world_layout.hpp. The German sizes are the default; app::CareerSession
// installs those of the loaded game from the EXE tables. One game per process.
//
// Installs the league sizes of the loaded game; throws std::invalid_argument unless they
// add up to 138 (the league teams of every version) and every league has a fixture table (20, 18, 16, 12 or 10 teams).
// add up to the league teams of the world layout (138 in every version) and every league has a
// fixture table (20, 18, 16, 12 or 10 teams).
void set_league_sizes(const uint8_t (&sizes)[kLeagueCount]);
// The calendar groups of the loaded game: competition bits 0-7 play the leagues
// kGroupLeague[bit] .. + kGroupLeagues[bit] - 1 (CalendarFirstLeague / CalendarLeagueCounts), and a league
// plays on calendar bit kLeagueBit[league] (LeagueCalendarBits). German: 3. Liga A and B share
// bit 2; English: every division has its own bit and the 10-team fifth league none (0xff
// in kLeagueBit, not played). Set with the league sizes from the EXE tables.
inline uint8_t kGroupLeague[8] = {0, 1, 2, 4, 5, 6, 7, 8};
inline uint8_t kGroupLeagues[8] = {1, 1, 2, 1, 1, 1, 1, 1};
inline uint8_t kLeagueBit[kLeagueCount] = {0, 1, 2, 2, 3, 4, 4, 4, 4};
// Installs the calendar groups (first league and league count per competition bit) and derives
// the calendar bit of every league from them.
void set_league_groups(const uint8_t (&first)[8], const uint8_t (&count)[8]);
// The promotion ladder of the loaded game (Void / English ClubName), set with
// the league sizes from the EXE tables:
// - kLeagueRelegation[league]: relegation places (CareerSession_InstallLeagueSizes_RuntimeField2; German 3 4 2 2 3, English
// 4 4 4 4 4),
// - kGroupBelow[group] .. + kGroupBelowCount[group] - 1: the league(s) a promotion group
// takes its promoted clubs from (CareerSession_InstallLeagueSizes_RuntimeField5 / CareerSession_InstallLeagueSizes_RuntimeField4; German 1 | 2 | 4 with the
// two Regionalligen in one group, English 1 | 2 | 3),
// - kLeagueSuffix[league]: the letter after a league's name (CareerSession_InstallLeagueSizes_RuntimeField3, two bytes per
// league; German A/B for the Regionalligen, English none),
// - kNewcomerFirst / kNewcomerCount: the clubs the lowest league is refilled from
// (CareerSession_DispatchLineup_RuntimeField / CareerSession_InstallLeagueSizes_RuntimeField6; German the 30 amateur clubs 138-167; the English game
// draws from its 12 further English clubs 138-149 - its later ids have no name - so the
// session counts only named clubs).
inline uint8_t kLeagueRelegation[kLeagueCount] = {3, 4, 2, 2, 3, 0, 0, 0, 0};
// European places per league for the table prediction (CareerSession_InstallLeagueSizes_RuntimeField; German 0 3 2 2 4 - league
// 0 uses 4 in the prediction -, English 0 4 4 4 4)
inline uint8_t kLeagueEurope[kLeagueCount] = {0, 3, 2, 2, 4, 0, 0, 0, 0};
inline uint8_t kGroupBelow[8] = {1, 2, 4, 5, 6, 7, 8, 0};
inline uint8_t kGroupBelowCount[8] = {1, 2, 1, 1, 1, 1, 1, 0};
inline char kLeagueSuffix[kLeagueCount] = {0, 0, 'A', 'B', 0, 0, 0, 0, 0};
inline int kNewcomerFirst = 0x8a, kNewcomerCount = 0x1e;
// The English competition structure (Football Limited): an FA Cup of 68 clubs with a
// qualifying stage (cup entries 0 and 28) and a League Cup (entries 25-27). Its cup memory
// lies partly in blocks of its own (career.hpp, english_competition_blocks). Set with the
// league sizes: a first league of 20 clubs is the English structure.
inline bool kEnglishCompetitions = false;
// First team id of a league (sum of the sizes of all previous leagues).
int league_first_team(int league);
// League of a team id, or kLeagueCount for teams outside league play (TeamLeague2).
@@ -116,7 +82,9 @@ std::vector<Fixture> league_fixtures(int league, int matchday);
std::vector<Fixture> generate_fixtures(int teams, int matchday, int rounds, int first_team);
constexpr uint8_t kNotPlayed = 0xCC;
// (one league's part of the block is kLeagueResultsStride bytes, records.hpp)
constexpr size_t kResultsSize = 0xD5C;
static_assert(kResultsSize == size_t(kLeagueCount) * kLeagueResultsStride, "the results block holds every league");
struct Result {
bool played = false;
@@ -132,7 +100,7 @@ inline Result decode_result(uint8_t v) {
// Index into the results block for a league match.
inline size_t result_index(int league, int matchday, int match) {
return size_t(league) * 0x17C + size_t(matchday - 1) * 10 + size_t(match);
return size_t(league) * kLeagueResultsStride + size_t(matchday - 1) * 10 + size_t(match);
}
} // namespace bmh
+1 -1
View File
@@ -13,7 +13,7 @@
namespace bmh {
namespace {
constexpr size_t kRecord = 0xB0C; // manager record
constexpr size_t kRecord = kManagerRecordSize; // manager record
constexpr uint32_t kTransferList = ::bmh::layout::EditorList;
constexpr uint32_t kListEntry = 0x58;
constexpr int kPoolFirst = 0xb70; // the transfer list lives in the first 40 pool slots
+53 -53
View File
@@ -35,8 +35,8 @@ constexpr uint32_t kTransferList = ::bmh::layout::EditorList; // 44 entries of
constexpr uint32_t kListEntry = 0x58;
constexpr size_t kPoolSlots = 0xb70; // CareerRuntimeField
constexpr uint32_t kOffers = ::bmh::layout::OfferSlots; // OfferSlots: 4 offers, -1 = free
constexpr size_t kBoard = 0x840; // tactics board of a manager
constexpr size_t kBoardSlot = 0x58;
constexpr size_t kBoard = kTacticsBoardSize; // tactics board of a manager
constexpr size_t kBoardSlot = kTacticsBoardSlotSize;
uint32_t board32(const GameState& g, size_t at) {
return uint32_t(g.tactics.at(at) | g.tactics.at(at + 1) << 8 | g.tactics.at(at + 2) << 16) |
@@ -202,7 +202,7 @@ struct Entrants {
// OnTableJust(league, rank, ranks): the club with that final rank (0 if none)
int club_at_rank(int league, int rank, const uint8_t* ranks) {
for (int i = 0; i < kLeagueSizes[league]; i++)
for (int i = 0; i < league_system().sizes[league]; i++)
if (ranks[i] == rank) return league_first_team(league) + i;
return 0;
}
@@ -283,10 +283,10 @@ void observe_initial_international_groups(GameState& g, WatcomRandom& rand, int
for(const Fixture& fixture:generate_fixtures(schedule_teams,event.round+1,rounds,0)) {
for(int position:{fixture.home,fixture.away}) {
const int team=mem.u16(teams+uint32_t(position)*2);
const bool manager_national=mem.has(::bmh::layout::CupDraw_FormatError_RuntimeField2)&&mem.has(::bmh::layout::CupDraw_FormatError_RuntimeField3)&&
mem.u16(::bmh::layout::CupDraw_FormatError_RuntimeField2)==0x165&&mem.u16(::bmh::layout::CupDraw_FormatError_RuntimeField3)==team;
const bool manager_national=mem.has(::bmh::layout::ManagerRecord0Club)&&mem.has(::bmh::layout::ManagerRecord4Club)&&
mem.u16(::bmh::layout::ManagerRecord0Club)==kNoTeam&&mem.u16(::bmh::layout::ManagerRecord4Club)==team;
const bool human_owned=g.manager_of(team)>=0||manager_national;
if(team<168||team==kNoTeam||!human_owned)continue;
if(team<world_layout().first_foreign_cup()||team==kNoTeam||!human_owned)continue;
SeasonCupDrawEvent::GroupAverageSnapshot snapshot;
snapshot.runtime_id=uint16_t(team);
snapshot.values={team_average(g,team,0x0f1,&rand).value,
@@ -325,7 +325,7 @@ void european_setup(GameState& g, GameRandom& game, WatcomRandom& rand, const Se
constexpr uint32_t kField0 = ::bmh::layout::Field0;
if (!mem.has(kField0)) mem.add_block(kField0, 0x30);
const int s = g.season % 4;
const int base = 0xbd + 0x8a + 0x1e; // ClubPlayerDetail_ClubPlayerDetailFromGame_RuntimeField3 + CareerSession_DispatchLineup_RuntimeField + CareerSession_InstallLeagueSizes_RuntimeField6
const int base = world_layout().no_team(); // ForeignCupClubCount + LeagueClubCount + NewcomerClubCount
int n = 1;
std::vector<uint16_t> last;
if (s % 2 == 0) {
@@ -370,12 +370,12 @@ void european_setup(GameState& g, GameRandom& game, WatcomRandom& rand, const Se
if (u == 0) {
// the national cup winner and finalist (+0x22/+0x24): entry 0, in the English
// structure the FA Cup proper, entry 28 (U16: SeasonRuntimeField8/83c)
const uint32_t cup = kEnglishCompetitions ? ::bmh::layout::CupTable + 28 * 0x28 : ::bmh::layout::CupTable;
const uint32_t cup = league_system().english_competitions ? ::bmh::layout::CupTable + 28 * 0x28 : ::bmh::layout::CupTable;
a = mem.u16(cup + 0x22), b = mem.u16(cup + 0x24);
if (mem.has(::bmh::layout::Season_CareerSeasonSetup_RuntimeField7)) mem.set16(::bmh::layout::Season_CareerSeasonSetup_RuntimeField7, uint16_t(a));
} else {
a = rand.range(0, kLeagueSizes[kLeague[u]] - 1);
do b = rand.range(0, kLeagueSizes[kLeague[u]] - 1); while (b == a);
a = rand.range(0, league_system().sizes[kLeague[u]] - 1);
do b = rand.range(0, league_system().sizes[kLeague[u]] - 1); while (b == a);
}
const int first = kLeague[u] == 0 ? 0 : league_first_team(kLeague[u]);
league_entrants(g, kLeague[u], uint8_t(a + first), uint8_t(b + first), kUefa[u]);
@@ -395,7 +395,7 @@ void european_setup(GameState& g, GameRandom& game, WatcomRandom& rand, const Se
void european_fields(GameState& g, GameRandom& game, WatcomRandom& rand) {
StaticMemory& mem = g.memory;
Entrants en{mem};
const int pool = 0x8a + 0x1e; // CareerSession_DispatchLineup_RuntimeField + CareerSession_InstallLeagueSizes_RuntimeField6: the first foreign club
const int pool = world_layout().first_foreign_cup(); // LeagueClubCount + NewcomerClubCount: the first foreign club
auto pick = [&](int from) {
int t;
do t = rand.range(from, from + 6); while (en.find(t) != 0);
@@ -427,14 +427,14 @@ void european_fields(GameState& g, GameRandom& game, WatcomRandom& rand) {
}
int32_t rec32(const GameState& g, int m, size_t o) {
const size_t at = size_t(m) * 0xB0C + o;
const size_t at = size_t(m) * kManagerRecordSize + o;
return int32_t(uint32_t(g.manager_records.at(at) | g.manager_records.at(at + 1) << 8 | g.manager_records.at(at + 2) << 16) |
uint32_t(g.manager_records.at(at + 3)) << 24);
}
void set_rec32(GameState& g, int m, size_t o, int32_t v) {
for (size_t i = 0; i < 4; i++) g.manager_records.at(size_t(m) * 0xB0C + o + i) = uint8_t(uint32_t(v) >> (8 * i));
for (size_t i = 0; i < 4; i++) g.manager_records.at(size_t(m) * kManagerRecordSize + o + i) = uint8_t(uint32_t(v) >> (8 * i));
}
uint8_t& rec8(GameState& g, int m, size_t o) { return g.manager_records.at(size_t(m) * 0xB0C + o); }
uint8_t& rec8(GameState& g, int m, size_t o) { return g.manager_records.at(size_t(m) * kManagerRecordSize + o); }
uint16_t mem_u16(const GameState& g, uint32_t a) { return g.memory.u16(a); }
// HighscoreScore(mask, 0, 0xff): bit 0 the account (+0x314), 1 the deposit (+0x318), 2 the
@@ -512,8 +512,8 @@ void season_tickets(GameState& g, int m, WatcomRandom& rand) {
const int low = std::max(pop - kBase[league], 0);
const int r = rand.range(low, low + 10);
const int sold = ((100 - g.level * 5) * (kTickets[league] + r * 300)) / 100;
g.manager_records.at(size_t(m) * 0xB0C + 0x2ac) = uint8_t(sold);
g.manager_records.at(size_t(m) * 0xB0C + 0x2ad) = uint8_t(sold >> 8);
g.manager_records.at(size_t(m) * kManagerRecordSize + 0x2ac) = uint8_t(sold);
g.manager_records.at(size_t(m) * kManagerRecordSize + 0x2ad) = uint8_t(sold >> 8);
const int32_t income = int32_t(kPrice[league]) * int16_t(sold);
book_money(g, m, -income, true);
set_rec32(g, m, 0x754, rec32(g, m, 0x754) + income);
@@ -768,7 +768,7 @@ void season_accounts(GameState& g, int m, GameRandom& game, WatcomRandom& rand,
// swaps twice for them (no change), once otherwise.
void change_places(GameState& g, int a, int b) {
StaticMemory& mem = g.memory;
if (a >= 0x8a + 0x1e || b >= 0x8a + 0x1e) return;
if (a >= world_layout().first_foreign_cup() || b >= world_layout().first_foreign_cup()) return;
auto swap_bytes = [](std::vector<uint8_t>& v, size_t x, size_t y, size_t n) {
for (size_t i = 0; i < n; i++)
if (x + i < v.size() && y + i < v.size()) std::swap(v[x + i], v[y + i]);
@@ -785,7 +785,7 @@ void change_places(GameState& g, int a, int b) {
else if (v == uint16_t(b)) mem.set16(at + uint32_t(i) * 2, uint16_t(a));
}
};
const bool league_clubs = a < 0x8a && b < 0x8a;
const bool league_clubs = a < world_layout().league_teams && b < world_layout().league_teams;
if (league_clubs)
for (uint32_t k = 0; k < 200; k++) { // loans: seller and buyer
const uint32_t e = mem.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField + k * 4);
@@ -795,7 +795,7 @@ void change_places(GameState& g, int a, int b) {
buyer = buyer == a ? b : buyer == b ? a : buyer;
mem.set32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField + k * 4, (e & 0xfff) | uint32_t(seller) << 12 | uint32_t(buyer) << 22);
}
if (!g.club_table.empty() && a < 0xa8 && b < 0xa8) swap_bytes(g.club_table, size_t(a) * 0x4a, size_t(b) * 0x4a, 0x4a);
if (!g.club_table.empty() && a < world_layout().first_foreign_cup() && b < world_layout().first_foreign_cup()) swap_bytes(g.club_table, size_t(a) * 0x4a, size_t(b) * 0x4a, 0x4a);
swap_statistics_clubs(g, a, b);
std::swap(g.club_ids.at(size_t(a)), g.club_ids.at(size_t(b)));
swap_bytes(g.club_heap_bc, size_t(a) * 2, size_t(b) * 2, 2);
@@ -818,7 +818,7 @@ void change_places(GameState& g, int a, int b) {
replace(::bmh::layout::Career_CompetitionPointersEnglish_ExecutableField19, 0x20);
replace(::bmh::layout::Career_CompetitionPointersEnglish_ExecutableField25, 0x40);
// (the English national cup field: 68 clubs at layout field, InitializeNationalCup(0x44, ...))
if (kEnglishCompetitions) {
if (league_system().english_competitions) {
if (mem.has(kEnglishFaField)) replace(kEnglishFaField, 0x44);
} else {
replace(::bmh::layout::Field, 0x40);
@@ -850,7 +850,7 @@ void change_places(GameState& g, int a, int b) {
void order_cup_ties(GameState& g, int teams, int offset) {
StaticMemory& mem = g.memory;
uint32_t list = mem.pointer(::bmh::layout::CupTable) + uint32_t(offset) * 2;
if (kEnglishCompetitions) {
if (league_system().english_competitions) {
// the Football Limited CupField: the FA Cup stage decides the range - qualifying
// round 1 (48 clubs from 0), round 2 (24 from 48), the proper rounds (entry 28);
// with 0x80 the League Cup (entry 25)
@@ -937,7 +937,7 @@ namespace {
void shuffle_leagues(GameState& g, WatcomRandom& rand) {
int first = 0;
for (int l = 0; l < kLeagueCount; l++) {
const int end = first + kLeagueSizes[l];
const int end = first + league_system().sizes[l];
for (int t = first; t < end; t++) {
int r;
do r = rand.range(first, end - 1); while (uint8_t(r) == uint8_t(t));
@@ -994,12 +994,12 @@ void cup_fields_english(GameState& g, GameRandom& game, const uint8_t (&ranks)[4
};
uint32_t n = 0;
for (int l = 0; l < 4; l++)
for (int i = 0; i < kLeagueSizes[l]; i++) {
for (int i = 0; i < league_system().sizes[l]; i++) {
if (l >= 3 && i >= 8) continue;
const int team = club_at_rank(l, i, ranks[l]);
mem.set16(kEnglishFaField + n++ * 2, uint16_t(team));
if (const int m = g.manager_of(team); m >= 0)
g.manager_records.at(size_t(m) * 0xB0C + 0xda + 1 + size_t(std::min<int>(g.season, 0x31)) * 3) = 1;
g.manager_records.at(size_t(m) * kManagerRecordSize + 0xda + 1 + size_t(std::min<int>(g.season, 0x31)) * 3) = 1;
}
shuffle(kEnglishFaField, 0x14);
shuffle(kEnglishFaQualifyingField, 0x30);
@@ -1012,7 +1012,7 @@ void cup_fields_english(GameState& g, GameRandom& game, const uint8_t (&ranks)[4
}
n = 0;
for (int l = 0; l < 3; l++)
for (int i = 0; i < kLeagueSizes[l]; i++) {
for (int i = 0; i < league_system().sizes[l]; i++) {
if (l >= 2 && i >= 4) continue;
mem.set16(kEnglishLeagueCupField + n++ * 2, uint16_t(club_at_rank(l, i, ranks[l])));
}
@@ -1029,19 +1029,19 @@ void cup_field(GameState& g, GameRandom& game, const std::function<void(const ch
const LeagueTable t = compute_league_table(g, l, 0, league_matchdays(l), 7, 1);
for (int i = 0; i < t.size; i++) ranks[l][i] = uint8_t(t.rank(i));
}
if (kEnglishCompetitions) {
if (league_system().english_competitions) {
cup_fields_english(g, game, ranks, pause, cup_draw);
return;
}
constexpr uint32_t kField = ::bmh::layout::Field;
uint32_t n = 0;
for (int l = 0; l < 4; l++)
for (int i = 0; i < kLeagueSizes[l]; i++) {
for (int i = 0; i < league_system().sizes[l]; i++) {
if (l >= 2 && i >= 0xe) continue;
const int team = club_at_rank(l, i, ranks[l]);
mem.set16(kField + n++ * 2, uint16_t(team));
if (const int m = g.manager_of(team); m >= 0)
g.manager_records.at(size_t(m) * 0xB0C + 0xda + 1 + size_t(std::min<int>(g.season, 0x31)) * 3) = 1;
g.manager_records.at(size_t(m) * kManagerRecordSize + 0xda + 1 + size_t(std::min<int>(g.season, 0x31)) * 3) = 1;
}
for (uint32_t i = 0; i < 0x40; i++) { // PrepareEvent
const uint32_t j = uint32_t(game.range(0, 0x3f));
@@ -1202,8 +1202,8 @@ void season_players(GameState& g, GameRandom& game, WatcomRandom& rand, MinuteRe
bool gone = true;
if (owner != -1) {
std::string text;
const int doctor = int16_t(g.manager_records.at(size_t(owner) * 0xB0C + 0x8ae) |
g.manager_records.at(size_t(owner) * 0xB0C + 0x8af) << 8);
const int doctor = int16_t(g.manager_records.at(size_t(owner) * kManagerRecordSize + 0x8ae) |
g.manager_records.at(size_t(owner) * kManagerRecordSize + 0x8af) << 8);
if (doctor > rand.range(700, 0x4b0)) {
text = message_text(g, ::bmh::layout::Season_SeasonPlayers_TextPointer) + g.player_name(player) + message_text(g, ::bmh::layout::Season_SeasonPlayers_TextPointer2);
gone = false;
@@ -1358,8 +1358,8 @@ void licence_withdrawals(GameState& g, int league, std::vector<uint16_t>& down,
const int first = league_first_team(league);
for (size_t m = 0; m < g.manager_teams.size(); m++) {
const int team = g.manager_teams[m];
if (team < first || team >= first + kLeagueSizes[league] || ranks[team - first] <= 5) continue;
static const uint8_t kDownPlaces[kLeagueCount] = {3, 4, 2, 2, 3, 0, 0, 0, 0}; // CareerSession_InstallLeagueSizes_RuntimeField2
if (team < first || team >= first + league_system().sizes[league] || ranks[team - first] <= 5) continue;
static const uint8_t kDownPlaces[kLeagueCount] = {3, 4, 2, 2, 3, 0, 0, 0, 0}; // LeagueRelegationPlaces
if (kDownPlaces[league] == 0) continue;
const uint8_t cut = rec8(g, int(m), 0x220);
const int32_t total = int32_t(rec8(g, int(m), 0x26f)) * 80000 + (assets(g, int(m), 0xf) - assets(g, int(m), 0x10));
@@ -1375,7 +1375,7 @@ void licence_withdrawals(GameState& g, int league, std::vector<uint16_t>& down,
int t = 0, r = 0;
do {
do {
r = rand.range(0, kLeagueSizes[league] - 1);
r = rand.range(0, league_system().sizes[league] - 1);
t = first + r;
} while (g.manager_of(t) >= 0);
} while (ranks[r] < 10 || ranks[r] > 15);
@@ -1407,22 +1407,22 @@ void promotion(GameState& g, GameRandom& game, WatcomRandom& rand, MinuteReport&
}
// The league ladder is data of the loaded game (schedule.hpp, installed from the EXE):
// Void reads the German tables, the English ClubName its own copies -
// first league / number of leagues of each promotion group (kGroupLeague/s), relegation
// places (kLeagueRelegation), the league(s) below (kGroupBelow/Count). German:
// first league / number of leagues of each promotion group (league_system().group_first/s), relegation
// places (league_system().relegation), the league(s) below (league_system().below_first/Count). German:
// 0 | 1 | 2+3 (Regionalliga A/B) | 4; English: 0 | 1 | 2 | 3.
const uint8_t* kFirst = kGroupLeague;
const uint8_t* kCount = kGroupLeagues;
const uint8_t* kDown = kLeagueRelegation;
const uint8_t* kBelow = kGroupBelow;
const uint8_t* kBelowCount = kGroupBelowCount;
// The clubs that refill the lowest league: kNewcomerCount clubs from kNewcomerFirst
const uint8_t* kFirst = league_system().group_first;
const uint8_t* kCount = league_system().group_count;
const uint8_t* kDown = league_system().relegation;
const uint8_t* kBelow = league_system().below_first;
const uint8_t* kBelowCount = league_system().below_count;
// The clubs that refill the lowest league: league_system().newcomer_count clubs from league_system().newcomer_first
// (German: the 30 amateur clubs 138-167). The English game draws from its 12 further
// English clubs (ClubName: range(CareerSession_DispatchLineup_RuntimeField, CareerSession_DispatchLineup_RuntimeField + 11)); its later ids have no name.
// English clubs (ClubName: range(LeagueClubCount, LeagueClubCount + 11)); its later ids have no name.
// The span ends at the last named club, which keeps the German draws unchanged.
// (OpenBMH deviates from the English original here: its extra coin flip per draw is not
// ported.)
const int newcomer_first = kNewcomerFirst;
int newcomer_count = kNewcomerCount;
const int newcomer_first = league_system().newcomer_first;
int newcomer_count = league_system().newcomer_count;
while (newcomer_count > 1) {
const std::string name = g.club_name(newcomer_first + newcomer_count - 1);
if (club_has_name(name)) break;
@@ -1433,7 +1433,7 @@ void promotion(GameState& g, GameRandom& game, WatcomRandom& rand, MinuteReport&
for (int l = kFirst[grp]; l < kFirst[grp] + kCount[grp]; l++) {
int places = kDown[l];
licence_withdrawals(g, l, down, places, ranks[l], game, rand);
for (int rank = kLeagueSizes[l] - 1; places != 0; rank--) {
for (int rank = league_system().sizes[l] - 1; places != 0; rank--) {
const int team = club_at_rank(l, rank, ranks[l]);
if (std::find(down.begin(), down.end(), uint16_t(team)) == down.end()) down.push_back(uint16_t(team)), places--;
}
@@ -1509,12 +1509,12 @@ void promotion(GameState& g, GameRandom& game, WatcomRandom& rand, MinuteReport&
} // namespace
// LeagueName(buf, league): the name of a league (< 5): the texts from Achievements_FormatError_TextPointer3 on - a
// league whose suffix letter (CareerSession_InstallLeagueSizes_RuntimeField3, two bytes per league) is set shares the text of
// league whose suffix letter (LeagueNameSuffixes, two bytes per league) is set shares the text of
// the one before when its letter is from 'B' on (LeagueName2) - with " " + the letter.
std::string league_name(const GameState& g, int league) {
// CareerSession_InstallLeagueSizes_RuntimeField3 of the loaded game (schedule.hpp: German A/B for the two Regionalligen,
// LeagueNameSuffixes of the loaded game (schedule.hpp: German A/B for the two Regionalligen,
// English none - its four divisions are one ladder)
const char* kSuffix = kLeagueSuffix;
const char* kSuffix = league_system().suffix;
int index = 0;
for (int l = 0; l < league; l++)
if (uint8_t(kSuffix[l + 1]) < 0x42) index++;
@@ -1537,7 +1537,7 @@ int best_scorer_team(GameState& g, int league, int flags) {
for (int i = 0; i < 40; i += 4) list[size_t(i)] = 0xfff, list[size_t(i) + 1] = 0xfff;
int16_t best[10] = {};
const int first = league_first_team(league);
for (int team = first; team < first + kLeagueSizes[league]; team++) {
for (int team = first; team < first + league_system().sizes[league]; team++) {
if (g.manager_of(team) < 0 && (flags & 1)) continue;
const SquadRange range = squad_range(team);
for (size_t s = range.first; s < range.first + range.count; s++) {
@@ -1570,7 +1570,7 @@ int best_scorer_team(GameState& g, int league, int flags) {
// club's card counter DeskRecords_Teams_RuntimeField) and 1 per yellow, sorted ascending (Games).
// Returns the club with the fewest points.
int fair_play_team(const GameState& g, int league) {
const int first = league_first_team(league), count = kLeagueSizes[league];
const int first = league_first_team(league), count = league_system().sizes[league];
std::vector<int16_t> teams(static_cast<size_t>(count));
std::vector<uint32_t> points(static_cast<size_t>(count));
for (int i = 0; i < count; i++) {
@@ -1673,17 +1673,17 @@ bool career_season_setup(GameState& g, GameRandom& game, WatcomRandom& rand, Min
const SeasonCupDrawHook& cup_draw) {
StaticMemory& mem = g.memory;
g.team_morale.at(0x165) |= 0x80;
for (int team = 0; team < 0x8a; team++) {
for (int team = 0; team < world_layout().league_teams; team++) {
club_balance(g, team, rand);
auto_lineup(g, team, g.manager_of(team) >= 0 ? 0xe4 : 100); // (byte 100 - 0x80 for humans)
}
// the title holders of the cup entries (+0x22): none yet, the placeholder clubs
const uint16_t first_small = 90; // TeamsWithSquads
const uint16_t foreign = 189 + 138 + 30; // ClubPlayerDetail_ClubPlayerDetailFromGame_RuntimeField3 + CareerSession_DispatchLineup_RuntimeField + CareerSession_InstallLeagueSizes_RuntimeField6 (0x165)
const uint16_t foreign = uint16_t(world_layout().no_team()); // ForeignCupClubCount + LeagueClubCount + NewcomerClubCount (0x165)
mem.set16(::bmh::layout::Season_CareerSeasonSetup_RuntimeField2, foreign);
mem.set16(::bmh::layout::Season_CareerSeasonSetup_RuntimeField6, uint16_t(first_small + 7));
mem.set16(::bmh::layout::Season_CareerSeasonSetup_RuntimeField, 7);
if (kEnglishCompetitions) mem.set16(::bmh::layout::CupTable + 28 * 0x28 + 0x22, 7); // (EN: the FA Cup proper, SeasonRuntimeField8)
if (league_system().english_competitions) mem.set16(::bmh::layout::CupTable + 28 * 0x28 + 0x22, 7); // (EN: the FA Cup proper, SeasonRuntimeField8)
mem.set16(::bmh::layout::Season_CareerSeasonSetup_RuntimeField5, uint16_t(first_small + 0x1f));
mem.set16(::bmh::layout::Season_CareerSeasonSetup_RuntimeField4, uint16_t(first_small + 0x13));
mem.set16(::bmh::layout::Season_CareerSeasonSetup_RuntimeField3, uint16_t(foreign + 1));
+1 -1
View File
@@ -76,7 +76,7 @@ std::optional<SportschauAwardsView> finish_sportschau_awards(GameState& state,
for (size_t i = 0; i < 11; ++i) {
const int manager = state.manager_of(slot_team(group.desc.at(0x70 + i)));
if (manager >= 0) {
auto& counter = state.manager_records.at(size_t(manager) * 0xb0c + 0x21e);
auto& counter = state.manager_records.at(size_t(manager) * kManagerRecordSize + 0x21e);
counter = uint8_t(counter + 1);
}
}
+1 -1
View File
@@ -15,7 +15,7 @@ namespace bmh {
SportschauRatingTables sportschau_rating_tables(const LeImage& exe) {
SportschauRatingTables t;
t.domestic_teams = exe.u16(::bmh::layout::CareerSession_DispatchLineup_RuntimeField);
t.domestic_teams = exe.u16(::bmh::layout::LeagueClubCount);
for (size_t i = 0; i < 4; ++i) {
const auto offset = uint32_t(i);
t.position_limit[i] = std::bit_cast<int8_t>(exe.u8(::bmh::layout::SportschauRating_SportschauRatingTables_RuntimeField + offset));
+8 -13
View File
@@ -14,7 +14,7 @@
namespace bmh {
namespace {
constexpr size_t kRecordSize = 0xb0c;
constexpr size_t kRecordSize = kManagerRecordSize;
constexpr size_t kManagerClub = 0x290;
constexpr size_t kBuild = 0x34;
constexpr size_t kFlags = 0x44;
@@ -70,25 +70,20 @@ bool valid_resolved_offer(const StandBlockOffer& offer, const StadiumBlockExpans
} // namespace
StadiumBlockExpansionConstants stadium_block_expansion_constants(const LeImage& image) {
// OpenBMH deviates from the original: allow 144,000 standard places and
// size-aware construction times while retaining edition-owned unit prices.
static constexpr std::array<uint32_t, 8> minima{
14000, 24000, 14000, 20000, 14000, 24000, 14000, 20000};
// The limits, prices and construction periods of the edition, unchanged: Diamond 3.7 allows
// 8/18/8/14 thousand places per block (A-D and E-H), 96,000 in total. Versions 1.0.3 to 1.0.12
// raised the limits to 144,000; that is withdrawn, because the match broadcast of the original
// has no room for attendances of 100,000 and more and showed them wrongly.
StadiumBlockExpansionConstants out;
uint32_t total = 0;
for (size_t i = 0; i < minima.size(); ++i) {
for (size_t i = 0; i < out.max_places.size(); ++i) {
out.price_per_1000[i] = image.u32(
layout::CareerSession_DispatchStadium_RuntimeField + uint32_t((i + 8) * 4));
const auto original = uint32_t(image.u8(
out.max_places[i] = uint32_t(image.u8(
layout::CareerSession_Invalid_RuntimeField + uint32_t(i))) * 1000;
out.max_places[i] = std::max(original, minima[i]);
total += out.max_places[i];
const auto source_weeks = image.u8(
out.weeks[i] = image.u8(
layout::CareerSession_DispatchStadium_RuntimeField2 + uint32_t((i + 22) * 5));
const auto weeks = std::max<uint32_t>(source_weeks, 2 * (out.max_places[i] / 1000));
if (weeks > 255)
throw FormatError("stadium: expanded construction period exceeds saved byte");
out.weeks[i] = uint8_t(weeks);
}
if (total > 255000)
throw FormatError("stadium: combined stand limits exceed saved capacity byte");
+3 -2
View File
@@ -23,8 +23,9 @@ struct StadiumBlockExpansionConstants {
std::array<uint32_t, 8> max_places{};
};
// OpenBMH1.0.3 expands standard A-H limits to at least144k total. Prices
// still come from the edition; larger blocks have at least2weeks per1000places.
// The edition's limits (thousands of places per block A-H), unit prices and construction weeks,
// exactly as supplied: Diamond 3.7 gives 8/18/8/14 twice = 96,000 places. (1.0.3 to 1.0.12 raised
// the limits to 144,000; withdrawn in 1.0.13, see stadium_blocks.cpp.)
StadiumBlockExpansionConstants stadium_block_expansion_constants(const LeImage&);
// An immutable quote binds the Source owner and every record/table value that
+10 -10
View File
@@ -1,7 +1,7 @@
// SPDX-License-Identifier: GPL-3.0-only
// GameState construction and accessors: building the state from a loaded save and the database
// counts, manager of a team, club and player names, formation and formation positions.
// Squad table layout constants are defined here. Draws no random numbers.
// The squad table comes from the world layout (world_layout.hpp). Draws no random numbers.
// Interface in state.hpp; every other file in this directory works on GameState.
#include "formats/executable_layout.hpp"
#include "game/state.hpp"
@@ -10,16 +10,12 @@
#include <stdexcept>
#include "game/rating.hpp"
#include "game/world_layout.hpp"
namespace bmh {
namespace {
// Squad table layout constants of V2.24 (TeamsWithSquads, LargeSquadClubCount, NoTeamSquadStart).
constexpr int kBigSquadTeams = 90;
constexpr size_t kNoTeamSquadStart = 3072;
constexpr int kTeamsWithSquads = 168;
// C-style signed division by 8 as compiled by Watcom (rounds toward zero).
int div8(int x) { return x / 8; }
@@ -172,14 +168,18 @@ void GameState::formation_position(int team, int slot, int& x, int& y) const {
}
SquadRange squad_range(int team) {
if (team == kNoTeam) return {kNoTeamSquadStart, 24};
if (team < kBigSquadTeams) return {size_t(team) * 24, 24};
if (team < 138) return {size_t(team) * 16 + kBigSquadTeams * 8, 16};
// The squad table of the world layout (world_layout.hpp). Classic: 24 slots for the 90 domestic clubs, 16 for
// the 48 international ones from slot 2160, 24 for kNoTeam at 3072.
const WorldLayout& w = world_layout();
if (team == w.no_team()) return {w.pool_end, w.no_team_slots};
// (a negative id is no team: the table arithmetic of the original gives a range far outside the slots)
if (team < 0) return {size_t(team) * 24, 24};
if (team < w.league_teams) return {w.squad_start[size_t(team)], w.squad_size[size_t(team)]};
return {0, 0};
}
TeamAverage team_average(const GameState& g, int team, uint16_t flags, WatcomRandom* rand) {
if (team >= kTeamsWithSquads && team != kNoTeam) {
if (team >= world_layout().first_foreign_cup() && team != world_layout().no_team()) {
// TeamRating(team, profile 2 at layout field): a random value around the club's level
if (!rand) throw std::invalid_argument("team_average: a team without squad needs the Watcom generator");
RatingContext ctx;
+3 -1
View File
@@ -14,6 +14,8 @@
#include "formats/m3d.hpp"
#include "formats/savestate.hpp"
#include "game/records.hpp"
#include "game/world_layout.hpp"
#include "formats/textd.hpp"
#include "game/memory.hpp"
#include "game/random.hpp"
@@ -51,7 +53,7 @@ struct GameState {
// Block Formations = contents of M3.DAT: formation tables, 2 sets (outdoor, indoor) of
// 0xB0 bytes = 8 formations x (11 x positions, 11 y positions). The engine uses 4.
std::vector<uint8_t> formations;
// Team id managed by each human manager (manager record +0x290, CupDraw_FormatError_RuntimeField2), one entry
// Team id managed by each human manager (manager record +0x290, ManagerRecord0Club), one entry
// per human manager (ManagerCount).
std::vector<int> manager_teams;
bool indoor = false; // OpenBMH deviates from the original: retains designated set-piece selections in the supported manager-record extension.
+4 -4
View File
@@ -77,12 +77,12 @@ void sort_table(LeagueTable& t, int parts) {
}
int league_matchdays(int league) { return kLeagueSizes[league] * 2 - 2; }
int league_matchdays(int league) { return league_system().sizes[league] * 2 - 2; }
LeagueTable compute_league_table(const GameState& g, int league, int from, int to, int flags, int points_mode) {
LeagueTable t;
t.league = league;
t.size = kLeagueSizes[league];
t.size = league_system().sizes[league];
int parts = 0;
if (points_mode & 0xE) {
parts = points_mode >> 1;
@@ -94,7 +94,7 @@ LeagueTable compute_league_table(const GameState& g, int league, int from, int t
for (int c = 0; c < t.size; c++) {
int manager = g.manager_of(first_team + c);
if (manager < 0) continue;
uint8_t d = g.manager_records.at(size_t(manager) * 0xB0C + 0x220);
uint8_t d = g.manager_records.at(size_t(manager) * kManagerRecordSize + 0x220);
if (d >> 5 == 3) t.points[c] = int8_t(t.points[c] - (d & 0x1F));
}
flags &= ~4;
@@ -111,7 +111,7 @@ LeagueTable compute_league_table(const GameState& g, int league, int from, int t
std::vector<Fixture> fx = generate_fixtures(league_table_teams(league), r + 1, matchdays / 2, first_team);
bool counted = false;
for (size_t i = 0; i < fx.size(); i++) {
uint8_t b = g.results.at(size_t(league) * 0x17C + size_t(r) * 10 + i);
uint8_t b = g.results.at(size_t(league) * kLeagueResultsStride + size_t(r) * 10 + i);
int club[2] = {fx[i].home - first_team, fx[i].away - first_team};
if ((b & 0xCC) == 0xCC) {
if (b == 0xCD)
+2 -3
View File
@@ -14,7 +14,6 @@
namespace bmh::game {
namespace {
constexpr size_t kManagerRecordSize = 0xb0c;
constexpr size_t kNationalBackupManager = 4;
constexpr size_t kManagerTeamOffset = 0x290;
@@ -79,8 +78,8 @@ TopScorersProjection top_scorers_from_game(const GameState& g, int manager_slot,
invalid("manager team is outside Source's nine domestic leagues");
const int first_team = league_first_team(league);
const int team_count = kLeagueSizes[league];
if (first_team < 0 || first_team + team_count > 138 ||
const int team_count = league_system().sizes[league];
if (first_team < 0 || first_team + team_count > world_layout().league_teams ||
g.club_ids.size() < size_t(first_team + team_count) || g.club_names.empty())
invalid("incomplete domestic club table");
+1 -1
View File
@@ -202,7 +202,7 @@ void finish_event(GameState& g, std::vector<MatchGroup>& groups, uint16_t calend
if (id < 0x15) {
if (league_screen_shown(buttons, 1, 90, int(id))) stir_random(game, rand);
const int round = g.league_rounds.at(id);
for (int m = 0; m < grp.matches(); m++) g.results.at(size_t(id) * 0x17C + size_t(round) * 10 + size_t(m)) = grp.results.at(size_t(m));
for (int m = 0; m < grp.matches(); m++) g.results.at(size_t(id) * kLeagueResultsStride + size_t(round) * 10 + size_t(m)) = grp.results.at(size_t(m));
} else {
store_cup_results(g, grp);
}
+3 -3
View File
@@ -20,7 +20,7 @@ namespace bmh {
namespace {
constexpr size_t kManagerRecord = 0xB0C;
constexpr size_t kManagerRecord = kManagerRecordSize;
int32_t rd32(const std::vector<uint8_t>& v, size_t o) {
return int32_t(uint32_t(v.at(o)) | uint32_t(v.at(o + 1)) << 8 | uint32_t(v.at(o + 2)) << 16 | uint32_t(v.at(o + 3)) << 24);
@@ -150,7 +150,7 @@ void familiarity_decay(GameState& g, GameRandom& game, WatcomRandom& rand) {
}
void train_squad(GameState& g, int manager, GameRandom& game, WatcomRandom& rand) {
const size_t rec = size_t(manager) * 0xB0C;
const size_t rec = size_t(manager) * kManagerRecordSize;
uint8_t table[4][9];
for (int pos = 0; pos < 4; pos++)
for (int a = 0; a < 9; a++)
@@ -247,7 +247,7 @@ void auto_training(GameState& g, int manager) {
uint8_t& option = g.manager_options.at(size_t(manager) * 5 + 4); // CareerSessionRuntimeField3
if (!(option & 0x80)) option = 0x9f;
const uint8_t flags = (option & 1) ? option : 0; // local_14
const size_t rec = size_t(manager) * 0xB0C;
const size_t rec = size_t(manager) * kManagerRecordSize;
const int team = int16_t(rd16w(g.manager_records, rec + 0x290));
uint8_t plan[13];
for (int i = 0; i < 13; i++) plan[i] = g.manager_records.at(rec + 0xc5 + size_t(i));
+22 -23
View File
@@ -34,13 +34,12 @@ namespace bmh {
namespace {
constexpr size_t kRecord = 0xB0C; // manager record
constexpr size_t kBoard = 0x840; // tactics board of a manager
constexpr size_t kBoardSlot = 0x58;
constexpr size_t kRecord = kManagerRecordSize; // manager record
constexpr size_t kBoard = kTacticsBoardSize; // tactics board of a manager
constexpr size_t kBoardSlot = kTacticsBoardSlotSize;
constexpr uint32_t kTransferList = ::bmh::layout::EditorList; // 44 entries of 0x58 bytes, one per pool slot
constexpr uint32_t kListEntry = 0x58;
constexpr size_t kPoolSlots = 0xb70; // CareerRuntimeField: first squad slot of the transfer pool
constexpr int kLeagueClubs = 0x8a; // CareerSession_DispatchLineup_RuntimeField
constexpr int kBigSquadClubs = 90; // TeamsWithSquads
// Offers and incidents (Bool): 1 in WeeklyRuntimeField[kind] is only possible while the
@@ -121,9 +120,9 @@ bool source_pending_owner_valid(const GameState& g,const SourcePendingOwner& own
!mem.has(::bmh::layout::OfferSlots+uint32_t(entry-40)*4+3))return false;
const auto team=[&](int manager){const size_t at=size_t(manager)*kRecord+0x290;
return int(g.manager_records[at]) | int(g.manager_records[at+1])<<8;};
if(team(0)!=kNoTeam || team(4)<0 || team(4)>=kLeagueClubs ||
if(team(0)!=kNoTeam || team(4)<0 || team(4)>=world_layout().league_teams ||
team(owner.manager)!=owner.team ||
(owner.manager==0 ? owner.team!=kNoTeam : owner.team<0 || owner.team>=kLeagueClubs))return false;
(owner.manager==0 ? owner.team!=kNoTeam : owner.team<0 || owner.team>=world_layout().league_teams))return false;
const uint32_t list=kTransferList+uint32_t(entry)*kListEntry;
if(!mem.has(list+kListEntry-1) || mem.u16(list+2)!=0xffff ||
mem.u16(list+4)!=0xffff || mem.u16(list+6)!=0xffff)return false;
@@ -582,7 +581,7 @@ void transfer_bid(GameState& g, int slot, uint32_t list, bool high, int months,
std::vector<uint32_t> keys;
std::vector<int> needs;
int region = 0; // local_20 (not reset between the clubs)
for (int team = 0; team < kLeagueClubs; team++) {
for (int team = 0; team < world_layout().league_teams; team++) {
if (team == own || g.manager_of(team) >= 0) continue;
if (team >= kBigSquadClubs) region = team_region(team) & 0xFF;
if (own >= 0 && g.manager_of(own) >= 0 && list != 0 && (w35c >> 27) != 0 && game.range(0, 0xf) != 0) continue;
@@ -867,7 +866,7 @@ TransferBidRating rate_transfer_bid_source(GameState& g, const TransferBidRating
const int bidder = int(int16_t(g.memory.u16(list + uint32_t(request.bid_slot) * 2)));
if (player == 0x0fff || size_t(player) >= g.players.size() ||
player != request.expected_player || bidder != request.expected_bidder ||
bidder < 0 || bidder >= kLeagueClubs)
bidder < 0 || bidder >= world_layout().league_teams)
return fail("source player/bidder identity mismatch");
uint32_t fee_base = 0, salary_base = 0;
offer_bases(g.memory, list, request.bid_slot, fee_base, salary_base);
@@ -955,7 +954,7 @@ TransferBidRating rate_transfer_bid_source(GameState& g, const TransferBidRating
static void lineup_after_transfer_impl(GameState& g, int team, bool native_takeover) {
if (pending_native_manager_of(g,team,native_takeover)==4)
auto_lineup_parked_club_source(g,team,100);
else if (team < kLeagueClubs || team == kNoTeam) auto_lineup(g, team, 100);
else if (team < world_layout().league_teams || team == kNoTeam) auto_lineup(g, team, 100);
}
void lineup_after_transfer(GameState& g, int team) { lineup_after_transfer_impl(g,team,false); }
@@ -1156,7 +1155,7 @@ bool preflight_human_owner_loan(const GameState& g, int seller, size_t pool_slot
report.fail("transfer: Source free-agent loan return destination is not represented");
return false;
}
if (buyer < 0 || buyer >= kLeagueClubs) {
if (buyer < 0 || buyer >= world_layout().league_teams) {
report.fail("transfer: loan buyer has no squad");
return false;
}
@@ -1334,7 +1333,7 @@ bool decide_bids(GameState& g, int k, GameRandom& game, WatcomRandom& rand, Minu
const int bidder_manager = g.manager_of(bidder);
if (bidder_manager >= 0) {
const int32_t fee = int32_t(mem.u32(list + 0x1c + uint32_t(bid) * 4));
const size_t rec = size_t(bidder_manager) * 0xb0c;
const size_t rec = size_t(bidder_manager) * kManagerRecordSize;
const int32_t balance = int32_t(uint32_t(g.manager_records.at(rec + 0x314)) |
uint32_t(g.manager_records.at(rec + 0x315)) << 8 | uint32_t(g.manager_records.at(rec + 0x316)) << 16 |
uint32_t(g.manager_records.at(rec + 0x317)) << 24);
@@ -1685,7 +1684,7 @@ static TransferOfferListView project_transfer_offer_list_impl(const GameState& g
}
// Only club IDs have a squad range in the source transfer path. Keep
// malformed IDs visible for diagnosis but never use them as indexes.
const SquadRange range = buyer >= 0 && buyer < kLeagueClubs ? squad_range(buyer) : SquadRange{};
const SquadRange range = buyer >= 0 && buyer < world_layout().league_teams ? squad_range(buyer) : SquadRange{};
offer.has_squad_room = range.count != 0 && squad_count(g, buyer, 3) < int(range.count) - 1;
offer.passes_foreign_limit = range.count != 0;
if (view.seller_manager < 0 && range.count != 0) {
@@ -1872,7 +1871,7 @@ PendingSettleOutcome pending_settle(GameState& g, int raw, int player, int bid,
const int movement_seller = pending_native_manager_of(g, seller, native_takeover);
const int buyer = int16_t(mem.u16(list+uint32_t(bid)*2));
const int buyer_manager = pending_native_manager_of(g, buyer, native_takeover);
if (seller_manager < 0 || seller_manager >= 4 || buyer < 0 || buyer >= kLeagueClubs) {
if (seller_manager < 0 || seller_manager >= 4 || buyer < 0 || buyer >= world_layout().league_teams) {
report.fail("DispatchClubPlayerPendingOffers: invalid seller/buyer for Void2"); return PendingSettleOutcome::unsupported;
}
const uint8_t term = mem.u8(list+0x34+uint32_t(bid));
@@ -1884,7 +1883,7 @@ PendingSettleOutcome pending_settle(GameState& g, int raw, int player, int bid,
return PendingSettleOutcome::unsupported;
}
if (buyer_manager >= 0) {
const auto buyer_range = buyer >= 0 && buyer < kLeagueClubs ? squad_range(buyer) : SquadRange{};
const auto buyer_range = buyer >= 0 && buyer < world_layout().league_teams ? squad_range(buyer) : SquadRange{};
if (buyer_range.count != 24) {
report.fail("DispatchClubPlayerPendingOffers: human buyer uses unsupported non-24-slot squad layout");
return PendingSettleOutcome::unsupported;
@@ -2112,8 +2111,8 @@ HumanBuyerSaleResult settle_human_buyer_sale(GameState& g, const HumanBuyerSaleR
const bool free_agent = seller == 0x0fff;
if (player == 0x0fff || size_t(player) >= g.players.size() ||
seller != request.expected_seller || buyer != request.expected_buyer ||
(!free_agent && (seller < 0 || seller >= kLeagueClubs)) ||
buyer < 0 || buyer >= kLeagueClubs || seller == buyer)
(!free_agent && (seller < 0 || seller >= world_layout().league_teams)) ||
buyer < 0 || buyer >= world_layout().league_teams || seller == buyer)
return fail("SettleHumanBuyerSale/Fail: source player/seller/buyer identity mismatch");
// SettleHumanBuyerSale uses param8 for the seller's accounts; Fail separately
// resolves actual movement ownership through FindManagerForClub.
@@ -2387,7 +2386,7 @@ PendingOfferResult process_pending_batch(GameState& g, int clicked_player, int c
const int expected_seller=owner->team==kNoTeam
? int(g.manager_records.at(4*kRecord+0x290)) |
(int(g.manager_records.at(4*kRecord+0x291))<<8) : owner->team;
if(seller<0 || seller>=kLeagueClubs || seller!=expected_seller ||
if(seller<0 || seller>=world_layout().league_teams || seller!=expected_seller ||
(g.squad_slots.at(kPoolSlots+size_t(raw+40))&0x0fff)!=player) {
report.fail("DispatchClubPlayerPendingOffers: invalid special offer seller/pool provenance (PreMatchOffer requires a club seller)");
return result;
@@ -2512,7 +2511,7 @@ PendingOfferResult process_natural_pending_offers_after_desk(GameState& g,
// Records1..3 survive the count-one national takeover. AdvanceTurn reads
// these records directly even while their clubs have no current desk.
if ((takeover && manager<count && g.manager_teams[size_t(manager)]!=native_team) ||
(native_team!=kNoTeam && (native_team<0 || native_team>=kLeagueClubs)) ||
(native_team!=kNoTeam && (native_team<0 || native_team>=world_layout().league_teams)) ||
(native_team==kNoTeam && (!takeover || manager!=0)))
return fail("AdvanceTurn: invalid native ordered owner team");
const auto inactive_club_offer = [&](int raw, int player) {
@@ -2532,7 +2531,7 @@ PendingOfferResult process_natural_pending_offers_after_desk(GameState& g,
};
if (record_team(0)!=kNoTeam) return false;
const int club=record_team(4*kRecord);
if (club<0 || club>=138) return false;
if (club<0 || club>=world_layout().league_teams) return false;
const auto squad=squad_range(club);
if (squad.first+squad.count>g.squad_slots.size()) return false;
for (size_t i=squad.first;i<squad.first+squad.count;++i)
@@ -2546,7 +2545,7 @@ PendingOfferResult process_natural_pending_offers_after_desk(GameState& g,
if(offer==0xffffffffu || int(offer&31)!=manager)continue;
const int team=native_team;
const bool national_owner = takeover && team == kNoTeam;
if (team<0 || (team>=138 && !national_owner))
if (team<0 || (team>=world_layout().league_teams && !national_owner))
return fail("AdvanceTurn: national or unknown owner is unsupported for normal-club offers");
// AdvanceTurn scans raw offer words until the first owned player resolves in
// an ordinary squad. A missing earlier player requires PresentLoanReturn's error
@@ -2710,8 +2709,8 @@ void transfer_list_countdown(GameState& g, GameRandom& game, WatcomRandom& rand,
// FindManagerForClub also recognizes the coach's temporarily saved
// club as owner 4 while manager 0 runs the national team.
return g.manager_of(club) >= 0 || (!g.manager_teams.empty() &&
g.manager_teams[0] == 0x165 && mem.has(::bmh::layout::DeskActions_NationalOpponentManager_RuntimeField) &&
int(mem.u16(::bmh::layout::CupDraw_FormatError_RuntimeField3)) == club);
g.manager_teams[0] == kNoTeam && mem.has(::bmh::layout::DeskActions_NationalOpponentManager_RuntimeField) &&
int(mem.u16(::bmh::layout::ManagerRecord4Club)) == club);
};
bool human_involved = human_participant(seller);
for (int bid = 0; bid < 4 && !human_involved; ++bid) {
@@ -3026,7 +3025,7 @@ bool pre_match_offer(GameState& g, int manager, GameRandom& game, WatcomRandom&
message_text(g, ::bmh::layout::Weekly_PreMatchOffer_TextPointer7) +
// German: "<amount> KAUFEN" (with WeeklyRuntimeField11 " "); the English MessageText puts
// the verb first: "BUY him for <amount>"
(kEnglishCompetitions ? verb + amount : amount + " " + verb) + message_text(g, ::bmh::layout::Weekly_PreMatchOffer_TextPointer10);
(league_system().english_competitions ? verb + amount : amount + " " + verb) + message_text(g, ::bmh::layout::Weekly_PreMatchOffer_TextPointer10);
}
// SystemIdentity shows it, PostMessage posts it
post_composed(g, manager, text);
+58
View File
@@ -0,0 +1,58 @@
// SPDX-License-Identifier: GPL-3.0-only
// WorldLayout: see world_layout.hpp.
#include "game/world_layout.hpp"
#include <stdexcept>
#include <utility>
namespace bmh {
namespace {
WorldLayout& current() {
static WorldLayout layout = classic_world_layout();
return layout;
}
} // namespace
WorldLayout classic_world_layout() {
// Squad table of the original (TeamsWithSquads, LargeSquadClubCount, NoTeamSquadStart): the 90
// domestic clubs have 24 slots each, the 48 international clubs 16 each from slot 90 * 24.
WorldLayout w;
w.squad_start.resize(size_t(w.league_teams));
w.squad_size.resize(size_t(w.league_teams));
for (int team = 0; team < w.league_teams; ++team) {
const bool domestic = team < w.domestic_teams;
w.squad_start[size_t(team)] = domestic ? uint32_t(team) * 24 : uint32_t(team) * 16 + uint32_t(w.domestic_teams) * 8;
w.squad_size[size_t(team)] = domestic ? 24 : 16;
}
return w;
}
const WorldLayout& world_layout() { return current(); }
void set_world_layout(WorldLayout layout) {
const size_t teams = size_t(layout.league_teams);
if (layout.league_teams <= 0 || layout.domestic_teams < 0 || layout.domestic_teams > layout.league_teams ||
layout.amateur_teams < 0 || layout.foreign_cup_teams < 0 || layout.national_teams < 1 ||
layout.squad_start.size() != teams || layout.squad_size.size() != teams)
throw std::invalid_argument("world layout: inconsistent team ranges");
// Squads lie back to back in id order before the pools; the pools and the squad of "no club"
// follow in their fixed order.
uint32_t next = 0;
for (size_t team = 0; team < teams; ++team) {
if (layout.squad_start[team] != next || layout.squad_size[team] == 0)
throw std::invalid_argument("world layout: squads must be consecutive");
next += layout.squad_size[team];
}
if (layout.transfer_list != next || layout.free_agents != layout.transfer_list + 44 ||
layout.foreign_offers != layout.free_agents + 80 || layout.pool_end != layout.foreign_offers + 20 ||
layout.total_slots < layout.pool_end + layout.no_team_slots)
throw std::invalid_argument("world layout: pools must follow the squads");
// Squad slot values hold 12-bit player ids; loans store 10-bit club ids.
if (layout.total_teams() > 1023) throw std::invalid_argument("world layout: too many teams");
current() = std::move(layout);
}
} // namespace bmh
+123
View File
@@ -0,0 +1,123 @@
// SPDX-License-Identifier: GPL-3.0-only
#pragma once
// The dimensions of a game world: team id ranges and the squad slot table.
//
// The original game fixes them (and so does every supported edition, German and English):
// ids 0..137 the 138 league clubs: 90 clubs of the five domestic leagues with 24 squad slots,
// 48 clubs of the four international leagues with 16
// ids 138..167 30 amateur clubs (cup newcomers), without squads
// ids 168..356 189 foreign cup clubs without squads (a strength byte each)
// id 357 the pseudo team "no club" (kNoTeam, 0x165): national team / player pool, 24 slots
// ids 358..418 61 national teams
// and behind the squads the three player pools (transfer list, free agents, offers from abroad).
//
// Until 1.0.12 these numbers stood as literals all over the engine (138, 168, 0x165, 90 * 24, ...).
// WorldLayout names them in one place. OpenBMH Classic never installs another layout:
// classic_world_layout() returns exactly the original numbers, so every function that asks the
// layout computes what it computed before. A later edition with more leagues (OpenBMH Extended)
// installs its own layout instead of patching literals.
//
// One game per process, like the league tables of schedule.hpp.
#include <cstddef>
#include <cstdint>
#include <vector>
namespace bmh {
struct WorldLayout {
// Team id ranges, in this order: league clubs, amateur clubs, squadless foreign cup clubs,
// the pseudo team "no club", national teams.
int league_teams = 138; // ids 0 .. league_teams-1 have squads
int domestic_teams = 90; // the first league clubs (the five domestic leagues)
int amateur_teams = 30; // ids league_teams .. +amateur_teams-1, no squads
int foreign_cup_teams = 189; // squadless foreign clubs (27 nations x 7)
int national_teams = 62; // "no club" (the first of them) and the 61 national teams
// Squad slot table: first slot and slot count per league club, then the pools.
std::vector<uint32_t> squad_start; // per league club
std::vector<uint8_t> squad_size; // per league club
uint32_t transfer_list = 0xB70; // 44 slots: players on the transfer list
uint32_t free_agents = 0xB9C; // 80 slots: players without a club
uint32_t foreign_offers = 0xBEC; // 20 slots: players offered from abroad
uint32_t pool_end = 0xC00; // end of the pools = first slot of "no club"
uint32_t no_team_slots = 24; // the squad of "no club"
uint32_t total_slots = 3150; // including the reserve behind "no club"
int first_amateur() const { return league_teams; }
// The first team without a squad of its own that is a foreign cup club (Classic: 168); the
// clubs before it are "the clubs with league records" (league clubs + amateurs).
int first_foreign_cup() const { return league_teams + amateur_teams; }
int no_team() const { return first_foreign_cup() + foreign_cup_teams; }
int total_teams() const { return no_team() + national_teams; }
bool has_squad(int team) const { return (team >= 0 && team < league_teams) || team == no_team(); }
};
// The original dimensions (V2.24 and the supported German and English editions).
WorldLayout classic_world_layout();
// The layout of the running game (Classic unless another one was installed).
const WorldLayout& world_layout();
// Installs a layout; throws std::invalid_argument when its ranges or its slot table are inconsistent.
void set_world_layout(WorldLayout layout);
// The league structure of a game world: sizes, calendar groups, promotion ladder, cup structure.
//
// The German versions have 5 leagues of 18 and 4 of 12; the English Football Limited 20 20 20 20 10
// and the same four international leagues of 12 (both 138 league teams, so the squad layout is the
// same). Until 1.0.12 these tables were separate mutable globals of schedule.hpp (kLeagueSizes,
// kGroupLeague, ...). The values and every use are unchanged; the German ones are the default.
//
// Still fixed (open for an edition with more leagues): the number of leagues (kLeagueCount, the size
// of several tables of the save file), eight calendar groups, and the results block of schedule.hpp.
constexpr int kLeagueCount = 9;
struct LeagueSystem {
// Number of teams per league (LeagueSizes of the loaded game). Leagues are contiguous id ranges.
uint8_t sizes[kLeagueCount] = {18, 18, 18, 18, 18, 12, 12, 12, 12};
// The calendar groups: competition bits 0-7 play the leagues group_first[bit] .. + group_count[bit] - 1
// (CalendarFirstLeague / CalendarLeagueCounts), and a league plays on calendar bit calendar_bit[league]
// (LeagueCalendarBits). German: 3. Liga A and B share bit 2; English: every division has its own
// bit and the 10-team fifth league none (0xff in calendar_bit, not played).
uint8_t group_first[8] = {0, 1, 2, 4, 5, 6, 7, 8};
uint8_t group_count[8] = {1, 1, 2, 1, 1, 1, 1, 1};
uint8_t calendar_bit[kLeagueCount] = {0, 1, 2, 2, 3, 4, 4, 4, 4};
// The promotion ladder (Void / English ClubName):
// - relegation[league]: relegation places (LeagueRelegationPlaces; German 3 4 2 2 3,
// English 4 4 4 4 4),
// - below_first[group] .. + below_count[group] - 1: the league(s) a promotion group takes its promoted
// clubs from (PromotionGroupBelowLeagues / PromotionGroupBelowCounts;
// German 1 | 2 | 4 with the two Regionalligen in one group, English 1 | 2 | 3),
// - suffix[league]: the letter after a league's name (LeagueNameSuffixes, two
// bytes per league; German A/B for the Regionalligen, English none),
// - newcomer_first / newcomer_count: the clubs the lowest league is refilled from
// (LeagueClubCount / NewcomerClubCount; German the 30
// amateur clubs 138-167; the English game draws from its 12 further English clubs 138-149 - its later
// ids have no name - so the session counts only named clubs).
uint8_t relegation[kLeagueCount] = {3, 4, 2, 2, 3, 0, 0, 0, 0};
// European places per league for the table prediction (LeagueEuropeanPlaces;
// German 0 3 2 2 4 - league 0 uses 4 in the prediction -, English 0 4 4 4 4)
uint8_t europe[kLeagueCount] = {0, 3, 2, 2, 4, 0, 0, 0, 0};
uint8_t below_first[8] = {1, 2, 4, 5, 6, 7, 8, 0};
uint8_t below_count[8] = {1, 2, 1, 1, 1, 1, 1, 0};
char suffix[kLeagueCount] = {0, 0, 'A', 'B', 0, 0, 0, 0, 0};
int newcomer_first = 0x8a, newcomer_count = 0x1e;
// The English competition structure (Football Limited): an FA Cup of 68 clubs with a qualifying
// stage (cup entries 0 and 28) and a League Cup (entries 25-27). Its cup memory lies partly in
// blocks of its own (career.hpp, english_competition_blocks). A first league of 20 clubs is the
// English structure.
bool english_competitions = false;
};
// The league structure of the running game. Read through league_system(); the installer of a game
// version (app::CareerSession, set_league_sizes / set_league_groups of schedule.hpp) writes through
// installed_league_system(). One game per process.
inline LeagueSystem g_league_system;
inline const LeagueSystem& league_system() { return g_league_system; }
inline LeagueSystem& installed_league_system() { return g_league_system; }
} // namespace bmh
+1 -1
View File
@@ -6,7 +6,7 @@
// M3D.MAN. prepare_english_game() turns an English installation into such a data directory,
// once, in the launcher cache:
// - TEXTE.BLK -> TEXTD.BLK and M3E.MAN -> M3D.MAN (same formats, the text slots are the
// same variables; docs/formats/TEXTD_INVENTORY.md),
// same variables; docs/formats/TEXTD.md),
// - FLTD.EXE -> "BMH.exe" in the OpenBMH image format (formats/le.hpp): an image in the
// German address space. Every German data object the engine reads is filled from its
// English counterpart (src/launch/fltd_map.inc, generated by runtime verification), German
+6 -6
View File
@@ -159,10 +159,10 @@
{::bmh::layout::CareerSession_BeginFriendlyOpponentTable_RuntimeField, 9, Kind::copy, ::bmh::layout::EnglishLayoutTranslation257, {}},
{::bmh::layout::LeagueSizes, 1, Kind::copy, ::bmh::layout::EnglishLayoutTranslation258, {}},
{::bmh::layout::LeaguePairings_LeaguePairingsConstants_RuntimeField, 3, Kind::copy, ::bmh::layout::EnglishLayoutTranslation259, {}},
{::bmh::layout::CareerSession_InstallLeagueSizes_RuntimeField, 9, Kind::copy, ::bmh::layout::EnglishLayoutTranslation260, {}},
{::bmh::layout::CareerSession_InstallLeagueSizes_RuntimeField2, 9, Kind::copy, ::bmh::layout::EnglishLayoutTranslation261, {}},
{::bmh::layout::LeagueEuropeanPlaces, 9, Kind::copy, ::bmh::layout::EnglishLayoutTranslation260, {}},
{::bmh::layout::LeagueRelegationPlaces, 9, Kind::copy, ::bmh::layout::EnglishLayoutTranslation261, {}},
{::bmh::layout::DeskDrawers_Curve_RuntimeField, 5, Kind::copy, ::bmh::layout::EnglishLayoutTranslation262, {}},
{::bmh::layout::CareerSession_InstallLeagueSizes_RuntimeField3, 2, Kind::copy, ::bmh::layout::EnglishLayoutTranslation264, {}},
{::bmh::layout::LeagueNameSuffixes, 2, Kind::copy, ::bmh::layout::EnglishLayoutTranslation264, {}},
{::bmh::layout::Manager_FormatError_RuntimeField, 8, Kind::copy, ::bmh::layout::EnglishLayoutTranslation263, {}},
{::bmh::layout::CalendarLeagueCounts, 1, Kind::copy, ::bmh::layout::EnglishLayoutTranslation265, {}},
{::bmh::layout::LeaguePairings_SelectorEvent_RuntimeField, 4, Kind::copy, ::bmh::layout::EnglishLayoutTranslation266, {}},
@@ -171,9 +171,9 @@
{::bmh::layout::GermanLayoutTranslation2, 8, Kind::copy, ::bmh::layout::EnglishLayoutTranslation269, {}},
{::bmh::layout::GermanLayoutTranslation3, 2, Kind::copy, ::bmh::layout::EnglishLayoutTranslation270, {}},
{::bmh::layout::TeamsWithSquads, 2, Kind::copy, ::bmh::layout::EnglishLayoutTranslation271, {}},
{::bmh::layout::CareerSession_DispatchLineup_RuntimeField, 4, Kind::copy, ::bmh::layout::EnglishLayoutTranslation272, {}},
{::bmh::layout::CareerSession_InstallLeagueSizes_RuntimeField6, 2, Kind::copy, ::bmh::layout::EnglishLayoutTranslation273, {}},
{::bmh::layout::ClubPlayerDetail_ClubPlayerDetailFromGame_RuntimeField3, 2, Kind::copy, ::bmh::layout::EnglishLayoutTranslation274, {}},
{::bmh::layout::LeagueClubCount, 4, Kind::copy, ::bmh::layout::EnglishLayoutTranslation272, {}},
{::bmh::layout::NewcomerClubCount, 2, Kind::copy, ::bmh::layout::EnglishLayoutTranslation273, {}},
{::bmh::layout::ForeignCupClubCount, 2, Kind::copy, ::bmh::layout::EnglishLayoutTranslation274, {}},
{::bmh::layout::NoTeamSquadStart, 6, Kind::copy, ::bmh::layout::EnglishLayoutTranslation275, {}},
{::bmh::layout::CareerSession_DataDirectory_RuntimeField, 4, Kind::copy, ::bmh::layout::EnglishLayoutTranslation276, {}},
{::bmh::layout::CareerSession_DataDirectory_RuntimeField2, 12, Kind::copy, ::bmh::layout::EnglishLayoutTranslation277, {}},
+13
View File
@@ -0,0 +1,13 @@
// SPDX-License-Identifier: GPL-3.0-only
#pragma once
// The check of the test programs: a failed expectation ends the test with its message (the main
// function of a test prints the message and returns 1). Until 1.0.12 every test file had its own copy.
#include <stdexcept>
namespace bmh::test_support {
inline void check(bool ok, const char* message) {
if (!ok) throw std::runtime_error(message);
}
} // namespace bmh::test_support
+3 -3
View File
@@ -15,6 +15,7 @@
#include "game/schedule.hpp"
#include "ui/manager.hpp"
#include "ui/setup.hpp"
#include "ui/draw.hpp"
namespace bmh::ui {
namespace {
@@ -32,8 +33,7 @@ void fill(Image& out, int x, int y, int w, int h, uint8_t color) {
}
void copy(Image& out,const Image& source,int sx,int sy,int x,int y,int w,int h,int transparent=-1) {
if(sx<0||sy<0||sx+w>source.width||sy+h>source.height)throw FormatError("achievements: Source KB56 bounds");
for(int yy=0;yy<h;++yy)for(int xx=0;xx<w;++xx){const uint8_t c=source.pixels[size_t(sy+yy)*size_t(source.width)+size_t(sx+xx)];
if(c!=transparent&&x+xx>=0&&y+yy>=0&&x+xx<out.width&&y+yy<out.height)out.at(x+xx,y+yy)=c;}
draw::copy_clipped(out, source, sx, sy, x, y, w, h, transparent);
}
uint16_t rd16(const std::vector<uint8_t>& b,size_t at){return uint16_t(b.at(at))|uint16_t(uint16_t(b.at(at+1))<<8);}
// FNT files consume the game's single-byte encoding; only JSON/test boundaries use UTF-8.
@@ -56,7 +56,7 @@ AchievementsState achievements_from_game(const GameState& game,const LeImage& ex
size_t(owner.manager_slot)>=game.manager_teams.size()||owner.revision==UINT64_MAX||
underlay.width!=320||underlay.height!=240||!game.texts)
throw FormatError("achievements: invalid Source desk owner");
const size_t base=size_t(owner.manager_slot)*0xb0c;
const size_t base=size_t(owner.manager_slot)*kManagerRecordSize;
if(base+0x556>game.manager_records.size())throw FormatError("achievements: truncated Source manager history");
AchievementsState out;out.owner=owner;out.manager_slot=owner.manager_slot;out.underlay=underlay;
out.season_count=std::clamp(game.season+1,1,50);out.selected_season=out.season_count-1;
+2 -1
View File
@@ -1,5 +1,6 @@
// Tests for the achievements projection and screen (ui/achievements.hpp).
#include "../../tests/test_inputs.hpp"
#include "testing/check.hpp"
// SPDX-License-Identifier: GPL-3.0-only
#include "formats/executable_layout.hpp"
#include "ui/achievements.hpp"
@@ -12,7 +13,7 @@
#include "game/messages.hpp"
namespace {
void check(bool ok, const char* why) { if (!ok) throw std::runtime_error(why); }
using bmh::test_support::check;
}
int main(int argc, char** argv) {
+5 -8
View File
@@ -27,10 +27,11 @@
#include "game/state.hpp"
#include "ui/manager.hpp"
#include "ui/setup.hpp"
#include "ui/draw.hpp"
namespace bmh::ui {
namespace {
constexpr size_t kManagerRecord = 0xb0c;
constexpr size_t kManagerRecord = kManagerRecordSize;
constexpr size_t kAdvertisingContracts = 0xa34;
constexpr size_t kContractBytes = 0x0c;
constexpr int kBoardCount = 14;
@@ -200,7 +201,7 @@ AdvertisingFinancePreview original_finance_preview_impl(const GameState& game, i
int32_t(game.manager_records.at(rec + 0x2e + size_t(i)) & 7) * kFacilityCost[size_t(i)]);
expenses = wrap_add(expenses, signed32(u32(game.manager_records, rec + 0x854)));
expenses = wrap_add(expenses, signed32(u32(game.manager_records, rec + 0x858)));
constexpr size_t kBoard = 0x840, kBoardSlot = 0x58;
constexpr size_t kBoard = kTacticsBoardSize, kBoardSlot = kTacticsBoardSlotSize;
for (size_t slot = 0; slot < 24; ++slot) {
const size_t board = size_t(manager) * kBoard + slot * kBoardSlot;
if (game.tactics.at(board + 0x3d) == 0xff) continue;
@@ -270,17 +271,13 @@ void copy(Image& out, const Image& src, int sx, int sy, int x, int y, int w, int
if (sx < 0 || sy < 0 || sx + w > src.width || sy + h > src.height ||
x < 0 || y < 0 || x + w > out.width || y + h > out.height)
throw FormatError("advertising: original VGA crop outside image");
for (int yy = 0; yy < h; ++yy)
for (int xx = 0; xx < w; ++xx)
out.at(x + xx, y + yy) = src.pixels[size_t(sy + yy) * src.width + sx + xx];
draw::copy_unclipped(out, src, sx, sy, x, y, w, h, -1);
}
void fill_rect(Image& image, int x, int y, int width, int height, uint8_t color) {
if (x < 0 || y < 0 || width < 0 || height < 0 || x + width > image.width || y + height > image.height)
throw FormatError("advertising: rectangle outside image");
for (int yy = y; yy < y + height; ++yy)
for (int xx = x; xx < x + width; ++xx)
image.at(xx, yy) = color;
draw::fill(image, x, y, width, height, color);
}
void rectangle(Image& image, int x, int y, int width, int height, uint8_t color) {
+2 -3
View File
@@ -19,14 +19,13 @@
#include "game/state.hpp"
#include "ui/manager.hpp"
#include "ui/setup.hpp"
#include "testing/check.hpp"
using namespace bmh;
using namespace bmh::ui;
namespace {
void check(bool ok, const char* message) {
if (!ok) throw std::runtime_error(message);
}
using bmh::test_support::check;
void rejected(const std::function<void()>& action) {
try { action(); } catch (const FormatError&) { return; }
throw std::runtime_error("expected invalid advertising projection rejection");
+8 -3
View File
@@ -8,11 +8,16 @@
#include "game/table.hpp"
#include "ui/manager.hpp"
#include "ui/setup.hpp"
#include "ui/draw.hpp"
namespace bmh::ui { namespace {
constexpr uint32_t kFirst=::bmh::layout::First, kLeague=::bmh::layout::AlltimeTable_Layout_ExecutableField;
std::string original_text(const TextDb& t,uint32_t at){if(at<::bmh::layout::TextPointerTable||((at-::bmh::layout::TextPointerTable)&3U))throw FormatError("alltime: invalid TEXTD address");return original_to_utf8(t[(at-::bmh::layout::TextPointerTable)/4]);}
void fill(Image&o,int x,int y,int w,int h,uint8_t c){for(int j=0;j<h;++j)for(int i=0;i<w;++i)o.at(x+i,y+j)=c;}
void copy(Image&o,const Image&s,int sx,int sy,int x,int y,int w,int h,int tr=-1){if(sx<0||sy<0||x<0||y<0||sx+w>s.width||sy+h>s.height||x+w>o.width||y+h>o.height)throw FormatError("alltime: Original asset bounds");for(int j=0;j<h;++j)for(int i=0;i<w;++i){auto c=s.pixels[size_t(sy+j)*s.width+sx+i];if(c!=tr)o.at(x+i,y+j)=c;}}
void fill(Image&o,int x,int y,int w,int h,uint8_t c){
draw::fill(o, x, y, w, h, c);
}
void copy(Image&o,const Image&s,int sx,int sy,int x,int y,int w,int h,int tr=-1){if(sx<0||sy<0||x<0||y<0||sx+w>s.width||sy+h>s.height||x+w>o.width||y+h>o.height)throw FormatError("alltime: Original asset bounds");
draw::copy_unclipped(o, s, sx, sy, x, y, w, h, tr);
}
std::string source_number(uint32_t value,uint8_t flags){
const unsigned width=flags&0x3f;std::string digits=std::to_string(value);
const bool grouped=(flags&0x40)==0&&width>3;
@@ -32,7 +37,7 @@ AllTimeTableState alltime_table_from_game(const GameState&g,const LeImage&exe,De
for(int t=0;t<168;++t){size_t b=size_t(t)*0x4a+0x1e;auto u=[&](int o){return uint16_t(g.club_table[b+size_t(o)]|uint16_t(g.club_table[b+size_t(o+1)])<<8);};auto&r=s.records[size_t(t)];r.points=u(0);r.goals_for=u(2);r.goals_against=u(4);r.wins=u(6);r.draws=u(8);r.losses=u(10);if(t<int(g.club_ids.size()))s.club_names[size_t(t)]=g.club_name(t);s.club_name_colors[size_t(t)]=team_color(g,t);}
for(int n=0;n<5;++n)if(0x165+n<int(g.club_ids.size()))s.nation_names[size_t(n)]=g.club_name(0x165+n);
const uint32_t start=kFirst+uint32_t(nation)*8;const int league=exe.u8(kLeague+uint32_t(nation));const uint32_t full=uint32_t(league_matchdays(league));
for(int part=0;part<2;++part){int first=exe.u16(start+uint32_t(part)*4),end=exe.u16(::bmh::layout::AlltimeTable_AlltimeTableFromGame_RuntimeField+uint32_t(nation)*8+uint32_t(part)*4);for(int team=first;team<end;++team){if(team<0||team>=168)continue;const auto&r=s.records[size_t(team)];int played=int(r.wins)+r.draws+r.losses;if(!played)continue;uint32_t p=r.points,gf=r.goals_for,ga=r.goals_against;if(relative){p=p*full*10U/uint32_t(played);gf=gf*full*10U/uint32_t(played);ga=ga*full*10U/uint32_t(played);}AllTimeRow row;row.team=team;row.played=played;row.points=p;row.goals_for=gf;row.goals_against=ga;row.points_key=p*0x10001U+0x7d000000U;row.goal_key=gf*0x10001U-ga*0x10000U+0x7d000000U;s.rows.push_back(row);}}
for(int part=0;part<2;++part){int first=exe.u16(start+uint32_t(part)*4),end=exe.u16(::bmh::layout::AlltimeTable_AlltimeTableFromGame_RuntimeField+uint32_t(nation)*8+uint32_t(part)*4);for(int team=first;team<end;++team){if(team<0||team>=world_layout().first_foreign_cup())continue;const auto&r=s.records[size_t(team)];int played=int(r.wins)+r.draws+r.losses;if(!played)continue;uint32_t p=r.points,gf=r.goals_for,ga=r.goals_against;if(relative){p=p*full*10U/uint32_t(played);gf=gf*full*10U/uint32_t(played);ga=ga*full*10U/uint32_t(played);}AllTimeRow row;row.team=team;row.played=played;row.points=p;row.goals_for=gf;row.goals_against=ga;row.points_key=p*0x10001U+0x7d000000U;row.goal_key=gf*0x10001U-ga*0x10000U+0x7d000000U;s.rows.push_back(row);}}
std::stable_sort(s.rows.begin(),s.rows.end(),[](const auto&a,const auto&b){if(a.points_key!=b.points_key)return a.points_key>b.points_key;return a.goal_key>b.goal_key;});if(s.rows.size()>24)s.rows.resize(24);return s;
}
AllTimeTableScreen::AllTimeTableScreen(const std::filesystem::path&data,AllTimeTableState s):state_(std::move(s)),data_(data),exe_(load_le(asset_path(data,"BMH.exe"))),font_(load_font(asset_path(data/"F","BMH3.FNT"))),header_(load_font(asset_path(data/"F","BMH2.FNT"))),sprite_(data),window_(load_vga(asset_path(data/"KB","56.VGA"))),buttons_(load_vga(asset_path(data/"KB","0.VGA"))),texts_(load_textd(asset_path(data,"TEXTD.BLK"))){if(state_.underlay.width!=320||state_.underlay.height!=240)throw FormatError("alltime: invalid parent frame");}
+2 -1
View File
@@ -7,8 +7,9 @@
#include "ui/manager.hpp"
#include <iostream>
#include <stdexcept>
#include "testing/check.hpp"
namespace {
void check(bool ok,const char* why){if(!ok)throw std::runtime_error(why);}
using bmh::test_support::check;
void put16(bmh::Bytes& b,uint32_t base,uint32_t a,uint16_t x){b.at(a-base)=uint8_t(x);b.at(a-base+1)=uint8_t(x>>8);}
void rec(bmh::GameState&g,int team,uint16_t points,uint16_t gf,uint16_t ga,uint16_t w,uint16_t d,uint16_t l){size_t p=size_t(team)*0x4a+0x1e;for(auto [o,v]:{std::pair{0,points},std::pair{2,gf},std::pair{4,ga},std::pair{6,w},std::pair{8,d},std::pair{10,l}}){g.club_table[p+o]=uint8_t(v);g.club_table[p+o+1]=uint8_t(v>>8);}}
}
+1 -1
View File
@@ -16,7 +16,7 @@
namespace bmh::ui {
namespace {
constexpr size_t kManagerRecord = 0xb0c;
constexpr size_t kManagerRecord = kManagerRecordSize;
constexpr size_t kFlags = ::bmh::layout::Flags;
constexpr int kSeriesCount = 6;
constexpr int kSourcePointLimit = 52; // local_1d8[52] in CopyOpaqueSlice.
Loaded 100 of 282 files, more files were not shown because too many files have changed in this diff. Show more