diff --git a/docs/new_engine/README.md b/docs/new_engine/README.md index 39a2cc9..405a94a 100644 --- a/docs/new_engine/README.md +++ b/docs/new_engine/README.md @@ -60,5 +60,6 @@ Für 0.3 gilt außerdem: | M6 | Modern-Spielstände (`modern-career-v1`), Projektionen für die UI | Spielstände erledigt (Rundreise identisch); Projektionen offen | | M7 | Balance-Läufe und Anpassungen | erledigt: Spielerwerte nach Rangfolge, Langläufe über 12 Saisons ohne Drift gegenüber Classic ([Balance](balance.md)); offen nur Läufe mit aktivem Manager | | M8 | Fußball-Almanach: alle Spiele mit Ereignissen und Aufstellungen ([Almanach](almanach.md)) | Engine erledigt (Aufzeichnung, Spielstand, IDs); UI und Projektionen offen | +| M9 | Nationalteams mit echten Kadern ([Nationalteams](nationalteams.md)) | Engine erledigt: 24 von 61 Nationen des Diamond-Datensatzes spielen mit Spielern | Details und Abnahmekriterien stehen in [Phasen](phasen.md). diff --git a/docs/new_engine/almanach.md b/docs/new_engine/almanach.md index 435704c..46e9b18 100644 --- a/docs/new_engine/almanach.md +++ b/docs/new_engine/almanach.md @@ -19,7 +19,7 @@ Pro Spiel (`AlmanacMatch`): | Menschliche Manager | je Seite der Manager (Index und Name) oder −1 für Computer; Grundlage für spätere Vereinswechsel | | Ergebnis | Tore nach regulärer Zeit bzw. Verlängerung, Elfmeterschießen getrennt, `decided` (0 regulär, 1 Verlängerung, 2 Elfmeter) | | Schiedsrichter, Zuschauer, Wetter | Name (Tabelle der Saison), Zuschauerzahl, Temperatur in °C, Regen 0–7 | -| Aufstellungen | je Seite die 11 Startspieler, dann die Bank: Ligavereine und die deutsche Nationalmannschaft, solange der Mensch an Länderspieltagen Bundestrainer ist (sonst spielt sie wie die anderen Länder- und Amateurteams ohne Spieler) | +| Aufstellungen | je Seite die 11 Startspieler, dann die Bank: Ligavereine und die Nationalteams mit nominiertem Kader ([Nationalteams](nationalteams.md)); Teams ohne Spieler haben keine | | Ereignisse | Minute, Seite, Spieler und ggf. zweiter Spieler: Tor (mit Vorlage und Art: Spiel, Elfmeter/Freistoß, Nachschuss, Ecke), Fehlschuss, Gelb, Gelb-Rot, Rot, Verletzung, Wechsel (ein/aus), Elfmeter im Elfmeterschießen | Pro Saison zusätzlich: @@ -67,7 +67,7 @@ keine F10-/OBS-Dateien und ändert keine Engine- oder Spielstanddaten. ## Offen -- Kader für die übrigen Länder- und Amateurteams (die Engine lässt sie ohne Spieler antreten), damit auch deren Aufstellungen und Torschützen aufgezeichnet werden. +- Nationalteams spielen seit M9 mit Kader, wenn der Datensatz genug Spieler ihrer Nationalität hat ([Nationalteams](nationalteams.md)); die übrigen Nationen, die Amateure und die Pokal-Ausländer spielen weiter ohne Spieler. - Behoben (25.10.2026): Die Spiele der deutschen Nationalmannschaft fehlten ganz, weil ihre Team-Nummer (357) zugleich „kein Team“ ist und als Platzhalter aussortiert wurde. - Projektionen für die Almanach-Oberfläche. - Kompression: Version 3 spart gegenüber Version 2 rund ein Viertel (eine halbe Saison: Almanach 294 → 218 KB, Spielstand 501 → 432 KB). Den Rest belegen vor allem die Ereignisse; eine stärkere ZIP-Stufe brächte nur etwa 10 %. diff --git a/docs/new_engine/nationalteams.md b/docs/new_engine/nationalteams.md new file mode 100644 index 0000000..0ce08a2 --- /dev/null +++ b/docs/new_engine/nationalteams.md @@ -0,0 +1,28 @@ +# Nationalteams mit Kadern · Modern-Engine + +Stand: 25. Oktober 2026 (M9). + +## Classic (Ausgangspunkt) + +- Die deutsche Nationalmannschaft ist das Team `no_team` (357). An jedem Länderspieltag werden die stärksten fitten deutschen Spieler nominiert (3 Torhüter, 5 Abwehr, 7 Mittelfeld, 5 Angriff; `national_team_day`), und sie spielt mit diesen Spielern. Karten und Verletzungen gibt es nur, wenn ein Mensch Bundestrainer ist. +- Alle anderen Nationalteams (358–418) spielen ohne Spieler. Ihre Stärke wird gewürfelt; die Grundlage ist ein Stärkebyte je Team (`ForeignClubStrength`). Ihre Spiele haben keine Torschützen und keine Aufstellungen. + +## Modern + +- **Kaderplätze:** Hinter der Reserve hat jedes Nationalteam außer Deutschland 24 Plätze (`WorldLayout::national_start`, `national_slots`; Team `no_team() + n` gehört zur Nationalität `n`). Classic hat keine (`national_slots = 0`). +- **Nominierung:** Am Länderspieltag wird direkt nach der deutschen Nominierung für jede Nation dasselbe Verfahren angewandt (gleiche Quoten, gleiches Stärkemaß; nur der Zuschlag für Spieler bei Vereinen im Ausland entfällt, weil fast jede Nation im Ausland spielt). Danach stellt der Computer die Mannschaft auf. Es wird kein Zufallsgenerator gezogen (`nominate_national_squads`). +- **Untergrenze:** Eine Nation braucht einen Torhüter und mindestens 14 Nominierte. Sonst bleibt ihr Kader leer, und sie spielt wie in Classic mit der gewürfelten Stärke. +- **Im Spiel:** Ein Team „spielt mit Spielern“ (`fields_players`), wenn es ein Ligaverein ist, `no_team` oder ein Nationalteam mit nominiertem Kader. Für diese Teams gelten Spielerauswahl, Torhüter, Torschütze, Elfmeterschießen, Auswechslungen und die Weiterentwicklung der Spieler nach dem Spiel wie für die deutsche Nationalmannschaft. Karten und Verletzungen gibt es bei den anderen Nationen nicht (wie bei Deutschland ohne menschlichen Bundestrainer); ein Länderspiel schadet den Vereinen also nicht. +- **Almanach und Statistik:** Aufstellungen, Torschützen, Vorlagen und Wechsel der Länderspiele werden aufgezeichnet. +- **Spielstände:** Ältere Modern-Spielstände bekommen die neuen Plätze leer; bis zum nächsten Länderspieltag spielen die Nationen mit der gewürfelten Stärke. + +## Ergebnis mit dem Diamond-Datensatz (Revision 1.5) + +- 24 von 61 Nationen spielen mit Kader: Spanien, England, Frankreich, Italien, Portugal, Niederlande, Belgien, Türkei, Österreich, Dänemark, Schweiz, Griechenland, Serbien, Kroatien, Norwegen, Polen, Kosovo, Brasilien, Argentinien, USA, Senegal, Nigeria, Algerien, Japan. Die übrigen haben zu wenige Spieler im Datensatz. +- Drei Läufe über zwölf Saisons: Welt- und Europameister waren Spanien, Frankreich, Deutschland und einmal die Schweiz. Ligen, Alter und Marktwerte unterscheiden sich nicht von den Läufen ohne Nationalkader (Abweichungen im Rauschen, [Balance](balance.md)). +- Classic-Daten: unverändert (gleiche Ergebnisse wie vorher). + +## Offen + +- Nationen mit zu wenigen Spielern im Datensatz: Der Datensatz kann sie mit Spielern ohne Verein ergänzen, oder die Engine füllt mit erzeugten Spielern auf. +- Die Länder- und Amateurteams im DFB-Pokal und die Pokal-Ausländer spielen weiter ohne Spieler. diff --git a/src/game/lineup.cpp b/src/game/lineup.cpp index 6e949a4..1615b79 100644 --- a/src/game/lineup.cpp +++ b/src/game/lineup.cpp @@ -319,7 +319,7 @@ bool save_pitch_formation_source(GameState& g, int manager_slot, int runtime_clu } static void auto_lineup_impl(GameState& g, int team, int mode, int manager) { - if (team >= world_layout().league_teams && team != no_team()) return; // teams without squads + if (!fields_players(g, team)) return; // teams without players if (g.lineups_frozen) return; // LineupRuntimeField (the season change) const bool improve_from_reserves = (mode & 0x80) != 0; mode &= 0x7F; @@ -631,7 +631,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 < world_layout().league_teams || team == no_team())) return false; + if (!fields_players(g, team)) 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_engine.cpp b/src/game/match_engine.cpp index 8e01eaa..b75826f 100644 --- a/src/game/match_engine.cpp +++ b/src/game/match_engine.cpp @@ -87,7 +87,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 >= world_layout().league_teams && team != no_team()) return 0xFFF; // clubs without squad: nobody, no draws + if (!fields_players(state, team)) return 0xFFF; // teams without players: nobody, no draws SquadRange range = squad_range(team); if (range.count == 0) return 0xFFF; RatingContext ctx{state.chance_rain, state.chance_temperature}; @@ -531,6 +531,7 @@ 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). + // The squads of the other national teams (Modern) get no cards or injuries either. if (!(team < 90 || rand.range(0, 1) == 0)) return result; if (!(team < world_layout().league_teams || team == no_team())) return result; if (team == no_team() && (state.manager_teams.empty() || state.manager_teams[0] != no_team())) return result; @@ -953,7 +954,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 < world_layout().first_foreign_cup() || opp_team == no_team())) { + if (!reality_played && (opp_team < world_layout().first_foreign_cup() || fields_players(state, opp_team))) { 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; @@ -988,7 +989,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 >= world_layout().first_foreign_cup() && team != no_team()) { + if (team >= world_layout().first_foreign_cup() && !fields_players(state, team)) { // clubs without squad: the attack rating (TeamRating, profile 3), drawn RatingContext drawn; drawn.rand = &rand; @@ -998,7 +999,7 @@ void MatchEngine::side(MatchGroup& g, int m, int& s, int minute, int& own_att, i } } if (keeper == 0xFFF) { - if (opp_team >= world_layout().first_foreign_cup() && opp_team != no_team()) { + if (opp_team >= world_layout().first_foreign_cup() && !fields_players(state, opp_team)) { // clubs without squad: the goalkeeping rating (profile 0), drawn RatingContext drawn; drawn.rand = &rand; @@ -1205,7 +1206,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 < world_layout().league_teams || team == no_team()) { + if (fields_players(state, team)) { // 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/rating.cpp b/src/game/rating.cpp index bb8a3d9..29a4d49 100644 --- a/src/game/rating.cpp +++ b/src/game/rating.cpp @@ -122,7 +122,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 >= world_layout().first_foreign_cup() && team != no_team()) { + if (team >= world_layout().first_foreign_cup() && !fields_players(g, team)) { // 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 diff --git a/src/game/state.cpp b/src/game/state.cpp index 07abcd9..e9a470e 100644 --- a/src/game/state.cpp +++ b/src/game/state.cpp @@ -157,11 +157,20 @@ SquadRange squad_range(int team) { const WorldLayout& w = world_layout(); if (team == w.no_team()) return {w.pool_end, w.no_team_slots}; if (team >= 0 && team < w.league_teams) return {w.squad_start[size_t(team)], w.squad_size[size_t(team)]}; + if (w.national_squad(team)) return {w.national_start + uint32_t(team - w.no_team() - 1) * w.national_slots, w.national_slots}; return {0, 0}; } +bool fields_players(const GameState& g, int team) { + const WorldLayout& w = world_layout(); + if ((team >= 0 && team < w.league_teams) || team == w.no_team()) return true; + if (!w.national_squad(team)) return false; + const SquadRange r = squad_range(team); + return r.first < g.squad_slots.size() && (g.squad_slots[r.first] & 0x0FFF) != 0x0FFF; +} + TeamAverage team_average(const GameState& g, int team, uint16_t flags, WatcomRandom* rand) { - if (team >= world_layout().first_foreign_cup() && team != no_team()) { + if (team >= world_layout().first_foreign_cup() && !fields_players(g, 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; diff --git a/src/game/state.hpp b/src/game/state.hpp index 3ced5e1..3a4c114 100644 --- a/src/game/state.hpp +++ b/src/game/state.hpp @@ -255,6 +255,10 @@ struct SquadRange { size_t count = 0; }; SquadRange squad_range(int team); +// Whether the team plays with its players (squad, line-up, scorers) rather than with a drawn rating: +// the league clubs and no_team always; in Modern a national team once players are nominated into +// its squad (its first slot is taken). Classic: exactly the league clubs and no_team. +bool fields_players(const GameState& g, int team); // Selection and value flags of team_average (the "param_2" of QuoteNationalFriendlyMatch). namespace avg { diff --git a/src/game/world_layout.cpp b/src/game/world_layout.cpp index 5f1758e..b9b4380 100644 --- a/src/game/world_layout.cpp +++ b/src/game/world_layout.cpp @@ -37,6 +37,9 @@ int WorldLayout::team_of_slot(int slot) const { return int(it - squad_start.begin()) - 1; } if (uint32_t(slot) >= pool_end && uint32_t(slot) < pool_end + no_team_slots) return no_team(); + if (national_slots != 0 && uint32_t(slot) >= national_start && + uint32_t(slot) < national_start + uint32_t(national_teams - 1) * national_slots) + return no_team() + 1 + int((uint32_t(slot) - national_start) / national_slots); return -1; } @@ -60,6 +63,10 @@ void set_world_layout(WorldLayout layout) { 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"); + if (layout.national_slots != 0 && + (layout.national_start < layout.pool_end + layout.no_team_slots || layout.national_teams < 1 || + layout.total_slots < layout.national_start + uint32_t(layout.national_teams - 1) * layout.national_slots)) + throw std::invalid_argument("world layout: national squads must follow the no-club squad"); // 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); diff --git a/src/game/world_layout.hpp b/src/game/world_layout.hpp index 1f147ec..4abb43f 100644 --- a/src/game/world_layout.hpp +++ b/src/game/world_layout.hpp @@ -38,14 +38,22 @@ struct WorldLayout { uint32_t pool_end = 0xC00; // end of the pools = first slot of no_team uint32_t no_team_slots = 24; // the national team / no-club squad uint32_t total_slots = 3150; // including the reserve behind no_team + // Modern: squads of the national teams after no_team (national_slots each, from slot + // national_start: team no_team() + n at national_start + (n - 1) * national_slots). Classic: none, + // the national teams play without players. + uint32_t national_start = 0, national_slots = 0; int first_amateur() const { return league_teams; } 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 team whose squad holds `slot`: a league club, no_team() for the no-club squad, -1 for - // the pools and the reserve. + // A national team other than no_team with squad slots of its own (Modern). + bool national_squad(int team) const { return national_slots != 0 && team > no_team() && team < total_teams(); } + bool has_squad(int team) const { + return (team >= 0 && team < league_teams) || team == no_team() || national_squad(team); + } + // The team whose squad holds `slot`: a league club, no_team() for the no-club squad, a + // national team for its squad, -1 for the pools and the reserve. int team_of_slot(int slot) const; }; diff --git a/src/modern/app/modern_session.cpp b/src/modern/app/modern_session.cpp index 03785d6..dfe4e01 100644 --- a/src/modern/app/modern_session.cpp +++ b/src/modern/app/modern_session.cpp @@ -651,6 +651,9 @@ ModernSession::ModernSession(const std::filesystem::path &data, uint32_t watcom_ if (saved.state.master_database_metadata.size() != db_.raw_referee_properties.size() * 2) throw FormatError("the save and its world disagree on the referees"); g_ = std::move(saved.state); + // saves from before the national squads end at the reserve: the national squads + // start empty (those teams play with their drawn rating until the next nomination) + if (g_.squad_slots.size() < world_layout().total_slots) g_.squad_slots.resize(world_layout().total_slots, 0x0fff); rand_ = saved.random; game_ = saved.game; native.emplace(); diff --git a/src/modern/content/world_expand.cpp b/src/modern/content/world_expand.cpp index d429965..e4cf542 100644 --- a/src/modern/content/world_expand.cpp +++ b/src/modern/content/world_expand.cpp @@ -138,7 +138,11 @@ WorldLayout modern_layout(int league_clubs, int german_clubs) { w.free_agents = w.transfer_list + 44; w.foreign_offers = w.free_agents + 80; w.pool_end = w.foreign_offers + 20; - w.total_slots = w.pool_end + w.no_team_slots + 54; + // behind the no-club squad and its 54 reserve slots: 24 slots for each national team after + // no_team, filled on the international days from the players of its nationality + w.national_start = w.pool_end + w.no_team_slots + 54; + w.national_slots = kSquadSlots; + w.total_slots = w.national_start + uint32_t(w.national_teams - 1) * w.national_slots; return w; } diff --git a/src/modern/game/almanac.cpp b/src/modern/game/almanac.cpp index 462539e..e115504 100644 --- a/src/modern/game/almanac.cpp +++ b/src/modern/game/almanac.cpp @@ -15,7 +15,6 @@ #include "modern/game/cup.hpp" #include "modern/game/matchday.hpp" #include "modern/game/modern_state.hpp" -#include "modern/game/national.hpp" namespace bmh::modern { @@ -539,10 +538,9 @@ AlmanacRecorder::AlmanacRecorder(ModernState& g, const std::vector& if (const int ref = group.desc.at(0x10 + size_t(m)); ref > 0) rec.referee = season.referee(referee_name(g, ref)); for (int side = 0; side < 2; ++side) { const int team = side ? away : home; - // only the league clubs and the German national team (no_team, squad nominated on the - // national team days, used only while a human is the national coach, as in the match engine) have - // squads; the other national and amateur teams play without players - if (team >= league_clubs() && (team != no_team() || !national_coach_active(g))) continue; + // the teams that play with their players (fields_players: the league clubs and the + // national teams with a nominated squad); the others play with a drawn rating + if (!fields_players(g, team)) continue; const SquadRange range = squad_range(team); for (size_t s = 0; s < range.count; ++s) { const uint16_t e = g.squad_slots.at(range.first + s); @@ -572,7 +570,7 @@ uint16_t AlmanacRecorder::player_ref(int player) { // sent off or injured loses it; a substitute takes the slot of the player he replaces). std::vector AlmanacRecorder::on_pitch(int team) const { std::vector out; - if (team < 0 || (team >= league_clubs() && (team != no_team() || !national_coach_active(g_)))) return out; + if (team < 0 || !fields_players(g_, team)) return out; const SquadRange range = squad_range(team); for (size_t s = 0; s < std::min(11, range.count); ++s) { const uint16_t e = g_.squad_slots.at(range.first + s); diff --git a/src/modern/game/matchday.cpp b/src/modern/game/matchday.cpp index 406bd4d..26349a2 100644 --- a/src/modern/game/matchday.cpp +++ b/src/modern/game/matchday.cpp @@ -406,7 +406,9 @@ void develop_players(ModernState& g, const MatchGroup& grp, int m, GameRandom& g 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 < first_foreign_cup() || team == no_team())) continue; + // the clubs and every national team that plays with its players (Germany always, the + // other nations of a Modern world once nominated) + if (!(team < first_foreign_cup() || fields_players(g, team))) continue; const uint8_t cls = (type == 0xb && team == no_team()) ? 3 : uint8_t(competition_class(type)); const int manager = g.manager_of(team); const SquadRange range = squad_range(team); diff --git a/src/modern/game/national.cpp b/src/modern/game/national.cpp index 783be3f..ae706a6 100644 --- a/src/modern/game/national.cpp +++ b/src/modern/game/national.cpp @@ -4,7 +4,9 @@ #include "modern/game/national.hpp" #include +#include #include +#include #include "game/lineup.hpp" #include "game/match_engine.hpp" @@ -21,6 +23,7 @@ constexpr size_t kBoardSlot = 0x58; constexpr uint32_t kDesktops = ::bmh::layout::Desktops; // desktop layouts, 0x360 per manager slot constexpr size_t kDesktop = 0x360; constexpr uint8_t kNominated[4] = {3, 5, 7, 5}; // NationalRuntimeField: keepers, defence, midfield, attack +constexpr int kMinNationalSquad = 14; // Modern: fewer nominees keep a national team on its drawn rating // the manager's team (record +0x290) as the port caches it void refresh_manager_teams(ModernState& g) { @@ -96,6 +99,54 @@ void new_board_entry(ModernState& g, int manager, int index, int slot, WatcomRan std::memset(e + 0x12, 0, 7); } +void nominate_national_squads(ModernState& g) { + const WorldLayout& w = world_layout(); + if (w.national_slots == 0) return; + // the strongest fit players of each nationality per position, the quotas and the strength of + // the German nomination (without its bonus for clubs abroad: every nation plays abroad) + const int nations = w.national_teams; + struct Picks { + int16_t best[4][7] = {}, slot[4][7] = {}; // ascending per position, as for Germany + int found[4] = {}; // nominees per position (up to the quota) + }; + std::vector picks(static_cast(nations)); + for (size_t s = 0; s < transfer_list_slot(); s++) { + const int id = g.squad_slots.at(s) & 0xfff; + if (id == 0xfff) continue; + const int n = modern::nationality(g, id); + if (n < 1 || n >= nations) continue; // 0: Germany, nominated above + const Player& p = g.players.at(size_t(id)); + const bool fit = (p.w35c >> 27) == 0 || ((p.w364 >> 16) & 0x1f) == 0; + if (!fit) continue; + const int pos = int(p.w364 & 3); + int16_t strength = int16_t(p.strength(false)); + if (pos > 1) strength = int16_t(strength + ((p.w364 >> 2) & 0x3f) + (((p.w368 >> 18) & 0x3f) >> 1)); + Picks& pick = picks[size_t(n)]; + int16_t* row = pick.best[pos]; + int16_t* at = pick.slot[pos]; + int i = 0; + while (i < kNominated[pos] && strength > row[i]) i++; + if (i == 0) continue; + for (int k = 0; k < i - 1; k++) row[k] = row[k + 1], at[k] = at[k + 1]; + row[i - 1] = strength; + at[i - 1] = int16_t(s); + pick.found[pos] = std::min(pick.found[pos] + 1, kNominated[pos]); + } + for (int n = 1; n < nations; n++) { + const int team = no_team() + n; + const SquadRange range = squad_range(team); + for (size_t s = range.first; s < range.first + range.count; s++) g.squad_slots.at(s) = kEmptySlot; + // A nation needs a goalkeeper and 14 players; with fewer it keeps its drawn rating. + const int* f = picks[size_t(n)].found; + if (f[0] == 0 || f[0] + f[1] + f[2] + f[3] < kMinNationalSquad) continue; + size_t next = range.first; + for (int pos = 0; pos < 4; pos++) + for (int k = kNominated[pos] - f[pos]; k < kNominated[pos]; k++) // the found ones fill the top + g.squad_slots.at(next++) = uint16_t(g.squad_slots.at(size_t(picks[size_t(n)].slot[pos][k])) & 0x0fff); + auto_lineup(g, team, 100); + } +} + bool national_team_day(ModernState& g, WatcomRandom& rand, MinuteReport& report) { StaticMemory& mem = g.memory; const SquadRange national = squad_range(no_team()); @@ -146,6 +197,7 @@ bool national_team_day(ModernState& g, WatcomRandom& rand, MinuteReport& report) } catch (const std::exception& ex) { report.fail(std::string("national team line-up: ") + ex.what()); } + nominate_national_squads(g); // Modern: the other nations' squads (none in a Classic layout) if (coach == 0) modern::swap_manager_slots(g, 4, 0); g.manager_options.at(0) = option; return coach != 0; // (with a Bundestrainer his desk follows: AdvanceTurn's local_28 = 4) diff --git a/src/modern/game/national.hpp b/src/modern/game/national.hpp index 0bfd0d3..72667fb 100644 --- a/src/modern/game/national.hpp +++ b/src/modern/game/national.hpp @@ -39,6 +39,13 @@ void new_board_entry(ModernState& g, int manager, int index, int slot, WatcomRan // the national team (CoachActive) - then his desk follows (AdvanceTurn: local_28 = 4). bool national_team_day(ModernState& g, WatcomRandom& rand, MinuteReport& report); +// Modern (a layout with national squads): on every national team day after the German +// nomination, each other national team (no_team() + nationality) gets the strongest fit players +// of its nationality from the league clubs (quotas 3/5/7/5, the German strength measure) and a +// computer line-up. A nation without a goalkeeper or with fewer than 14 nominees stays empty and +// plays with its drawn rating as in Classic. No generator is drawn. +void nominate_national_squads(ModernState& g); + // The Bundestrainer (national coach), see national.cpp. SwapManagerSlots2: notes the number of // managers (OriginalManagerCount) and `active_manager` (ClubPlayerDetail_InvalidArgument_RuntimeField3 = ActiveManager); a manager // flagged in his record (+0x21c), every manager in the world game without leagues diff --git a/tests/modern_season_sim.cpp b/tests/modern_season_sim.cpp index 57faf50..9deb077 100644 --- a/tests/modern_season_sim.cpp +++ b/tests/modern_season_sim.cpp @@ -707,6 +707,14 @@ int main(int argc, char** argv) { } } print_first_league_results(g, "run end"); + if (world_layout().national_slots != 0) { // the national teams with a nominated squad + std::string names; + int with = 0; + for (int t = no_team() + 1; t < world_layout().total_teams(); ++t) + if (fields_players(g, t)) ++with, names += " " + g.club_name(t); + std::printf("national squads: %d of %d nations play with players:%s\n", with, world_layout().national_teams - 1, + names.c_str()); + } // MODERN_ALMANAC_SUMMARY=1: also on Classic data (balance comparisons) if (modern::current_world() || std::getenv("MODERN_ALMANAC_SUMMARY")) print_almanac(g); // MODERN_STATS=1: the queries of the game statistics menu (docs/new_engine/statistik.md)