At the start of the season transition, before promotion moves the clubs, the almanac stores the final table of every league (rank, games, wins, draws, defeats, goals, points) and each league's champion and runner-up. Every decided cup (national cup, European cups, supercup, play-off, national tournaments, each indoor tournament and the Masters) is noted with its date, last stage and runner-up. Almanac format version 2; version 1 seasons are still read. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
790 lines
43 KiB
C++
790 lines
43 KiB
C++
// SPDX-License-Identifier: GPL-3.0-only
|
|
#include "formats/executable_layout.hpp"
|
|
#include "modern/game/modern_state.hpp"
|
|
#include "modern/game/cup.hpp"
|
|
|
|
#include <algorithm>
|
|
#include <array>
|
|
#include <string>
|
|
#include <utility>
|
|
#include <vector>
|
|
|
|
#include "modern/game/driver.hpp"
|
|
#include "game/lineup.hpp"
|
|
#include "modern/game/matchday.hpp"
|
|
#include "modern/game/matchday_setup.hpp"
|
|
#include "game/messages.hpp"
|
|
#include "game/schedule.hpp"
|
|
#include "game/table.hpp"
|
|
|
|
namespace bmh::modern {
|
|
|
|
// After the fifth indoor tournament (the end of AdvanceCup for competition 0xb): the
|
|
// field of the Masters.
|
|
// MastersQualification2: the holders of the three titles of last season (Cup_AdvanceCup_RuntimeField6[0..2],
|
|
// u16 club ids) qualify directly, each once (list Cup_MastersQualification_RuntimeField, count CupRuntimeField);
|
|
// they head the team list (Teams).
|
|
// IndoorStandingsFromGame(0): the clubs 0-39 are sorted by their Masters points (Cup_AdvanceCup_ExecutableField,
|
|
// Games descending); IndoorTournamentDraw only resets the tournament (no draw while
|
|
// CupRuntimeField != 0); the best clubs not qualified yet fill the list up to eight, which
|
|
// is shuffled (PrepareEvent, one game draw per club). The strength class Cup_AdvanceCup_RuntimeField3
|
|
// stays that of the last tournament.
|
|
// The test "qualified yet" (MastersQualification) scans Cup_MastersQualification_RuntimeField[0 .. CupRuntimeField), but
|
|
// CupRuntimeField also counts the clubs filled in from the points list, which never enter
|
|
// Cup_MastersQualification_RuntimeField: the scan runs over the stale entries 2 and 3 (0 unless an earlier Masters
|
|
// had three direct qualifiers) and from entry 4 into the invitation counters that follow
|
|
// (MatchdaySetup_IndoorTournamentDraw_RuntimeField, u16 per club). A club whose id equals one of those values (team 0 with a
|
|
// 0 there, small ids with an invitation count) is skipped although it has the points.
|
|
// The list is not in the savegame; the replay keeps it in memory, starting at 0.
|
|
void masters_qualification(ModernState& g, GameRandom& game) {
|
|
StaticMemory& mem = g.memory;
|
|
constexpr uint32_t kTeams = ::bmh::layout::Teams, kDirect = ::bmh::layout::Cup_MastersQualification_RuntimeField;
|
|
if (!mem.has(kDirect)) mem.add_block(kDirect, 8);
|
|
// MastersQualification: whether club t is in Cup_MastersQualification_RuntimeField[0 .. count)
|
|
auto listed = [&](uint16_t t, size_t count) {
|
|
for (size_t k = 0; k < count; k++)
|
|
if (mem.u16(kDirect + uint32_t(k) * 2) == t) return true;
|
|
return false;
|
|
};
|
|
size_t count = 0; // CupRuntimeField
|
|
for (uint32_t k = 0; k < 3; k++) {
|
|
const uint16_t t = mem.u16(::bmh::layout::Cup_AdvanceCup_RuntimeField6 + k * 2);
|
|
if (k == 0 || !listed(t, count)) mem.set16(kDirect + uint32_t(count++) * 2, t);
|
|
}
|
|
for (size_t k = 0; k < count; k++) mem.set16(kTeams + uint32_t(k) * 2, mem.u16(kDirect + uint32_t(k) * 2));
|
|
int16_t order[0x28];
|
|
uint32_t points[0x28];
|
|
for (int i = 0; i < 0x28; i++) order[i] = int16_t(i), points[i] = mem.u16(::bmh::layout::Cup_AdvanceCup_ExecutableField + uint32_t(i) * 2);
|
|
quicksort_by_key(order, points, 0x28);
|
|
modern::indoor_tournament_reset(g);
|
|
for (int i = 0; count < 8; i++) {
|
|
const uint16_t t = uint16_t(order[i]);
|
|
if (!listed(t, count)) mem.set16(kTeams + uint32_t(count++) * 2, t);
|
|
}
|
|
for (uint32_t i = 0; i < 8; i++) { // PrepareEvent(8, teams)
|
|
const uint32_t j = uint32_t(game.range(0, 7));
|
|
const uint16_t a = mem.u16(kTeams + i * 2);
|
|
mem.set16(kTeams + i * 2, mem.u16(kTeams + j * 2));
|
|
mem.set16(kTeams + j * 2, a);
|
|
}
|
|
for (uint32_t k = 0; k < 8; k++) {
|
|
const int manager = g.manager_of(mem.u16(kTeams + k * 2));
|
|
if (manager < 0) continue;
|
|
post_composed(g, manager, kMastersQualificationText); // MastersQualificationText
|
|
modern::book_money(g, manager, -150000, true, true);
|
|
}
|
|
const std::string name = message_text(g, ::bmh::layout::Cup_MastersQualification_TextPointer);
|
|
if (g.tournament_name.size() < 0x24) g.tournament_name.resize(0x24, 0);
|
|
for (size_t i = 0; i <= name.size() && i < 0x24; i++) g.tournament_name[i] = i < name.size() ? uint8_t(name[i]) : 0;
|
|
}
|
|
|
|
namespace {
|
|
|
|
void put32(Bytes& b, size_t o, uint32_t v) {
|
|
for (int i = 0; i < 4; i++) b.at(o + i) = uint8_t(v >> (8 * i));
|
|
}
|
|
|
|
// Replays of postponed league matches: cup entry type 9 plays the matches whose replay day
|
|
// (table Postponed, 40 entries of 6 bytes: day, round, league, match) is today.
|
|
constexpr uint32_t kPostponed = ::bmh::layout::Postponed;
|
|
constexpr uint32_t kReplayFixtures = ::bmh::layout::ReplayFixtures; // team list of the type 9 entry (home, away)
|
|
constexpr uint32_t kReplayResults = ::bmh::layout::ReplayResults; // its result array (u16 per match)
|
|
|
|
// AddBlock: the fixtures of today's replays; the entry's team count (+0x1a) and played
|
|
// counter (+0x1d) restart.
|
|
void prepare_replays(ModernState& g, uint32_t e, int day) {
|
|
StaticMemory& mem = g.memory;
|
|
mem.add_block(kReplayFixtures, 0x50);
|
|
mem.add_block(kReplayResults, 0x12);
|
|
mem.set8(e + 0x1d, 0);
|
|
mem.set8(e + 0x1a, 0);
|
|
for (uint32_t i = 0; i < 0x12; i++) mem.set8(kReplayResults + i, 0xcc);
|
|
int k = 0;
|
|
for (int n = 0; n < 0x28; n++) {
|
|
const uint32_t at = kPostponed + uint32_t(n) * 6;
|
|
if (mem.u16(at) != day) continue;
|
|
const int league = mem.u8(at + 3);
|
|
const std::vector<Fixture> fx = generate_fixtures(league_table_teams(league), mem.u8(at + 2) + 1, league_matchdays(league) / 2,
|
|
league_first_team(league));
|
|
const Fixture& f = fx.at(mem.u8(at + 4));
|
|
mem.set16(kReplayFixtures + uint32_t(k++) * 2, uint16_t(f.home));
|
|
mem.set16(kReplayFixtures + uint32_t(k++) * 2, uint16_t(f.away));
|
|
mem.set8(e + 0x1a, uint8_t(mem.u8(e + 0x1a) + 2));
|
|
}
|
|
}
|
|
|
|
// EndCompetition(id): takes a competition off the list of running ones (ActiveSelectors).
|
|
void remove_competition(StaticMemory& mem, int id) {
|
|
for (int i = 0; i < 8; i++) {
|
|
if (int8_t(mem.u8(::bmh::layout::ActiveSelectors + uint32_t(i))) != id) continue;
|
|
for (int j = i; j < 7; j++) mem.set8(::bmh::layout::ActiveSelectors + uint32_t(j), mem.u8(::bmh::layout::Cup_RemoveCompetition_RuntimeField + uint32_t(j)));
|
|
mem.set8(::bmh::layout::Cup_RemoveCompetition_RuntimeField2, 0x14);
|
|
return;
|
|
}
|
|
}
|
|
|
|
// UndoReschedule(day, 0, 0): today's replay results go back into the league result table and
|
|
// their entries are freed; then EndCompetition(9) takes the competition off the list of
|
|
// running competitions (ActiveSelectors).
|
|
void store_replays(ModernState& g, int day) {
|
|
StaticMemory& mem = g.memory;
|
|
int k = 0;
|
|
for (int n = 0; n < 0x28; n++) {
|
|
const uint32_t at = kPostponed + uint32_t(n) * 6;
|
|
if (mem.u16(at) != day) continue;
|
|
const uint16_t r = mem.u16(kReplayResults + uint32_t(k++) * 2);
|
|
const uint8_t result = uint8_t(((r >> 5) << 4) | (r & 0xf));
|
|
g.results.at(size_t(mem.u8(at + 4)) + size_t(mem.u8(at + 2)) * 10 + size_t(mem.u8(at + 3)) * 0x17C) = result;
|
|
mem.set16(at, 0);
|
|
}
|
|
remove_competition(mem, 9);
|
|
}
|
|
|
|
// Size of the round string table a cup group plays with (pointer at entry +8).
|
|
int group_table_teams(const StaticMemory& mem, uint32_t e) {
|
|
switch (mem.pointer(e + 8)) {
|
|
case ::bmh::layout::CareerSession_RuntimeError_RuntimeField: return 4;
|
|
case ::bmh::layout::CareerSession_RuntimeError_RuntimeField2: return 6;
|
|
case ::bmh::layout::CareerSession_RuntimeError_RuntimeField3: return 12;
|
|
case ::bmh::layout::CareerSession_RuntimeError_ExecutableField3: return 16;
|
|
case ::bmh::layout::CareerSession_RuntimeError_ExecutableField: return 18;
|
|
case ::bmh::layout::CareerSession_RuntimeError_ExecutableField2: return 20;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
// AddResult(entry, 0): the table of a cup group from its result array (u16 per match,
|
|
// 0xCCCC = not played), indexed by draw position. Bit 7 of the flags: three points for a
|
|
// win. The ranks are sorted like the league tables (AddResult2) after the last two rounds
|
|
// and after later rounds with results.
|
|
LeagueTable group_table(const StaticMemory& mem, uint32_t e) {
|
|
LeagueTable t;
|
|
const uint8_t flags = mem.u8(e + 0x14);
|
|
const int teams = mem.u8(e + 0x1a), rounds = mem.u8(e + 0x1b), played = mem.u8(e + 0x1d);
|
|
t.size = teams;
|
|
const int three_points = flags >> 7;
|
|
int last = played - 1, before_last = 0x80;
|
|
if (last > 1) before_last = played - 2;
|
|
if (last < 0) last = 0;
|
|
sort_table(t, 0);
|
|
const uint32_t results = mem.pointer(e + 0x0c);
|
|
for (int r = 0; r < rounds; r++) {
|
|
const std::vector<Fixture> fx = generate_fixtures(group_table_teams(mem, e), r + 1, rounds / ((flags & 1) + 1), 0);
|
|
bool counted = false;
|
|
for (int s = 0; s < teams; s += 2) {
|
|
const uint16_t u = mem.u16(results + uint32_t(s / 2 + r * teams / 2) * 2);
|
|
if (u == 0xcccc) continue;
|
|
const uint8_t goals[2] = {uint8_t((u >> 5) & 0x1f), uint8_t(u & 0x1f)};
|
|
const int club[2] = {fx.at(size_t(s / 2)).home, fx.at(size_t(s / 2)).away};
|
|
add_result(t, club, goals, 3, three_points);
|
|
counted = true;
|
|
}
|
|
if (before_last == r || last == r || (last < r && counted)) sort_table(t, 0);
|
|
}
|
|
return t;
|
|
}
|
|
|
|
// The end of a group stage (AdvanceCup): the qualifiers place by place (all group
|
|
// winners, then the runners-up, ...) until the stage's quota (+0x1f) is reached; a place
|
|
// taken only partly keeps its best clubs by the table key. Group winner and runner-up are
|
|
// noted in +0x22 / +0x24 of every group. Returns the qualifiers and in `loser_pair` the
|
|
// first two clubs of the first group ordered by the last table's second place (for a final
|
|
// of two).
|
|
std::vector<uint16_t> group_qualifiers(StaticMemory& mem, uint32_t e, std::array<uint16_t, 2>& loser_pair) {
|
|
const int groups = mem.u8(e + 0x1e) & 0xF;
|
|
int quota = int8_t(mem.u8(e + 0x1f));
|
|
std::vector<uint16_t> teams;
|
|
std::vector<uint32_t> keys;
|
|
LeagueTable t;
|
|
for (int place = 0; quota > 0; place++) {
|
|
for (int grp = 0; grp < groups; grp++) {
|
|
uint32_t ge = e;
|
|
while ((mem.u8(ge + 0x1e) >> 4) != grp) ge += kCupEntrySize;
|
|
t = group_table(mem, ge);
|
|
int idx = 0;
|
|
while (idx < mem.u8(ge + 0x1a) && t.rank(idx) != place) idx++;
|
|
const uint16_t team = mem.u16(mem.pointer(ge) + uint32_t(idx) * 2);
|
|
if (place == 0) mem.set16(ge + 0x22, team);
|
|
if (place == 1) mem.set16(ge + 0x24, team);
|
|
keys.push_back(sort_key(t, idx, 0));
|
|
teams.push_back(team);
|
|
quota--;
|
|
}
|
|
}
|
|
const uint32_t list = mem.pointer(e);
|
|
loser_pair[0] = t.rank(0) == 1 ? mem.u16(list) : mem.u16(list + 2);
|
|
const int wanted = int8_t(mem.u8(e + 0x1f));
|
|
const int cut = wanted - wanted % groups;
|
|
for (; quota < 0; quota++) {
|
|
uint32_t worst = keys.back();
|
|
size_t at = 0;
|
|
for (int k = cut; k < wanted; k++)
|
|
if (keys[size_t(k)] < worst) at = size_t(k), worst = keys[size_t(k)];
|
|
if (worst < keys.back()) {
|
|
std::swap(teams.back(), teams[at]);
|
|
std::swap(keys.back(), keys[at]);
|
|
}
|
|
teams.pop_back();
|
|
keys.pop_back();
|
|
}
|
|
return teams;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
LeagueTable cup_group_table(const StaticMemory& mem, uint32_t entry_address) {
|
|
return group_table(mem, entry_address);
|
|
}
|
|
|
|
int cup_group_schedule_teams(const StaticMemory& mem, uint32_t entry_address) {
|
|
return group_table_teams(mem, entry_address);
|
|
}
|
|
|
|
void end_competition(StaticMemory& mem, int id) { remove_competition(mem, id); }
|
|
|
|
void prepare_friendlies(ModernState& g) {
|
|
StaticMemory& mem = g.memory;
|
|
if (!mem.has(::bmh::layout::FriendlyDays) || !mem.has(::bmh::layout::FriendlyTeams) || !mem.has(::bmh::layout::Career_CompetitionPointersEnglish_ExecutableField24)) return;
|
|
const int today = g.season_day(); // DaysIntoSeason
|
|
int count = 0; // local_c: two teams per friendly
|
|
for (int i = 0; i < 0x1e; i++) {
|
|
if (int16_t(mem.u16(::bmh::layout::FriendlyDays + uint32_t(i) * 2)) != int16_t(today)) continue;
|
|
for (int c = 0; c < 2; c++)
|
|
mem.set16(::bmh::layout::Career_CompetitionPointersEnglish_ExecutableField24 + uint32_t(c + count) * 2, mem.u16(::bmh::layout::FriendlyTeams + uint32_t(i * 2 + c) * 2));
|
|
mem.set16(::bmh::layout::Career_CompetitionPointersEnglish_ExecutableField29 + uint32_t(count >> 1) * 2, 0xcccc);
|
|
mem.set16(::bmh::layout::FriendlyDays + uint32_t(i) * 2, 0);
|
|
count += 2;
|
|
if (i < 0x1d) {
|
|
// the planned ones after it move up (the last place keeps its copy)
|
|
for (int k = i; k < 0x1d; k++) {
|
|
mem.set32(::bmh::layout::FriendlyTeams + uint32_t(k) * 4, mem.u32(::bmh::layout::Cup_PrepareFriendlies_RuntimeField + uint32_t(k) * 4));
|
|
mem.set16(::bmh::layout::FriendlyDays + uint32_t(k) * 2, mem.u16(::bmh::layout::Cup_PrepareFriendlies_RuntimeField2 + uint32_t(k) * 2));
|
|
}
|
|
i--;
|
|
// the planner's entry 30 counts them (two per friendly); only decreased here,
|
|
// not for the last place (as in the original)
|
|
const uint32_t planned = modern::cup_entry_address(30) + 0x1a;
|
|
mem.set8(planned, uint8_t(mem.u8(planned) - 2));
|
|
}
|
|
}
|
|
mem.set8(modern::cup_entry_address(24) + 0x1a, uint8_t(count)); // today's friendlies (CupRuntimeField2)
|
|
}
|
|
|
|
int find_cup(const StaticMemory& mem, int id) {
|
|
for (int i = 0; i < kCupEntries; i++)
|
|
if (int16_t(mem.u16(modern::cup_entry_address(i) + 0x18)) == id) return i;
|
|
return -1;
|
|
}
|
|
|
|
int cup_round(const StaticMemory& mem, int entry) {
|
|
const uint32_t e = modern::cup_entry_address(entry);
|
|
const uint8_t flags = mem.u8(e + 0x14), played = mem.u8(e + 0x1d);
|
|
if (!(flags & 4)) return played;
|
|
return played / ((flags & 1) + 1);
|
|
}
|
|
|
|
int cup_round_offset(const StaticMemory& mem, int entry, int round) {
|
|
if (round == 0) return 0;
|
|
const int teams = mem.u8(modern::cup_entry_address(entry) + 0x1a);
|
|
return teams * 2 - teams / (1 << (round - 1));
|
|
}
|
|
|
|
void rebuild_replay_lists(ModernState& g, uint32_t competitions) {
|
|
for (int bit = 5; bit < 0x13; bit++) {
|
|
if (!((competitions >> bit) & 1)) continue;
|
|
const int entry = modern::find_cup(g.memory, bit - 5);
|
|
if (entry >= 0 && int16_t(g.memory.u16(modern::cup_entry_address(entry) + 0x18)) == 9)
|
|
prepare_replays(g, modern::cup_entry_address(entry), g.season_day());
|
|
}
|
|
}
|
|
|
|
void setup_cup_groups(ModernState& g, int id, std::vector<MatchGroup>& groups, MinuteReport& report) {
|
|
const StaticMemory& mem = g.memory;
|
|
int entry = modern::find_cup(mem, id);
|
|
if (entry < 0) {
|
|
report.fail("cup " + std::to_string(id) + " not in the cup table");
|
|
return;
|
|
}
|
|
const int type = int16_t(mem.u16(modern::cup_entry_address(entry) + 0x18));
|
|
if (type == 9) prepare_replays(g, modern::cup_entry_address(entry), g.season_day());
|
|
if (type == 10) modern::prepare_friendlies(g);
|
|
if (type > 9 && mem.u8(modern::cup_entry_address(entry) + 0x1a) != 0) {
|
|
// AddCompetition: onto the list of running competitions (ActiveSelectors, 0x14 = free)
|
|
for (uint32_t i = 0; i < 8; i++) {
|
|
if (int8_t(mem.u8(::bmh::layout::ActiveSelectors + i)) == type) break;
|
|
if (g.memory.u8(::bmh::layout::ActiveSelectors + i) == 0x14) {
|
|
g.memory.set8(::bmh::layout::ActiveSelectors + i, uint8_t(type));
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
// (the friendlies 10, the promotion play-off 0xd and the indoor tournament 0xb only join
|
|
// the running list above)
|
|
if (type > 0xb && type != 0xd && mem.u8(modern::cup_entry_address(entry) + 0x1a) != 0) {
|
|
report.fail("cup " + std::to_string(id) + ": preparation of this competition (AddBlock/2631b/26175)");
|
|
return;
|
|
}
|
|
// skip the stages that are completed (bounded: a broken chain would loop for ever)
|
|
for (int steps = 0; modern::cup_round(mem, entry) >= mem.u8(modern::cup_entry_address(entry) + 0x1b); ++steps) {
|
|
const int next = int8_t(mem.u8(modern::cup_entry_address(entry) + 0x16));
|
|
if (steps > 0x24 || next < 0 || next >= 0x24) {
|
|
report.fail("cup " + std::to_string(id) + ": stage chain without an open stage (entry " + std::to_string(entry) +
|
|
", round " + std::to_string(modern::cup_round(mem, entry)) + " of " +
|
|
std::to_string(mem.u8(modern::cup_entry_address(entry) + 0x1b)) + ", next " + std::to_string(next) + ")");
|
|
return;
|
|
}
|
|
entry = next;
|
|
}
|
|
const int parallel = mem.u8(modern::cup_entry_address(entry) + 0x1e) & 0xF;
|
|
if (mem.u32(modern::cup_entry_address(entry)) == 0) return;
|
|
for (int k = 0; k < parallel; k++) {
|
|
const uint32_t e = modern::cup_entry_address(entry);
|
|
const uint8_t flags = mem.u8(e + 0x14);
|
|
const int teams = mem.u8(e + 0x1a);
|
|
if (teams == 0) continue; // (the original then looks at the same entry again)
|
|
MatchGroup grp;
|
|
grp.desc = modern::group_descriptor(g, groups.size());
|
|
grp.desc.at(0) = uint8_t(type + 1);
|
|
grp.desc.at(1) = flags;
|
|
// competition 11 is the German indoor tournament; in the English game the same entry
|
|
// is the League Cup ("Koka Kola Cup"), an ordinary cup on grass (EN Put32)
|
|
if (type == 0xb && !kEnglishCompetitions) g.indoor = true;
|
|
put32(grp.desc, 0xcc, e);
|
|
// the first leg of a two-legged knockout tie is never decided on the day
|
|
if ((flags & 5) == 5 && mem.u8(e + 0x1d) % 2 == 0) grp.desc.at(1) &= 0xF7;
|
|
int matches = 0, first = 0; // local_1c; the result index is `first` / 2
|
|
const uint32_t list = mem.pointer(e);
|
|
if (!(flags & 4)) {
|
|
// a group: GenerateFixtures on the cup's round strings (+8), round = played + 1, the
|
|
// draw positions index the group's team list; two-legged groups play the rounds
|
|
// of the string table twice, home and away swapped
|
|
matches = teams / 2;
|
|
const int played = mem.u8(e + 0x1d);
|
|
first = uint8_t(matches * played * 2);
|
|
const int rounds = mem.u8(e + 0x1b) / ((flags & 1) + 1);
|
|
int table_teams = 0;
|
|
switch (mem.pointer(e + 8)) {
|
|
case ::bmh::layout::CareerSession_RuntimeError_RuntimeField: table_teams = 4; break;
|
|
case ::bmh::layout::CareerSession_RuntimeError_RuntimeField2: table_teams = 6; break;
|
|
case ::bmh::layout::CareerSession_RuntimeError_RuntimeField3: table_teams = 12; break;
|
|
case ::bmh::layout::CareerSession_RuntimeError_ExecutableField3: table_teams = 16; break;
|
|
case ::bmh::layout::CareerSession_RuntimeError_ExecutableField: table_teams = 18; break;
|
|
case ::bmh::layout::CareerSession_RuntimeError_ExecutableField2: table_teams = 20; break;
|
|
}
|
|
if (table_teams == 0) {
|
|
report.fail("cup group with unknown round strings");
|
|
return;
|
|
}
|
|
for (const Fixture& f : generate_fixtures(table_teams, played + 1, rounds, 0)) {
|
|
if (int(grp.fixtures.size()) >= matches * 2) break;
|
|
grp.fixtures.push_back(int16_t(mem.u16(list + uint32_t(f.home) * 2)));
|
|
grp.fixtures.push_back(int16_t(mem.u16(list + uint32_t(f.away) * 2)));
|
|
}
|
|
// the fixtures are kept in the descriptor itself (+0x88; +0x7c points there)
|
|
for (size_t i = 0; i < grp.fixtures.size(); i++) {
|
|
grp.desc.at(0x88 + i * 2) = uint8_t(grp.fixtures[i]);
|
|
grp.desc.at(0x89 + i * 2) = uint8_t(uint16_t(grp.fixtures[i]) >> 8);
|
|
}
|
|
} else {
|
|
const int round = modern::cup_round(mem, entry);
|
|
matches = teams / (1 << (round + 1));
|
|
first = modern::cup_round_offset(mem, entry, round);
|
|
for (int i = 0; i < matches * 2; i++) grp.fixtures.push_back(int16_t(mem.u16(list + uint32_t(first + i) * 2)));
|
|
}
|
|
grp.desc.at(2) = uint8_t(matches);
|
|
if (type == 0 && matches == 1) grp.desc.at(1) &= 0xFD; // the national cup final
|
|
// MatchdayNeedsManagerDesks: a human manager's club notes its side (record +0x28a)
|
|
for (int i = 0; i < matches * 2; i++)
|
|
for (size_t mgr = 0; mgr < g.manager_teams.size(); mgr++)
|
|
if (g.manager_teams[mgr] == grp.fixtures[size_t(i)]) g.manager_records.at(mgr * 0xB0C + 0x28a) = uint8_t(i % 2);
|
|
for (int leg = 0; leg < 2; leg++) {
|
|
if (leg == 1 && !(flags & 1)) break;
|
|
const uint32_t results = mem.pointer(e + 0x0c + uint32_t(leg) * 4);
|
|
if (results == 0) continue;
|
|
grp.cup_result_address[leg] = results + uint32_t(first / 2) * 2;
|
|
std::vector<uint16_t>& r = leg == 0 ? grp.cup_results : grp.cup_other_leg;
|
|
for (int i = 0; i < matches; i++) r.push_back(mem.u16(grp.cup_result_address[leg] + uint32_t(i) * 2));
|
|
}
|
|
groups.push_back(grp);
|
|
entry++;
|
|
}
|
|
}
|
|
|
|
} // namespace bmh::modern
|
|
|
|
namespace bmh::modern {
|
|
|
|
void store_cup_results(ModernState& g, const MatchGroup& grp) {
|
|
if (grp.desc.at(0) == 0 || grp.cup_result_address[0] == 0) return;
|
|
for (size_t i = 0; i < grp.cup_results.size(); i++)
|
|
g.memory.set16(grp.cup_result_address[0] + uint32_t(i) * 2, grp.cup_results[i]);
|
|
}
|
|
|
|
namespace {
|
|
|
|
// NationalTournamentEnd, at the end of the international tournament (competition type 4): the
|
|
// honours list of the tournaments (Placements, 4 bytes per tournament, newest first)
|
|
// moves one place on and gets the first four (final winner and loser Cup_NationalTournamentEnd_RuntimeField/2dce,
|
|
// third place match Cup_NationalTournamentEnd_RuntimeField3/2df6) as national team index | 0x80. A Bundestrainer's
|
|
// association (manager slot 0 holds team 0x165) pays 400000 for taking part and the
|
|
// premium of the place (CupRuntimeField3).
|
|
void national_tournament_end(ModernState& g) {
|
|
StaticMemory& mem = g.memory;
|
|
const int teams[4] = {int16_t(mem.u16(::bmh::layout::Cup_NationalTournamentEnd_RuntimeField)), int16_t(mem.u16(::bmh::layout::Cup_NationalTournamentEnd_RuntimeField2)), int16_t(mem.u16(::bmh::layout::Cup_NationalTournamentEnd_RuntimeField3)),
|
|
int16_t(mem.u16(::bmh::layout::Cup_NationalTournamentEnd_RuntimeField4))};
|
|
static constexpr int32_t kPremium[4] = {1000000, 600000, 300000, 200000}; // CupRuntimeField3
|
|
if (mem.has(::bmh::layout::Placements))
|
|
for (int i = 0x4c - 1; i >= 0; i--) mem.set8(::bmh::layout::Cup_NationalTournamentEnd_RuntimeField5 + uint32_t(i), mem.u8(::bmh::layout::Placements + uint32_t(i)));
|
|
const bool coach = !g.manager_teams.empty() && g.manager_teams[0] == no_team();
|
|
if (coach) modern::book_money(g, 0, -400000, true, true);
|
|
for (int i = 0; i < 4; i++) {
|
|
if (teams[i] == no_team() && coach) modern::book_money(g, 0, -kPremium[i], true, true);
|
|
// (0x8a + 0x1e + 0xbd = 0x165: CareerSession_DispatchLineup_RuntimeField + CareerSession_InstallLeagueSizes_RuntimeField6 + ClubPlayerDetail_ClubPlayerDetailFromGame_RuntimeField3)
|
|
if (mem.has(::bmh::layout::Placements)) mem.set8(::bmh::layout::Placements + uint32_t(i), uint8_t((teams[i] - no_team()) | 0x80));
|
|
}
|
|
}
|
|
|
|
// cup_tie on the result arrays of a stage (CupTie(results0, results1, index, flags))
|
|
int stage_tie(const StaticMemory& mem, uint32_t e, int index) {
|
|
MatchGroup grp;
|
|
grp.desc.assign(0xd0, 0);
|
|
grp.desc.at(1) = mem.u8(e + 0x14);
|
|
const uint32_t r0 = mem.pointer(e + 0x0c), r1 = mem.pointer(e + 0x10);
|
|
grp.cup_results.assign(size_t(index) + 1, 0);
|
|
grp.cup_results[size_t(index)] = mem.u16(r0 + uint32_t(index) * 2);
|
|
if (r1 != 0) {
|
|
grp.cup_other_leg.assign(size_t(index) + 1, 0);
|
|
grp.cup_other_leg[size_t(index)] = mem.u16(r1 + uint32_t(index) * 2);
|
|
}
|
|
return modern::cup_tie(grp, index);
|
|
}
|
|
|
|
void swap16(StaticMemory& mem, uint32_t a, uint32_t b) {
|
|
const uint16_t x = mem.u16(a);
|
|
mem.set16(a, mem.u16(b));
|
|
mem.set16(b, x);
|
|
}
|
|
|
|
// Getenv(teams, offset): Source home advantage followed by an unstable-free
|
|
// descending sort on each tie's combined league weight. Kept in this Core module so
|
|
// finish_cup can expose the Original draw before the inner sort and retain its outer sort.
|
|
void order_national_cup_ties(ModernState& g, int teams, int offset) {
|
|
StaticMemory& mem = g.memory;
|
|
const uint32_t list = mem.pointer(modern::cup_entry_address(0)) + uint32_t(offset) * 2;
|
|
static constexpr uint8_t kWeight[10] = {3, 1, 0, 0, 2, 0, 0, 0, 7, 0};
|
|
const int lower = league_first_team(2);
|
|
std::vector<uint8_t> weights;
|
|
weights.reserve(size_t(teams / 2));
|
|
auto team = [&](int i) { return int16_t(mem.u16(list + uint32_t(i) * 2)); };
|
|
auto swap_pair = [&](int a, int b) {
|
|
swap16(mem, list + uint32_t(a) * 2, list + uint32_t(b) * 2);
|
|
swap16(mem, list + uint32_t(a + 1) * 2, list + uint32_t(b + 1) * 2);
|
|
};
|
|
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); };
|
|
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]));
|
|
}
|
|
for (int i = 0; i < teams / 2 - 1; ++i)
|
|
for (int j = i + 1; j < teams / 2; ++j)
|
|
if (weights[size_t(i)] < weights[size_t(j)]) {
|
|
std::swap(weights[size_t(i)], weights[size_t(j)]);
|
|
swap_pair(i * 2, j * 2);
|
|
}
|
|
}
|
|
|
|
bool source_cup_draw_enabled(const StaticMemory& mem, int competition) {
|
|
// CupDrawFromGame: outside leagues 4..7 the leagues must be enabled, then the
|
|
// competition's display option must be clear. The follow-up package targets comp0.
|
|
if (competition < 4 || competition > 7) {
|
|
if (!mem.has(::bmh::layout::CompetitionSelection) || (mem.u8(::bmh::layout::CompetitionSelection) & 1) == 0) return false;
|
|
}
|
|
const uint32_t option = ::bmh::layout::LeaguePresentationOptions + uint32_t(competition + 5) * 9;
|
|
return mem.has(option) && mem.u8(option) == 0;
|
|
}
|
|
|
|
void observe_cup_draw(const ModernState& g, int entry, SeasonCupDrawPhase phase,
|
|
const SeasonCupDrawHook& hook) {
|
|
if (!hook) return;
|
|
const StaticMemory& mem = g.memory;
|
|
const uint32_t address = modern::cup_entry_address(entry);
|
|
SeasonCupDrawEvent event;
|
|
event.phase = phase;
|
|
event.entry_address = address;
|
|
event.competition = mem.u8(address + 0x18);
|
|
event.round = modern::cup_round(mem, entry);
|
|
event.offset = modern::cup_round_offset(mem, entry, event.round);
|
|
event.count = size_t(mem.u8(address + 0x1a)) >> event.round;
|
|
const uint32_t first = mem.pointer(address) + uint32_t(event.offset) * 2;
|
|
event.participants.reserve(event.count);
|
|
for (size_t i = 0; i < event.count; ++i)
|
|
event.participants.push_back(mem.u16(first + uint32_t(i) * 2));
|
|
hook(g, event);
|
|
}
|
|
|
|
} // namespace
|
|
|
|
void advance_cup(ModernState& g, int id, WatcomRandom& rand, MinuteReport& report, GameRandom* game,
|
|
const SeasonCupDrawHook& cup_draw, const CompetitionWinnerHook& winner_display) {
|
|
StaticMemory& mem = g.memory;
|
|
int entry = modern::find_cup(mem, id);
|
|
if (entry < 0) return;
|
|
const int type = int16_t(mem.u16(modern::cup_entry_address(entry) + 0x18));
|
|
if (type == 9) return store_replays(g, g.season_day());
|
|
// EndCompetition(type), re-added at the next preparation; the English Put32 keeps its
|
|
// League Cup (type 0xb) running like the other cups
|
|
if (type == 0xb && !kEnglishCompetitions) remove_competition(mem, type);
|
|
if (type == 10) {
|
|
// the friendlies: off the running list, the day's calendar entry masked with 0xffe
|
|
// (0x4001 becomes 0) and no teams left in today's entry (CupRuntimeField2)
|
|
remove_competition(mem, type);
|
|
const uint32_t day = ::bmh::layout::CompetitionCalendar + uint32_t(g.season_day()) * 2;
|
|
if (mem.has(day)) mem.set16(day, uint16_t(mem.u16(day) & 0xffe));
|
|
mem.set8(modern::cup_entry_address(24) + 0x1a, 0);
|
|
return;
|
|
}
|
|
if (type > 8 && type != 0xd && type != 0xb) {
|
|
report.fail("cup " + std::to_string(id) + ": processing of this competition (AdvanceCup)");
|
|
return;
|
|
}
|
|
while (modern::cup_round(mem, entry) >= mem.u8(modern::cup_entry_address(entry) + 0x1b))
|
|
entry = int8_t(mem.u8(modern::cup_entry_address(entry) + 0x16));
|
|
uint32_t e = modern::cup_entry_address(entry);
|
|
std::vector<uint16_t> winners, losers;
|
|
std::array<uint16_t, 2> loser_pair{};
|
|
if (!(mem.u8(e + 0x14) & 4)) {
|
|
// a group stage: every group (the consecutive entries up to the one without a
|
|
// parallel link, +0x17) counts the round
|
|
for (uint32_t ge = e;; ge += kCupEntrySize) {
|
|
mem.set8(ge + 0x1d, uint8_t(mem.u8(ge + 0x1d) + 1));
|
|
if (mem.u8(ge + 0x17) == 0) break;
|
|
}
|
|
if (mem.u8(e + 0x1d) < mem.u8(e + 0x1b)) return;
|
|
winners = group_qualifiers(mem, e, loser_pair);
|
|
} else {
|
|
const int round = modern::cup_round(mem, entry);
|
|
const int slots = mem.u8(e + 0x1a) / (1 << round); // local_3c: teams in this round
|
|
const int first = modern::cup_round_offset(mem, entry, round);
|
|
mem.set8(e + 0x1d, uint8_t(mem.u8(e + 0x1d) + 1)); // (unless CupRuntimeField4)
|
|
const uint32_t list = mem.pointer(e);
|
|
if ((mem.u8(e + 0x14) & 1) && mem.u8(e + 0x1d) % 2 != 0) {
|
|
// after the first leg: the pairs turn round, the results go to the second array
|
|
for (int i = 0; i < slots; i += 2) {
|
|
swap16(mem, list + uint32_t(first + i) * 2, list + uint32_t(first + i + 1) * 2);
|
|
const uint32_t k = uint32_t((first + i) / 2) * 2;
|
|
swap16(mem, mem.pointer(e + 0x0c) + k, mem.pointer(e + 0x10) + k);
|
|
}
|
|
return;
|
|
}
|
|
for (int i = 0; i < slots; i += 2) {
|
|
int t = stage_tie(mem, e, (first + i) / 2);
|
|
if (t > 1) t = 1;
|
|
winners.push_back(mem.u16(list + uint32_t(first + i + t) * 2));
|
|
losers.push_back(mem.u16(list + uint32_t(first + i + 1 - t) * 2));
|
|
}
|
|
}
|
|
// CupRuntimeField5[type] < 5 (national cup and the three European cups): a human manager's
|
|
// club that goes through counts one more round in his season record (ManagerOf,
|
|
// record +0xda + season * 3 + 1 national / 2 European)
|
|
if (type >= 0 && type <= 3)
|
|
for (uint16_t t : winners) {
|
|
const int manager = g.manager_of(t);
|
|
if (manager < 0) continue;
|
|
const size_t at = size_t(manager) * 0xB0C + 0xda + size_t(std::min(g.season, 0x31)) * 3 + (type > 0 ? 2 : 1);
|
|
g.manager_records.at(at) = uint8_t(g.manager_records.at(at) + 1);
|
|
}
|
|
if (modern::cup_round(mem, entry) == mem.u8(e + 0x1b)) {
|
|
// the stage is over
|
|
if (mem.u8(e + 0x16) == 0) {
|
|
// The last stage of the competition. A single final notes its winner (+0x22) and
|
|
// loser (+0x24); competition 0xc leaves the running list.
|
|
if (winners.size() == 1) {
|
|
mem.set16(e + 0x22, winners[0]);
|
|
if (!losers.empty()) mem.set16(e + 0x24, losers[0]);
|
|
}
|
|
if (type == 0xc) remove_competition(mem, 0xc);
|
|
// The almanac notes every decided competition (not the replay and friendly
|
|
// containers 9 and 10): the runner-up is the final's loser or the group's second.
|
|
if (type != 9 && type != 10 && !winners.empty())
|
|
modern::almanac_cup_winner(g, type, entry, winners[0],
|
|
winners.size() > 1 ? winners[1] : losers.empty() ? -1 : losers[0]);
|
|
// CupRuntimeField5: the title of the competition (0xFF: none)
|
|
static constexpr uint8_t kTitle[14] = {1, 2, 3, 4, 5, 0xff, 6, 0xff, 8, 0xff, 0xff, 0xff, 0xff, 0xff};
|
|
const uint8_t title = type >= 0 && type < 14 ? kTitle[type] : 0xff;
|
|
if (title != 0xff && !winners.empty()) {
|
|
if (type == 4) national_tournament_end(g); // NationalTournamentEnd
|
|
// CompetitionWinnerScreen(0, title, winner): the winner screen (unless switched off,
|
|
// Cup_AdvanceCup_RuntimeField; no draws) clears CareerSession_BeginFriendlyOpponentTable_ExecutableField2. A human manager's club counts
|
|
// the title in his record: +0x8a6 national cup, +0x8a8 European cups.
|
|
if (mem.u8(::bmh::layout::Cup_AdvanceCup_RuntimeField) == 0 && winner_display)
|
|
winner_display(g, {title, winners[0]});
|
|
if (mem.u8(::bmh::layout::Cup_AdvanceCup_RuntimeField) == 0 && mem.has(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField2)) mem.set8(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField2, 0);
|
|
const int manager = g.manager_of(winners[0]);
|
|
if (manager >= 0 && type >= 0 && type < 4) {
|
|
const size_t at = size_t(manager) * 0xB0C + (type == 0 ? 0x8a6 : 0x8a8);
|
|
const uint16_t n = uint16_t(g.manager_records.at(at) | g.manager_records.at(at + 1) << 8);
|
|
g.manager_records.at(at) = uint8_t(n + 1), g.manager_records.at(at + 1) = uint8_t((n + 1) >> 8);
|
|
}
|
|
// ListTitleHoldersAf(winner, title): the list of title holders (Titles)
|
|
mem.set16(::bmh::layout::Titles + uint32_t(title) * 100 + uint32_t(std::min<int>(g.season, 0x31)) * 2, winners[0]);
|
|
}
|
|
if (type == 0 && !winners.empty()) {
|
|
// the national cup: winner (Cup_AdvanceCup_RuntimeField5) and the previous holder
|
|
// (Career_CompetitionPointersEnglish_ExecutableField28 = Cup_AdvanceCup_RuntimeField6); Cup_AdvanceCup_RuntimeField2 = 0 if the holder won again, else 2
|
|
mem.set16(::bmh::layout::Cup_AdvanceCup_RuntimeField5, winners[0]);
|
|
mem.set16(::bmh::layout::Career_CompetitionPointersEnglish_ExecutableField28, mem.u16(::bmh::layout::Cup_AdvanceCup_RuntimeField6));
|
|
if (mem.has(::bmh::layout::Career_CompetitionPointersEnglish_ExecutableField31)) mem.set16(::bmh::layout::Career_CompetitionPointersEnglish_ExecutableField31, 0xcccc);
|
|
if (mem.has(::bmh::layout::Cup_AdvanceCup_RuntimeField2)) mem.set8(::bmh::layout::Cup_AdvanceCup_RuntimeField2, mem.u16(::bmh::layout::Cup_AdvanceCup_RuntimeField6) == winners[0] ? 0 : 2);
|
|
}
|
|
// a linked stage (+0x17) takes the runner-up (the indoor tournament's final group
|
|
// notes it in the group for third place)
|
|
if (mem.u8(e + 0x17) != 0 && winners.size() > 1)
|
|
mem.set16(modern::cup_entry_address(mem.u8(e + 0x17)) + 0x22, winners[1]);
|
|
// (the indoor tournament only: the English League Cup has no Masters; its winner
|
|
// would go to EN CupRuntimeField6 for Europe - not ported, see docs/fltd.md)
|
|
if (type != 0xb || kEnglishCompetitions) return;
|
|
// the indoor tournament: the four places (CupRuntimeField7 picks them from the list
|
|
// champion..fourth) earn points for the Masters (CupRuntimeField8 x strength class
|
|
// Cup_AdvanceCup_RuntimeField3, clubs of the first two leagues only), then the next tournament is
|
|
// drawn; after five tournaments the Masters follow
|
|
int held = mem.u8(::bmh::layout::Cup_AdvanceCup_RuntimeField4);
|
|
if (held > 4) {
|
|
// the end of the Masters: CompetitionWinnerScreen(0, 7, winner) shows the winner (unless
|
|
// switched off, Cup_AdvanceCup_RuntimeField; no draws) and clears CareerSession_BeginFriendlyOpponentTable_ExecutableField2;
|
|
// ListTitleHoldersAf(winner, 7) enters it in the list of title holders (Titles,
|
|
// 50 seasons per competition); Cup_AdvanceCup_RuntimeField7 = winner; a human manager's club
|
|
// gets a message and 250 000; EndCompetition removes the competition
|
|
const uint16_t winner = mem.u16(e + 0x22);
|
|
if (mem.u8(::bmh::layout::Cup_AdvanceCup_RuntimeField) == 0 && winner_display)
|
|
winner_display(g, {7, winner});
|
|
if (mem.u8(::bmh::layout::Cup_AdvanceCup_RuntimeField) == 0 && mem.has(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField2)) mem.set8(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField2, 0);
|
|
mem.set16(::bmh::layout::Titles + 7 * 100 + uint32_t(std::min<int>(g.season, 0x31)) * 2, winner);
|
|
modern::almanac_cup_winner(g, 0xb, entry, winner, -1, true); // the Masters (almanac)
|
|
if (mem.has(::bmh::layout::Cup_AdvanceCup_RuntimeField7)) mem.set16(::bmh::layout::Cup_AdvanceCup_RuntimeField7, winner);
|
|
const int manager = g.manager_of(winner);
|
|
if (manager >= 0) {
|
|
post_composed(g, manager, kMastersWinnerText); // MastersWinnerText
|
|
modern::book_money(g, manager, -250000, true, true);
|
|
}
|
|
remove_competition(mem, type);
|
|
return;
|
|
}
|
|
static constexpr uint8_t kPlaceOrder[4] = {0, 2, 1, 3}; // CupRuntimeField7
|
|
static constexpr uint8_t kPlacePoints[5] = {0, 6, 4, 2, 1}; // CupRuntimeField8
|
|
for (int i = 0; i < 4 && size_t(kPlaceOrder[i]) < winners.size(); i++) { // Uint32T
|
|
const int team = winners[kPlaceOrder[i]];
|
|
if (team < kLeagueSizes[0] + kLeagueSizes[1]) {
|
|
const uint32_t at = ::bmh::layout::Cup_AdvanceCup_ExecutableField + uint32_t(team) * 2;
|
|
mem.set16(at, uint16_t(mem.u16(at) + kPlacePoints[i + 1] * mem.u8(::bmh::layout::Cup_AdvanceCup_RuntimeField3)));
|
|
}
|
|
}
|
|
mem.set8(::bmh::layout::Cup_AdvanceCup_RuntimeField4, uint8_t(++held));
|
|
if (!game) {
|
|
report.fail("indoor tournament: the next draw needs the game generator");
|
|
return;
|
|
}
|
|
if (held >= 5) {
|
|
modern::masters_qualification(g, *game);
|
|
return;
|
|
}
|
|
modern::indoor_tournament_draw(g, *game, rand); // (CupRuntimeField = 0)
|
|
return;
|
|
}
|
|
uint32_t last = e;
|
|
const int seeded = mem.u8(e + 0x20);
|
|
if (seeded != 0) {
|
|
// clubs seeded directly into the next stage stand before the team lists
|
|
const int groups = mem.u8(e + 0x1e) & 0xF;
|
|
int left = seeded;
|
|
for (int k = 0; left != 0; k++)
|
|
for (int grp = 0; grp < groups; grp++) {
|
|
uint32_t ge = e;
|
|
while ((mem.u8(ge + 0x1e) >> 4) != grp) ge += kCupEntrySize;
|
|
last = ge;
|
|
if (left != 0) {
|
|
winners.push_back(mem.u16(mem.pointer(ge) - 2 - uint32_t(k) * 2));
|
|
left--;
|
|
}
|
|
}
|
|
}
|
|
entry = int8_t(mem.u8(last + 0x16));
|
|
e = modern::cup_entry_address(entry);
|
|
}
|
|
const int count = int(winners.size()); // local_14
|
|
if (mem.u8(e + 0x14) & 0x20) {
|
|
// the draw
|
|
for (int i = 0; i < count; i++) {
|
|
const int a = rand.range(0, count - 1);
|
|
const int b = rand.range(0, count - 1);
|
|
std::swap(winners[size_t(b)], winners[size_t(a)]);
|
|
}
|
|
}
|
|
if (!(mem.u8(e + 0x14) & 4)) {
|
|
// a group stage: the teams go round the groups, taken from the end
|
|
// groups of two (third place and final): the losers of the ties are added (local_88)
|
|
if (mem.u8(e + 0x1a) == 2)
|
|
for (int i = 0; i < 2 && size_t(i) < losers.size(); i++) winners.push_back(losers[size_t(i)]);
|
|
const int groups = mem.u8(e + 0x1e) & 0xF;
|
|
int left = int(winners.size());
|
|
uint32_t ge = e;
|
|
for (int slot = 0; slot < mem.u8(e + 0x1a); slot++)
|
|
for (int grp = 0; grp < groups; grp++) {
|
|
ge = e;
|
|
while ((mem.u8(ge + 0x1e) >> 4) != grp) ge += kCupEntrySize;
|
|
mem.set16(mem.pointer(ge) + uint32_t(slot) * 2, winners.at(size_t(--left)));
|
|
}
|
|
// AdvanceCup leaves any entrants beyond the regular group slots in the reserved
|
|
// list immediately before the final linked group's team list (entry +0x20 is the
|
|
// source guard). The Source consumes the remaining local list backwards.
|
|
if (mem.u8(ge + 0x20) != 0) {
|
|
for (int slot = 0; left > 0; ++slot)
|
|
for (int grp = 0; grp < groups; ++grp)
|
|
if (left > 0)
|
|
mem.set16(mem.pointer(ge) - 2 - uint32_t(slot) * 2, winners.at(size_t(--left)));
|
|
}
|
|
if (mem.u8(e + 0x1a) == 2) {
|
|
// the first club of this group and the second of the linked group change places
|
|
const uint32_t a = mem.pointer(e), b = mem.pointer(modern::cup_entry_address(mem.u8(e + 0x17))) + 2;
|
|
const uint16_t x = mem.u16(a);
|
|
mem.set16(a, mem.u16(b));
|
|
mem.set16(b, x);
|
|
}
|
|
} else {
|
|
const int next_round = modern::cup_round(mem, entry);
|
|
const int offset = modern::cup_round_offset(mem, entry, next_round);
|
|
const uint32_t to = mem.pointer(e);
|
|
int first_pair = 0;
|
|
if (next_round == mem.u8(e + 0x1b) && mem.u8(e + 0x20) != 0) {
|
|
first_pair = mem.u8(e + 0x20);
|
|
for (int i = 0; i < first_pair; ++i)
|
|
mem.set16(to - 2 - uint32_t(i) * 2, winners.at(size_t(i)));
|
|
}
|
|
for (int i = first_pair; i < count / 2; i++) {
|
|
mem.set16(to + uint32_t(offset + i * 2) * 2, winners[size_t(i)]);
|
|
mem.set16(to + uint32_t(offset + i * 2 + 1) * 2, winners[size_t(count - 1 - i)]);
|
|
}
|
|
if (e == modern::cup_entry_address(0)) {
|
|
const bool eligible = type == 0 && count > 2 && (mem.u8(e + 0x14) & 0x20) != 0 &&
|
|
source_cup_draw_enabled(mem, type);
|
|
if (eligible) {
|
|
// CupDrawFromGame displays the just-written shuffled order first.
|
|
observe_cup_draw(g, entry, SeasonCupDrawPhase::draw, cup_draw);
|
|
// It then performs Getenv and CupGroupOverviewEffects before returning.
|
|
order_national_cup_ties(g, count, offset);
|
|
modern::cup_overview_effects(g); // simulation effects occur even without an observer
|
|
observe_cup_draw(g, entry, SeasonCupDrawPhase::overview, cup_draw);
|
|
}
|
|
// AdvanceCup performs this outer sort after CupDrawFromGame returns (including
|
|
// its hidden-display early return). It is idempotent after the inner sort.
|
|
order_national_cup_ties(g, count, offset);
|
|
}
|
|
}
|
|
// Career_EuropeanClub_ExecutableField / Career_EuropeanClub_ExecutableField2 / Career_EuropeanClub_ExecutableField3: clubs left in the European cups
|
|
const uint32_t left_at[4] = {0, ::bmh::layout::Career_EuropeanClub_ExecutableField, ::bmh::layout::Career_EuropeanClub_ExecutableField2, ::bmh::layout::Career_EuropeanClub_ExecutableField3};
|
|
if (type >= 1 && type <= 3 && mem.has(left_at[type])) mem.set8(left_at[type], uint8_t(count));
|
|
}
|
|
|
|
} // namespace bmh::modern
|