World layout: team id ranges and the squad slot table as data

WorldLayout names the dimensions of a game world (league clubs, amateurs,
foreign cup clubs, the pseudo team, national teams, squad slots and pools).
classic_world_layout() holds the numbers of the original; squad_range() and
team_average() ask it instead of literals. A test compares squad_range() with
the former arithmetic for every team id and checks that inconsistent layouts
are refused.

Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
ClaudeandClaude committed 2026-11-10 21:19:54 +01:00
1 parent 0bcb0d2507
commit 74d6cde914
5 files changed
+210 -10

No files matched your search

+6
View File
@@ -271,6 +271,7 @@ add_library(bmhcore STATIC
src/game/career.cpp
src/game/save.cpp
src/game/digest.cpp
src/game/world_layout.cpp
src/game/turn.cpp
src/game/turn_driver.cpp
)
@@ -1187,6 +1188,11 @@ add_executable(classic_rules_unit_tests tests/classic_rules_unit_tests.cpp)
target_link_libraries(classic_rules_unit_tests PRIVATE bmhcore)
add_test(NAME classic_rules_unit_tests COMMAND classic_rules_unit_tests)
# The Classic world layout equals the numbers the engine used as literals (no game data needed).
add_executable(world_layout_tests tests/world_layout_tests.cpp)
target_link_libraries(world_layout_tests PRIVATE bmhcore)
add_test(NAME world_layout_tests COMMAND world_layout_tests)
add_executable(season_player_reset_tests tests/season_player_reset_tests.cpp)
target_link_libraries(season_player_reset_tests PRIVATE bmhcore)
add_test(NAME season_player_reset_tests COMMAND season_player_reset_tests)
+10 -10
View File
@@ -1,7 +1,7 @@
// SPDX-License-Identifier: GPL-3.0-only
// GameState construction and accessors: building the state from a loaded save and the database
// counts, manager of a team, club and player names, formation and formation positions.
// Squad table layout constants are defined here. Draws no random numbers.
// The squad table comes from the world layout (world_layout.hpp). Draws no random numbers.
// Interface in state.hpp; every other file in this directory works on GameState.
#include "formats/executable_layout.hpp"
#include "game/state.hpp"
@@ -10,16 +10,12 @@
#include <stdexcept>
#include "game/rating.hpp"
#include "game/world_layout.hpp"
namespace bmh {
namespace {
// Squad table layout constants of V2.24 (TeamsWithSquads, LargeSquadClubCount, NoTeamSquadStart).
constexpr int kBigSquadTeams = 90;
constexpr size_t kNoTeamSquadStart = 3072;
constexpr int kTeamsWithSquads = 168;
// C-style signed division by 8 as compiled by Watcom (rounds toward zero).
int div8(int x) { return x / 8; }
@@ -172,14 +168,18 @@ void GameState::formation_position(int team, int slot, int& x, int& y) const {
}
SquadRange squad_range(int team) {
if (team == kNoTeam) return {kNoTeamSquadStart, 24};
if (team < kBigSquadTeams) return {size_t(team) * 24, 24};
if (team < 138) return {size_t(team) * 16 + kBigSquadTeams * 8, 16};
// The squad table of the world layout (world_layout.hpp). Classic: 24 slots for the 90 domestic clubs, 16 for
// the 48 international ones from slot 2160, 24 for kNoTeam at 3072.
const WorldLayout& w = world_layout();
if (team == w.no_team()) return {w.pool_end, w.no_team_slots};
// (a negative id is no team: the table arithmetic of the original gives a range far outside the slots)
if (team < 0) return {size_t(team) * 24, 24};
if (team < w.league_teams) return {w.squad_start[size_t(team)], w.squad_size[size_t(team)]};
return {0, 0};
}
TeamAverage team_average(const GameState& g, int team, uint16_t flags, WatcomRandom* rand) {
if (team >= kTeamsWithSquads && team != kNoTeam) {
if (team >= world_layout().first_foreign_cup() && team != world_layout().no_team()) {
// TeamRating(team, profile 2 at layout field): a random value around the club's level
if (!rand) throw std::invalid_argument("team_average: a team without squad needs the Watcom generator");
RatingContext ctx;
+58
View File
@@ -0,0 +1,58 @@
// SPDX-License-Identifier: GPL-3.0-only
// WorldLayout: see world_layout.hpp.
#include "game/world_layout.hpp"
#include <stdexcept>
#include <utility>
namespace bmh {
namespace {
WorldLayout& current() {
static WorldLayout layout = classic_world_layout();
return layout;
}
} // namespace
WorldLayout classic_world_layout() {
// Squad table of the original (TeamsWithSquads, LargeSquadClubCount, NoTeamSquadStart): the 90
// domestic clubs have 24 slots each, the 48 international clubs 16 each from slot 90 * 24.
WorldLayout w;
w.squad_start.resize(size_t(w.league_teams));
w.squad_size.resize(size_t(w.league_teams));
for (int team = 0; team < w.league_teams; ++team) {
const bool domestic = team < w.domestic_teams;
w.squad_start[size_t(team)] = domestic ? uint32_t(team) * 24 : uint32_t(team) * 16 + uint32_t(w.domestic_teams) * 8;
w.squad_size[size_t(team)] = domestic ? 24 : 16;
}
return w;
}
const WorldLayout& world_layout() { return current(); }
void set_world_layout(WorldLayout layout) {
const size_t teams = size_t(layout.league_teams);
if (layout.league_teams <= 0 || layout.domestic_teams < 0 || layout.domestic_teams > layout.league_teams ||
layout.amateur_teams < 0 || layout.foreign_cup_teams < 0 || layout.national_teams < 1 ||
layout.squad_start.size() != teams || layout.squad_size.size() != teams)
throw std::invalid_argument("world layout: inconsistent team ranges");
// Squads lie back to back in id order before the pools; the pools and the squad of "no club"
// follow in their fixed order.
uint32_t next = 0;
for (size_t team = 0; team < teams; ++team) {
if (layout.squad_start[team] != next || layout.squad_size[team] == 0)
throw std::invalid_argument("world layout: squads must be consecutive");
next += layout.squad_size[team];
}
if (layout.transfer_list != next || layout.free_agents != layout.transfer_list + 44 ||
layout.foreign_offers != layout.free_agents + 80 || layout.pool_end != layout.foreign_offers + 20 ||
layout.total_slots < layout.pool_end + layout.no_team_slots)
throw std::invalid_argument("world layout: pools must follow the squads");
// Squad slot values hold 12-bit player ids; loans store 10-bit club ids.
if (layout.total_teams() > 1023) throw std::invalid_argument("world layout: too many teams");
current() = std::move(layout);
}
} // namespace bmh
+65
View File
@@ -0,0 +1,65 @@
// SPDX-License-Identifier: GPL-3.0-only
#pragma once
// The dimensions of a game world: team id ranges and the squad slot table.
//
// The original game fixes them (and so does every supported edition, German and English):
// ids 0..137 the 138 league clubs: 90 clubs of the five domestic leagues with 24 squad slots,
// 48 clubs of the four international leagues with 16
// ids 138..167 30 amateur clubs (cup newcomers), without squads
// ids 168..356 189 foreign cup clubs without squads (a strength byte each)
// id 357 the pseudo team "no club" (kNoTeam, 0x165): national team / player pool, 24 slots
// ids 358..418 61 national teams
// and behind the squads the three player pools (transfer list, free agents, offers from abroad).
//
// Until 1.0.12 these numbers stood as literals all over the engine (138, 168, 0x165, 90 * 24, ...).
// WorldLayout names them in one place. OpenBMH Classic never installs another layout:
// classic_world_layout() returns exactly the original numbers, so every function that asks the
// layout computes what it computed before. A later edition with more leagues (OpenBMH Extended)
// installs its own layout instead of patching literals.
//
// One game per process, like the league tables of schedule.hpp.
#include <cstddef>
#include <cstdint>
#include <vector>
namespace bmh {
struct WorldLayout {
// Team id ranges, in this order: league clubs, amateur clubs, squadless foreign cup clubs,
// the pseudo team "no club", national teams.
int league_teams = 138; // ids 0 .. league_teams-1 have squads
int domestic_teams = 90; // the first league clubs (the five domestic leagues)
int amateur_teams = 30; // ids league_teams .. +amateur_teams-1, no squads
int foreign_cup_teams = 189; // squadless foreign clubs (27 nations x 7)
int national_teams = 62; // "no club" (the first of them) and the 61 national teams
// Squad slot table: first slot and slot count per league club, then the pools.
std::vector<uint32_t> squad_start; // per league club
std::vector<uint8_t> squad_size; // per league club
uint32_t transfer_list = 0xB70; // 44 slots: players on the transfer list
uint32_t free_agents = 0xB9C; // 80 slots: players without a club
uint32_t foreign_offers = 0xBEC; // 20 slots: players offered from abroad
uint32_t pool_end = 0xC00; // end of the pools = first slot of "no club"
uint32_t no_team_slots = 24; // the squad of "no club"
uint32_t total_slots = 3150; // including the reserve behind "no club"
int first_amateur() const { return league_teams; }
// The first team without a squad of its own that is a foreign cup club (Classic: 168); the
// clubs before it are "the clubs with league records" (league clubs + amateurs).
int first_foreign_cup() const { return league_teams + amateur_teams; }
int no_team() const { return first_foreign_cup() + foreign_cup_teams; }
int total_teams() const { return no_team() + national_teams; }
bool has_squad(int team) const { return (team >= 0 && team < league_teams) || team == no_team(); }
};
// The original dimensions (V2.24 and the supported German and English editions).
WorldLayout classic_world_layout();
// The layout of the running game (Classic unless another one was installed).
const WorldLayout& world_layout();
// Installs a layout; throws std::invalid_argument when its ranges or its slot table are inconsistent.
void set_world_layout(WorldLayout layout);
} // namespace bmh
+71
View File
@@ -0,0 +1,71 @@
// SPDX-License-Identifier: GPL-3.0-only
// The Classic world layout must give exactly the numbers that stood as literals in the engine until
// 1.0.12, and squad_range() must return what its former table arithmetic returned for every team id.
// A layout with inconsistent ranges must be refused. Needs no game data.
#include <cstdio>
#include <stdexcept>
#include <string>
#include "game/state.hpp"
#include "game/world_layout.hpp"
using namespace bmh;
namespace {
void check(bool value, const char* message) {
if (!value) throw std::runtime_error(message);
}
// squad_range as it was written before the world layout existed (state.cpp up to 1.0.12).
SquadRange former_squad_range(int team) {
if (team == 0x165) return {3072, 24};
if (team < 90) return {size_t(team) * 24, 24};
if (team < 138) return {size_t(team) * 16 + 90 * 8, 16};
return {0, 0};
}
} // namespace
int main() {
try {
const WorldLayout w = classic_world_layout();
check(w.league_teams == 138 && w.domestic_teams == 90 && w.amateur_teams == 30 && w.foreign_cup_teams == 189 &&
w.national_teams == 62, "Classic team ranges are not the original ones");
check(w.first_amateur() == 138 && w.first_foreign_cup() == 168 && w.no_team() == 0x165 && w.no_team() == kNoTeam &&
w.total_teams() == 419, "derived team ids differ from 138 / 168 / 0x165 / 419");
check(w.transfer_list == 90 * 24 + 48 * 16 && w.transfer_list == 0xB70 && w.free_agents == 0xB9C &&
w.foreign_offers == 0xBEC && w.pool_end == 0xC00 && w.pool_end == 3072 && w.no_team_slots == 24 &&
w.total_slots == 3096 + 54, "pool offsets differ from the original slot table");
check(w.has_squad(0) && w.has_squad(137) && !w.has_squad(138) && !w.has_squad(167) && !w.has_squad(168) &&
w.has_squad(0x165) && !w.has_squad(0x166) && !w.has_squad(-1), "has_squad differs");
// the running game uses the Classic layout unless another one is installed
check(world_layout().league_teams == 138 && world_layout().squad_start.size() == 138, "default layout is not Classic");
for (int team = -3; team < 450; ++team) {
const SquadRange now = squad_range(team), then = former_squad_range(team);
if (now.first != then.first || now.count != then.count)
throw std::runtime_error("squad_range differs from the former table for team " + std::to_string(team));
}
// inconsistent layouts are refused and leave the installed one alone
const auto refused = [](WorldLayout layout) {
try { set_world_layout(std::move(layout)); } catch (const std::invalid_argument&) { return true; }
return false;
};
WorldLayout bad = classic_world_layout(); bad.squad_size[5] = 20; // squads no longer back to back
check(refused(bad), "a gap in the squad table was accepted");
bad = classic_world_layout(); bad.squad_start.pop_back(); // table shorter than the club count
check(refused(bad), "a short squad table was accepted");
bad = classic_world_layout(); bad.transfer_list += 16; // pools not behind the squads
check(refused(bad), "pools away from the squads were accepted");
bad = classic_world_layout(); bad.foreign_cup_teams = 900; // more teams than a loan can name
check(refused(bad), "more than 1023 teams were accepted");
check(world_layout().league_teams == 138 && squad_range(137).first == 137 * 16 + 720, "a refused layout changed the game");
// a consistent layout is accepted (here: the Classic one again)
set_world_layout(classic_world_layout());
check(squad_range(89).first == 89 * 24 && squad_range(90).first == 2160 && squad_range(0x165).first == 3072,
"installing the Classic layout changed the squad table");
std::printf("world layout: Classic numbers, squad table and validation passed\n");
return 0;
} catch (const std::exception& e) {
std::fprintf(stderr, "%s\n", e.what());
return 1;
}
}