The mutable globals of schedule.hpp (league sizes, calendar groups, promotion ladder, European places, league suffixes, newcomers, English competitions) are members of LeagueSystem in world_layout.hpp, read through league_system() and written only by the installer of a game version. Values and uses are unchanged. The size check of set_league_sizes asks the world layout for the league teams. Co-Authored-By: Claude <noreply@anthropic.com>
104 lines
4.8 KiB
C++
104 lines
4.8 KiB
C++
// SPDX-License-Identifier: GPL-3.0-only
|
|
#pragma once
|
|
// League fixtures and results.
|
|
//
|
|
// Team ids
|
|
// Every club has an index into all per-club tables (names, stadiums, squads, ...).
|
|
// Leagues are contiguous ranges of these ids: league 0 is ids 0..17, league 1 the next
|
|
// 18 ids and so on (sizes in kLeagueSizes, LeagueSizes; team -> league is
|
|
// TeamLeague2). When a new game starts the clubs of a league are shuffled by swapping
|
|
// all their table entries (swap function around 0x685xx), so a team's position inside
|
|
// its league is its "draw position" for the fixture list. The master database order is
|
|
// therefore NOT the order used by a running game; always take names from the savegame.
|
|
//
|
|
// Fixtures (GenerateFixtures)
|
|
// The fixture list is not stored. For each league size there is a fixed table of
|
|
// "round strings" loaded from the executable: round r of the first half of the season is a
|
|
// string of letters, each consecutive pair "xy" is one match, home team = draw position
|
|
// x - 'a', away team = y - 'a'. The second half repeats the rounds with home and away
|
|
// swapped, and so on for leagues that play more than twice (the round index wraps).
|
|
//
|
|
// Results (block LeagueResults, 0xD5C bytes)
|
|
// results[league * 380 + (matchday - 1) * 10 + match] = home_goals << 4 | away_goals
|
|
// Room for 9 leagues x 38 matchdays x 10 matches. 0xCC marks a match not yet played
|
|
// (the whole block is filled with 0xCC at season start, FUN at layout field in the dump);
|
|
// the code also tests (value & 0xCF) against 0xCC/0xCD/0xCE for postponed matches.
|
|
|
|
#include <cstdint>
|
|
#include <map>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "game/world_layout.hpp"
|
|
|
|
namespace bmh {
|
|
|
|
class LeImage;
|
|
// Round strings are installation content. Sparse authored caches are supported
|
|
// for isolated callers; real sessions install the tables from their executable.
|
|
using FixtureTableCache = std::map<int, std::vector<std::string>>;
|
|
// Validates every supplied table before replacing the current cache. Throws
|
|
// std::invalid_argument for malformed rows, team ids, sizes or round counts.
|
|
void set_fixture_tables(FixtureTableCache tables);
|
|
void install_fixture_tables(const LeImage& exe);
|
|
|
|
// The league structure of the loaded game (sizes, calendar groups, promotion ladder, cup structure)
|
|
// is league_system() of world_layout.hpp. The German sizes are the default; app::CareerSession
|
|
// installs those of the loaded game from the EXE tables. One game per process.
|
|
//
|
|
// Installs the league sizes of the loaded game; throws std::invalid_argument unless they
|
|
// add up to the league teams of the world layout (138 in every version) and every league has a
|
|
// fixture table (20, 18, 16, 12 or 10 teams).
|
|
void set_league_sizes(const uint8_t (&sizes)[kLeagueCount]);
|
|
// Installs the calendar groups (first league and league count per competition bit) and derives
|
|
// the calendar bit of every league from them.
|
|
void set_league_groups(const uint8_t (&first)[8], const uint8_t (&count)[8]);
|
|
|
|
// First team id of a league (sum of the sizes of all previous leagues).
|
|
int league_first_team(int league);
|
|
// League of a team id, or kLeagueCount for teams outside league play (TeamLeague2).
|
|
int team_league(int team);
|
|
// The round-string table a league plays with (its team count): the original points leagues
|
|
// 0-4 at the table of the first league and 5-8 at the 12-team table (DE CareerFirstSteps2, EN
|
|
// LeagueTableTeams). The same as the league size except for the English fifth league (10 teams),
|
|
// which belongs to no calendar group and is never played.
|
|
int league_table_teams(int league);
|
|
|
|
struct Fixture {
|
|
int home; // team id
|
|
int away; // team id
|
|
};
|
|
|
|
// Matches of a league matchday (1-based), home/away as team ids. `rounds` is the number of
|
|
// rounds per half season, normally team count - 1 (the original passes matchdays / 2).
|
|
std::vector<Fixture> league_fixtures(int league, int matchday);
|
|
|
|
// Raw fixture generator, a direct port of GenerateFixtures:
|
|
// teams - league size, selects the round-string table
|
|
// matchday - 1-based
|
|
// rounds - rounds per half season (normally teams - 1)
|
|
// first_team - id of the league's first team, added to every draw position
|
|
std::vector<Fixture> generate_fixtures(int teams, int matchday, int rounds, int first_team);
|
|
|
|
constexpr uint8_t kNotPlayed = 0xCC;
|
|
constexpr size_t kResultsSize = 0xD5C;
|
|
|
|
struct Result {
|
|
bool played = false;
|
|
int home_goals = 0;
|
|
int away_goals = 0;
|
|
};
|
|
|
|
// Decodes one result byte of block LeagueResults.
|
|
inline Result decode_result(uint8_t v) {
|
|
if ((v & 0xCF) >= 0xCC) return {};
|
|
return {true, v >> 4, v & 0x0F};
|
|
}
|
|
|
|
// Index into the results block for a league match.
|
|
inline size_t result_index(int league, int matchday, int match) {
|
|
return size_t(league) * 0x17C + size_t(matchday - 1) * 10 + size_t(match);
|
|
}
|
|
|
|
} // namespace bmh
|