From b5d60ef8a7c1eb0c0ab9083a193a5d5cbecbb3b7 Mon Sep 17 00:00:00 2001 From: Codex Date: Sat, 31 Oct 2026 10:20:09 +0100 Subject: [PATCH] Enable expanded international careers and private Classic-format preparation (by Codex) --- .github/workflows/ci.yml | 2 +- CMakeLists.txt | 4 +- docs/poc-1.1/FORMAT.md | 64 ++++++ docs/poc-1.1/STATUS.md | 19 +- src/app/career_session.cpp | 64 +++--- src/app/controller.cpp | 28 +-- src/app/main.cpp | 5 +- src/cli/console/windows_transfer.cpp | 2 +- src/formats/badge_policy.hpp | 3 + src/formats/executable_layout.hpp | 6 + src/formats/le.cpp | 56 ++++- src/formats/le.hpp | 2 + src/formats/m3d.cpp | 5 + src/formats/m3d.hpp | 3 +- src/formats/savestate.cpp | 12 +- src/game/balance_plan.cpp | 2 +- src/game/career.cpp | 24 +-- src/game/club_info.cpp | 2 +- src/game/club_player_detail.cpp | 8 +- src/game/club_player_detail.hpp | 2 +- src/game/cup.cpp | 2 +- src/game/desk_actions.cpp | 24 +-- src/game/league_pairings.cpp | 10 +- src/game/lineup.cpp | 8 +- src/game/match.cpp | 2 +- src/game/match_engine.cpp | 14 +- src/game/matchday.cpp | 17 +- src/game/matchday_setup.cpp | 13 +- src/game/memory.hpp | 11 +- src/game/month.cpp | 22 +- src/game/national.cpp | 2 +- src/game/other_games.cpp | 6 +- src/game/poach.cpp | 4 +- src/game/prediction.cpp | 2 +- src/game/rating.cpp | 4 +- src/game/save.cpp | 10 +- src/game/season.cpp | 61 +++--- src/game/sportschau_awards.cpp | 4 +- src/game/state.cpp | 9 + src/game/state.hpp | 3 + src/game/top_scorers.cpp | 4 +- src/game/weekly.cpp | 14 +- src/ui/alltime_table.cpp | 9 +- src/ui/alltime_table.hpp | 4 +- src/ui/analytics.cpp | 2 +- src/ui/calendar.cpp | 2 +- src/ui/club_player_detail.cpp | 7 +- src/ui/cup_draw.cpp | 13 +- src/ui/desk_drawers.cpp | 5 +- src/ui/desk_records.cpp | 3 +- src/ui/desk_state.cpp | 19 +- src/ui/friendly_match.cpp | 5 +- src/ui/incoming_transfer.cpp | 3 +- src/ui/league_pairings.cpp | 3 +- src/ui/league_table.cpp | 3 +- src/ui/lineup.cpp | 3 +- src/ui/live_matchday.cpp | 4 +- src/ui/manager.cpp | 2 +- src/ui/matchday_results.cpp | 3 +- src/ui/national_friendly_ui.cpp | 11 +- src/ui/other_games_state.cpp | 2 +- src/ui/pending_offer.cpp | 9 +- src/ui/player_card.cpp | 9 +- src/ui/preparation.cpp | 4 +- src/ui/preparation_flow.cpp | 3 +- src/ui/save_load.cpp | 2 +- src/ui/series_records.cpp | 7 +- src/ui/settings.cpp | 1 - src/ui/sportschau.cpp | 5 +- src/ui/strengths_state.cpp | 5 +- src/ui/team_statistics.cpp | 25 +-- src/ui/team_statistics.hpp | 2 +- src/ui/transfer_market.cpp | 2 +- src/ui/world_cup_statistics.cpp | 7 +- tests/data_profile_tests.cpp | 35 ++++ tests/season_sim.cpp | 4 +- tools/poc/prepare_international.py | 265 ++++++++++++++++++++++++ tools/poc/test_prepare_international.py | 38 ++++ 78 files changed, 816 insertions(+), 269 deletions(-) create mode 100644 docs/poc-1.1/FORMAT.md create mode 100644 tools/poc/prepare_international.py create mode 100644 tools/poc/test_prepare_international.py diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index f38deb6..b566f73 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -3,7 +3,7 @@ name: Build without game data on: push: - branches: [main, release/1.0] + branches: [main, release/1.0, poc/1.1-international] pull_request: workflow_dispatch: workflow_call: diff --git a/CMakeLists.txt b/CMakeLists.txt index ccb3944..a0a4f1d 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,11 +1,11 @@ # SPDX-License-Identifier: GPL-3.0-only cmake_minimum_required(VERSION 3.24) -project(OpenBMH VERSION 1.0.2 LANGUAGES CXX C) +project(OpenBMH VERSION 1.1.0 LANGUAGES CXX C) if(APPLE) # Enable native languages before dependencies/subdirectories inherit rules. enable_language(OBJC OBJCXX) endif() -set(OPENBMH_PRERELEASE "" CACHE STRING "Prerelease identifier; empty for final release") +set(OPENBMH_PRERELEASE "poc.1" CACHE STRING "Prerelease identifier; empty for final release") set(OPENBMH_PRODUCT_VERSION "${PROJECT_VERSION}") if(OPENBMH_PRERELEASE) string(APPEND OPENBMH_PRODUCT_VERSION "-${OPENBMH_PRERELEASE}") diff --git a/docs/poc-1.1/FORMAT.md b/docs/poc-1.1/FORMAT.md new file mode 100644 index 0000000..63e4b3e --- /dev/null +++ b/docs/poc-1.1/FORMAT.md @@ -0,0 +1,64 @@ +# Classic-plus-1 profile + +This opt-in experimental profile keeps the Classic competition types and indexed artwork formats. It is not a DOS patch. The original executable is read only; verified dimension data and the expanded calendar are prepared in memory. Unmarked installations retain Classic dimensions and save identity. + +## Discovery and dimensions + +`OBMHPROF.INI` contains exactly: + +```ini +[OpenBMH] +profile=classic-plus-1 +``` + +Unknown keys/profiles are rejected. The German executable and calendar are required. + +| Table | Classic | Classic-plus-1 | +| --- | ---: | ---: | +| League sizes, German divisions | 18/18/18/18/18 | 18/18/18/18/18 | +| Spain/England/France/Italy | 12/12/12/12 | 18/20/18/18 | +| League clubs | 138 | 164 | +| Cup-only clubs | 30 | 30 | +| League and cup records | 168 | 194 | +| Other foreign clubs | 189 | 189 | +| National teams | 62 | 62 | +| All club/country entries | 419 | 445 | +| Players | 2,574 | 3,334 | +| Clubs with 24 roster slots | 90 | 164 | +| First market slot | 2,928 | 3,936 | +| First national roster slot | 3,072 | 4,080 | +| First extra-player slot | 3,096 | 4,104 | +| Total runtime slots | 3,150 | 4,158 | + +Player identifiers still use twelve bits, with 4,095 reserved for empty. **An absolute roster slot is not a player identifier**: extended auxiliary slots exceed 4,095 and must not be masked. Club identifiers fit existing packed club fields and crest selectors fit nine bits. + +## Master database and artwork + +The M3D table order and encoding remain unchanged. Kit selectors scale with all club/country entries; short-name offsets and auxiliary words scale with league-plus-cup entries. The squad master has four fewer rows than runtime, because temporary transfer rows are inserted during career initialization. String pools retain unsigned 16-bit offsets. Imported names use ISO 646-DE, with explicit transliteration of unsupported letters. + +The preparation script keeps original player words and original IDs, appends supplemental players and records the source-to-runtime club mapping. Existing twelve-club foreign cores are retained; additional clubs are ranked by donor mean player strength. Missing-person data are not silently fetched or invented. Every supplied provenance/fictional-field note is retained in the private import report. + +Crests are fitted into 38-by-38 cells of 304-by-38 VGA sheets, using the supplied VGA palette. No PNG/SVG decoder is needed at runtime. Transparency is index zero for these generated crest cells. Existing protected crest cells remain intact. Asset source and rights notes remain separate from the application's GPL license. + +The offline preparation utility accepts local paths: + +```sh +python3 -m venv asset-tools +asset-tools/bin/pip install Pillow CairoSVG +asset-tools/bin/python tools/poc/prepare_international.py \ + --source /path/to/supplied/german-game \ + --supplement /path/to/supplied/season.obw \ + --output /path/to/new/private-data +``` + +The destination must not exist. Inputs are never overwritten. Original content and private import reports must stay outside public source trees, issues and CI artifacts. + +## Save and memory boundaries + +Classic containers retain `V2.24`. Extended containers use `O1.1`, checked against the selected installation before state decoding. The table sequence remains familiar, with count-derived sizes for club records, manager/opponent histories, crests, kits and short-name offsets. Extended typed tables must not grow into adjacent globals in the guest-memory compatibility representation. + +The result store already reserves nine leagues with 38 rounds and ten matches per round. Expanded scheduling uses each league's own fixture size. The shared foreign calendar supplies 38 dates; each league stops at its own 34 or 38 rounds. Domestic/cup/national flags are preserved. Dates are an experimental calendar policy, not a claim about real-world fixtures. + +## Distribution + +Public artifacts contain the implementation, build information and corresponding sources. The community data ZIP is prepared privately and separately; existing content provenance and rights are unchanged. The stable 1.0 release line is not replaced by this POC. diff --git a/docs/poc-1.1/STATUS.md b/docs/poc-1.1/STATUS.md index 232b0d5..251ab3f 100644 --- a/docs/poc-1.1/STATUS.md +++ b/docs/poc-1.1/STATUS.md @@ -1,9 +1,20 @@ # International-league POC -Working branch: poc/1.1-international, based on v1.0.2. The stable main line is separate. +Working branch: `poc/1.1-international`, based on `v1.0.2`. Stable main remains separate. -The explicit `OBMHPROF.INI` profile marker selects classic-plus-1; missing metadata retains the original Classic mode. Unknown or inconsistent metadata is rejected. Profiles define database counts and roster boundaries, with tests for the existing layout, the expanded layout and packed-player limits. +Implemented: -Target: five German divisions unchanged, international sizes 18/20/18/18, 164 league clubs, 24 roster slots and normally 20 starting players per league club. The expanded runtime needs 4,158 roster and auxiliary slots. Player IDs remain below the 4,095 empty sentinel; absolute slot references must not be truncated to twelve bits. +- Explicit `OBMHPROF.INI` metadata; unmarked installations retain Classic dimensions. +- Five German divisions unchanged; international sizes 18/20/18/18, 164 league clubs. +- Twenty starting players and 24 slots per league club; 4,158 runtime roster/auxiliary slots. +- Profile-aware master-database and executable-data views, preserving executable bytes on disk. +- Count-derived club records, opponent histories, kit/short-name and fair-play tables. +- Per-league fixtures and 38 foreign calendar dates, with smaller leagues stopping at 34 rounds. +- Extended save identity `O1.1`; Classic retains `V2.24` and its existing dimensions. +- Offline private data preparation, provenance, crest fitting and Original-format VGA output. -This is a development status, not a claim of completed expanded gameplay. Next stages migrate semantic limits and index-dependent buffers, prepare the private dataset, distinguish extended save identity, and verify two complete seasons. No original data or rendered proprietary assets belong in this public tree. Classic readers retain their default counts and byte structure. +Local integration evidence so far: the expanded career completed 180 turns with seed 1 (three season ends), and another 180 with seed 11 (two season ends). No simulator invariant violations or contract-policy errors were reported. These are automated manager-policy runs, not claims of complete human gameplay QA or validation of all editions/platforms. + +The prepared private dataset has 445 club/country entries, 3,334 players and 263 individual foreign club crests. Original German rosters and all 2,574 Original player word records are preserved by assertions during preparation. All 263 foreign crests have supplied assets; no fictional crest fallback was needed. Donor fields retain their real/fictional provenance. No original game content is committed here. + +Remaining release gates: complete configured regression tests, explicit save/reload and cross-profile rejection checks, screenshots of the expanded tables/crests, and platform package validation. See [FORMAT.md](FORMAT.md) for dimensions, preparation and distribution boundaries. A development commit is not a completed release claim. diff --git a/src/app/career_session.cpp b/src/app/career_session.cpp index a6ed18e..dd4d549 100644 --- a/src/app/career_session.cpp +++ b/src/app/career_session.cpp @@ -2,6 +2,7 @@ #include "formats/badge_policy.hpp" #include "game/calendar.hpp" #include "formats/executable_layout.hpp" +#include "formats/data_profile.hpp" #include "app/career_session.hpp" #include @@ -71,7 +72,7 @@ int national_opportunities_rank(const GameState& game,int team,std::array=league_matchdays(0))return 0; - return team>=138?9:0; + return team>=runtime_dimensions.league_teams?9:0; } uint8_t source_runtime_byte(const GameState& state,const std::map& runtime, @@ -548,8 +549,13 @@ static void install_league_sizes(const LeImage& exe) { install_calendar_rules(exe); } +static std::filesystem::path install_session_profile(const std::filesystem::path& data) { + install_runtime_profile(load_data_profile(data)); + return data; +} + CareerSession::CareerSession(const std::filesystem::path& data, uint32_t watcom_seed) - : data_directory_(data), exe_(load_le(data / "BMH.exe")), + : data_directory_(install_session_profile(data)), exe_(load_le(data / "BMH.exe")), db_(load_database(data / "M3D.MAN")), texts_(load_textd(data / "TEXTD.BLK")), rand_(watcom_seed) { @@ -576,7 +582,7 @@ CareerSession::CareerSession(const std::filesystem::path& data, uint32_t watcom_ CareerSession::CareerSession(const std::filesystem::path& data, uint32_t watcom_seed, const std::filesystem::path& save_path) - : data_directory_(data), exe_(load_le(data / "BMH.exe")), db_(load_database(data / "M3D.MAN")), + : data_directory_(install_session_profile(data)), exe_(load_le(data / "BMH.exe")), db_(load_database(data / "M3D.MAN")), texts_(load_textd(data / "TEXTD.BLK")), rand_(watcom_seed) { install_league_sizes(exe_); turn_driver_.alternate_match_event_roll = exe_.u8(::bmh::layout::AlternateEventRoll) != 0; @@ -586,8 +592,8 @@ CareerSession::CareerSession(const std::filesystem::path& data, uint32_t watcom_ session_id_ = next_session_id.fetch_add(1, std::memory_order_relaxed); initialize_club_modal_runtime(); const Savegame file = load_savegame(save_path); - if (!file.checksum_ok || file.version != "V2.24") throw std::runtime_error("savegame: unsupported or damaged FBM"); - const DbCounts counts{exe_.u32(::bmh::layout::CareerSession_DataDirectory_RuntimeField), exe_.u32(::bmh::layout::CareerSession_DataDirectory_RuntimeField3), exe_.u32(::bmh::layout::CareerSession_DataDirectory_RuntimeField2), exe_.u32(::bmh::layout::CareerSession_DataDirectory_RuntimeField4)}; + if (!file.checksum_ok || file.version != (runtime_dimensions.expanded ? "O1.1" : "V2.24")) throw std::runtime_error("savegame: unsupported or damaged FBM"); + const DbCounts counts{exe_.u32(::bmh::layout::CareerSession_DataDirectory_RuntimeField), exe_.u32(::bmh::layout::CareerSession_DataDirectory_RuntimeField3), exe_.u32(::bmh::layout::CareerSession_DataDirectory_RuntimeField2), exe_.u32(::bmh::layout::CareerSession_DataDirectory_RuntimeField4), db_.counts.league_teams, db_.counts.cup_teams}; const SaveState save(file.stream, counts); g_ = GameState::from_save(save, counts); // CompetitionPointers2, after DeskDate2: these are process statics, not FBM fields. @@ -1278,7 +1284,7 @@ std::optional CareerSession::begin_friendly_opponent_tabl uint64_t revision,std::string& error) { error.clear(); const auto request=strengths_open_request(revision); - if(!request||request->identity.runtime_club>=168||request->identity.source_param2|| + if(!request||request->identity.runtime_club>=runtime_dimensions.record_teams||request->identity.source_param2|| league_family_owner_||strengths_owner_||league_pairings_draft_) { error="friendly table: unavailable club entry";return {}; } @@ -1326,7 +1332,7 @@ std::optional CareerSession::resolve_friendly_table_opponent( if(visible.runtime_team_id!=request.runtime_team||visible.club_identity_key!=request.expected_club_identity|| visible.runtime_team_id<0||size_t(visible.runtime_team_id)>=g_.club_ids.size()|| visible.club_identity_key!=int(g_.club_ids[size_t(visible.runtime_team_id)])|| - normal.rank!=row+1||normal.runtime_team_id<0||normal.runtime_team_id>=168|| + normal.rank!=row+1||normal.runtime_team_id<0||normal.runtime_team_id>=runtime_dimensions.record_teams|| size_t(normal.runtime_team_id)>=g_.club_ids.size()|| normal.club_identity_key!=int(g_.club_ids[size_t(normal.runtime_team_id)])) { error="friendly table: opponent row identity changed";return {}; @@ -1783,13 +1789,13 @@ std::optional CareerSession::open_running // CupGroupOverviewEffects resolves this exact active descriptor through FindCup(selector, ordinal). const int competition_id = int16_t(g_.memory.u16(cup_entry_address(entry_index)+0x18)); int stable_team = request.runtime_team; - if (stable_team > 0x164) { + if (stable_team > (kNoTeam - 1)) { const size_t backup = 4 * 0xb0c + 0x290; if (request.manager_slot != 0 || backup + 2 > g_.manager_records.size()) throw FormatError("live overview: unsupported national cup owner"); stable_team = int(uint16_t(g_.manager_records[backup] | uint16_t(g_.manager_records[backup+1])<<8)); } - if (stable_team < 0 || stable_team >= 138 || size_t(stable_team) >= g_.club_ids.size()) + if (stable_team < 0 || stable_team >= runtime_dimensions.league_teams || size_t(stable_team) >= g_.club_ids.size()) throw FormatError("live overview: missing stable cup owner identity"); ui::OtherGamesIdentity identity; identity.manager_slot=request.manager_slot; identity.runtime_team=request.runtime_team; @@ -2259,7 +2265,7 @@ std::optional CareerSession::dispatch_family_table_team_i if(poach_selection && *poach_selection) { const auto chosen=club_player_detail_context(next,**poach_selection); if(chosen.selection.runtime_team!=selected_team || chosen.source_slot<0 || - chosen.source_slot>=0xb70 || chosen.human_loan) + chosen.source_slot>=runtime_dimensions.pool_first || chosen.human_loan) throw FormatError("poach: card returned a different ordinary squad player"); refreshed.expected_family_word=next.memory.u16(family_word_at); // A successful param1=1 selection leaves50775 here. Its common @@ -2575,12 +2581,12 @@ std::optional CareerSession::open_top_scorers( throw FormatError("top scorers: unsupported national-coach owner"); stable_team = int(uint16_t(g_.manager_records[backup] | uint16_t(g_.manager_records[backup + 1]) << 8)); - } else if (team < 0 || team >= 138) { + } else if (team < 0 || team >= runtime_dimensions.league_teams) { throw FormatError("top scorers: manager team is outside Source league scope"); } - if (stable_team < 0 || stable_team >= 138 || size_t(stable_team) >= g_.club_ids.size()) + if (stable_team < 0 || stable_team >= runtime_dimensions.league_teams || size_t(stable_team) >= g_.club_ids.size()) throw FormatError("top scorers: missing stable club identity"); - const int league = team > 0x164 ? 0 : team_league(team); + const int league = team > (kNoTeam - 1) ? 0 : team_league(team); if (league < 0 || league > 8) throw FormatError("top scorers: manager has no supported Source league"); @@ -2645,7 +2651,7 @@ std::optional CareerSession::dispatch_top_sco (backup + 2 <= g_.manager_records.size() ? int(uint16_t(g_.manager_records[backup] | uint16_t(g_.manager_records[backup + 1]) << 8)) : -1) : identity.runtime_team; - if (identity_team < 0 || identity_team >= 138 || + if (identity_team < 0 || identity_team >= runtime_dimensions.league_teams || size_t(identity_team) >= g_.club_ids.size() || int(g_.club_ids[size_t(identity_team)]) != identity.club_identity) throw FormatError("top scorers: stable club identity changed"); @@ -2748,9 +2754,9 @@ std::optional CareerSession::open_opportunities( const int manager=request.manager_slot,team=g_.manager_teams[size_t(manager)]; const int league=national_source_case?0:team_league(team); if(national_source_case) { - if(team!=0x165||league!=0)throw FormatError("opportunities: invalid national menu-6 owner"); + if(team!=kNoTeam||league!=0)throw FormatError("opportunities: invalid national menu-6 owner"); if(stable_identity<0)throw FormatError("opportunities: missing national Desk identity"); - } else if(team<0||team>=138||size_t(team)>=g_.club_ids.size()||league<0||league>=9) + } else if(team<0||team>=runtime_dimensions.league_teams||size_t(team)>=g_.club_ids.size()||league<0||league>=9) throw FormatError("opportunities: unsupported team/league"); if(underlay.width!=320||underlay.height!=240)throw FormatError("opportunities: expected captured 320x240 desktop"); const uint32_t choice_at=::bmh::layout::CareerSession_FormatError_ExecutableField+uint32_t(manager)*2; @@ -2787,7 +2793,7 @@ std::optional CareerSession::dispatch_oppo uint32_t(g_.date)!=current.identity.day_counter|| size_t(current.identity.runtime_team)>=g_.club_ids.size()|| (!national_source_case&&int(g_.club_ids[size_t(current.identity.runtime_team)])!=current.identity.stable_club_identity)|| - (national_source_case&&(current.identity.runtime_team!=0x165|| + (national_source_case&&(current.identity.runtime_team!=kNoTeam|| current.identity.stable_club_identity<0))) throw FormatError("opportunities: desk owner changed"); OpportunitiesDispatch result;result.page=current; @@ -2867,14 +2873,14 @@ std::optional CareerSession::open_other_games( uint16_t(next.manager_records[record + 0x291]) << 8) != uint16_t(team)) throw FormatError("other games: manager record does not own the active team"); int stable_team = team; - if (team > 0x164) { + if (team > (kNoTeam - 1)) { const size_t backup = 4 * 0xb0c + 0x290; if (manager != 0 || backup + 2 > next.manager_records.size()) throw FormatError("other games: unsupported national-coach owner"); stable_team = int(uint16_t(next.manager_records[backup] | uint16_t(next.manager_records[backup + 1]) << 8)); } - if (stable_team < 0 || stable_team >= 138 || size_t(stable_team) >= next.club_ids.size()) + if (stable_team < 0 || stable_team >= runtime_dimensions.league_teams || size_t(stable_team) >= next.club_ids.size()) throw FormatError("other games: missing stable manager club identity"); const uint8_t source_view = next.memory.u8(::bmh::layout::CareerSession_DispatchOtherGames_RuntimeField + uint32_t(manager)); @@ -2965,13 +2971,13 @@ std::optional CareerSession::dispatch_other_g uint16_t(id.runtime_team)) throw FormatError("other games: manager record changed"); int stable_team = id.runtime_team; - if (id.runtime_team > 0x164) { + if (id.runtime_team > (kNoTeam - 1)) { const size_t backup = 4 * 0xb0c + 0x290; if (id.manager_slot != 0 || backup + 2 > g_.manager_records.size()) throw FormatError("other games: unsupported national owner"); stable_team = int(uint16_t(g_.manager_records[backup] | uint16_t(g_.manager_records[backup + 1]) << 8)); } - if (stable_team < 0 || stable_team >= 138 || size_t(stable_team) >= g_.club_ids.size() || + if (stable_team < 0 || stable_team >= runtime_dimensions.league_teams || size_t(stable_team) >= g_.club_ids.size() || int(g_.club_ids[size_t(stable_team)]) != id.club_identity) throw FormatError("other games: stable club identity changed"); if (request.action == ui::OtherGamesAction::team_info) { @@ -3020,10 +3026,10 @@ std::optional CareerSession::dispatch_other_g uint16_t(next.manager_records[active_record+0x290]| uint16_t(next.manager_records[active_record+0x291])<<8)!=uint16_t(id.runtime_team)) throw FormatError("other games: TeamInfo changed the active manager record"); - const int retained_team=id.runtime_team>0x164 + const int retained_team=id.runtime_team>(kNoTeam - 1) ? int(uint16_t(next.manager_records[4*0xb0c+0x290]| uint16_t(next.manager_records[4*0xb0c+0x291])<<8)) : id.runtime_team; - if(retained_team<0||retained_team>=138||size_t(retained_team)>=next.club_ids.size()|| + if(retained_team<0||retained_team>=runtime_dimensions.league_teams||size_t(retained_team)>=next.club_ids.size()|| int(next.club_ids[size_t(retained_team)])!=id.club_identity) throw FormatError("other games: TeamInfo changed the stable desk club identity"); @@ -3576,7 +3582,7 @@ std::optional CareerSession::open_tr !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) { + request.bid.source_slot != runtime_dimensions.pool_first + request.bid.list_entry || request.selected_players.size() > 1) { error = "transfer offer: stale, nested or unsupported marked opening"; return std::nullopt; } @@ -3638,7 +3644,7 @@ std::optional CareerSession::open_poach( 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, + const TransferOfferEditorRequest input{manager_slot, g_.manager_teams[size_t(manager_slot)], row, runtime_dimensions.pool_first + 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; } @@ -3761,7 +3767,7 @@ bool CareerSession::dispatch_poach_ui(const ui::TransferMarketRequest& request, 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 || + if(slot<0 || slot>=runtime_dimensions.pool_first || slot_team(slot)!=selection->runtime_team || (next.squad_slots.at(size_t(slot))&0xfff)!=selection->player_id) throw FormatError("poach: stale player selection"); } @@ -3926,7 +3932,7 @@ std::optional CareerSession::previ 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.preview_source_slot != runtime_dimensions.pool_first + request.bid.list_entry || request.bid.player != request.expected_player) { error = "transfer market: mismatched preview listing identity"; return std::nullopt; @@ -7203,7 +7209,7 @@ ui::PreparationState CareerSession::preparation_projection(const GameState& stat uint16_t(state.manager_records.at(size_t(stadium.manager_slot) * 0xb0c + 0x2ad)) << 8; const int source_team = int16_t(uint16_t(state.manager_records.at(size_t(stadium.manager_slot) * 0xb0c + 0x290)) | uint16_t(state.manager_records.at(size_t(stadium.manager_slot) * 0xb0c + 0x291)) << 8); - const int source_league = source_team > 0x164 ? 0 : team_league(source_team); + const int source_league = source_team > (kNoTeam - 1) ? 0 : team_league(source_team); if (source_league < 0 || size_t(source_league) >= state.league_rounds.size()) throw FormatError("stadium source league is outside the live league table"); stadium.live_league_round = state.league_rounds.at(size_t(source_league)); @@ -7947,7 +7953,7 @@ bool CareerSession::dispatch_stadium(const ui::StadiumRequest& supplied_request, } 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 || + request.runtime_club < 0 || request.runtime_club >= kNoTeam || size_t(request.runtime_club) >= g_.club_ids.size() || request.stable_club_identity != std::optional(int(g_.club_ids[size_t(request.runtime_club)])) || request.revision != revision || revision == UINT64_MAX || !g_.memory.has(::bmh::layout::GameMode)) { diff --git a/src/app/controller.cpp b/src/app/controller.cpp index 8e3e3b1..7cf272d 100644 --- a/src/app/controller.cpp +++ b/src/app/controller.cpp @@ -145,12 +145,12 @@ void serve_friendly_action(ui::StartupFlow& flow, CareerSession& session, const auto& national=*request.national_booking; const auto expected=FriendlyActions::national_owner(request); if(request.kind!=ui::FriendlyRequestKind::book||!request.quote_id|| - request.runtime_team!=0x165||request.opponent<0x166||request.opponent>0x1a2|| + request.runtime_team!=kNoTeam||request.opponent<(kNoTeam + 1)||request.opponent>(kNoTeam + 61)|| request.season_day<0||request.season_day>365||request.planner_count<0|| request.planner_count>253||request.revision!=revision|| national.owner!=expected||national.quote.owner!=expected|| national.season_day!=request.season_day||national.quote.terms.manager!=manager|| - national.quote.terms.manager_team!=0x165||national.quote.terms.opponent!=request.opponent|| + national.quote.terms.manager_team!=kNoTeam||national.quote.terms.opponent!=request.opponent|| national.quote.terms.planner_count!=request.planner_count|| national.quote.terms.home_team!=request.home_team||national.quote.terms.away_team!=request.away_team|| national.quote.terms.payer_manager!=request.payer_manager|| @@ -232,7 +232,7 @@ void serve_friendly_action(ui::StartupFlow& flow, CareerSession& session, if (request.kind != ui::FriendlyRequestKind::book || request.quote_id == 0 || request.season_day < 0 || request.season_day > 365 || request.opponent < 0 || - request.opponent >= 168 || request.cost < 0 || request.planner_count > 253) { + request.opponent >= runtime_dimensions.record_teams || request.cost < 0 || request.planner_count > 253) { flow.reject_friendly_action("Die Angaben zum Spieltermin sind ungültig."); return; } @@ -257,13 +257,13 @@ bool valid_national_friendly_family(const ui::StartupFlow& flow,const GameState& const auto* origin=flow.national_friendly_desk_owner(); const auto* menu=flow.statistics_menu(); const auto* desk=flow.desktop(); - if(!owner||!origin||!menu||!desk||owner->desk_menu!=6||owner->runtime_team!=0x165|| + if(!owner||!origin||!menu||!desk||owner->desk_menu!=6||owner->runtime_team!=kNoTeam|| owner->manager<0||owner->revision!=revision||origin->kind!=ui::DeskRequestKind::open_menu|| origin->menu_kind!=6||origin->manager_slot!=owner->manager||origin->revision!=revision|| desk->state().revision!=revision||desk->state().manager_slot!=owner->manager|| menu->state().owner.kind!=ui::DeskRequestKind::open_menu||menu->state().owner.menu_kind!=23|| menu->state().owner.manager_slot!=owner->manager||menu->state().owner.revision!=revision|| - size_t(owner->manager)>=game.manager_teams.size()||game.manager_teams[size_t(owner->manager)]!=0x165|| + size_t(owner->manager)>=game.manager_teams.size()||game.manager_teams[size_t(owner->manager)]!=kNoTeam|| !game.memory.has(::bmh::layout::ActiveManager)||int(game.memory.u8(::bmh::layout::ActiveManager))!=owner->manager)return false; return true; } @@ -278,17 +278,17 @@ void serve_national_friendly_selection(ui::StartupFlow& flow,CareerSession& sess const auto& game=session.state(); const auto& desk=flow.desktop()->state(); const int manager=owner->manager; - if(owner->desk_menu!=6||owner->runtime_team!=0x165||owner->revision!=revision|| + if(owner->desk_menu!=6||owner->runtime_team!=kNoTeam||owner->revision!=revision|| desk_request->kind!=ui::DeskRequestKind::open_menu||desk_request->menu_kind!=6|| desk_request->revision!=revision||desk_request->manager_slot!=manager|| desk.revision!=revision||desk.manager_slot!=manager||manager<0|| - size_t(manager)>=game.manager_teams.size()||game.manager_teams[size_t(manager)]!=0x165|| - int(game.memory.u8(::bmh::layout::ActiveManager))!=manager||selected_team<0x166||selected_team>0x1a2) { + size_t(manager)>=game.manager_teams.size()||game.manager_teams[size_t(manager)]!=kNoTeam|| + int(game.memory.u8(::bmh::layout::ActiveManager))!=manager||selected_team<(kNoTeam + 1)||selected_team>(kNoTeam + 61)) { flow.close_national_friendly_picker(); return; } if(!presenter) { flow.close_national_friendly_picker(); return; } - ui::NationalFriendlyUi dialog_flow(*owner,national_friendly_identity(game,manager,0x165)); + ui::NationalFriendlyUi dialog_flow(*owner,national_friendly_identity(game,manager,kNoTeam)); auto venue=dialog_flow.select_opponent(game,selected_team); if(venue.kind!=ui::NationalFriendlyUiActionKind::show_question||!venue.question) { flow.close_national_friendly_picker();return; @@ -321,7 +321,7 @@ void serve_national_friendly_selection(ui::StartupFlow& flow,CareerSession& sess } ui::FriendlyQuoteProjection projection; projection.request_id=quote_request.engine_owner->request_id; - projection.revision=revision;projection.manager_slot=manager;projection.runtime_team=0x165; + projection.revision=revision;projection.manager_slot=manager;projection.runtime_team=kNoTeam; projection.opponent=selected_team;projection.opponent_manager=quote.terms.opponent_manager; projection.payer_manager=quote.terms.payer_manager;projection.home_team=quote.terms.home_team; projection.away_team=quote.terms.away_team;projection.cost=quote.terms.cost; @@ -336,7 +336,7 @@ void serve_national_friendly_selection(ui::StartupFlow& flow,CareerSession& sess projection.dates.push_back({day,mark}); } ui::FriendlyMatchState calendar; - calendar.revision=revision;calendar.manager_slot=manager;calendar.runtime_team=0x165; + calendar.revision=revision;calendar.manager_slot=manager;calendar.runtime_team=kNoTeam; calendar.current_day=game.season_day();calendar.planner_count=quote.terms.planner_count; calendar.season_start_counter=game.season_start;calendar.mode_three=desk.options.mode==3; calendar.national_team=true;calendar.manager_name=ui::original_to_utf8(desk.manager_name); @@ -957,7 +957,7 @@ std::string serve_flow_request(ui::StartupFlow& flow, const ui::FlowResult& resu const int team=game.manager_teams[size_t(manager)]; if(team!=kNoTeam&&(team<0||size_t(team)>=game.team_flags.size())) throw FormatError("fair play: active manager has no Source roster"); - const int league=team>0x164?0:team_league(team); + const int league=team>(kNoTeam - 1)?0:team_league(team); page=ui::fair_play_state_from_game(game,league,underlay,manager); } else { page.kind=ui::DeskRecordKind::highscore; @@ -2110,11 +2110,11 @@ std::string serve_flow_request(ui::StartupFlow& flow, const ui::FlowResult& resu const auto& desk = flow.desktop()->state(); const int manager=request.manager_slot; if(manager>=0&&size_t(manager) session; @@ -945,7 +948,7 @@ int main(int argc, char** argv) { int manager, int source_slot, int list_entry, const HumanBuyerSaleHooks& sale_hooks) -> int { if (!running || manager < 0 || manager >= 4 || list_entry < 40 || list_entry >= 44 || - source_slot != 2928 + list_entry || !staged.memory.has(::bmh::layout::EditorList + uint32_t(list_entry) * 0x58 + 0x57)) + source_slot != runtime_dimensions.pool_first + 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; diff --git a/src/cli/console/windows_transfer.cpp b/src/cli/console/windows_transfer.cpp index 72c9127..97d2732 100644 --- a/src/cli/console/windows_transfer.cpp +++ b/src/cli/console/windows_transfer.cpp @@ -420,7 +420,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: (ListPoachClubs)"); + if (!id || *id < 0 || *id >= runtime_dimensions.league_teams) fail("E_BAD_ARGUMENT", "club is club: (ListPoachClubs)"); return int(*id); }; Param club = detail::text("club"); diff --git a/src/formats/badge_policy.hpp b/src/formats/badge_policy.hpp index 086fe09..be29e04 100644 --- a/src/formats/badge_policy.hpp +++ b/src/formats/badge_policy.hpp @@ -9,6 +9,7 @@ namespace bmh { // Installed alongside the loaded edition's other runtime tables. Club selectors // remain database/savegame data; this only reproduces the original drawing gate. inline int original_foreign_badge_end = 138; +inline bool expanded_badges = false; inline int original_badge_gate(const LeImage& exe) { constexpr auto instruction = layout::ForeignBadgeGateInstruction; @@ -25,10 +26,12 @@ inline int original_badge_gate(const LeImage& exe) { inline void install_original_badge_policy(const LeImage& exe) { original_foreign_badge_end = original_badge_gate(exe); + expanded_badges = exe.expanded_profile(); } inline bool original_badge_fallback(int token, const LeImage* exe = nullptr) { const int team = token & 0xfff; + if (exe ? exe->expanded_profile() : expanded_badges) return team == 0xfff; const int end = exe ? original_badge_gate(*exe) : original_foreign_badge_end; return team == 0xfff || (team >= 90 && team < end) || (team >= 168 && team < 357); } diff --git a/src/formats/executable_layout.hpp b/src/formats/executable_layout.hpp index 732827d..870457f 100644 --- a/src/formats/executable_layout.hpp +++ b/src/formats/executable_layout.hpp @@ -1412,7 +1412,13 @@ inline constexpr auto NationalFriendlyPayerPrefixText = 0xa000f; inline constexpr auto NextDeskManager = 0xbd6cc; inline constexpr auto NoClubText = 0xaec74; inline constexpr auto NoPlayerText = 0xaec78; +// Legacy symbol name: this is the league+cup team count, NOT a squad slot offset. inline constexpr auto NoTeamSquadStart = 0xa2c38; +inline constexpr auto ProfileSmallSquadClubs = 0xa2c32; +inline constexpr auto ProfilePoolFirst = 0xa2c56; +inline constexpr auto ProfileFreeFirst = 0xa2c5a; +inline constexpr auto ProfileForeignFreeFirst = 0xa2c5e; +inline constexpr auto ProfileNationalSlotsFirst = 0xa2c62; inline constexpr auto OfferSlots = 0xbb844; inline constexpr auto Opportunities_FormatError_RuntimeField = 0xa3a6e; inline constexpr auto Opportunities_FormatError_RuntimeField2 = 0xa3a80; diff --git a/src/formats/le.cpp b/src/formats/le.cpp index dd2091d..5d883ec 100644 --- a/src/formats/le.cpp +++ b/src/formats/le.cpp @@ -1,5 +1,7 @@ // SPDX-License-Identifier: GPL-3.0-only #include "formats/le.hpp" +#include "formats/data_profile.hpp" +#include "formats/executable_layout.hpp" #include #include @@ -36,13 +38,63 @@ void save_image(const LeImage& image, const std::filesystem::path& path) { } LeImage load_le(const std::filesystem::path& path) { + const auto profile = load_data_profile(path.parent_path()); + const auto apply_profile = [&](LeImage img) { + if (!profile.extended()) return img; + const auto put = [&](uint32_t address, uint32_t value, int width) { + if (!img.contains(address) || !img.contains(address + uint32_t(width - 1))) + throw FormatError("profile: executable lacks verified data dimensions"); + for (int b = 0; b < width; ++b) img.bytes_.at(address - img.base_ + uint32_t(b)) = uint8_t(value >> (8 * b)); + }; + if (img.u8(layout::LeagueSizes) != 18) + throw FormatError("profile: classic-plus-1 requires a German installation"); + put(layout::CareerSession_DataDirectory_RuntimeField, profile.counts.clubs, 4); + put(layout::CareerSession_DataDirectory_RuntimeField3, profile.counts.players, 4); + put(layout::CareerSession_DataDirectory_RuntimeField2, profile.counts.n42, 4); + put(layout::CareerSession_DataDirectory_RuntimeField4, profile.counts.n66, 4); + put(layout::CareerSession_DispatchLineup_RuntimeField, profile.counts.league_teams, 2); + put(layout::TeamsWithSquads, profile.big_squad_teams, 2); + put(layout::NoTeamSquadStart, profile.counts.n42, 2); + put(layout::ProfileSmallSquadClubs, profile.counts.league_teams - profile.big_squad_teams, 2); + put(layout::ClubPlayerDetail_ClubPlayerDetailRedraw_RuntimeField, profile.counts.players, 4); + put(layout::ProfilePoolFirst, profile.pool_first(), 4); + put(layout::ProfileFreeFirst, profile.pool_first() + 44, 4); + put(layout::ProfileForeignFreeFirst, profile.pool_first() + 124, 4); + put(layout::ProfileNationalSlotsFirst, profile.national_slots_first(), 4); + for (size_t league = 0; league < profile.leagues.size(); ++league) + put(layout::LeagueSizes + uint32_t(league), profile.leagues[league], 1); + std::vector foreign_days; + for (int day = 0; day < 365; ++day) { + const auto at = layout::CompetitionCalendar + uint32_t(day * 2); + const uint16_t flags = img.u16(at); + if ((flags & 0x4001) == 1 && day + 1 < 365) foreign_days.push_back(day + 1); + put(at, flags & ~0x10u, 2); + } + if (foreign_days.size() != 34) throw FormatError("profile: unsupported domestic calendar"); + for (int target : {60, 110, 250, 290}) { + int chosen = -1; + for (int delta = 0; delta < 7 && chosen < 0; ++delta) { + const int day = target + delta; + if (img.u16(layout::CompetitionCalendar + uint32_t(day * 2)) == 0 && + std::find(foreign_days.begin(), foreign_days.end(), day) == foreign_days.end()) chosen = day; + } + if (chosen < 0) throw FormatError("profile: no calendar space for extra English fixtures"); + foreign_days.push_back(chosen); + } + for (int day : foreign_days) { + const auto at = layout::CompetitionCalendar + uint32_t(day * 2); + put(at, img.u16(at) | 0x10, 2); + } + img.expanded_profile_ = true; + return img; + }; const Bytes raw = read_file(path); if (raw.size() >= sizeof kImageMagic + 8 && std::equal(kImageMagic, kImageMagic + sizeof kImageMagic, raw.begin())) { const auto word = [&](size_t at) { return uint32_t(raw[at] | raw[at + 1] << 8 | raw[at + 2] << 16) | uint32_t(raw[at + 3]) << 24; }; const uint32_t base = word(sizeof kImageMagic), size = word(sizeof kImageMagic + 4); if (raw.size() != sizeof kImageMagic + 8 + size_t(size)) throw FormatError("OpenBMH image: wrong size"); LeImage img = LeImage::from_bytes(base, Bytes(raw.begin() + sizeof kImageMagic + 8, raw.end())); - return img; + return apply_profile(std::move(img)); } auto u8 = [&](size_t o) -> uint32_t { if (o >= raw.size()) throw FormatError("LE: read beyond the file"); @@ -131,7 +183,7 @@ LeImage load_le(const std::filesystem::path& path) { } } } - return img; + return apply_profile(std::move(img)); } } // namespace bmh diff --git a/src/formats/le.hpp b/src/formats/le.hpp index da41164..b606c02 100644 --- a/src/formats/le.hpp +++ b/src/formats/le.hpp @@ -43,10 +43,12 @@ public: return img; } const Bytes& bytes() const { return bytes_; } + bool expanded_profile() const { return expanded_profile_; } friend LeImage load_le(const std::filesystem::path& path); private: + bool expanded_profile_ = false; uint32_t base_ = 0; Bytes bytes_; }; diff --git a/src/formats/m3d.cpp b/src/formats/m3d.cpp index 49e53db..990d908 100644 --- a/src/formats/m3d.cpp +++ b/src/formats/m3d.cpp @@ -1,5 +1,6 @@ // SPDX-License-Identifier: GPL-3.0-only #include "formats/m3d.hpp" +#include "formats/data_profile.hpp" #include @@ -34,6 +35,10 @@ std::string pool_string(const Bytes& pool, size_t offset) { } // namespace +Database load_database(const std::filesystem::path& path) { + return load_database(path, load_data_profile(path.parent_path()).counts); +} + Database load_database(const std::filesystem::path& path, const DbCounts& c) { Bytes d = read_file(path); Reader r{d}; diff --git a/src/formats/m3d.hpp b/src/formats/m3d.hpp index f3a72cf..24bd210 100644 --- a/src/formats/m3d.hpp +++ b/src/formats/m3d.hpp @@ -76,6 +76,7 @@ struct Database { Bytes raw_player_bonus_values, raw_database_metadata, raw_club_auxiliary_words, raw_club_badge_selectors, raw_foreign_club_strength, raw_league_auxiliary_bytes, raw_referee_properties, raw_club_kit_selectors, raw_club_short_name_offsets; }; -Database load_database(const std::filesystem::path& path, const DbCounts& counts = {}); +Database load_database(const std::filesystem::path& path, const DbCounts& counts); +Database load_database(const std::filesystem::path& path); } // namespace bmh diff --git a/src/formats/savestate.cpp b/src/formats/savestate.cpp index 43c2f37..ccd996d 100644 --- a/src/formats/savestate.cpp +++ b/src/formats/savestate.cpp @@ -31,7 +31,7 @@ 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 {::bmh::layout::Loans, false, 0x1e0, Count::None, 0, false}, - {::bmh::layout::ManagerMatchHistory, false, 0x20d0, Count::None, 0, false}, // form history: 5 managers x 168 teams x 10 + {::bmh::layout::ManagerMatchHistory, false, 0, Count::N42, 50, false}, // form history: 5 managers x 168 teams x 10 {::bmh::layout::MatchdayGroupDescriptors, false, 0x4e0, Count::None, 0, false}, {::bmh::layout::ManagerAutomation, false, 0x14, Count::None, 0, false}, {::bmh::layout::Desktops, false, 0x10e0, Count::None, 0, false}, // desktop layouts (.MEN), 5 x 0x360 {::bmh::layout::CareerSession_DispatchToto_RuntimeField, false, 1, Count::None, 0, false}, {::bmh::layout::Cup_AdvanceCup_RuntimeField4, false, 1, Count::None, 0, false}, @@ -43,7 +43,7 @@ constexpr BlockDef kBlocks[] = { {::bmh::layout::Placements, false, 0x50, Count::None, 0, false}, {::bmh::layout::ActiveSelectors, false, 8, Count::None, 0, false}, {::bmh::layout::Career_CareerAddManager_RuntimeField2, false, 0x90, Count::None, 0, false}, {::bmh::layout::DeskActions_SubmitPoolsCoupon_RuntimeField, false, 0x2c, Count::None, 0, false}, {::bmh::layout::NextDeskManager, false, 8, Count::None, 0, false}, {::bmh::layout::Savestate_Layout_ExecutableField8, false, 10, Count::None, 0, false}, - {::bmh::layout::DeskPosition, false, 1, Count::None, 0, false}, {::bmh::layout::DeskRecords_Teams_RuntimeField, false, 0x114, Count::None, 0, false}, + {::bmh::layout::DeskPosition, false, 1, Count::None, 0, false}, {::bmh::layout::DeskRecords_Teams_RuntimeField, false, 0, Count::Teams, 2, false}, {::bmh::layout::CareerSession_FormatError_RuntimeField7, false, 2, Count::None, 0, false}, {::bmh::layout::Cup_AdvanceCup_RuntimeField6, false, 6, Count::None, 0, false}, {::bmh::layout::CurrentMatchday, false, 4, Count::None, 0, false}, // seed of the game RNG (GameRandom) {::bmh::layout::ClubPlayerDetail_InvalidArgument_RuntimeField3, false, 1, Count::None, 0, false}, {::bmh::layout::CoachActive, false, 1, Count::None, 0, false}, @@ -51,12 +51,12 @@ constexpr BlockDef kBlocks[] = { {::bmh::layout::CareerDuration, false, 1, Count::None, 0, false}, {::bmh::layout::GameMode, false, 1, Count::None, 0, false}, {::bmh::layout::CompetitionSelection, false, 4, Count::None, 0, false}, {::bmh::layout::ManagerCount, false, 1, Count::None, 0, false}, // number of managers {::bmh::layout::SavedCompetition, false, 4, Count::None, 0, false}, {::bmh::layout::Difficulty, false, 1, Count::None, 0, false}, - {::bmh::layout::StockExchange, false, 0x450, Count::None, 0, false}, {::bmh::layout::FundBlock, false, 0xa8, Count::None, 0, false}, + {::bmh::layout::StockExchange, false, 0x450, Count::None, 0, false}, {::bmh::layout::FundBlock, false, 0, Count::N42, 1, false}, {::bmh::layout::Coupon, false, 100, Count::None, 0, false}, {::bmh::layout::Savestate_Layout_ExecutableField2, false, 3, Count::None, 0, false}, {::bmh::layout::Savestate_Layout_ExecutableField, false, 1, Count::None, 0, false}, {::bmh::layout::AdGroupId, false, 1, Count::None, 0, false}, {::bmh::layout::OfferSlots, false, 0x10, Count::None, 0, false}, {::bmh::layout::ForeignClubStrength, false, 0xfb, Count::None, 0, false}, - {::bmh::layout::Career_Put_ExecutableField3, false, 0xbd, Count::None, 0, false}, {::bmh::layout::ClubShortNameOffsets, false, 0xa8, Count::None, 0, false}, - {::bmh::layout::ClubKitSelectors, false, 0x1a3, Count::None, 0, false}, {::bmh::layout::Savestate_Layout_ExecutableField7, false, 0x18, Count::None, 0, false}, + {::bmh::layout::Career_Put_ExecutableField3, false, 0xbd, Count::None, 0, false}, {::bmh::layout::ClubShortNameOffsets, false, 0, Count::N42, 1, false}, + {::bmh::layout::ClubKitSelectors, false, 0, Count::Clubs, 1, false}, {::bmh::layout::Savestate_Layout_ExecutableField7, false, 0x18, Count::None, 0, false}, {::bmh::layout::ClubInfo_FormatError_RuntimeField, false, 0x420, Count::None, 0, false}, {::bmh::layout::Career_CareerManagersEnd_RuntimeField, false, 0x18, Count::None, 0, false}, {::bmh::layout::ClubInfo_FormatError_RuntimeField2, false, 0xc, Count::None, 0, false}, {::bmh::layout::DeskActions_Unsupported_RuntimeField, false, 4, Count::None, 0, false}, {::bmh::layout::Career_RemoveJoinLoans_RuntimeField, false, 800, Count::None, 0, false}, {::bmh::layout::ClubPlayerDetail_InvalidArgument_RuntimeField, false, 200, Count::None, 0, false}, @@ -98,7 +98,7 @@ constexpr BlockDef kBlocks[] = { {::bmh::layout::Career_EuropeanClub_ExecutableField, false, 1, Count::None, 0, false}, {::bmh::layout::Career_EuropeanClub_ExecutableField2, false, 1, Count::None, 0, false}, {::bmh::layout::Career_EuropeanClub_ExecutableField3, false, 1, Count::None, 0, false}, {::bmh::layout::Career_CompetitionPointersEnglish_ExecutableField24, false, 0x28, Count::None, 0, false}, {::bmh::layout::Career_CompetitionPointersEnglish_ExecutableField29, false, 0x14, Count::None, 0, false}, {::bmh::layout::ClubSeasonRecords, false, 4, Count::None, 0, false}, - {::bmh::layout::ClubSeasonRecords, true, 0x3090, Count::None, 0, true}, // club records (168 x 74), only if pointer != 0 + {::bmh::layout::ClubSeasonRecords, true, 0, Count::N42, 74, true}, // club records (168 x 74), only if pointer != 0 }; } // namespace diff --git a/src/game/balance_plan.cpp b/src/game/balance_plan.cpp index e65d81d..a22abe0 100644 --- a/src/game/balance_plan.cpp +++ b/src/game/balance_plan.cpp @@ -261,7 +261,7 @@ int32_t stadium_required_attendance(const GameState& source, int manager) { if (manager < 0 || manager > 4) throw FormatError("stadium attendance: invalid manager"); GameState g = source; const int team = g.manager_teams.at(size_t(manager)); - const int league = team > 0x164 ? 0 : team_league(team); + const int league = team > (kNoTeam - 1) ? 0 : team_league(team); if (league < 0 || league >= kLeagueCount) throw FormatError("stadium attendance: manager has no Source league"); const int home_games = league_matchdays(league) / 2; diff --git a/src/game/career.cpp b/src/game/career.cpp index 9e01685..dd8dad5 100644 --- a/src/game/career.cpp +++ b/src/game/career.cpp @@ -154,7 +154,7 @@ GameState startup_state(const LeImage& exe, const Database& db, const Bytes& m3_ if (b.heap) { for (size_t i = 0; i < db.players.size() && 4 * i + 3 < data.size(); i++) { uint32_t w = b.address == ::bmh::layout::PlayerConditionTechniqueForm ? db.players[i].w35c : b.address == ::bmh::layout::PlayerSkillWords ? db.players[i].w368 : db.players[i].w364; - if (b.address == ::bmh::layout::PlayerSkillWords && i + 32 >= db.players.size()) + if (b.address == ::bmh::layout::PlayerSkillWords && !runtime_dimensions.expanded && i + 32 >= db.players.size()) w = (w & 0x07ffffffu) | uint32_t(exe.u8(::bmh::layout::Career_BuildStadium_RuntimeField4 - uint32_t(db.players.size() - i))) << 27; for (int k = 0; k < 4; k++) data[4 * i + size_t(k)] = uint8_t(w >> (8 * k)); } @@ -213,14 +213,14 @@ void new_career_markets_and_moods(GameState& g, GameRandom& game, WatcomRandom& } bool new_career_players(GameState& g, GameRandom& game, WatcomRandom& rand, MinuteReport& report) { - for (size_t slot = 0; slot < 2928; slot++) { + for (size_t slot = 0; slot < runtime_dimensions.pool_first; slot++) { const int id = g.squad_slots.at(slot) & 0x0fff; if (id == 0x0fff) continue; Player& p = g.players.at(size_t(id)); p.w364 |= uint32_t(rand.range(4, 0x10)) << 21; p.w368 = (p.w368 & 0xffffc000u) + uint32_t(rand.range(0, 0x3fff)); } - for (int slot = 3096; slot < 3096 + 0x36; slot++) + for (int slot = runtime_dimensions.extra_slots_first; slot < runtime_dimensions.extra_slots_first + 0x36; slot++) if (!release_player(g, slot, game, rand, report)) return false; return !report.unsupported; } @@ -258,7 +258,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. @@ -431,17 +431,17 @@ bool career_add_manager(GameState& g, const LeImage& exe, int m, const CareerMan 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 >= runtime_dimensions.record_teams || 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.manager_results.size() < g.manager_teams.size() * (runtime_dimensions.record_teams * 10) || + g.squad_slots.size() < kSquadSlots || g.club_ids.size() < runtime_dimensions.record_teams || + g.team_morale.size() < runtime_dimensions.record_teams || g.team_flags.size() < runtime_dimensions.record_teams || + g.club_heap_bc.size() < runtime_dimensions.record_teams * 2 || g.club_heap_78.size() < runtime_dimensions.record_teams * 2 || + g.club_heap_b8.size() < runtime_dimensions.record_teams || g.position_history.size() < runtime_dimensions.league_teams * 0x1a || + (!g.club_table.empty() && g.club_table.size() < runtime_dimensions.record_teams * 0x4a) || 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)) { @@ -554,7 +554,7 @@ bool career_add_manager(GameState& g, const LeImage& exe, int m, const CareerMan new_board_entry(g, m, int(i), int(slot), rand); g.tactics.at(size_t(m) * 0x840 + i * 0x58 + 0xd) = 100; } - for (size_t i = 0; i < 0x690; i++) g.manager_results.at(size_t(m) * 0x690 + i) = 0xff; + for (size_t i = 0; i < (runtime_dimensions.record_teams * 10); i++) g.manager_results.at(size_t(m) * (runtime_dimensions.record_teams * 10) + i) = 0xff; const uint8_t level = mem.u8(::bmh::layout::Difficulty); const uint32_t money = level == 0 ? 50000000u : 4000000u - level * 200000u; put32(r, rec + 0x314, money); diff --git a/src/game/club_info.cpp b/src/game/club_info.cpp index b355162..8e064a8 100644 --- a/src/game/club_info.cpp +++ b/src/game/club_info.cpp @@ -4,7 +4,7 @@ #include namespace bmh { ClubInfoEntry prepare_club_info_entry(GameState& g, int team) { - if (team < 0 || (team >= 138 && team != kNoTeam)) + if (team < 0 || (team >= runtime_dimensions.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) diff --git a/src/game/club_player_detail.cpp b/src/game/club_player_detail.cpp index 0f1666a..1f4d342 100644 --- a/src/game/club_player_detail.cpp +++ b/src/game/club_player_detail.cpp @@ -31,9 +31,9 @@ int source_manager(const GameState& g, int club) { int club_of_slot(int slot) { if (slot < 0) return -1; - if (slot < 90 * 24) return slot / 24; - if (slot < 90 * 24 + 48 * 16) return (slot - 90 * 8) / 16; - if (slot >= 3072 && slot < 3096) return kNoTeam; + if (slot < runtime_dimensions.big_squad_teams * 24) return slot / 24; + if (slot < runtime_dimensions.pool_first) return (slot - runtime_dimensions.big_squad_teams * 8) / 16; + if (slot >= runtime_dimensions.national_slots_first && slot < runtime_dimensions.extra_slots_first) return kNoTeam; return -1; } @@ -72,7 +72,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 >= runtime_dimensions.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"); diff --git a/src/game/club_player_detail.hpp b/src/game/club_player_detail.hpp index b8a5126..82a8d30 100644 --- a/src/game/club_player_detail.hpp +++ b/src/game/club_player_detail.hpp @@ -53,7 +53,7 @@ struct ClubPlayerDetailContext { // OpenTransferEditor passes actual slots CareerRuntimeField + entry (0..39) for ordinary // transfer-market pool cards. It never turns the entry into a squad row. -constexpr int kClubPlayerDetailMarketPoolFirst = 0xb70; +inline const int& kClubPlayerDetailMarketPoolFirst = runtime_dimensions.pool_first; constexpr int kClubPlayerDetailMarketPoolCount = 40; // Resolves runtime club, explicit row and Source loan/national ownership without diff --git a/src/game/cup.cpp b/src/game/cup.cpp index 766843f..648526e 100644 --- a/src/game/cup.cpp +++ b/src/game/cup.cpp @@ -482,7 +482,7 @@ void order_national_cup_ties(GameState& g, int teams, int offset) { for (int i = 0; i < teams; i += 2) { if (lower <= team(i + 1) && team(i) < lower) swap16(mem, list + uint32_t(i) * 2, list + uint32_t(i + 1) * 2); - auto league = [](int t) { return t > 0x164 ? 0 : team_league(t); }; + auto league = [](int t) { return t > (kNoTeam - 1) ? 0 : team_league(t); }; const int la = league(team(i)), lb = league(team(i + 1)); weights.push_back(uint8_t(kWeight[la < 10 ? la : 9] + kWeight[lb < 10 ? lb : 9])); } diff --git a/src/game/desk_actions.cpp b/src/game/desk_actions.cpp index e1fed7c..9914a98 100644 --- a/src/game/desk_actions.cpp +++ b/src/game/desk_actions.cpp @@ -69,7 +69,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 >= runtime_dimensions.record_teams || opponent < 0 || opponent >= runtime_dimensions.record_teams || opponent == own_team) { out.status = FriendlyQuoteStatus::invalid_opponent; return out; } @@ -122,7 +122,7 @@ NationalFriendlyQuote make_national_friendly_quote(const GameState& g, return out; } // Page 4 cannot return Germany (0); the engine boundary repeats that gate. - if (opponent <= kNoTeam || opponent > 0x1a2 || opponent == kNoTeam) { + if (opponent <= kNoTeam || opponent > (kNoTeam + 61) || opponent == kNoTeam) { out.terms.status = FriendlyQuoteStatus::invalid_opponent; return out; } @@ -624,7 +624,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 >= runtime_dimensions.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 || @@ -790,7 +790,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 >= runtime_dimensions.league_teams) { report.fail(kOrdinarySellerBoundary); out.status = TransferActionStatus::unsupported; out.player = player; out.list_entry = request.list_entry; @@ -1009,7 +1009,7 @@ TransferActionResult submit_transfer_bid_source_impl(GameState& g, const Transfe std::optional 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>=runtime_dimensions.league_teams||index<0||index>=12) return std::nullopt; const auto owner=squad_range(runtime_club); int count=0,ordinal=-1; @@ -1036,7 +1036,7 @@ std::optional 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>=runtime_dimensions.league_teams||borrower==runtime_club)return std::nullopt; } if(borrower<0)return std::nullopt; const auto range=squad_range(borrower); @@ -1072,9 +1072,9 @@ TransferMarketPreviewResult quote_transfer_market_preview_source( return unsupported("market preview: stale Source player/slot"); if(request.purchase) { if(request.snapshot_index!=-1)return unsupported("market preview: snapshot is not a purchase row"); - if(request.source_slot<2928||request.source_slot>=2928+40) + if(request.source_slot=runtime_dimensions.pool_first+40) return unsupported("market preview: purchase is not an ordinary market row"); - const uint32_t seller_at=::bmh::layout::EditorList+uint32_t(request.source_slot-2928)*0x58+8; + const uint32_t seller_at=::bmh::layout::EditorList+uint32_t(request.source_slot-runtime_dimensions.pool_first)*0x58+8; if(!g.memory.has(seller_at)||!g.memory.has(seller_at+1)) return unsupported("market preview: missing Source seller word"); const uint16_t raw=g.memory.u16(seller_at); @@ -1091,7 +1091,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>=runtime_dimensions.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()|| @@ -1133,7 +1133,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>=runtime_dimensions.league_teams) return "OpenTransferEditor: stale ordinary manager/team"; const size_t record=size_t(r.manager)*kRecordSize; if(record+kRecordSize>g.manager_records.size()|| @@ -1143,7 +1143,7 @@ std::string editor_identity(const GameState& g,const TransferOfferEditorRequest& const bool ordinary_entry = r.list_entry >= 0 && r.list_entry < 40 && !r.poach && !r.loan_return_entry; const bool poach_entry = r.list_entry >= 40 && r.list_entry < 44 && r.poach && !r.loan_return_entry; const bool return_entry = r.list_entry >= 40 && r.list_entry < 44 && r.loan_return_entry && !r.poach; - if((!ordinary_entry&&!poach_entry&&!return_entry)||r.source_slot!=2928+r.list_entry|| + if((!ordinary_entry&&!poach_entry&&!return_entry)||r.source_slot!=runtime_dimensions.pool_first+r.list_entry|| size_t(r.source_slot)>=g.squad_slots.size()||r.expected_player<0||r.expected_player>=0x0fff|| size_t(r.expected_player)>=g.players.size()|| int(g.squad_slots[size_t(r.source_slot)]&0x0fff)!=r.expected_player) @@ -1159,7 +1159,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>=runtime_dimensions.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"; diff --git a/src/game/league_pairings.cpp b/src/game/league_pairings.cpp index 212d3de..53736c0 100644 --- a/src/game/league_pairings.cpp +++ b/src/game/league_pairings.cpp @@ -108,7 +108,7 @@ void validate(const GameState& g,const LeaguePairingsOwner& o) { require(o.supported&&!o.closed&&o.manager>=0&&o.manager<4&& size_t(o.manager)=0&&o.runtime_club<138))&& + (national||(o.runtime_club>=0&&o.runtime_club=kResultsSize&&g.club_ids.size()>=138&&g.league_rounds.size()>=9&& + require(g.results.size()>=kResultsSize&&g.club_ids.size()>=runtime_dimensions.league_teams&&g.league_rounds.size()>=9&& 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=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=0&&manager<4&&size_t(manager)=0&&out.runtime_club<138))&& + require((national||(out.runtime_club>=0&&out.runtime_club 3 || team < 0 || team >= 138 || g.lineups_frozen || + if (manager < 0 || manager > 3 || team < 0 || team >= runtime_dimensions.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 || @@ -326,7 +326,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 >= runtime_dimensions.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; @@ -646,7 +646,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; - if (team<0 || team>=138 || g.manager_teams.size()!=1 || g.manager_teams[0]!=kNoTeam || + if (team<0 || team>=runtime_dimensions.league_teams || 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 || !g.memory.has(::bmh::layout::OriginalManagerCount) || g.memory.u8(::bmh::layout::OriginalManagerCount)<1 || g.memory.u8(::bmh::layout::OriginalManagerCount)>4 || @@ -682,7 +682,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 < runtime_dimensions.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) { diff --git a/src/game/match.cpp b/src/game/match.cpp index 565449f..6a59f45 100644 --- a/src/game/match.cpp +++ b/src/game/match.cpp @@ -103,7 +103,7 @@ void rate_side(GameState& g, const MatchSetup& m, int side, int previous6, Watco } } if (side == 0) { - int league = team > 0x164 ? 0 : team_league(team); // TeamLeague2 + int league = team > (kNoTeam - 1) ? 0 : team_league(team); // TeamLeague2 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 diff --git a/src/game/match_engine.cpp b/src/game/match_engine.cpp index 806c557..b7841a7 100644 --- a/src/game/match_engine.cpp +++ b/src/game/match_engine.cpp @@ -78,7 +78,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 >= runtime_dimensions.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}; @@ -522,8 +522,8 @@ ForcedMatchEvent MatchEngine::event_impl(MatchGroup& g, int m, int s, int minute // 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). - if (!(team < 90 || rand.range(0, 1) == 0)) return result; - if (!(team < 138 || team == kNoTeam)) return result; + if (!(team < runtime_dimensions.big_squad_teams || rand.range(0, 1) == 0)) return result; + if (!(team < runtime_dimensions.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; @@ -944,7 +944,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 < runtime_dimensions.record_teams || 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; @@ -979,7 +979,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 >= runtime_dimensions.record_teams && team != kNoTeam) { // clubs without squad: the attack rating (TeamRating, profile 3), drawn RatingContext drawn; drawn.rand = &rand; @@ -989,7 +989,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 >= runtime_dimensions.record_teams && opp_team != kNoTeam) { // clubs without squad: the goalkeeping rating (profile 0), drawn RatingContext drawn; drawn.rand = &rand; @@ -1196,7 +1196,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 < runtime_dimensions.league_teams || team == kNoTeam) { // a player who has not taken a penalty yet (after 100 tries the list restarts) int tries = 0; bool fresh; diff --git a/src/game/matchday.cpp b/src/game/matchday.cpp index 7e60bbf..c2dbbac 100644 --- a/src/game/matchday.cpp +++ b/src/game/matchday.cpp @@ -46,7 +46,7 @@ int competition_class(int type) { return type >= 0 && type < 24 ? kCompetitionCl // TeamLeague2: league (0-8) of a club id, 9 for clubs outside the leagues. int league_of(int team) { - if (team > 0x164) return 0; + if (team > (kNoTeam - 1)) return 0; int end = 0; for (int l = 0; l < 9; l++) { end += kLeagueSizes[l]; @@ -129,10 +129,10 @@ 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 < runtime_dimensions.record_teams) { 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)); + const uint8_t source = state.club_short_offset(team); const size_t offset = source >> 4; const size_t length = (source & 0x0f) + 1; if (offset <= full.size()) { @@ -302,7 +302,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 < kLeagueSizes[0] || (home >= 90 && home < runtime_dimensions.league_teams); const int win_points = kThreePoints[league_of(home)] ? 3 : 2; if (league) { add16(H + 0x20, hg); @@ -404,7 +404,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 < runtime_dimensions.record_teams || 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); @@ -586,7 +586,7 @@ bool league_screen_shown(const std::vector& buttons, int param_1, int p int table_position(const GameState& g, int team) { - if (team >= 138) return 2; + if (team >= runtime_dimensions.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; @@ -667,8 +667,8 @@ void manager_match_record(GameState& g, const MatchGroup& grp, int m, int home_g rating = std::clamp(int16_t(rating), int16_t(0), int16_t(200)); rate_manager(g, int(k), rating, 0); } - if (opp < 0xa8) { - size_t at = k * 0x690 + size_t(opp) * 10 + (side == 1 ? 5 : 0); + if (opp < runtime_dimensions.record_teams) { + size_t at = k * (runtime_dimensions.record_teams * 10) + 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); g.manager_results.at(at) = uint8_t(own + (against << 4)); @@ -717,6 +717,7 @@ void advance_league_rounds(GameState& g, uint32_t competitions, WatcomRandom& ra const int end = bit < 4 ? bit + 1 : 8; for (int c = bit; c < end; c++) { for (int league = kFirst[c]; league < kFirst[c] + kCount[c]; league++) { + if (runtime_dimensions.expanded && g.league_rounds.at(size_t(league)) >= 2 * (kLeagueSizes[league] - 1)) continue; if (league == 0) { for (size_t m = 0; m < g.manager_teams.size(); m++) { advance_youth_teams(g, int(m), rand); diff --git a/src/game/matchday_setup.cpp b/src/game/matchday_setup.cpp index a266d50..7321e76 100644 --- a/src/game/matchday_setup.cpp +++ b/src/game/matchday_setup.cpp @@ -35,9 +35,9 @@ constexpr uint8_t kCompetitionClass[24] = {0, 1, 2, 2, 2, 3, 3, 3, 3, 255, 0, 25 // 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; +const int& kLeagueClubCount = runtime_dimensions.league_teams; // Squad slots checked by the driver (CareerRuntimeField). -constexpr size_t kSquadSlotCount = 0xb70; +const int& kSquadSlotCount = runtime_dimensions.pool_first; // The attendance tables MatchdaySetup_Attendance_ExecutableField .. MatchdaySetupRuntimeField2 as one block, because the original // indexes them with league classes 0-7 although they only have four entries: classes 4-7 @@ -76,7 +76,7 @@ void wr16(Bytes& b, size_t o, uint16_t v) { b.at(o) = uint8_t(v), b.at(o + 1) = // TeamLeague2: league of a club, 0 for the special ids above 0x164, 9 outside the leagues. int league_of(int team) { - if (team > 0x164) return 0; + if (team > (kNoTeam - 1)) return 0; return team_league(team); } @@ -376,7 +376,7 @@ void indoor_tournament_draw(GameState& g, GameRandom& game, WatcomRandom& rand) indoor_tournament_reset(g); uint8_t attempts = 0; const int guest = rand.range(0, 1); - if (guest != 0) mem.set16(kTeams, uint16_t(rand.range(90, 137))); + if (guest != 0) mem.set16(kTeams, uint16_t(rand.range(runtime_dimensions.domestic_teams, runtime_dimensions.league_teams - 1))); int count = guest != 0; int n = rand.range(5, 7); uint8_t lo = 0, hi = uint8_t(kLeagueSizes[0]); @@ -431,7 +431,7 @@ void indoor_tournament_draw(GameState& g, GameRandom& game, WatcomRandom& rand) int sum = 0; // IndoorTournamentReset 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 + const int league = t > (kNoTeam - 1) ? 0 : team_league(t); // TeamLeague2 if (league < 2) sum += (0x26 - table_position(g, t)) - kLeagueSizes[0] * league; else if (league < 5) sum += 1; else sum += 0x19; @@ -563,6 +563,7 @@ std::vector setup_matchday(GameState& g, uint32_t competitions, cons for (int k = from; k < to; k++) { // FixturesFromGenerateFixtures(k) for (int league = kGroupLeague[k]; league < kGroupLeague[k] + kGroupLeagues[k]; league++) { + if (runtime_dimensions.expanded && g.league_rounds.at(size_t(league)) >= 2 * (kLeagueSizes[league] - 1)) continue; turn_step = "setup: winter postponements"; winter_postponements(g, ctx.season_day, league, game, rand); const int round = g.league_rounds.at(size_t(league)); @@ -886,7 +887,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 + const int kLeagueTeams = runtime_dimensions.league_teams; // CareerSession_DispatchLineup_RuntimeField if (g.indoor || own >= kLeagueTeams || other >= kLeagueTeams || (own_manager < 0 && other_manager < 0)) return; if (other_manager >= 0) for (size_t s = 0; s < 24; s++) { diff --git a/src/game/memory.hpp b/src/game/memory.hpp index cfcd813..692666b 100644 --- a/src/game/memory.hpp +++ b/src/game/memory.hpp @@ -20,6 +20,7 @@ #include #include "formats/savestate.hpp" +#include "formats/executable_layout.hpp" namespace bmh { @@ -34,7 +35,15 @@ public: explicit StaticMemory(const SaveState& save) { for (const SaveBlock& b : save.blocks()) if (!b.heap && b.size != 0 && !blocks_.count(b.address)) - blocks_[b.address].assign(save.stream().begin() + b.offset, save.stream().begin() + b.offset + b.size); + { + // Expanded tails live in typed GameState vectors. Keep guest + // memory at Original extents to avoid aliasing adjacent globals. + size_t size = b.size; + if (b.address == layout::ClubKitSelectors) size = std::min(size, size_t(419)); + if (b.address == layout::ClubShortNameOffsets) size = std::min(size, size_t(168)); + if (b.address == layout::ManagerMatchHistory) size = std::min(size, size_t(8400)); + blocks_[b.address].assign(save.stream().begin() + b.offset, save.stream().begin() + b.offset + size); + } } // A global the savegame does not store (e.g. a work list the original rebuilds before diff --git a/src/game/month.cpp b/src/game/month.cpp index ee02477..3a23fbf 100644 --- a/src/game/month.cpp +++ b/src/game/month.cpp @@ -30,12 +30,12 @@ constexpr size_t kBoard = 0x840; // tactics board of a manager constexpr size_t kBoardSlot = 0x58; constexpr uint32_t kTransferList = ::bmh::layout::EditorList; constexpr uint32_t kListEntry = 0x58; -constexpr int kPoolFirst = 0xb70; // CareerRuntimeField: the transfer list (40 slots + 4) -constexpr int kFreeAgents = 0xb9c; // CareerRuntimeField2: free agents (80 slots) -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 +const int& kPoolFirst = runtime_dimensions.pool_first; // CareerRuntimeField: the transfer list (40 slots + 4) +const int& kFreeAgents = runtime_dimensions.free_first; // CareerRuntimeField2: free agents (80 slots) +const int& kForeignAgents = runtime_dimensions.foreign_free_first; // MonthRuntimeField: foreign free agents (20 slots) +const int& kPoolEnd = runtime_dimensions.national_slots_first; // LargeSquadClubCount +const int& kBigSquadClubs = runtime_dimensions.big_squad_teams; // TeamsWithSquads +const int& kLeagueClubs = runtime_dimensions.league_teams; // CareerSession_DispatchLineup_RuntimeField // MonthRuntimeField2: development steps by strength / 10; the ten bytes after it (PlayerCard_PlayerCardMarketValue_RuntimeField) // are the extra value above 500 points. @@ -162,8 +162,8 @@ bool in_pseudo_squad(const GameState& g, int slot) { void list_club_player(GameState& g, int first, int last, WatcomRandom& rand, MinuteReport& report) { const int8_t* wanted = first < kBigSquadClubs ? kWantedBig : kWantedSmall; // Attempt for (;;) { - int16_t teams[138]; - uint32_t keys[138]; + std::vector teams(size_t(kLeagueClubs), 0); + std::vector keys(size_t(kLeagueClubs), 0); int n = 0; // local_14 g.list_toggle = g.list_toggle + 1 == 2 ? 0 : g.list_toggle + 1; int best_line = 0; // local_1c, keeps its value between the clubs @@ -207,10 +207,10 @@ void list_club_player(GameState& g, int first, int last, WatcomRandom& rand, Min n++; } } - int pick = 0x8a; // sVar11 + int pick = runtime_dimensions.league_teams; // sVar11 int slot = -1; // unaff_EDI: the slot tried last if (n != 0) { - quicksort_by_key(teams, keys, n); + quicksort_by_key(teams.data(), keys.data(), n); for (pick = 0; pick < n; pick++) { const int team = teams[pick]; const SquadRange range = squad_range(team); @@ -229,7 +229,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 < runtime_dimensions.league_teams) { list_player(g, slot, rand, report); return; } diff --git a/src/game/national.cpp b/src/game/national.cpp index 77cf4f8..cec48ca 100644 --- a/src/game/national.cpp +++ b/src/game/national.cpp @@ -19,7 +19,7 @@ constexpr size_t kBoard = 0x840; // one manager's tactics board (24 x 0 constexpr size_t kBoardSlot = 0x58; 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 +const int& kPoolSlots = runtime_dimensions.pool_first; // CareerRuntimeField: the clubs' squads end here constexpr uint8_t kNominated[4] = {3, 5, 7, 5}; // NationalRuntimeField: keepers, defence, midfield, attack // the manager's team (record +0x290) as the port caches it diff --git a/src/game/other_games.cpp b/src/game/other_games.cpp index ff97713..7da3b69 100644 --- a/src/game/other_games.cpp +++ b/src/game/other_games.cpp @@ -156,13 +156,13 @@ OtherGamesClubMetadata source_metadata(const GameState& game, int team) { 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 >= runtime_dimensions.record_teams && !manager_owned) { + const size_t at = size_t(team - runtime_dimensions.record_teams); 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 >= runtime_dimensions.record_teams && team != kNoTeam) invalid("manager-controlled foreign-club row needs live TeamRating W-generator context"); constexpr std::array kFlags{0x0f1, 0x0f2, 0x0f4, 0x0f8, 0x0ff}; for (size_t i = 0; i < kFlags.size(); ++i) diff --git a/src/game/poach.cpp b/src/game/poach.cpp index bdc2c73..f24a93b 100644 --- a/src/game/poach.cpp +++ b/src/game/poach.cpp @@ -16,9 +16,9 @@ constexpr size_t kRecordSize = 0xb0c; 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; -constexpr size_t kPoolFirst = 0xb70; // CareerRuntimeField: squad slot of list row 0 +const int& kPoolFirst = runtime_dimensions.pool_first; // CareerRuntimeField: squad slot of list row 0 constexpr uint32_t kOfferSlots = ::bmh::layout::OfferSlots; // OfferSlots: 4 words, -1 free -constexpr int kBigSquadClubs = 90; // TeamsWithSquads +const int& kBigSquadClubs = runtime_dimensions.big_squad_teams; // TeamsWithSquads // Attempt: how many players of each position a club wants (MonthRuntimeField4 / MonthRuntimeField5) constexpr int8_t kWantedBig[4] = {2, 6, 7, 5}, kWantedSmall[4] = {2, 4, 5, 4}; diff --git a/src/game/prediction.cpp b/src/game/prediction.cpp index 17c3dfb..f763a66 100644 --- a/src/game/prediction.cpp +++ b/src/game/prediction.cpp @@ -21,7 +21,7 @@ constexpr size_t kBoardSlot = 0x58; // 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 +const int& kLeagueTeams = runtime_dimensions.league_teams; // CareerSession_DispatchLineup_RuntimeField: clubs in the league system // Text of a pointer variable of the text table TextPointerTable. } // namespace diff --git a/src/game/rating.cpp b/src/game/rating.cpp index 9e554d0..4c64aa0 100644 --- a/src/game/rating.cpp +++ b/src/game/rating.cpp @@ -121,7 +121,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 >= runtime_dimensions.record_teams && 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 @@ -130,7 +130,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 - runtime_dimensions.record_teams)); int16_t total = 0; for (int i = 0; i < 4; i++) { const int level = kLevel[s >> 5]; diff --git a/src/game/save.cpp b/src/game/save.cpp index bb88d41..e36f3c0 100644 --- a/src/game/save.cpp +++ b/src/game/save.cpp @@ -94,6 +94,12 @@ Bytes save_stream(const GameState& live) { // the blocks GameState keeps in typed fields switch (b.address) { case ::bmh::layout::ManagerRecords: put(d, g.manager_records); break; + case ::bmh::layout::ClubKitSelectors: + if (g.counts.league_teams == 164) put(d, g.club_kits); + break; + case ::bmh::layout::ClubShortNameOffsets: + if (g.counts.league_teams == 164) put(d, g.club_short_offsets); + break; case ::bmh::layout::ManagerMatchHistory: put(d, g.manager_results); break; case ::bmh::layout::ManagerRatings: put(d, g.manager_ratings); break; case ::bmh::layout::LeagueResults: put(d, g.results); break; @@ -140,7 +146,7 @@ Bytes save_header(const GameState& g) { for (int m = 0; m < managers && m < 4; m++) { const size_t rec = size_t(m) * 0xb0c; 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; @@ -156,7 +162,7 @@ Savegame make_savegame(const GameState& g, WatcomRandom& rand) { Savegame s; s.plain_header = save_header(g); s.id1 = 0; - s.version = "V2.24"; + s.version = g.counts.league_teams == 164 ? "O1.1" : "V2.24"; const uint32_t hi = uint32_t(rand.range(0, 0x8fff)), lo = uint32_t(rand.range(0, 0x8fff)); s.id2 = lo + hi * 0x10000 + 1; s.key = uint8_t(rand.range(0, 0xff) + 'n'); diff --git a/src/game/season.cpp b/src/game/season.cpp index 739edeb..4905feb 100644 --- a/src/game/season.cpp +++ b/src/game/season.cpp @@ -28,7 +28,7 @@ namespace { constexpr uint32_t kTransferList = ::bmh::layout::EditorList; // 44 entries of 0x58 bytes constexpr uint32_t kListEntry = 0x58; -constexpr size_t kPoolSlots = 0xb70; // CareerRuntimeField +const int& kPoolSlots = runtime_dimensions.pool_first; // 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; @@ -173,7 +173,7 @@ void club_balance(GameState& g, int team, WatcomRandom& rand) { namespace { // TeamLeague2: the league of a club; ids above 0x164 (national teams) count as league 0 -int club_league(int team) { return team > 0x164 ? 0 : team_league(team); } +int club_league(int team) { return team > (kNoTeam - 1) ? 0 : team_league(team); } // The European entrants (Career_CompetitionPointersEnglish_ExecutableField25 UEFA Cup, Career_CompetitionPointersEnglish_RuntimeField14 Champions League, // Career_CompetitionPointersEnglish_ExecutableField19 Cup Winners' Cup) and their counts (Career_EuropeanClub_ExecutableField / Career_EuropeanClub_ExecutableField2 / Career_EuropeanClub_ExecutableField3). @@ -279,9 +279,9 @@ void observe_initial_international_groups(GameState& g, WatcomRandom& rand, int 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; + mem.u16(::bmh::layout::CupDraw_FormatError_RuntimeField2)==kNoTeam&&mem.u16(::bmh::layout::CupDraw_FormatError_RuntimeField3)==team; const bool human_owned=g.manager_of(team)>=0||manager_national; - if(team<168||team==kNoTeam||!human_owned)continue; + if(team last; if (s % 2 == 0) { @@ -390,7 +390,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 = runtime_dimensions.league_teams + 0x1e; // CareerSession_DispatchLineup_RuntimeField + CareerSession_InstallLeagueSizes_RuntimeField6: the first foreign club auto pick = [&](int from) { int t; do t = rand.range(from, from + 6); while (en.find(t) != 0); @@ -759,7 +759,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 >= runtime_dimensions.league_teams + 0x1e || b >= runtime_dimensions.league_teams + 0x1e) return; auto swap_bytes = [](std::vector& 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]); @@ -776,7 +776,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 < runtime_dimensions.league_teams && b < runtime_dimensions.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); @@ -786,21 +786,28 @@ 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 < runtime_dimensions.record_teams && b < runtime_dimensions.record_teams) swap_bytes(g.club_table, size_t(a) * 0x4a, size_t(b) * 0x4a, 0x4a); 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); std::swap(g.team_morale.at(size_t(a)), g.team_morale.at(size_t(b))); - swap_mem8(::bmh::layout::ClubShortNameOffsets); - swap_mem8(::bmh::layout::ClubKitSelectors); + if (runtime_dimensions.expanded) { + std::swap(g.club_short_offsets.at(size_t(a)), g.club_short_offsets.at(size_t(b))); + std::swap(g.club_kits.at(size_t(a)), g.club_kits.at(size_t(b))); + } else { + swap_mem8(::bmh::layout::ClubShortNameOffsets); + swap_mem8(::bmh::layout::ClubKitSelectors); + } swap_bytes(g.club_heap_78, size_t(a) * 2, size_t(b) * 2, 2); std::swap(g.team_flags.at(size_t(a)), g.team_flags.at(size_t(b))); if (league_clubs) { - swap_bytes(g.club_heap_b8, size_t(a) * 2, size_t(b) * 2, 2); + if (runtime_dimensions.expanded) std::swap(g.club_heap_b8.at(size_t(a)), g.club_heap_b8.at(size_t(b))); + else swap_bytes(g.club_heap_b8, size_t(a) * 2, size_t(b) * 2, 2); swap_bytes(g.position_history, size_t(a) * 0x1a, size_t(b) * 0x1a, 0x1a); const SquadRange ra = squad_range(a), rb = squad_range(b); for (size_t i = 0; i < ra.count; i++) std::swap(g.squad_slots.at(ra.first + i), g.squad_slots.at(rb.first + i)); } - swap_bytes(g.club_heap_b8, size_t(a) * 2, size_t(b) * 2, 2); + if (runtime_dimensions.expanded) std::swap(g.club_heap_b8.at(size_t(a)), g.club_heap_b8.at(size_t(b))); + else swap_bytes(g.club_heap_b8, size_t(a) * 2, size_t(b) * 2, 2); replace(::bmh::layout::Titles, 0x1c2); // title holders replace(::bmh::layout::Career_CompetitionPointersEnglish_ExecutableField28, 2); if (!mem.has(::bmh::layout::CareerSession_FormatError_RuntimeField6) || mem.u8(::bmh::layout::CareerSession_FormatError_RuntimeField6) == 0) { @@ -830,7 +837,7 @@ void change_places(GameState& g, int a, int b) { const uint16_t w = v == uint16_t(a) ? uint16_t(b) : v == uint16_t(b) ? uint16_t(a) : v; g.manager_records.at(at) = uint8_t(w), g.manager_records.at(at + 1) = uint8_t(w >> 8); } - swap_bytes(g.manager_results, size_t(a) * 10 + m * 0x690, size_t(b) * 10 + m * 0x690, 10); + swap_bytes(g.manager_results, size_t(a) * 10 + m * (runtime_dimensions.record_teams * 10), size_t(b) * 10 + m * (runtime_dimensions.record_teams * 10), 10); } } @@ -1080,7 +1087,7 @@ bool release_player(GameState& g, int slot, GameRandom& game, WatcomRandom& rand } const int team = slot_team(slot); const bool foreign = nationality(g, player) != 0; - const int start = foreign ? 0xbec : 0xb9c, count = foreign ? 0x14 : 0x50; // FirstFreeSlotSquad + const int start = foreign ? runtime_dimensions.foreign_free_first : runtime_dimensions.free_first, count = foreign ? 0x14 : 0x50; // FirstFreeSlotSquad int free = -1; for (int s = start; s < start + count && free < 0; s++) if (g.squad_slots.at(size_t(s)) == 0x0FFF) free = s; @@ -1168,7 +1175,7 @@ void season_players(GameState& g, GameRandom& game, WatcomRandom& rand, MinuteRe int8_t owner = -1; // local_24: the club's human manager size_t board_first = 0; // local_3c std::vector processed(g.players.size(), false); - for (int s = 0; s < 0xc00 && !report.unsupported; s++) { + for (int s = 0; s < runtime_dimensions.national_slots_first && !report.unsupported; s++) { for (;;) { const int player = g.squad_slots.at(size_t(s)) & 0xFFF; if (player == 0xFFF) break; @@ -1186,7 +1193,7 @@ void season_players(GameState& g, GameRandom& game, WatcomRandom& rand, MinuteRe } Player& p = g.players.at(size_t(player)); bool leaves = false; - if (s < 0xb70 && (p.w35c >> 27) == 0x1f) { + if (s < runtime_dimensions.pool_first && (p.w35c >> 27) == 0x1f) { // out for his career bool gone = true; if (owner != -1) { @@ -1267,8 +1274,8 @@ void season_players(GameState& g, GameRandom& game, WatcomRandom& rand, MinuteRe g.lineups_frozen = false; } for (size_t l = 0; l < g.league_rounds.size() && l < 9; l++) g.league_rounds[l] = 0; - fill8(::bmh::layout::DeskRecords_Teams_RuntimeField, 0x114, 0); - for (size_t i = 0; i < size_t(0x8a) * 0x1a && i < g.position_history.size(); i++) g.position_history[i] = 0; + fill8(::bmh::layout::DeskRecords_Teams_RuntimeField, uint32_t(g.counts.league_teams * 2), 0); + for (size_t i = 0; i < size_t(runtime_dimensions.league_teams) * 0x1a && i < g.position_history.size(); i++) g.position_history[i] = 0; std::fill(g.results.begin(), g.results.end(), uint8_t(0xcc)); } @@ -1654,8 +1661,8 @@ void initialize_european_qualification_seed(GameState& g) { if (g.memory.u16(entry + 0x22) == 0 && g.memory.u16(entry + 0x24) == 0) { // OpenBMH deviates from the original: initializes the empty EM qualifier // seeds with national teams, preventing club zero from entering the EM. - g.memory.set16(entry + 0x22, 357); - g.memory.set16(entry + 0x24, 358); + g.memory.set16(entry + 0x22, kNoTeam); + g.memory.set16(entry + 0x24, (kNoTeam + 1)); } } @@ -1663,20 +1670,20 @@ bool career_season_setup(GameState& g, GameRandom& game, WatcomRandom& rand, Min const std::function& pause, const SeasonCupDrawHook& cup_draw) { StaticMemory& mem = g.memory; - g.team_morale.at(0x165) |= 0x80; - for (int team = 0; team < 0x8a; team++) { + g.team_morale.at(kNoTeam) |= 0x80; + for (int team = 0; team < runtime_dimensions.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 first_small = uint16_t(league_first_team(5)); // TeamsWithSquads + const uint16_t foreign = 189 + runtime_dimensions.league_teams + 30; // ClubPlayerDetail_ClubPlayerDetailFromGame_RuntimeField3 + CareerSession_DispatchLineup_RuntimeField + CareerSession_InstallLeagueSizes_RuntimeField6 (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) - 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_RuntimeField5, uint16_t(league_first_team(7) + 7)); + mem.set16(::bmh::layout::Season_CareerSeasonSetup_RuntimeField4, uint16_t(league_first_team(6) + 7)); mem.set16(::bmh::layout::Season_CareerSeasonSetup_RuntimeField3, uint16_t(foreign + 1)); initialize_european_qualification_seed(g); mem.set16(::bmh::layout::Career_CompetitionPointersEnglish_ExecutableField28, 0); diff --git a/src/game/sportschau_awards.cpp b/src/game/sportschau_awards.cpp index 06e1c36..d35347b 100644 --- a/src/game/sportschau_awards.cpp +++ b/src/game/sportschau_awards.cpp @@ -25,7 +25,7 @@ std::optional matchday_intro_view(const GameState& state, if (league >= 9) throw FormatError("matchday intro: invalid Source league"); // LeagueName with TeamStatistics_SourceLeagueName_RuntimeField=1 includes the secondary-league prefix. name = league < 5 ? league_name(state, int(league)) : - message_text(state, ::bmh::layout::SportschauAwards_MatchdayIntroView_TextPointer) + state.club_name(0x165 + int(league) - 4); + message_text(state, ::bmh::layout::SportschauAwards_MatchdayIntroView_TextPointer) + state.club_name(kNoTeam + int(league) - 4); } else { if (type > 14) throw FormatError("matchday intro: invalid Source competition type"); name = message_text(state, ::bmh::layout::DeskState_FormatError_ExecutableField3 + uint32_t(type) * 4); @@ -43,7 +43,7 @@ std::string sportschau_competition_title(const GameState& state, const MatchGrou if (id > 20) index = state.memory.u8(id + 0x18) + 9; else if (index >= 9) index = std::min(index + 12, 19); if (index < 5) return league_name(state, index); - if (index < 9) return state.club_name(0x165 + index - 4); + if (index < 9) return state.club_name(kNoTeam + index - 4); return message_text(state, ::bmh::layout::CupDraw_FormatError_ExecutableField6 + uint32_t(index - 9) * 4); } diff --git a/src/game/state.cpp b/src/game/state.cpp index a10096c..7048eb8 100644 --- a/src/game/state.cpp +++ b/src/game/state.cpp @@ -90,6 +90,8 @@ GameState GameState::from_save(const SaveState& save, const DbCounts& c) { auto bytes = [&](uint32_t address) { return std::vector(save.data(address), save.data(address) + save.block(address).size); }; + g.club_kits = bytes(layout::ClubKitSelectors); + g.club_short_offsets = bytes(layout::ClubShortNameOffsets); g.manager_results = bytes(::bmh::layout::ManagerMatchHistory); g.manager_ratings = bytes(::bmh::layout::ManagerRatings); g.position_history = bytes(::bmh::layout::LeagueRankHistory); @@ -113,6 +115,13 @@ GameState GameState::from_save(const SaveState& save, const DbCounts& c) { return g; } +uint8_t GameState::club_kit(int team) const { + return counts.league_teams == 164 ? club_kits.at(size_t(team)) : memory.u8(layout::ClubKitSelectors + uint32_t(team)); +} +uint8_t GameState::club_short_offset(int team) const { + return counts.league_teams == 164 ? club_short_offsets.at(size_t(team)) : memory.u8(layout::ClubShortNameOffsets + uint32_t(team)); +} + int GameState::manager_of(int team) const { for (size_t m = 0; m < manager_teams.size(); m++) if (manager_teams[m] == team) return int(m); diff --git a/src/game/state.hpp b/src/game/state.hpp index a54b8f1..0377ab8 100644 --- a/src/game/state.hpp +++ b/src/game/state.hpp @@ -38,6 +38,9 @@ constexpr uint16_t kSlotInLineup = 0x8000; struct GameState { DbCounts counts{}; + std::vector club_kits, club_short_offsets; + uint8_t club_kit(int team) const; + uint8_t club_short_offset(int team) const; std::vector squad_slots; // *SquadSlots, all squads back to back (see squad_range) std::vector players; // *PlayerConditionTechniqueForm / *PlayerSkillWords / *PlayerIdentityWords, names not filled std::vector team_morale; // *TeamMorale, per team: bits 0-5 morale / 2, bits 6-7 flags diff --git a/src/game/top_scorers.cpp b/src/game/top_scorers.cpp index 22ffb47..bc27a6c 100644 --- a/src/game/top_scorers.cpp +++ b/src/game/top_scorers.cpp @@ -70,13 +70,13 @@ TopScorersProjection top_scorers_from_game(const GameState& g, int manager_slot, invalid("manager has no supported domestic league"); // TeamLeague2 deliberately maps team IDs above 0x164 (including the // national team 0x165) to league zero; ordinary cup-only teams map to 9. - const int league = manager_team > 0x164 ? 0 : team_league(manager_team); + const int league = manager_team > (kNoTeam - 1) ? 0 : team_league(manager_team); if (league < 0 || league >= kLeagueCount) 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 || + if (first_team < 0 || first_team + team_count > runtime_dimensions.league_teams || g.club_ids.size() < size_t(first_team + team_count) || g.club_names.empty()) invalid("incomplete domestic club table"); diff --git a/src/game/weekly.cpp b/src/game/weekly.cpp index 757514d..bd574bb 100644 --- a/src/game/weekly.cpp +++ b/src/game/weekly.cpp @@ -125,7 +125,7 @@ bool source_pending_owner_valid(const GameState& g,const SourcePendingOwner& own int((word>>10)&0x0fff)==int(g.squad_slots[slot]&0x0fff); } -int league_of(int team) { return team > 0x164 ? 0 : team_league(team); } // TeamLeague2 +int league_of(int team) { return team > (kNoTeam - 1) ? 0 : team_league(team); } // TeamLeague2 } // namespace @@ -959,7 +959,7 @@ static bool remove_from_seller_impl(GameState& g, int seller, int player, Minute bool native_takeover) { player &= 0xFFF; if (seller == 0xFFF || seller == 0xFFFF) { - for (size_t s = kPoolSlots; s < 3072; s++) // CareerRuntimeField .. LargeSquadClubCount + for (size_t s = kPoolSlots; s < runtime_dimensions.national_slots_first; s++) // CareerRuntimeField .. LargeSquadClubCount if ((g.squad_slots[s] & 0xFFF) == player) g.squad_slots[s] = 0xFFF; return true; } @@ -970,7 +970,7 @@ static bool remove_from_seller_impl(GameState& g, int seller, int player, Minute report.fail("transfer: the player is not in the seller's squad (internal error 0x21)"); return false; } - for (size_t s = kPoolSlots; s < 2972; s++) // CareerRuntimeField .. CareerRuntimeField2 + for (size_t s = kPoolSlots; s < runtime_dimensions.free_first; s++) // CareerRuntimeField .. CareerRuntimeField2 if ((g.squad_slots[s] & 0xFFF) == player) g.squad_slots[s] = 0xFFF; for (size_t s = at; s + 1 < range.first + range.count; s++) g.squad_slots[s] = g.squad_slots[s + 1]; g.squad_slots[range.first + range.count - 1] = 0xFFF; @@ -2151,7 +2151,7 @@ HumanBuyerSaleResult settle_human_buyer_sale(GameState& g, const HumanBuyerSaleR if (free_agent) { // ReleasePlayer's canonical 0FFF seller scans the entire free-player pool, // not a fictitious seller squad. FFFF is not an alias for this seller. - if (g.squad_slots.size() < 3072) + if (g.squad_slots.size() < runtime_dimensions.national_slots_first) return fail("ReleasePlayer: free-agent pool is outside native squad storage"); } else { const auto seller_range = squad_range(seller); @@ -2525,7 +2525,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>=runtime_dimensions.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=138 && !national_owner)) + if (team<0 || (team>=runtime_dimensions.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 @@ -2662,7 +2662,7 @@ 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) && + g.manager_teams[0] == kNoTeam && mem.has(::bmh::layout::DeskActions_NationalOpponentManager_RuntimeField) && int(mem.u16(::bmh::layout::CupDraw_FormatError_RuntimeField3)) == club); }; bool human_involved = human_participant(seller); diff --git a/src/ui/alltime_table.cpp b/src/ui/alltime_table.cpp index 37e5eb2..51353c7 100644 --- a/src/ui/alltime_table.cpp +++ b/src/ui/alltime_table.cpp @@ -1,4 +1,5 @@ // SPDX-License-Identifier: GPL-3.0-only +#include "game/state.hpp" #include "formats/executable_layout.hpp" #include "alltime_table.hpp" #include @@ -25,11 +26,11 @@ void button(Image&out,const Image&a,const SpriteFont&spr,const LeImage&exe,int x } AllTimeTableState alltime_table_from_game(const GameState&g,const LeImage&exe,DeskRequest owner,const Image&underlay,int nation,bool relative){ if(nation<0||nation>4)throw FormatError("alltime: nation outside 0..4");if(underlay.width!=320||underlay.height!=240)throw FormatError("alltime: parent underlay must be 320x240");AllTimeTableState s;s.owner=owner;s.underlay=underlay;s.nation=nation;s.relative=relative;s.mask=uint8_t((1U<=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=runtime_dimensions.record_teams)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");} diff --git a/src/ui/alltime_table.hpp b/src/ui/alltime_table.hpp index 8458474..f4dae43 100644 --- a/src/ui/alltime_table.hpp +++ b/src/ui/alltime_table.hpp @@ -22,8 +22,8 @@ struct AllTimeTableState { Image underlay; std::vector records; std::array nation_names{}; - std::array club_names{}; - std::array club_name_colors{}; + std::vector club_names = std::vector(size_t(runtime_dimensions.record_teams)); + std::vector club_name_colors = std::vector(size_t(runtime_dimensions.record_teams)); std::vector rows; int nation=0; uint8_t mask=1; diff --git a/src/ui/analytics.cpp b/src/ui/analytics.cpp index d299d52..a95ee65 100644 --- a/src/ui/analytics.cpp +++ b/src/ui/analytics.cpp @@ -47,7 +47,7 @@ int32_t source_asset_mask_1e(const GameState& game, int manager) { } int source_manager_league(const GameState& game, const LeImage& exe, int manager) { const int team = game.manager_teams.at(size_t(manager)); - if (team > 0x164) return 0; // TeamLeague2 special-team early return. + if (team > (kNoTeam - 1)) return 0; // TeamLeague2 special-team early return. int cumulative = 0; for (int league = 0; league < 9; ++league) { cumulative += exe.u8(::bmh::layout::LeagueSizes + uint32_t(league)); diff --git a/src/ui/calendar.cpp b/src/ui/calendar.cpp index 074d392..cd74307 100644 --- a/src/ui/calendar.cpp +++ b/src/ui/calendar.cpp @@ -38,7 +38,7 @@ CalendarScreen::CalendarScreen(const std::filesystem::path& data, CalendarState if (runtime_club >= 0) { // TeamLeague2 returns zero for team handles above0x164 (national included). int league = 0, boundary = 0; - if (runtime_club <= 0x164) { + if (runtime_club <= (kNoTeam - 1)) { for (; league < 9; ++league) { boundary += exe_.u8(::bmh::layout::LeagueSizes + uint32_t(league)); if (runtime_club < boundary) break; diff --git a/src/ui/club_player_detail.cpp b/src/ui/club_player_detail.cpp index aa91b44..8ee67a5 100644 --- a/src/ui/club_player_detail.cpp +++ b/src/ui/club_player_detail.cpp @@ -1,4 +1,5 @@ // SPDX-License-Identifier: GPL-3.0-only +#include "game/state.hpp" #include "formats/badge_policy.hpp" #include "formats/executable_layout.hpp" #include "ui/club_player_detail.hpp" @@ -46,8 +47,8 @@ ClubPlayerDetailProjection club_player_detail_from_game(const GameState& g, for(int i=0;i<2;++i){ const int id=i?c.secondary_club:c.primary_club;if(id<0||id==0xffff)continue; ClubPlayerDetailClub club;club.runtime_team=id;club.original_full_name=g.club_name(id);club.original_short_name=club.original_full_name; - if(id<168){ - const uint8_t raw=g.memory.u8(::bmh::layout::ClubShortNameOffsets+uint32_t(id)); + if(id>4,(raw&15)+1); } // SourceBadgeFallback consults the selector only for real atlas clubs. @@ -98,7 +99,7 @@ ClubPlayerDetailScreen::ClubPlayerDetailScreen(const std::filesystem::path& data } // TextWidth national/foreign names: longest word, then remove two // trailing characters until FNT3 fits57 pixels. - if(id>=168 && small_.text_width(club.original_short_name)>57){ + if(id>=runtime_dimensions.record_teams && small_.text_width(club.original_short_name)>57){ std::string longest;size_t at=0; while(at=0)return (t-kCupOnlyTeams)/7-5+10; return 0; } -int league_for_team(int id) { return id>0x164?0:team_league(id); } +int league_for_team(int id) { return id>(kNoTeam - 1)?0:team_league(id); } uint8_t manager_color(const GameState& game,int id,uint8_t base) { const int active=game.memory.has(::bmh::layout::ActiveManager)?game.memory.u8(::bmh::layout::ActiveManager):-1; const int count=game.memory.has(::bmh::layout::ManagerCount)?game.memory.u8(::bmh::layout::ManagerCount):int(game.manager_teams.size()); @@ -142,10 +143,10 @@ CupDrawProjection cup_draw_from_game(const GameState& game,const SeasonCupDrawEv std::string context; if(event.group_stage&&event.phase==SeasonCupDrawPhase::overview) { const bool human_national=game.manager_of(id)>=0|| - (game.memory.has(::bmh::layout::CupDraw_FormatError_RuntimeField2)&&game.memory.has(::bmh::layout::CupDraw_FormatError_RuntimeField3)&&game.memory.u16(::bmh::layout::CupDraw_FormatError_RuntimeField2)==0x165&&game.memory.u16(::bmh::layout::CupDraw_FormatError_RuntimeField3)==id); - if(id>=168&&!human_national) { - if(size_t(id-168)>=game.foreign_strength.size())throw FormatError("cup draw: missing Source foreign-strength byte"); - const uint8_t strength=game.foreign_strength[size_t(id-168)]; + (game.memory.has(::bmh::layout::CupDraw_FormatError_RuntimeField2)&&game.memory.has(::bmh::layout::CupDraw_FormatError_RuntimeField3)&&game.memory.u16(::bmh::layout::CupDraw_FormatError_RuntimeField2)==kNoTeam&&game.memory.u16(::bmh::layout::CupDraw_FormatError_RuntimeField3)==id); + if(id>=runtime_dimensions.record_teams&&!human_national) { + if(size_t(id-runtime_dimensions.record_teams)>=game.foreign_strength.size())throw FormatError("cup draw: missing Source foreign-strength byte"); + const uint8_t strength=game.foreign_strength[size_t(id-runtime_dimensions.record_teams)]; const unsigned band=strength>>5; context=text_at(texts,size_t((::bmh::layout::CupDraw_FormatError_TextPointer4-::bmh::layout::TextPointerTable)/4)+band)+original_to_utf8(exe.cstring(::bmh::layout::CupDraw_FormatError_TextPointer)); for(unsigned bit=0;bit<3;++bit) @@ -153,7 +154,7 @@ CupDrawProjection cup_draw_from_game(const GameState& game,const SeasonCupDrawEv context+=original_to_utf8(exe.cstring(::bmh::layout::CupDraw_FormatError_ExecutableField)); } else { std::array values{}; - if(id>=168&&id!=kNoTeam) { + if(id>=runtime_dimensions.record_teams&&id!=kNoTeam) { const auto snapshot=std::find_if(event.group_average_snapshots.begin(),event.group_average_snapshots.end(), [&](const auto& v){return v.runtime_id==id;}); if(snapshot==event.group_average_snapshots.end()) diff --git a/src/ui/desk_drawers.cpp b/src/ui/desk_drawers.cpp index 62a06c4..bfe44b3 100644 --- a/src/ui/desk_drawers.cpp +++ b/src/ui/desk_drawers.cpp @@ -1,4 +1,5 @@ // SPDX-License-Identifier: GPL-3.0-only +#include "game/state.hpp" #include "formats/executable_layout.hpp" #include "ui/desk_drawers.hpp" @@ -54,7 +55,7 @@ std::optional source_drawer_team(const DeskState& state, int local_kind) { // away-side swap. The drawer cases use those retained values: when // both are open, uVar21 is local48; otherwise it is local44. const int local44 = state.next_opponent.value_or(-1); - const int local48 = state.national_team ? 0x165 : state.runtime_club; + const int local48 = state.national_team ? kNoTeam : state.runtime_club; const int uVar21 = (open_count == 2) ? local48 : local44; const bool first_case = local_kind == pair[0]; const int side = first_case ? (uVar21 != local48 ? local48 : local44) : uVar21; @@ -182,7 +183,7 @@ void DeskDrawerRenderer::recent(Image& target, const DeskState& state, const Des } void DeskDrawerRenderer::head_to_head(Image& target, const DeskState& state, const DeskItem& item) const { - if (!state.next_opponent || *state.next_opponent < 0 || *state.next_opponent > 0xa7) { + if (!state.next_opponent || *state.next_opponent < 0 || *state.next_opponent >= runtime_dimensions.record_teams) { text(target, state, item.x + 1, item.y + 13, texts_[1207], 0x6a, item.x + 115); // DeskDrawersRuntimeField return; } diff --git a/src/ui/desk_records.cpp b/src/ui/desk_records.cpp index e5793cd..2ff248e 100644 --- a/src/ui/desk_records.cpp +++ b/src/ui/desk_records.cpp @@ -1,4 +1,5 @@ // SPDX-License-Identifier: GPL-3.0-only +#include "game/state.hpp" #include "formats/executable_layout.hpp" #include "ui/desk_records.hpp" @@ -43,7 +44,7 @@ uint8_t source_team_color(const GameState& g,int team) { DeskRecordsState fair_play_state_from_game(const GameState& g, int league, const Image& underlay,int manager_slot) { if(league<0||league>=9) throw FormatError("fair play: invalid Source league"); const int first=league_first_team(league), count=kLeagueSizes[league]; - if(first<0||count<=0||first+count>138||g.club_ids.size()runtime_dimensions.league_teams||g.club_ids.size() teams(static_cast(count)); std::vector keys(static_cast(count)); for(int i=0;i& offsets, } int executable_league(const LeImage& exe, int team) { - if (team < 0 || team >= 138 || !exe.contains(::bmh::layout::LeagueSizes + 8)) return -1; + if (team < 0 || team >= runtime_dimensions.league_teams || !exe.contains(::bmh::layout::LeagueSizes + 8)) return -1; int first = 0; for (int league = 0; league < 9; ++league) { if (!exe.contains(::bmh::layout::LeagueSizes + uint32_t(league))) return -1; @@ -80,7 +81,7 @@ void project_drawer_rows(DeskState& d, const LeImage& exe, const Bytes& managers auto rank_curve = [&](int team, DeskRankCurve& curve) { curve.runtime_team = team; curve.team_name = pool_name(club_names, club_ids, team); - if (team == 0x165) { + if (team == kNoTeam) { // TablePosition returns rank 2 for this special national row; // QuoteNationalFriendlyMatch uses its native no-team squad (no random rating). curve.current_position = 2; @@ -100,16 +101,16 @@ void project_drawer_rows(DeskState& d, const LeImage& exe, const Bytes& managers curve.samples.push_back({round + 1, int((packed >> ((round % 3) * 5)) & 0x1f)}); } if (!curve.samples.empty()) curve.current_position = curve.samples.back().source_rank; - if (game && team < 138) curve.strength = team_average(*game, team, 0x1ff).value; + if (game && team < runtime_dimensions.league_teams) curve.strength = team_average(*game, team, 0x1ff).value; }; - rank_curve(d.runtime_club < 0 ? 0x165 : d.runtime_club, d.rank_curves[0]); + rank_curve(d.runtime_club < 0 ? kNoTeam : d.runtime_club, d.rank_curves[0]); if (authenticated_rival && *authenticated_rival >= 0 && *authenticated_rival != d.runtime_club) rank_curve(*authenticated_rival, d.rank_curves[1]); // SourceDrawerTeam reads only the prepared opponent's venue history. Other // teams' names need not be available to render this manager's current Desk. - if (!authenticated_rival || *authenticated_rival < 0 || *authenticated_rival >= 168) return; - const size_t at = manager * 0x690 + size_t(*authenticated_rival) * 10; + if (!authenticated_rival || *authenticated_rival < 0 || *authenticated_rival >= runtime_dimensions.record_teams) return; + const size_t at = manager * (runtime_dimensions.record_teams * 10) + size_t(*authenticated_rival) * 10; if (at + 10 > manager_results.size()) return; const bool present = std::any_of(manager_results.begin() + at, manager_results.begin() + at + 10, [](uint8_t value) { return value != 0xff; }); @@ -307,7 +308,7 @@ DeskState project(const StaticMemory& memory, const Tables& t, const LeImage& ex d.warnings[3] = remaining < 4; const int max24 = exe.u16(::bmh::layout::TeamsWithSquads), league_teams = exe.u16(::bmh::layout::CareerSession_DispatchLineup_RuntimeField); if (!d.national_team && d.runtime_club >= league_teams) throw FormatError("desk: cup-only squad projection not supported"); - const size_t first = d.national_team ? 3072 : size_t(d.runtime_club < max24 ? d.runtime_club * 24 : d.runtime_club * 16 + max24 * 8); + const size_t first = d.national_team ? runtime_dimensions.national_slots_first : size_t(d.runtime_club < max24 ? d.runtime_club * 24 : d.runtime_club * 16 + max24 * 8); const size_t count = d.national_team ? 24 : (d.runtime_club < max24 ? 24 : 16); if (t.squads.size() < first + count || t.tactics.size() < size_t(d.manager_slot) * 0x840 + count * 0x58) throw FormatError("desk: truncated squad/tactics"); @@ -691,8 +692,8 @@ DeskState desk_from_game(const GameState& g, const LeImage& exe, uint64_t revisi DeskState load_reference_desk(const std::filesystem::path& path, const LeImage& exe) { auto fbm = load_savegame(path); if (!fbm.checksum_ok) throw FormatError("desk: FBM checksum mismatch"); - if (fbm.version != "V2.24") throw FormatError("desk: unsupported FBM version"); - DbCounts counts{exe.u32(::bmh::layout::CareerSession_DataDirectory_RuntimeField), exe.u32(::bmh::layout::CareerSession_DataDirectory_RuntimeField3), exe.u32(::bmh::layout::CareerSession_DataDirectory_RuntimeField2), exe.u32(::bmh::layout::CareerSession_DataDirectory_RuntimeField4)}; + if (fbm.version != (exe.expanded_profile() ? "O1.1" : "V2.24")) throw FormatError("desk: unsupported FBM version"); + DbCounts counts{exe.u32(::bmh::layout::CareerSession_DataDirectory_RuntimeField), exe.u32(::bmh::layout::CareerSession_DataDirectory_RuntimeField3), exe.u32(::bmh::layout::CareerSession_DataDirectory_RuntimeField2), exe.u32(::bmh::layout::CareerSession_DataDirectory_RuntimeField4), uint32_t(exe.u16(layout::CareerSession_DispatchLineup_RuntimeField)), 30}; SaveState save(fbm.stream, counts); auto d = desk_from_save(save, exe); validate_desk_state(d); diff --git a/src/ui/friendly_match.cpp b/src/ui/friendly_match.cpp index ca17164..ef831cd 100644 --- a/src/ui/friendly_match.cpp +++ b/src/ui/friendly_match.cpp @@ -1,4 +1,5 @@ // SPDX-License-Identifier: GPL-3.0-only +#include "game/state.hpp" #include "ui/friendly_match.hpp" #include @@ -80,7 +81,7 @@ FriendlyMatchScreen::FriendlyMatchScreen(const std::filesystem::path& data, Frie data_(data), next_request_id_(state_.first_request_id) { const bool valid_national_slot = state_.national_team && state_.runtime_team == bmh::kNoTeam; if (state_.manager_slot < 0 || state_.manager_slot > 3 || state_.runtime_team < 0 || - (state_.runtime_team >= 168 && !valid_national_slot) || + (state_.runtime_team >= runtime_dimensions.record_teams && !valid_national_slot) || state_.revision == UINT64_MAX || !state_.first_request_id || state_.planner_count < 0 || state_.planner_count > std::numeric_limits::max() - 2) throw FormatError("friendly screen: invalid manager/request identity"); @@ -344,7 +345,7 @@ std::optional FriendlyMatchScreen::click(int x, int y, boo const int row = (y-0x1d)/7; if (row < 0 || size_t(row) >= rows.size()) return std::nullopt; selected_opponent_ = rows[size_t(row)].runtime_team_id; - if (selected_opponent_ == state_.runtime_team || selected_opponent_ < 0 || selected_opponent_ >= 168) { + if (selected_opponent_ == state_.runtime_team || selected_opponent_ < 0 || selected_opponent_ >= runtime_dimensions.record_teams) { selected_opponent_ = -1; feedback_ = "Bitte einen anderen Ligaverein waehlen."; return std::nullopt; diff --git a/src/ui/incoming_transfer.cpp b/src/ui/incoming_transfer.cpp index 2d8048c..41a9115 100644 --- a/src/ui/incoming_transfer.cpp +++ b/src/ui/incoming_transfer.cpp @@ -1,4 +1,5 @@ // SPDX-License-Identifier: GPL-3.0-only +#include "game/state.hpp" #include "formats/badge_policy.hpp" #include "formats/executable_layout.hpp" #include "ui/incoming_transfer.hpp" @@ -62,7 +63,7 @@ std::string source_money(uint32_t value, int width, uint32_t numerator, uint32_t } int team_badge(const GameState& game, int team) { - if (team < 0 || team >= 168 || size_t(team) * 2 + 2 > game.club_heap_78.size()) return -1; + if (team < 0 || team >= runtime_dimensions.record_teams || size_t(team) * 2 + 2 > game.club_heap_78.size()) return -1; return (int(game.club_heap_78[size_t(team) * 2]) | int(game.club_heap_78[size_t(team) * 2 + 1]) << 8) & 0x1ff; } diff --git a/src/ui/league_pairings.cpp b/src/ui/league_pairings.cpp index 6736051..2304f01 100644 --- a/src/ui/league_pairings.cpp +++ b/src/ui/league_pairings.cpp @@ -1,4 +1,5 @@ // SPDX-License-Identifier: GPL-3.0-only +#include "game/state.hpp" #include "formats/executable_layout.hpp" #include "ui/league_pairings.hpp" @@ -82,7 +83,7 @@ LeaguePairingsState league_pairings_from_game(const GameState& g,const LeaguePai //51329 ->LeagueName uses the league names prepared by6b98e, including //the shared Regionalliga A/B text and foreign country's Native name. //TeamStatistics_SourceLeagueName_RuntimeField's temporary prefix is only set around other callers, not this Desk. - const auto league_title=owner.league<5?league_name(g,owner.league):g.club_name(0x165+owner.league-4); + const auto league_title=owner.league<5?league_name(g,owner.league):g.club_name(kNoTeam+owner.league-4); if(owner.postponed_active) { out.title=message_text(g,::bmh::layout::LeaguePairings_FormatError_TextPointer12)+league_title; out.subtitle.clear(); diff --git a/src/ui/league_table.cpp b/src/ui/league_table.cpp index 37bf4a4..5c9bb84 100644 --- a/src/ui/league_table.cpp +++ b/src/ui/league_table.cpp @@ -1,4 +1,5 @@ // SPDX-License-Identifier: GPL-3.0-only +#include "game/state.hpp" #include "formats/executable_layout.hpp" #include "ui/league_table.hpp" @@ -145,7 +146,7 @@ LeagueTableState project_league_table(const bmh::GameState& game, int manager_sl // not a TEXTD entry at the domestic league-title address. state.league_name = league_id < 5 ? original_to_utf8(bmh::league_name(game, league_id)) - : original_to_utf8(game.club_name(0x165 + league_id - 4)); + : original_to_utf8(game.club_name(kNoTeam + league_id - 4)); state.header_text = original_to_utf8(bmh::message_text(game, ::bmh::layout::LeagueTable_OriginalToUtf8_TextPointer2)); // SelectsOriginalPanelWhenClear selects the original panel when SolidPanelBackground is clear. // Older/minimal saves may not serialize this presentation option. diff --git a/src/ui/lineup.cpp b/src/ui/lineup.cpp index e6ef68d..456d068 100644 --- a/src/ui/lineup.cpp +++ b/src/ui/lineup.cpp @@ -1,4 +1,5 @@ // SPDX-License-Identifier: GPL-3.0-only +#include "game/state.hpp" #include "formats/executable_layout.hpp" #include "ui/lineup.hpp" @@ -44,7 +45,7 @@ LineupState project(const StaticMemory& memory, const LeImage& exe, const std::v if (out.runtime_club < 0 || (out.runtime_club >= limit && !national)) throw FormatError("lineup: only domestic league squads are supported"); const size_t count = national || out.runtime_club < split ? 24 : 16; - const size_t first = national ? 3072 : out.runtime_club < split ? size_t(out.runtime_club) * 24 : size_t(out.runtime_club) * 16 + split * 8; + const size_t first = national ? runtime_dimensions.national_slots_first : out.runtime_club < split ? size_t(out.runtime_club) * 24 : size_t(out.runtime_club) * 16 + split * 8; const size_t board_base = size_t(out.manager_slot) * 0x840; if (first + count > squad.size() || board_base + count * 0x58 > tactics.size() || size_t(out.manager_slot) * 5 >= options.size()) throw FormatError("lineup: truncated squad/tactics/options"); diff --git a/src/ui/live_matchday.cpp b/src/ui/live_matchday.cpp index 7928ca0..fe30761 100644 --- a/src/ui/live_matchday.cpp +++ b/src/ui/live_matchday.cpp @@ -452,9 +452,9 @@ Palette LiveMatchdayScreen::shot_palette(const Palette& base, const LiveShotEven for (int side = 0; side < 2; ++side) { const int team = group.fixtures.at(size_t(shot.match * 2 + side)); if (team == -1) continue; - if (team < 0 || !state.memory.has(::bmh::layout::ClubKitSelectorsUnsigned + uint32_t(team))) + if (team < 0 || size_t(team) >= state.club_ids.size()) throw FormatError("live shot: original club colours missing"); - const int kit = state.memory.u8(::bmh::layout::ClubKitSelectorsUnsigned + uint32_t(team)); + const int kit = state.club_kit(team); int shirt = kit >> 4, shorts = kit & 15; if (side == 0) { home_shirt = shirt; home_shorts = shorts; } else if (shorts == home_shorts || (shirt == home_shorts && shorts == home_shirt)) { diff --git a/src/ui/manager.cpp b/src/ui/manager.cpp index 7c8797f..0f90b55 100644 --- a/src/ui/manager.cpp +++ b/src/ui/manager.cpp @@ -263,7 +263,7 @@ void ManagerScreen::portrait(Image& out, int x, int y, int id) const { } void ManagerScreen::badge(Image& out, int x, int y, int id) const { border(out, x, y); - if (id>=90 && id> 3) + ".VGA")); copy(out, atlas, (sprite & 7) * 38, 0, x, y, 38, 38); diff --git a/src/ui/matchday_results.cpp b/src/ui/matchday_results.cpp index 725cb6a..86a5dd3 100644 --- a/src/ui/matchday_results.cpp +++ b/src/ui/matchday_results.cpp @@ -1,4 +1,5 @@ // SPDX-License-Identifier: GPL-3.0-only +#include "game/state.hpp" #include "formats/executable_layout.hpp" #include "ui/matchday_results.hpp" @@ -57,7 +58,7 @@ std::string competition_name(const MatchdayResultGroup& group, std::string name; if (group.league_id) { const int league = *group.league_id; - name = league < 5 ? league_name(game, league) : game.club_name(0x165 + league - 4); + name = league < 5 ? league_name(game, league) : game.club_name(kNoTeam + league - 4); } else if (*group.cup_id == 0xb && !bmh::kEnglishCompetitions) { // (English: the League Cup, named below) // FinishEvent/BuildSideRecords: descriptor type 0x0c reads the runtime // TEXTD slot TournamentName, then appends edition TEXTD suffix MatchdayResults_CompetitionName_TextPointer. diff --git a/src/ui/national_friendly_ui.cpp b/src/ui/national_friendly_ui.cpp index 36397f9..77e4d12 100644 --- a/src/ui/national_friendly_ui.cpp +++ b/src/ui/national_friendly_ui.cpp @@ -1,4 +1,5 @@ // SPDX-License-Identifier: GPL-3.0-only +#include "game/state.hpp" #include "formats/executable_layout.hpp" #include "national_friendly_ui.hpp" @@ -6,9 +7,9 @@ namespace bmh::ui { namespace { -constexpr int kNationalTeam = 0x165; -constexpr int kFirstNationTeam = 0x166; // Nation zero is intentionally not selectable. -constexpr int kLastNationTeam = 0x165 + 61; +const int& kNationalTeam = kNoTeam; +int first_nation_team() { return kNoTeam + 1; } // Nation zero is intentionally not selectable. +int last_nation_team() { return kNoTeam + 61; } TaxDialogProjection question(const NationalFriendlyIdentity& identity, uint16_t flags, int manager, const GameState& game, std::string body) { @@ -70,14 +71,14 @@ NationalFriendlyUiAction NationalFriendlyUi::show(TaxDialogProjection p) const { NationalFriendlyUiAction NationalFriendlyUi::select_opponent(const GameState& g, int team) { if (stage_ != NationalFriendlyUiStage::picker) return {}; - if (team < kFirstNationTeam || team > kLastNationTeam) return cancel(); + if (team < first_nation_team() || team > last_nation_team()) return cancel(); opponent_ = team; stage_ = NationalFriendlyUiStage::venue_question; return show(question(identity_, 0x606, caller_.manager, g, bmh::message_text(g, ::bmh::layout::Controller_ClubFriendlyState_TextPointer))); } NationalFriendlyUiAction NationalFriendlyUi::answer_venue(bool yes) { - if (stage_ != NationalFriendlyUiStage::venue_question || opponent_ < kFirstNationTeam) return {}; + if (stage_ != NationalFriendlyUiStage::venue_question || opponent_ < first_nation_team()) return {}; manager_home_ = yes; stage_ = NationalFriendlyUiStage::quote_pending; NationalFriendlyUiAction a; diff --git a/src/ui/other_games_state.cpp b/src/ui/other_games_state.cpp index f13bca6..38c62e8 100644 --- a/src/ui/other_games_state.cpp +++ b/src/ui/other_games_state.cpp @@ -153,7 +153,7 @@ std::string original_literal(const LeImage& exe, uint32_t address) { } int source_league(const LeImage& exe, int team) { - if (team > 0x164) return 0; + if (team > (kNoTeam - 1)) return 0; if (team < 0) invalid("negative team for Source league lookup"); int cumulative = 0; for (int league = 0; league < 9; ++league) { diff --git a/src/ui/pending_offer.cpp b/src/ui/pending_offer.cpp index 04b689c..5d136c1 100644 --- a/src/ui/pending_offer.cpp +++ b/src/ui/pending_offer.cpp @@ -1,4 +1,5 @@ // SPDX-License-Identifier: GPL-3.0-only +#include "game/state.hpp" #include "formats/badge_policy.hpp" #include "formats/executable_layout.hpp" #include "ui/pending_offer.hpp" @@ -35,7 +36,7 @@ int pending_offer_owner_team(const GameState& game, int manager) { throw FormatError("pending offer UI: missing retained Source club"); const int team = int(game.manager_records[base + 0x290]) | (int(game.manager_records[base + 0x291]) << 8); - if (team >= 138) throw FormatError("pending offer UI: invalid retained Source club"); + if (team >= runtime_dimensions.league_teams) throw FormatError("pending offer UI: invalid retained Source club"); return team; } @@ -59,8 +60,8 @@ bool pending_offer_spare_buyer(const GameState& game, int raw_offer_slot, int ex const int buyer = team_at(4); const uint32_t offer = ::bmh::layout::OfferSlots + uint32_t(raw_offer_slot) * 4; const uint32_t list = ::bmh::layout::EditorList + uint32_t(raw_offer_slot + 40) * 0x58; - const size_t pool = 0xb70 + size_t(raw_offer_slot + 40); - if (team_at(0) != kNoTeam || buyer >= 138 || buyer != expected_team || !game.memory.has(offer + 3) || + const size_t pool = runtime_dimensions.pool_first + size_t(raw_offer_slot + 40); + if (team_at(0) != kNoTeam || buyer >= runtime_dimensions.league_teams || buyer != expected_team || !game.memory.has(offer + 3) || !game.memory.has(list + 0x57) || pool >= game.squad_slots.size()) return false; const uint32_t word = game.memory.u32(offer); @@ -69,7 +70,7 @@ bool pending_offer_spare_buyer(const GameState& game, int raw_offer_slot, int ex if (word == 0xffffffffu || int(word & 31) != owner || player == 0xfff || size_t(player) >= game.players.size() || (game.squad_slots[pool] & 0xfff) != player || game.memory.u16(list) != buyer || - seller >= 138 || seller == buyer || (owner > 0 && team_at(size_t(owner)) != seller)) + seller >= runtime_dimensions.league_teams || seller == buyer || (owner > 0 && team_at(size_t(owner)) != seller)) return false; return true; } diff --git a/src/ui/player_card.cpp b/src/ui/player_card.cpp index 31a4026..8d4064c 100644 --- a/src/ui/player_card.cpp +++ b/src/ui/player_card.cpp @@ -1,4 +1,5 @@ // SPDX-License-Identifier: GPL-3.0-only +#include "game/state.hpp" #include "formats/badge_policy.hpp" #include "formats/executable_layout.hpp" #include "ui/player_card.hpp" @@ -31,8 +32,8 @@ void validate(const PlayerCardState& s) { const auto& p=s.lineup.players.at(size_t(s.row)); if(p.player_id!=(p.slot&0xfff)||p.row!=s.row)throw FormatError("player card: inconsistent player identity"); if(s.statistics && s.statistics->months>12)throw FormatError("player statistics: more than twelve monthly samples"); - if(s.loan&&(s.loan->owner<0||s.loan->owner>=168||s.loan->borrower!=s.lineup.runtime_club|| - s.loan->borrower>=168||s.loan->months<0||s.loan->months>255|| + if(s.loan&&(s.loan->owner<0||s.loan->owner>=runtime_dimensions.record_teams||s.loan->borrower!=s.lineup.runtime_club|| + s.loan->borrower>=runtime_dimensions.record_teams||s.loan->months<0||s.loan->months>255|| std::any_of(s.loan->badges.begin(),s.loan->badges.end(),[](int badge){return badge<0||badge>511;}))) throw FormatError("player card: inconsistent ordinary loan context"); } @@ -67,7 +68,7 @@ void context(PlayerCardState& out,const StaticMemory& memory,const Bytes& club_h // the ordinary borrower row, not the lender's ClubInfo_FormatError_RuntimeField snapshot. PlayerCardLoan detail; detail.owner=int(loan>>12&0x3ff);detail.borrower=int(loan>>22&0x3ff); - if(detail.borrower!=out.lineup.runtime_club||detail.owner>=168||detail.borrower>=168||out.loan||!memory.has(::bmh::layout::ClubPlayerDetail_InvalidArgument_RuntimeField+i)){ + if(detail.borrower!=out.lineup.runtime_club||detail.owner>=runtime_dimensions.record_teams||detail.borrower>=runtime_dimensions.record_teams||out.loan||!memory.has(::bmh::layout::ClubPlayerDetail_InvalidArgument_RuntimeField+i)){ out.unsupported_record="loan_record";continue; } detail.months=memory.u8(::bmh::layout::ClubPlayerDetail_InvalidArgument_RuntimeField+i); @@ -125,7 +126,7 @@ PlayerCardState player_card_from_save(const SaveState& s,const LeImage& exe,int } PlayerCardState player_card_from_game(const GameState& g,const LeImage& exe,int row,uint64_t revision) { Bytes short_names; - for(int club=0;clubmanager_slot || editor.runtime_club != request->runtime_club || (!poach && (editor.list_entry != request->bid.list_entry || editor.source_slot != request->bid.source_slot || editor.player != request->bid.player)) || - (poach && (editor.list_entry<40 || editor.list_entry>43 || editor.source_slot!=2928+editor.list_entry || + (poach && (editor.list_entry<40 || editor.list_entry>43 || editor.source_slot!=runtime_dimensions.pool_first+editor.list_entry || editor.player<0 || editor.initial_action_loan)) || editor.revision != preparation.desktop.revision || preparation.desktop.revision != request->revision + 1) throw FormatError("transfer offer: invalid opening acknowledgement"); diff --git a/src/ui/save_load.cpp b/src/ui/save_load.cpp index e11a1c6..e35c024 100644 --- a/src/ui/save_load.cpp +++ b/src/ui/save_load.cpp @@ -185,7 +185,7 @@ bool SaveLoadScreen::info_press(int x, int y) { try { const auto saved = load_savegame(entries_.at(size_t(selected_)).path); const auto& h = saved.plain_header; - if (!saved.checksum_ok || saved.version != "V2.24" || h.size() < 172 || h[0] < 1 || h[0] > 4) + if (!saved.checksum_ok || (saved.version != "V2.24" && saved.version != "O1.1") || h.size() < 172 || h[0] < 1 || h[0] > 4) throw FormatError("save/load: invalid native information header"); const auto field = [&](size_t at, size_t count) { const auto end = h.begin() + at + count; diff --git a/src/ui/series_records.cpp b/src/ui/series_records.cpp index 76e5129..77e2c3a 100644 --- a/src/ui/series_records.cpp +++ b/src/ui/series_records.cpp @@ -1,4 +1,5 @@ // SPDX-License-Identifier: GPL-3.0-only +#include "game/state.hpp" #include "formats/executable_layout.hpp" #include "series_records.hpp" @@ -50,7 +51,7 @@ SeriesRecordsProjection series_records_from_game(const GameState& game, const Le throw FormatError("series records: manager record missing"); const size_t manager_at = size_t(manager_slot) * kManagerRecord; const int team = int(read16(game.manager_records, manager_at + 0x290)); - if (team < 0 || team > 0x165) + if (team < 0 || team > kNoTeam) throw FormatError("series records: invalid Source manager club"); SeriesRecordsProjection out; @@ -58,7 +59,7 @@ SeriesRecordsProjection series_records_from_game(const GameState& game, const Le out.runtime_team = team; out.gradient_text = (!game.memory.has(::bmh::layout::TextGradientDisabled) || game.memory.u8(::bmh::layout::TextGradientDisabled) == 0) && exe.u8(::bmh::layout::TextGradientMode) == 2; - if (team >= 0x5a || game.club_table.size() < 168 * kClubRecord) { + if (team >= 0x5a || game.club_table.size() < runtime_dimensions.record_teams * kClubRecord) { out.source_available = false; // TeamLeague shows SeriesRecordsRuntimeField outside its 0..89 table range. return out; } @@ -106,7 +107,7 @@ SeriesRecordsScreen::SeriesRecordsScreen(const std::filesystem::path& data, texts_(load_textd(asset_path(data, "TEXTD.BLK"))), font_(load_font(asset_path(data / "F", "BMH3.FNT"))) { if (projection_.manager_slot < 0 || projection_.manager_slot >= 4 || - projection_.runtime_team < 0 || projection_.runtime_team > 0x165 || + projection_.runtime_team < 0 || projection_.runtime_team > kNoTeam || (projection_.source_available && (projection_.league < 0 || projection_.league >= kLeagueCount || projection_.league_row < 0 || projection_.league_row >= kLeagueSizes[size_t(projection_.league)])) || diff --git a/src/ui/settings.cpp b/src/ui/settings.cpp index 459b99e..12c83c6 100644 --- a/src/ui/settings.cpp +++ b/src/ui/settings.cpp @@ -9,7 +9,6 @@ #include #include "game/messages.hpp" -#include "game/state.hpp" #include "ui/manager.hpp" #include "ui/setup.hpp" diff --git a/src/ui/sportschau.cpp b/src/ui/sportschau.cpp index 3efbbc3..ed3419e 100644 --- a/src/ui/sportschau.cpp +++ b/src/ui/sportschau.cpp @@ -1,4 +1,5 @@ // SPDX-License-Identifier: GPL-3.0-only +#include "game/state.hpp" #include "formats/badge_policy.hpp" #include "formats/executable_layout.hpp" #include "ui/sportschau.hpp" @@ -478,8 +479,8 @@ Image SportschauMatchReport::render_report(size_t visible_log_entries, text(out, heading_, 0, 54, home_name, 0x5f, 156); text(out, heading_, 156, 54, away_name, 0x5f, 312); - const bool home_domestic = fixture_.home_team < 168; - const bool away_domestic = fixture_.away_team < 168; + const bool home_domestic = fixture_.home_team < runtime_dimensions.record_teams; + const bool away_domestic = fixture_.away_team < runtime_dimensions.record_teams; // Some Original club abbreviation bytes are unavailable because the // source-side temporary buffer was never initialized. Keep the known // header, badge, score and report visible, and omit only that abbreviation. diff --git a/src/ui/strengths_state.cpp b/src/ui/strengths_state.cpp index 94ac81c..af3b01b 100644 --- a/src/ui/strengths_state.cpp +++ b/src/ui/strengths_state.cpp @@ -1,4 +1,5 @@ // SPDX-License-Identifier: GPL-3.0-only +#include "game/state.hpp" #include "formats/executable_layout.hpp" #include "ui/strengths_state.hpp" @@ -176,7 +177,7 @@ StrengthsProjection strengths_from_game(const GameState& game, int manager_slot, const int first = league_first_team(league); const int size = kLeagueSizes[league]; - if (first < 0 || first + size > 138) invalid("league bounds exceed domestic club table"); + if (first < 0 || first + size > runtime_dimensions.league_teams) invalid("league bounds exceed domestic club table"); if (game.club_ids.size() < size_t(first + size)) invalid("club ID table is truncated"); if (game.club_names.empty()) invalid("club name pool is empty"); for (int team = first; team < first + size; ++team) { @@ -235,7 +236,7 @@ StrengthsProjection strengths_from_game(const GameState& game, int manager_slot, if (league < 5) { out.league_name = iso646de_to_utf8(league_name(game, league).c_str()); } else { - const int title_team = 0x165 + league - 4; + const int title_team = kNoTeam + league - 4; if (size_t(title_team) >= game.club_ids.size() || game.club_ids[size_t(title_team)] >= game.club_names.size()) invalid("foreign league title is missing from the save name pool"); diff --git a/src/ui/team_statistics.cpp b/src/ui/team_statistics.cpp index adeb4f0..0bf1dfa 100644 --- a/src/ui/team_statistics.cpp +++ b/src/ui/team_statistics.cpp @@ -1,4 +1,5 @@ // SPDX-License-Identifier: GPL-3.0-only +#include "game/state.hpp" #include "formats/badge_policy.hpp" #include "formats/executable_layout.hpp" #include "ui/team_statistics.hpp" @@ -78,7 +79,7 @@ std::string source_league_name(const GameState& game, int league, const TextDb& std::string name; if (game.memory.has(::bmh::layout::TeamStatistics_SourceLeagueName_RuntimeField) && game.memory.u8(::bmh::layout::TeamStatistics_SourceLeagueName_RuntimeField) != 0) name = source_text(texts, ::bmh::layout::SportschauAwards_MatchdayIntroView_TextPointer); - name += game.club_name((mapped & 0x7f) + 0x165); + name += game.club_name((mapped & 0x7f) + kNoTeam); return name; } } @@ -86,17 +87,17 @@ std::string source_league_name(const GameState& game, int league, const TextDb& TeamStatisticsProjection team_statistics_from_game(const GameState& game, int team, TeamStatisticsMode mode, const LeImage& exe, const TextDb& texts) { - if (team < 0 || team > 0x165) throw FormatError("team statistics: runtime team outside LeagueCalculations range"); + if (team < 0 || team > kNoTeam) throw FormatError("team statistics: runtime team outside LeagueCalculations range"); const int mode_number = int(mode); if (mode_number < 0 || mode_number > 2) throw FormatError("team statistics: invalid mode"); - if (team >= 138 && team < 168) + if (team >= runtime_dimensions.league_teams && team < runtime_dimensions.record_teams) throw FormatError("team statistics: simulated teams require Source draw-state ratings and are not exposed here"); TeamStatisticsProjection out; out.runtime_team = team; out.mode = mode; out.source_badge_fallback = original_badge_fallback(team,&exe); out.badge_heap = game.club_heap_78; - if (team != 0x165) { + if (team != kNoTeam) { int region_team = team; const int league_gate = exe.u8(::bmh::layout::LeaguePairings_LeaguePairingsConstants_RuntimeField); for (int league = 0; league < 9; ++league) { @@ -109,8 +110,8 @@ TeamStatisticsProjection team_statistics_from_game(const GameState& game, int te out.flag_index = uint8_t((region_team - int(exe.u16(::bmh::layout::CareerSession_InstallLeagueSizes_RuntimeField6))) / 7 - league_gate + 10); } } - out.source_has_league_panel = team < 0xa8; - out.league = team > 0x164 ? 0 : team_league(team); + out.source_has_league_panel = team < runtime_dimensions.record_teams; + out.league = team > (kNoTeam - 1) ? 0 : team_league(team); if (size_t(team) < game.club_ids.size()) out.original_team_name = game.club_name(team); if (out.source_has_league_panel) { if (out.league < 0 || out.league >= kLeagueCount) @@ -135,7 +136,7 @@ TeamStatisticsProjection team_statistics_from_game(const GameState& game, int te out.position_history.size(), out.position_history.begin()); out.source_has_position_history = true; } - } else if (team == 0x165) { + } else if (team == kNoTeam) { // Source 357 maps to league 0 for common labels, but the save does not // contain a position-history row for this national-team pseudo-club. out.source_has_position_history = false; @@ -143,7 +144,7 @@ TeamStatisticsProjection team_statistics_from_game(const GameState& game, int te out.gradient_text = (!game.memory.has(::bmh::layout::TextGradientDisabled) || game.memory.u8(::bmh::layout::TextGradientDisabled) == 0) && exe.u8(::bmh::layout::TextGradientMode) == 2; out.decorated_background = !game.memory.has(::bmh::layout::PlainBackground) || game.memory.u8(::bmh::layout::PlainBackground) == 0; - if (team < 138) { + if (team < runtime_dimensions.league_teams) { constexpr std::array average_flags{0x1f1, 0x1f2, 0x1f4, 0x1f8, 0x1ff}; for (size_t i = 0; i < average_flags.size(); ++i) out.source_averages[i] = uint16_t(team_average(game, team, average_flags[i]).value); @@ -167,7 +168,7 @@ TeamStatisticsProjection team_statistics_from_game(const GameState& game, int te } if (game.memory.has(::bmh::layout::ActiveManager)) { const int manager = game.memory.u8(::bmh::layout::ActiveManager); - const size_t start = size_t(manager) * 0x690; + const size_t start = size_t(manager) * (runtime_dimensions.record_teams * 10); if (manager < 4 && start + out.active_manager_results.size() <= game.manager_results.size()) { out.active_manager_slot = manager; std::copy_n(game.manager_results.begin() + static_cast(start), @@ -178,7 +179,7 @@ TeamStatisticsProjection team_statistics_from_game(const GameState& game, int te out.active_manager_team = owned; if (owned >= 0 && size_t(owned) < game.club_ids.size()) out.active_manager_team_name = game.club_name(owned); - out.source_has_head_to_head = team != owned && team < 0xa8 && owned != 0x165; + out.source_has_head_to_head = team != owned && team < runtime_dimensions.record_teams && owned != kNoTeam; } } } @@ -194,7 +195,7 @@ TeamStatisticsScreen::TeamStatisticsScreen(const std::filesystem::path& data, flags_(load_vga(asset_path(data / "KB", "24.VGA"))), faces_(load_vga(asset_path(data / "KB", "27.VGA"))), ratings_(load_vga(asset_path(data / "KB", "30.VGA"))) { if (backdrop_.width != 320 || backdrop_.height != 240 || projection_.runtime_team < 0 || - projection_.runtime_team > 0x165 || + projection_.runtime_team > kNoTeam || (projection_.source_has_league_panel && (projection_.league < 0 || projection_.league >= kLeagueCount || projection_.table.league != projection_.league || projection_.league_row < 0 || projection_.league_row >= projection_.table.size))) @@ -431,7 +432,7 @@ Image TeamStatisticsScreen::render() const { uint16_t(projection_.badge_heap[size_t(projection_.runtime_team) * 2 + 1]) << 8) & 0x1ff; copy(out, crest_, (selector & 7) * 38, 0, 271, 55, 38, 38); } - if (projection_.source_has_league_panel || projection_.runtime_team == 0x165) { + if (projection_.source_has_league_panel || projection_.runtime_team == kNoTeam) { const int league = projection_.league; rect(out, 225, 150, 1, 43, 0x6a); rect(out, 225, 192, 81, 1, 0x6a); if (projection_.source_has_position_history && projection_.source_has_league_panel) { diff --git a/src/ui/team_statistics.hpp b/src/ui/team_statistics.hpp index 06408cb..f46f8c7 100644 --- a/src/ui/team_statistics.hpp +++ b/src/ui/team_statistics.hpp @@ -45,7 +45,7 @@ struct TeamStatisticsProjection { int active_manager_slot = -1; int active_manager_team = -1; std::string active_manager_team_name; - std::array active_manager_results{}; + std::vector active_manager_results = std::vector(size_t(runtime_dimensions.record_teams) * 10); bool has_active_head_to_head = false; bool source_has_league_panel = true; bool source_has_head_to_head = false; diff --git a/src/ui/transfer_market.cpp b/src/ui/transfer_market.cpp index 49a1d44..21a7d8f 100644 --- a/src/ui/transfer_market.cpp +++ b/src/ui/transfer_market.cpp @@ -14,7 +14,7 @@ namespace bmh::ui { namespace { -constexpr size_t kPoolFirst = 0xb70; +const int& kPoolFirst = runtime_dimensions.pool_first; constexpr int kMarketEntries = 40; constexpr uint32_t kTransferTable = ::bmh::layout::EditorList; constexpr uint32_t kTransferEntrySize = 0x58; diff --git a/src/ui/world_cup_statistics.cpp b/src/ui/world_cup_statistics.cpp index 7c92029..e6f541d 100644 --- a/src/ui/world_cup_statistics.cpp +++ b/src/ui/world_cup_statistics.cpp @@ -1,4 +1,5 @@ // SPDX-License-Identifier: GPL-3.0-only +#include "game/state.hpp" #include "formats/executable_layout.hpp" #include "world_cup_statistics.hpp" @@ -97,7 +98,7 @@ WorldCupStatisticsProjection world_cup_statistics_from_game(const GameState& gam throw FormatError("World Cup statistics: placement names a nation outside 0..61"); out.badge_heap = game.club_heap_78; for (int nation = 0; nation < kNationCount; ++nation) { - const int team = 0x165 + nation; + const int team = kNoTeam + nation; if (size_t(team) >= game.club_ids.size()) throw FormatError("World Cup statistics: national-team identity is unavailable"); out.country_names[size_t(nation)] = game.club_name(team); @@ -145,7 +146,7 @@ std::optional world_cup_nation_at(const WorldCupStatisticsProjection& p WorldCupStatisticsRequest world_cup_selection_request(const WorldCupStatisticsProjection& p, std::optional nation) { if (!p.can_select_opponent || !nation || *nation == 0 || *nation >= kNationCount) return {}; - return {WorldCupStatisticsRequestKind::select_opponent, 0x165 + *nation}; + return {WorldCupStatisticsRequestKind::select_opponent, kNoTeam + *nation}; } WorldCupStatisticsScreen::WorldCupStatisticsScreen(const std::filesystem::path& data, @@ -169,7 +170,7 @@ void WorldCupStatisticsScreen::draw_flag(Image& out, uint8_t nation, int x, int } void WorldCupStatisticsScreen::draw_badge(Image& out, uint8_t nation, int x, int y) const { - const int team = 0x165 + nation; + const int team = kNoTeam + nation; if (size_t(team) * 2 + 1 >= projection_.badge_heap.size()) return; const uint16_t selector = uint16_t(projection_.badge_heap[size_t(team) * 2] | uint16_t(projection_.badge_heap[size_t(team) * 2 + 1]) << 8) & 0x1ff; diff --git a/tests/data_profile_tests.cpp b/tests/data_profile_tests.cpp index 17803a8..1800a4f 100644 --- a/tests/data_profile_tests.cpp +++ b/tests/data_profile_tests.cpp @@ -1,6 +1,8 @@ // SPDX-License-Identifier: GPL-3.0-only #include "formats/data_profile.hpp" #include "formats/savestate.hpp" +#include "formats/le.hpp" +#include "formats/badge_policy.hpp" #include "game/profile_runtime.hpp" #include "game/state.hpp" #include "game/weekly.hpp" @@ -28,6 +30,17 @@ int main()try { bmh::SaveState decoded(stream, profile.counts); check(decoded.block(bmh::layout::SquadSlots).size == profile.total_slots() * 2, "squad block ignored configured profile counts"); + check(decoded.block(bmh::layout::ManagerMatchHistory).size == profile.counts.n42 * 50, + "opponent history truncated in extended saves"); + check(decoded.block(bmh::layout::ClubKitSelectors).size == profile.counts.clubs && + decoded.block(bmh::layout::ClubShortNameOffsets).size == profile.counts.n42, + "extended visual tables truncated"); + check(decoded.block(bmh::layout::DeskRecords_Teams_RuntimeField).size == profile.counts.league_teams * 2, + "last international club has no fair-play counter"); + bmh::StaticMemory memory(decoded); + const auto last = bmh::layout::DeskRecords_Teams_RuntimeField + (profile.counts.league_teams - 1) * 2; + memory.set16(last, 0x0102); + check(memory.u16(last) == 0x0102, "last club card counters are not addressable"); check(decoded.block(bmh::layout::PlayerConditionTechniqueForm).size == profile.counts.players * 4, "player block ignored configured profile counts"); } @@ -54,6 +67,28 @@ int main()try { check(!bmh::load_data_profile(dir).extended(),"Original installation did not select Classic"); {std::ofstream f(dir/"OBMHPROF.INI");f<<"[OpenBMH]\nprofile=classic-plus-1\n";} check(bmh::load_data_profile(dir).counts.n66==4104,"Profile marker not recognized"); + bmh::Bytes image_bytes(0x20000, 0); + const auto at = [&](uint32_t address) -> uint8_t& { return image_bytes.at(address - bmh::layout::GermanDataSegmentBegin); }; + for (int league = 0; league < 9; ++league) at(bmh::layout::LeagueSizes + uint32_t(league)) = classic.leagues[size_t(league)]; + for (int day = 24; day < 24 + 34 * 8; day += 8) at(bmh::layout::CompetitionCalendar + uint32_t(day * 2)) = 1; + bmh::save_image(bmh::LeImage::from_bytes(bmh::layout::GermanDataSegmentBegin, image_bytes), dir / "BMH.exe"); + const auto before = bmh::read_file(dir / "BMH.exe"); + const auto image = bmh::load_le(dir / "BMH.exe"); + check(image.expanded_profile() && image.u16(bmh::layout::NoTeamSquadStart) == 194, + "national name base confused with absolute national squad slot"); + check(image.u32(bmh::layout::ProfileNationalSlotsFirst) == 4080 && image.u32(bmh::layout::ProfilePoolFirst) == 3936, + "verified scalar overlay disagrees with runtime profile"); + check(image.u8(bmh::layout::LeagueSizes + 6) == 20 && image.u16(bmh::layout::TeamsWithSquads) == 164, + "UI executable view has stale league/roster dimensions"); + int domestic_days=0,foreign_days=0; + for(int day=0;day<365;++day) { + const auto flags=image.u16(bmh::layout::CompetitionCalendar+uint32_t(day*2)); + domestic_days += (flags & 1) != 0; + foreign_days += (flags & 16) != 0; + } + check(domestic_days==34 && foreign_days==38,"extended calendar changed domestic dates or omitted English fixtures"); + check(!bmh::original_badge_fallback(300, &image),"foreign cup clubs still use the computer badge"); + check(bmh::read_file(dir / "BMH.exe") == before,"loading modified the supplied executable"); {std::ofstream f(dir/"OBMHPROF.INI");f<<"[OpenBMH]\nprofile=unknown\n";} rejected=false;try{bmh::load_data_profile(dir);}catch(const bmh::FormatError&){rejected=true;} std::filesystem::remove_all(dir);check(rejected,"Unknown profile silently became Classic"); diff --git a/tests/season_sim.cpp b/tests/season_sim.cpp index 8b4503d..97c6b0e 100644 --- a/tests/season_sim.cpp +++ b/tests/season_sim.cpp @@ -55,7 +55,7 @@ void check_state(const GameState& g, const std::string& when, Checks& c) { std::set seen; // (only the clubs' squads up to format field = 0xb70: the national squad and the other // lists behind them hold club players a second time) - for (size_t s = 0; s < g.squad_slots.size() && s < 0xb70; s++) { + for (size_t s = 0; s < g.squad_slots.size() && s < size_t(runtime_dimensions.pool_first); s++) { const int id = g.squad_slots[s] & 0xfff; if (id == 0xfff) continue; if (!seen.insert(id).second) c.fail("player in two squad slots", when + " player " + std::to_string(id)); @@ -81,7 +81,7 @@ bool capture_duplicate(const GameState& before, const GameState& after, const std::filesystem::path& directory) { std::set seen; int duplicate = -1; - for (size_t slot = 0; slot < 2928 && slot < after.squad_slots.size(); ++slot) { + for (size_t slot = 0; slot < size_t(runtime_dimensions.pool_first) && slot < after.squad_slots.size(); ++slot) { const int id = after.squad_slots[slot] & 0xfff; if (id != 0xfff && !seen.insert(id).second) { duplicate = id; break; } } diff --git a/tools/poc/prepare_international.py b/tools/poc/prepare_international.py new file mode 100644 index 0000000..3a8d6d9 --- /dev/null +++ b/tools/poc/prepare_international.py @@ -0,0 +1,265 @@ +#!/usr/bin/env python3 +# SPDX-License-Identifier: GPL-3.0-only +"""Build private classic-plus-1 data from a supplied German installation and OBW donor. + +No data are downloaded. Pillow and CairoSVG are build-time image tools, not game dependencies. +Original installations and source archives are never modified. The output must not exist. +""" +import argparse +import collections +import datetime +import hashlib +import io +import json +from pathlib import Path +import shutil +import struct +import unicodedata +import zipfile + +SIZES = (18, 18, 18, 18, 18, 18, 20, 18, 18) +OLD_SIZES = (18, 18, 18, 18, 18, 12, 12, 12, 12) + +def sha(data): + return hashlib.sha256(data).hexdigest() + +def u16(data): + return list(struct.unpack('<' + 'H' * (len(data) // 2), data)) + +def words(values, width=2): + return struct.pack('<' + ('H' if width == 2 else 'I') * len(values), *values) + +def read_master(data, clubs=419, players=2574, records=168, extra=3096): + at = 0 + def take(n): + nonlocal at + if at + n > len(data): + raise ValueError('Master database is truncated or has unsupported dimensions') + result = data[at:at+n] + at += n + return result + lengths = u16(take(8)) + result = {'bonus': take(extra+50), 'pools': [take(n) for n in lengths]} + for key, n in [('clubs', clubs*2), ('names', players*2), ('meta', 100), ('aux', records*2), + ('badges', clubs*2), ('strength', 251), ('league_aux', 189), ('refs', 50), + ('kits', clubs), ('short', records), ('squads', (extra+50)*2), + ('form', players*4), ('skills', players*4), ('identity', players*4)]: + result[key] = take(n) + if at != len(data): + raise ValueError('Unsupported master database dimensions/trailing bytes') + return result + +def write_master(db): + return words([len(p) for p in db['pools']]) + db['bonus'] + b''.join(db['pools']) + b''.join( + db[k] for k in ('clubs', 'names', 'meta', 'aux', 'badges', 'strength', 'league_aux', + 'refs', 'kits', 'short', 'squads', 'form', 'skills', 'identity')) + +def legacy_name(name): + # Preserve Original ISO 646-DE and use a documented transliteration for other letters. + aliases = str.maketrans({'ø':'o', 'Ø':'O', 'ł':'l', 'Ł':'L', 'đ':'d', 'Đ':'D', + 'ß':'~', 'ä':'{', 'ö':'|', 'ü':'}', 'Ä':'[', 'Ö':'\\', 'Ü':']'}) + value = unicodedata.normalize('NFKD', name.translate(aliases)) + return ''.join(c for c in value if not unicodedata.combining(c)).upper().encode('ascii', errors='replace') + +def add_string(pool, name): + data = legacy_name(name) + b'\0' + if len(pool) + len(data) > 65535: + raise ValueError('String pool exceeds Original u16 offsets') + offset = len(pool) + pool.extend(data) + return offset + +def decode_vga(data): + width, height, length = struct.unpack_from('= 128: + pixels.extend([data[at]] * (c-127)); at += 1 + else: + pixels.extend(data[at:at+c+1]); at += c+1 + if len(pixels) != width*height or at+1 != 8+length: + raise ValueError('Malformed VGA input') + return width, height, pixels + +def encode_vga(width, height, pixels): + if len(pixels) != width*height: + raise ValueError('VGA dimensions do not match pixels') + # Valid literal packets, including the one trailing byte required by the Original reader. + payload = b''.join(bytes([len(pixels[i:i+128])-1]) + bytes(pixels[i:i+128]) + for i in range(0, len(pixels), 128)) + b'\0' + return struct.pack('>5}) + db['names']=words(names);db['pools'][1]=bytes(pool) + for k in new_words: db[k]+=words(new_words[k],4) + bonus=bytearray(4154);bonus[:2574]=db['bonus'][:2574] + for i,p in enumerate(player_additions): + nat=field_provenance[i]['nationality_code'];bonus[2574+i]=(int(p['attributes'].get('bonus',0))&127)|((nat>>5)<<7) + db['bonus']=bytes(bonus) + # Keep Original national flags/domestic crests. Assign private foreign crests to free cells. + used={b&511 for i,b in enumerate(old_badges) if i<90 or 138<=i<168 or i>=357} + free=iter(i for i in range(512) if i not in used) + palette=find_file(source,'M3PC.COL').read_bytes() + rgb=[tuple(((v&63)*255+31)//63 for v in palette[i:i+3]) for i in range(0,768,3)] + sheets={}; crest_report=[]; cache={} + w_dir=find_file(source,'W') + def sheet(n): + if n not in sheets: + file=next((p for p in w_dir.iterdir() if p.name.upper()==str(n)+'.VGA'),None) + sheets[n]=decode_vga(file.read_bytes()) if file else (304,38,bytearray([0]*11552)) + if sheets[n][:2]!=(304,38):raise ValueError('Unexpected crest sheet geometry') + return sheets[n][2] + for index,club in enumerate(new_clubs): + if not (90 <= index < 164 or 194 <= index < 383): continue + cell=next(free,None) + if cell is None: raise ValueError('512-cell badge space exhausted') + asset=assets.get(club.get('crest'),{});files=asset.get('files',{}); image=None; error=None + for kind in ('svg','png','native'): + path=files.get(kind) + if not path:continue + try: + data=archive.read(path) + if path.lower().endswith('.svg'):data=cairosvg.svg2png(bytestring=data,output_width=152,output_height=152) + image=Image.open(io.BytesIO(data)).convert('RGBA');break + except Exception as exc:error=type(exc).__name__ + fictional=image is None + if fictional: + image=Image.new('RGBA',(38,38));d=ImageDraw.Draw(image);d.polygon([(6,3),(31,3),(30,24),(19,35),(7,24)],fill=rgb[64+index%16],outline='white');d.text((12,11),str(index%100),fill='white') + image=ImageOps.contain(image,(36,36),method=Image.Resampling.LANCZOS) + canvas=Image.new('RGBA',(38,38));canvas.alpha_composite(image,((38-image.width)//2,(38-image.height)//2)) + pixels=bytearray() + for r,g,b,a in canvas.getdata(): + if a<128:pixels.append(0);continue + key=(r,g,b) + if key not in cache:cache[key]=min(range(1,256),key=lambda n:sum((x-y)**2 for x,y in zip(rgb[n],key))) + pixels.append(cache[key]) + dst=sheet(cell//8) + for y in range(38):dst[y*304+(cell%8)*38:y*304+(cell%8)*38+38]=pixels[y*38:(y+1)*38] + badges[index]=(badges[index]&~511)|cell + crest_report.append({'club':club['id'],'runtime_team':index,'cell':cell,'asset':club.get('crest'),'source':asset.get('source'),'license':asset.get('license'),'fictional':fictional,'last_decode_error':error}) + db['badges']=words(badges) + # Every Original player word and all German starting rosters remain unchanged. + original_db = read_master(master) + for key in ('form', 'skills', 'identity'): + assert db[key][:2574*4] == original_db[key] + for team in range(90): + assert new_squads[team*24:(team+1)*24] == runtime_squads[team*24:(team+1)*24] + occupied = [v & 4095 for v in new_squads[:3936] if (v & 4095) != 4095] + if len(occupied) != 3280 or len(set(occupied)) != len(occupied): + raise ValueError('Expanded club rosters contain missing or duplicated players') + encoded=write_master(db) + parsed=read_master(encoded,445,3334,194,4104) + assert write_master(parsed)==encoded + shutil.copytree(source,output,ignore=shutil.ignore_patterns('.git','.openeddi','*.FBM','*.fbm')) + find_file(output,'M3D.MAN').write_bytes(encoded) + out_w=find_file(output,'W') + for n,(width,height,pix) in sheets.items(): + target=next((p for p in out_w.iterdir() if p.name.upper()==str(n)+'.VGA'),out_w/(str(n)+'.VGA')) + vga=encode_vga(width,height,pix); assert decode_vga(vga)[2]==pix;target.write_bytes(vga) + (output/'OBMHPROF.INI').write_text('[OpenBMH]\nprofile=classic-plus-1\n',encoding='ascii') + report={'profile':'classic-plus-1','base_sha256':sha(master),'donor_sha256':sha(donor.read_bytes()),'output_sha256':sha(encoded),'league_sizes':SIZES,'club_count':445,'player_count':3334,'source_to_runtime':old_new,'selected_additions':selected,'rosters':roster_report,'fictional_club_fields':{'new_clubs':['/kit/selector','/short_name_offset'],'policy':'deterministic existing Classic kit palette and automatic stadium initialization'},'additional_players':field_provenance,'crests':crest_report,'content_license':json.loads(archive.read('manifest.json')).get('content_license'),'distribution':'Private prepared data; content rights/provenance unchanged. No game content belongs in public source/binary artifacts.'} + (output/'IMPORT-REPORT.json').write_text(json.dumps(report,ensure_ascii=False,indent=2)+'\n') + print(json.dumps({'output':str(output),'clubs':445,'players':3334,'foreign_crests':len(crest_report),'fictional_crests':sum(c['fictional'] for c in crest_report),'sha256':sha(encoded)})) + +if __name__=='__main__': + p=argparse.ArgumentParser(description=__doc__);p.add_argument('--source',required=True,type=Path);p.add_argument('--supplement',required=True,type=Path);p.add_argument('--output',required=True,type=Path);a=p.parse_args();build(a.source,a.supplement,a.output) diff --git a/tools/poc/test_prepare_international.py b/tools/poc/test_prepare_international.py new file mode 100644 index 0000000..faec2a5 --- /dev/null +++ b/tools/poc/test_prepare_international.py @@ -0,0 +1,38 @@ +# SPDX-License-Identifier: GPL-3.0-only +"""Synthetic encoder/reader tests; no Original game content required.""" +import unittest +from prepare_international import decode_vga, encode_vga, legacy_name, read_master, write_master, words + +class ProfileDataTests(unittest.TestCase): + def test_master_identity_and_sizes(self): + # Deliberately unrelated tiny table counts exercise the format, not copyrighted records. + db={'bonus':bytes(70),'pools':[b'CLUB\0',b'PLAYER\0',b'REF\0',b'GROUND\0'], + 'clubs':words([0,0]),'names':words([0,0,0]),'meta':bytes(100),'aux':bytes(8), + 'badges':words([8,9]),'strength':bytes(251),'league_aux':bytes(189),'refs':bytes(50), + 'kits':bytes([3,4]),'short':bytes(4),'squads':words([4095]*70), + 'form':words([41,42,43],4),'skills':words([0,1,2],4),'identity':words([0,1,3],4)} + encoded=write_master(db) + parsed=read_master(encoded,clubs=2,players=3,records=4,extra=20) + self.assertEqual(parsed,db) + self.assertEqual(write_master(parsed),encoded) + with self.assertRaises(ValueError):read_master(encoded+b'\0',2,3,4,20) + with self.assertRaises(ValueError):read_master(encoded[:-1],2,3,4,20) + + def test_vga_literal_boundaries_and_neighbours(self): + pixels=bytearray((i*17)%256 for i in range(304*38)) + _,_,decoded=decode_vga(encode_vga(304,38,pixels)) + self.assertEqual(decoded,pixels) + before=bytes(pixels) + for y in range(38):pixels[y*304+76:y*304+114]=bytes([21])*38 + _,_,decoded=decode_vga(encode_vga(304,38,pixels)) + for y in range(38): + self.assertEqual(decoded[y*304:y*304+76],before[y*304:y*304+76]) + self.assertEqual(decoded[y*304+114:(y+1)*304],before[y*304+114:(y+1)*304]) + with self.assertRaises(ValueError):encode_vga(4,4,b'123') + + def test_original_encoding(self): + self.assertEqual(legacy_name('Müller'),b'M}LLER') + self.assertEqual(legacy_name('Sørloth'),b'SORLOTH') + self.assertEqual(legacy_name('Alavés'),b'ALAVES') + +if __name__=='__main__':unittest.main()