// SPDX-License-Identifier: GPL-3.0-only #include "formats/executable_layout.hpp" #include "modern/game/traffic.hpp" #include "modern/game/modern_state.hpp" #include "modern/game/environment.hpp" #include "modern/game/month.hpp" #include "modern/game/desk_actions.hpp" #include "game/trace.hpp" #include #include #include #include #include #include #include #include "game/lineup.hpp" #include "modern/game/matchday.hpp" #include "game/messages.hpp" #include "modern/game/prediction.hpp" #include "game/schedule.hpp" #include "modern/game/season.hpp" #include "modern/game/weekly.hpp" #include "game/human_buyer_sale.hpp" namespace bmh::modern { namespace { constexpr size_t kRecord = 0xB0C; // manager record 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; // MonthRuntimeField2: development steps by strength / 10; the ten bytes after it (PlayerCard_PlayerCardMarketValue_RuntimeField) // are the extra value above 500 points. constexpr uint8_t kDevelopment[20] = {6, 6, 6, 5, 5, 5, 4, 4, 3, 1, 10, 15, 20, 30, 40, 45, 55, 75, 85, 95}; // BalancePlanRuntimeField5: value of the facilities (maintenance per month), u16 per facility. constexpr uint16_t kFacilityValue[22] = {2000, 3000, 3000, 8000, 4000, 3000, 2500, 2500, 2500, 2500, 2600, 2600, 2600, 2600, 13000, 9000, 9000, 8000, 1000, 1500, 1500, 2000}; // BalancePlanRuntimeField6: monthly income of facilities 0-5 per level. constexpr uint16_t kFacilityIncome[6] = {0, 5000, 5000, 4800, 2400, 8000}; // MonthRuntimeField3: share of the new list entries per kind (free agents, big clubs, foreign // agents, small clubs), percent. constexpr int16_t kListShare[4] = {47, 35, 10, 8}; // MonthRuntimeField4 / MonthRuntimeField5: players a club wants per position (big / small squads). constexpr int8_t kWantedBig[4] = {2, 6, 7, 5}, kWantedSmall[4] = {2, 4, 5, 4}; uint32_t rd32(const std::vector& v, size_t o) { return uint32_t(v.at(o) | v.at(o + 1) << 8 | v.at(o + 2) << 16) | uint32_t(v.at(o + 3)) << 24; } void wr32(std::vector& v, size_t o, uint32_t x) { for (int i = 0; i < 4; i++) v.at(o + size_t(i)) = uint8_t(x >> (8 * i)); } void add32(std::vector& v, size_t o, int32_t x) { wr32(v, o, rd32(v, o) + uint32_t(x)); } // BoughtEntry: index + 1 of a player in the table of players bought for later / on loan // (Career_RemoveJoinLoans_RuntimeField), 0 if none. int bought_entry(const ModernState& g, int player) { for (int k = 0; k < 200; k++) { const uint32_t e = g.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField + uint32_t(k) * 4); if (e != 0 && int(e & 0xFFF) == player) return k + 1; } return 0; } // PlayerOnTransferListFirstPoolSlots: index + 1 of the list entry of the player in an absolute squad slot (the // first 44 pool slots), 0 if he is not on the list. int list_index(const ModernState& g, int slot) { const int player = g.squad_slots.at(size_t(slot)) & 0xFFF; for (int s = int(transfer_list_slot()); s < int(transfer_list_slot()) + 0x2c; s++) if ((g.squad_slots[size_t(s)] & 0xFFF) == player) return s - int(transfer_list_slot()) + 1; return 0; } // FirstFreeSlotSquad(start, count): first empty squad slot from `start`, -1 if none. int free_slot(const ModernState& g, int start, int count) { for (int s = start; s < start + count && s < int(g.squad_slots.size()); s++) if (g.squad_slots[size_t(s)] == 0xFFF) return s; return -1; } // ListPlayer: puts the player in an absolute squad slot on the transfer list: the first // free list slot, asking price and demand percentages, 5-8 weeks, the market value; human // managers with a matching search profile are told. bool list_player(ModernState& g, int slot, WatcomRandom& rand, MinuteReport& report) { StaticMemory& mem = g.memory; const int player = g.squad_slots.at(size_t(slot)) & 0xFFF; if (bought_entry(g, player) != 0) { report.fail("transfer list: the player is bought for later (internal error 0x38)"); return false; } if (list_index(g, slot) != 0) { report.fail("transfer list: the player is listed already (ListPlayer message box)"); return false; } // (the original passes 0xb70 + 0x28 as the count: the search runs on past the list) const int free = free_slot(g, int(transfer_list_slot()), int(transfer_list_slot()) + 0x28); if (free == -1) return false; // message box MonthRuntimeField6 if (free >= int(transfer_list_slot()) + 0x2c) { report.fail("transfer list: the free slot lies beyond the list (the original overwrites memory)"); return false; } g.squad_slots[size_t(free)] = uint16_t(player); const uint32_t e = kTransferList + uint32_t(free - int(transfer_list_slot())) * kListEntry; if (slot < int(transfer_list_slot())) { const int seller = modern::slot_team(slot); uint16_t field = uint16_t(seller); mem.set16(e + 8, field); if (g.manager_of(seller) >= 0) mem.set8(e + 9, uint8_t(mem.u8(e + 9) | 0x80)); mem.set8(e + 0x54, uint8_t(rand.range(0x4b, 0x7a))); mem.set8(e + 0x55, uint8_t(rand.range(0x5c, 100))); if (seller >= german_clubs()) mem.set8(e + 0x54, uint8_t(mem.u8(e + 0x54) + rand.range(5, 0xf))); } else { mem.set16(e + 8, 0xFFF); mem.set8(e + 0x54, uint8_t(rand.range(0x46, 0x69))); mem.set8(e + 0x55, uint8_t(rand.range(0x3c, 0x60))); } mem.set8(e + 0x56, uint8_t(rand.range(5, 8))); uint32_t fee = 0, salary = 0; modern::market_value(g, slot, 0, mem.u8(e + 0x54), fee, salary, 1, 0, rand); mem.set32(e + 0x2c, fee); mem.set32(e + 0x30, salary); for (int b = 0; b < 4; b++) mem.set16(e + uint32_t(b) * 2, 0xFFFF); for (size_t m = 0; m < g.manager_teams.size(); m++) modern::search_profile_news(g, int(m), e, g.squad_slots[size_t(free)]); return true; } // PickFreeAgent(from, to): a random free agent in the pool slots from..to-1 who is not on // the list and not bought for later. int pick_free_agent(const ModernState& g, int from, int to, WatcomRandom& rand, MinuteReport& report) { std::vector slots; for (int s = from; s < to; s++) { const int p = g.squad_slots.at(size_t(s)) & 0xFFF; if (p != 0xFFF && list_index(g, s) == 0 && bought_entry(g, p) == 0) slots.push_back(s); } if (slots.empty()) { report.fail("transfer list: no free agent (internal error 0x26)"); return -1; } return slots[size_t(rand.range(0, int(slots.size()) - 1))]; } // InPseudoSquad: the player of a slot also plays in the squad of the pseudo club 0x165. bool in_pseudo_squad(const ModernState& g, int slot) { const int player = g.squad_slots.at(size_t(slot)) & 0xFFF; const SquadRange r = squad_range(no_team()); for (size_t s = r.first; s < r.first + r.count; s++) if ((g.squad_slots[s] & 0xFFF) == player) return true; return false; } // Int5(first, last): a computer club (every second one, starting alternately at the // first or second, MonthRuntimeField7) with too many goalkeepers or too many players in a line // puts one of them on the list. With no club found in first..last the search is repeated // over the big clubs. void list_club_player(ModernState& g, int first, int last, WatcomRandom& rand, MinuteReport& report) { const int8_t* wanted = first < german_clubs() ? kWantedBig : kWantedSmall; // Attempt for (;;) { std::vector teams(static_cast(league_clubs())); std::vector keys(static_cast(league_clubs())); 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 for (int team = first + g.list_toggle; team < last; team += 2) { if (g.manager_of(team) >= 0) continue; const SquadRange range = squad_range(team); int8_t count[4] = {0, 0, 0, 0}; // local_50 const int players = int16_t(modern::squad_count(g, team, 3)); for (int s = 0; s < players; s++) { const int p = g.squad_slots.at(range.first + size_t(s)) & 0xFFF; if (p != 0xFFF) count[g.players.at(size_t(p)).w364 & 3]++; } int key_base = 0, line = 0; bool add = false; if (rand.range(0, 1) + 2 < count[0]) { // three or four goalkeepers line = 0; key_base = count[0] + 100; add = true; } else if (players > 0xd) { const int flags = (g.team_flags.at(size_t(team)) >> 0xc) & 3; if (rand.range(0, flags * 2 + 2) != 0) { int8_t most = 0; // local_28 for (int k = 1; k < 4; k++) { const int8_t over = int8_t(count[k] - wanted[k]); if (most < over) most = over, best_line = k; } int chosen = best_line; if (most == 0) chosen = rand.range(1, 3); key_base = most * 8; const int8_t room = int8_t(range.count - ((team < german_clubs() ? 1 : 0) + 2)); if (room < players) key_base += (players - room) * 4; line = chosen; add = true; } } if (add) { const int a = rand.range(0, 5), b = rand.range(0, 5); keys[n] = uint32_t((key_base + a - b) * 4 + int8_t(line)); teams[n] = int16_t(team); n++; } } int pick = league_clubs(); // sVar11 int slot = -1; // unaff_EDI: the slot tried last if (n != 0) { 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); const int players = int16_t(modern::squad_count(g, team, 2)); const int line = int(keys[pick] & 3); int tries = 0; bool again; do { slot = int(range.first) + rand.range(0, players - 1); const int p = g.squad_slots.at(size_t(slot)) & 0xFFF; const bool taken = bought_entry(g, p) != 0 || list_index(g, slot) != 0; tries++; again = int(g.players.at(size_t(p)).w364 & 3) != line || in_pseudo_squad(g, slot) || taken; } while (tries < 0x23 && again); if (tries < 0x23) break; } // (when no club had a fitting player the slot tried last is listed all the same) } if (pick < league_clubs()) { list_player(g, slot, rand, report); return; } if (first == 0) { report.fail("transfer list: no club to take a player from (internal error 0x28)"); return; } first = 0; last = german_clubs(); } } // CareerFirstSteps: new players on the transfer list. The number depends on how full the list // is (at most 37 entries); free agents of the pool are preferred while there are many. void new_list_entries(ModernState& g, WatcomRandom& rand, MinuteReport& report) { uint8_t count[5] = {0, 0, 0, 0, 0}; // local_18: listed, free agents, foreign, listed of both for (int s = int(transfer_list_slot()); s < int(pool_end_slot()); s++) { if (g.squad_slots.at(size_t(s)) == 0xFFF) continue; if (!(s < int(transfer_list_slot()) + 0x28 || int(transfer_list_slot()) + 0x2c <= s)) continue; const int cls = s < int(free_agent_slot()) ? 0 : s < int(foreign_offer_slot()) ? 1 : 2; count[cls]++; if (cls != 0 && list_index(g, s) != 0) count[cls + 2]++; } uint8_t add[4] = {0, 0, 0, 0}; // local_10 const int r = rand.range(2, 0x16); uint8_t n = uint8_t(r); if (count[0] + int8_t(r) >= 0x26) { n = uint8_t(0x25 - count[0]); if (int8_t(n) <= 0) return; } count[1] = uint8_t(count[1] - count[3]); count[2] = uint8_t(count[2] - count[4]); for (int16_t u = count[1]; n != 0 && u > 0x36; u--) n--, add[0]++; for (int16_t u = count[2]; n != 0 && u > 0xe; u--) n--, add[2]++; for (int k = 0; k < 4; k++) add[k] = uint8_t(add[k] + int8_t(kListShare[k] * int8_t(n) / 100)); if (count[1] < add[0]) { add[1] = uint8_t(add[1] + ((add[0] - count[1]) >> 1)); add[0] = count[1]; } if (count[2] < add[2]) { add[3] = uint8_t(add[3] + ((add[2] - count[2]) >> 1)); add[2] = count[2]; } int8_t total = 0; for (int k = 0; k < 4; k++) total = int8_t(total + add[k]); if (total < 4) add[1] = uint8_t(add[1] + rand.range(2, 4)); if (add[3] == 0 && add[1] != 0 && rand.range(0, 10) == 5) add[3]++, add[1]--; // (MonthRuntimeField8, a debug switch for club players only, is 0) for (int k = 0; k < 4 && !report.unsupported; k++) { uint8_t left = add[k]; if (left == 0) continue; switch (k) { case 0: case 2: while (left != 0 && !report.unsupported) { const int slot = k == 0 ? pick_free_agent(g, int(free_agent_slot()), int(foreign_offer_slot()), rand, report) : pick_free_agent(g, int(foreign_offer_slot()), int(pool_end_slot()), rand, report); if (slot < 0) return; if (list_player(g, slot, rand, report)) left--; } break; case 1: while (left-- != 0 && !report.unsupported) list_club_player(g, 0, german_clubs(), rand, report); break; case 3: while (left-- != 0 && !report.unsupported) list_club_player(g, german_clubs(), league_clubs(), rand, report); break; } } } // Loaned players whose time is up go back to their clubs (part of DayStepRest2). void return_loans(ModernState& g, WatcomRandom& rand, GameRandom* game, MinuteReport& report) { StaticMemory& mem = g.memory; for (int s = 0; s < int(transfer_list_slot()) && !report.unsupported; s++) { const int player = g.squad_slots.at(size_t(s)) & 0xFFF; if (player == 0xFFF) continue; const int k = bought_entry(g, player) - 1; if (k < 0) continue; const uint32_t e = mem.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField + uint32_t(k) * 4); const int owner = int(e >> 12 & 0x3FF), club = int(e >> 22 & 0x3FF); // local_30, local_28 const int owner_manager = g.manager_of(owner); const int borrower_manager = g.manager_of(club); // Human owners have a saved tactics-board row in ClubInfo_FormatError_RuntimeField and a matching // player ID/manager in Career_CareerManagersEnd_RuntimeField/ClubInfo_FormatError_RuntimeField2 (Fail). Restore it on expiry; // AI owners have no snapshot. Stage the complete return so malformed state // or a failed lineup cannot lose the loan ledger first. if (owner_manager >= 0 || borrower_manager >= 0) { const uint8_t remaining = mem.u8(::bmh::layout::ClubPlayerDetail_InvalidArgument_RuntimeField + uint32_t(k)); if (remaining != 1) { // Source decrements an unsigned byte and returns only when the // decremented byte is zero (DayStepRest2). A malformed/stale zero // therefore wraps to 0xff instead of expiring immediately. mem.set8(::bmh::layout::ClubPlayerDetail_InvalidArgument_RuntimeField + uint32_t(k), uint8_t(remaining - 1)); continue; } if ((owner_manager >= 4) || (owner_manager >= 0 && (!mem.has(::bmh::layout::Career_CareerManagersEnd_RuntimeField + 0x17) || !mem.has(::bmh::layout::ClubInfo_FormatError_RuntimeField + 0x41f) || !mem.has(::bmh::layout::ClubInfo_FormatError_RuntimeField2 + 0x0b) || !mem.has(::bmh::layout::DeskActions_Unsupported_RuntimeField + uint32_t(owner_manager))))) { report.fail("month change: human-owner loan record is incomplete"); return; } int snapshot_slot = -1; if (owner_manager >= 0) { for (int i = 0; i < 12; ++i) { if (mem.u16(::bmh::layout::Career_CareerManagersEnd_RuntimeField + uint32_t(i) * 2) == uint16_t(player) && mem.u8(::bmh::layout::ClubInfo_FormatError_RuntimeField2 + uint32_t(i)) == uint8_t(owner_manager)) { snapshot_slot = i; break; } } } const SquadRange owner_range = squad_range(owner); const int owner_slot = free_slot(g, int(owner_range.first), int(owner_range.count)); const SquadRange borrower_range = squad_range(club); bool borrower_has_player = false; for (size_t i = 0; i < borrower_range.count; ++i) if ((g.squad_slots.at(borrower_range.first + i) & 0x0fff) == player) borrower_has_player = true; if ((owner_manager >= 0 && snapshot_slot < 0) || owner_slot < 0 || !borrower_has_player || (owner_manager >= 0 && size_t(owner_manager) * kBoard + size_t(owner_range.count) * kBoardSlot > g.tactics.size())) { report.fail("month change: human-owner loan cannot be restored safely"); return; } if (borrower_manager >= 0 && !g.loan_return_screen) { report.fail("month change: expiring human-borrower loan needs its Source return dialog owner"); return; } ModernState staged = g; try { staged.memory.set8(::bmh::layout::ClubPlayerDetail_InvalidArgument_RuntimeField + uint32_t(k), 0); staged.memory.set32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField + uint32_t(k) * 4, 0); staged.squad_slots.at(size_t(owner_slot)) = uint16_t(player); if (!modern::remove_from_seller(staged, club, player, report)) return; if (owner_manager >= 0) { const size_t board = size_t(owner_manager) * kBoard + size_t(owner_slot - int(owner_range.first)) * kBoardSlot; const uint32_t snapshot = ::bmh::layout::ClubInfo_FormatError_RuntimeField + uint32_t(snapshot_slot) * uint32_t(kBoardSlot); for (size_t b = 0; b < kBoardSlot; ++b) staged.tactics.at(board + b) = staged.memory.u8(snapshot + uint32_t(b)); staged.memory.set16(::bmh::layout::Career_CareerManagersEnd_RuntimeField + uint32_t(snapshot_slot) * 2, 0x0fff); const uint8_t count = staged.memory.u8(::bmh::layout::DeskActions_Unsupported_RuntimeField + uint32_t(owner_manager)); if (count == 0) { report.fail("month change: human-owner loan count is inconsistent"); return; } staged.memory.set8(::bmh::layout::DeskActions_Unsupported_RuntimeField + uint32_t(owner_manager), uint8_t(count - 1)); } // DayStepRest2 posts the return notice to whichever owner/borrower // managers exist. const std::string notice = message_text(staged, ::bmh::layout::Month_ReturnLoans_TextPointer) + staged.player_name(player) + message_text(staged, ::bmh::layout::Month_ReturnLoans_TextPointer2) + message_text(staged, ::bmh::layout::Month_ReturnLoans_TextPointer3) + staged.club_name(club) + message_text(staged, ::bmh::layout::Month_ReturnLoans_TextPointer4) + staged.club_name(owner) + message_text(staged, ::bmh::layout::Month_ReturnLoans_TextPointer5); if (borrower_manager >= 0) { const int keep = staged.loan_return_screen(staged, borrower_manager, notice + message_text(staged, ::bmh::layout::Month_ReturnLoans_TextPointer6)); if (keep < 0) { report.fail("month change: human-borrower loan return dialog stopped"); return; } if (keep != 0) { // DayStepRest2 makes the borrower the active manager before // RowWhose/Range2. The two W(90,100) draws occur even // when all four special offer slots are occupied. staged.memory.set8(::bmh::layout::ActiveManager, uint8_t(borrower_manager)); int offer = 0; while (offer < 4 && staged.memory.u32(::bmh::layout::OfferSlots + uint32_t(offer) * 4) != 0xffffffffu) ++offer; if (offer < 4 && (!game || !staged.loan_return_offer_screen)) { report.fail("month change: OpenTransferEditor return-offer editor has no typed runtime owner"); return; } WatcomRandom offer_rand = rand; std::optional offer_game; if (game) offer_game = *game; const int percent = offer_rand.range(90, 100); const int demand = offer_rand.range(90, 100); if (offer < 4) { const uint32_t entry = kTransferList + uint32_t(40 + offer) * kListEntry; uint16_t team_word = uint16_t(owner); if (owner_manager >= 0) team_word |= 0x8000; staged.memory.set16(entry + 8, team_word); for (int bid = 0; bid < 4; ++bid) staged.memory.set16(entry + uint32_t(bid) * 2, 0xffff); staged.memory.set8(entry + 0x54, uint8_t(percent)); staged.memory.set8(entry + 0x55, uint8_t(demand)); uint32_t fee = 0, salary = 0; modern::market_value(staged, owner_slot, 0, uint8_t(percent), fee, salary, 1, 0, offer_rand); staged.memory.set32(entry + 0x2c, fee); staged.memory.set32(entry + 0x30, salary); const int source_slot = int(transfer_list_slot()) + 40 + offer; staged.squad_slots.at(size_t(source_slot)) = uint16_t(player); staged.memory.set32(::bmh::layout::OfferSlots + uint32_t(offer) * 4, uint32_t(player) * 0x400 + uint32_t(borrower_manager)); // A modal may replace staged (and its hook) while paused. // Own the active callable until the synchronous invocation returns. const auto present_return_offer = staged.loan_return_offer_screen; const int submitted = present_return_offer(staged, *offer_game, offer_rand, borrower_manager, source_slot, 40 + offer, HumanBuyerSaleHooks{}); if (submitted < 0) { report.fail("month change: OpenTransferEditor return-offer editor stopped"); return; } // The original month caller performs this cleanup only // after OpenTransferEditor has returned from the actual editor. staged.squad_slots.at(size_t(int(transfer_list_slot()) + 40 + offer)) = 0x0fff; staged.memory.set32(::bmh::layout::OfferSlots + uint32_t(offer) * 4, 0xffffffffu); } rand = offer_rand; if (game && offer_game) *game = *offer_game; } } std::string return_notice = notice; if (borrower_manager >= 0) { const SquadRange returned_borrower_range = squad_range(club); for (size_t i = 0; i < returned_borrower_range.count; ++i) { if ((staged.squad_slots.at(returned_borrower_range.first + i) & 0x0fff) == player) { return_notice += message_text(staged, ::bmh::layout::Month_ReturnLoans_TextPointer7) + staged.club_name(club) + message_text(staged, ::bmh::layout::Month_ReturnLoans_TextPointer8); break; } } } uint32_t managers = 0x80000000u; if (borrower_manager >= 0) managers = 1u << borrower_manager; if (owner_manager >= 0) managers |= 1u << owner_manager; post_composed(staged, int64_t(managers), return_notice); auto_lineup(staged, owner, owner_manager >= 0 ? 0xe4 : 100); auto_lineup(staged, club, borrower_manager >= 0 ? 0xe4 : 100); } catch (const std::exception&) { report.fail("month change: human-owner loan cannot be restored safely"); return; } g = std::move(staged); continue; } const uint8_t months = uint8_t(mem.u8(::bmh::layout::ClubPlayerDetail_InvalidArgument_RuntimeField + uint32_t(k)) - 1); mem.set8(::bmh::layout::ClubPlayerDetail_InvalidArgument_RuntimeField + uint32_t(k), months); if (months != 0) continue; mem.set32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField + uint32_t(k) * 4, 0); const SquadRange range = squad_range(owner); const int slot = free_slot(g, int(range.first), int(range.count)); if (slot == -1) { report.fail("month change: no room for a returning player (internal error 0x2e)"); return; } g.squad_slots[size_t(slot)] = uint16_t(player); if (!modern::remove_from_seller(g, club, player, report)) return; modern::lineup_after_transfer(g, owner); modern::lineup_after_transfer(g, club); } } // OriginalFinancePreview(1): the month's expenses of a human manager: facility maintenance // (BMHExeXa), record +0x854/+0x858, the wages of the squad (MonthlyPay with flags // 14), all six monthly environment budgets and the debt // service (+0x179 x 1000); each booked in the statistics. int32_t monthly_expenses(ModernState& g, int m) { std::vector& r = g.manager_records; const size_t rec = size_t(m) * kRecord; int32_t sum = 0; for (int i = 0; i < 0xe; i++) sum += kFacilityValue[i]; for (int i = 0xe; i < 0x16; i++) sum += (r.at(rec + 0x2e + size_t(i)) & 7) * kFacilityValue[i]; add32(r, rec + 0x87c, sum); for (int k = 1; k < 3; k++) { const int32_t v = int32_t(rd32(r, rec + 0x850 + size_t(k) * 4)); add32(r, rec + 0x890 + size_t(k) * 4, v); sum += v; } // MonthlyPay(manager, 14): salaries (+0x50) and bonus bases (+0x4e) of the board int32_t wages = 0; uint32_t bonus = 0; for (size_t s = 0; s < 24; s++) { const size_t slot = size_t(m) * kBoard + s * kBoardSlot; if (g.tactics.at(slot + 0x3d) == 0xFF) continue; bonus = uint32_t(g.tactics.at(slot + 0x4e) | (g.tactics.at(slot + 0x4f) & 0x7F) << 8); const int32_t salary = int32_t(rd32(g.tactics, slot + 0x50)); add32(r, rec + 0x338, salary); add32(r, rec + 0x33c, int32_t(bonus)); wages += salary + int32_t(bonus); } sum += wages; for (int k = 0; k < 6; k++) { const int32_t v = modern::environment_monthly_cost(g, m, k); if (k >= 3 && k <= 5) add32(r, rec + 0x878 + size_t(k) * 4, v); else add32(r, rec + 0x880, v); sum += v; } const int debt = r.at(rec + 0x179); if (debt != 0) { add32(r, rec + 0x8a0, debt * 1000); sum += debt * 1000; } return sum < 0 ? 0 : sum; } // FinanceTotalsFromGame3(1): the month's income: facilities (FacilityIncome) and the 16 advertising // contracts (record +0xa34), booked in the statistics. int32_t monthly_income(ModernState& g, int m) { std::vector& r = g.manager_records; const size_t rec = size_t(m) * kRecord; int32_t sum = 0; for (int k = 0; k < 6; k++) { const uint8_t v = r.at(rec + size_t(k)); if (v == 0) continue; const int level = k == 0 ? traffic_stage(v) & 0xFF : 1; // Add32 (traffic.hpp) sum += level * kFacilityIncome[k]; } add32(r, rec + 0x86c, sum); for (int k = 0; k < 16; k++) { const int32_t v = int32_t(rd32(r, rec + 0xa34 + size_t(k) * 0xc)); add32(r, rec + (k < 14 ? 0x860 : k == 14 ? 0x85c : 0x864), v); sum += v; } return sum; } // The monthly bookkeeping of the players on a human manager's tactics board. void board_month(ModernState& g, int m, WatcomRandom& rand, MinuteReport& report, GameRandom* game) { std::vector& r = g.manager_records; const size_t rec = size_t(m) * kRecord; const SquadRange range = squad_range(g.manager_teams.at(size_t(m))); auto board = [&](int s) { return size_t(m) * kBoard + size_t(s) * kBoardSlot; }; // the value history has 12 months; when it is full it moves on by one int month = r.at(rec + 0x286); // local_24 if (month < 0xc) { r.at(rec + 0x286) = uint8_t(month + 1); } else { for (int s = 0; s < 24; s++) { if (g.squad_slots.at(range.first + size_t(s)) == 0xFFF) continue; for (int k = 0; k < 3; k++) { const size_t at = board(s) + 0x19 + size_t(k) * 0xc; std::copy(g.tactics.begin() + long(at + 1), g.tactics.begin() + long(at + 0xc), g.tactics.begin() + long(at)); } } month = 0xb; } for (int s = 0; s < 24; s++) { // (a player who leaves closes the gap: the same row is looked at again, or after the // contracts screen all rows from the first one - those done are marked 0x80) next_player: const size_t b = board(s); const int player = g.squad_slots.at(range.first + size_t(s)) & 0xFFF; if (player == 0xFFF || (g.tactics.at(b + 0xb) & 0x80)) continue; g.tactics.at(b + 0xb) |= 0x80; if (rand.range(0, 0xb) == 0) { const uint32_t limit = uint32_t(rand.range(0x11, 0x17)); if (limit < (g.players.at(size_t(player)).w364 >> 21 & 0x1F) && !(g.tactics.at(b + 0xb) & 0x20)) { // he wants to end his career at the end of his contract g.tactics.at(b + 0xb) |= 0x20; post_composed(g, m, g.player_name(player) + message_text(g, ::bmh::layout::Month_BoardMonth_TextPointer)); } } g.tactics.at(b + 0x11)++; if (rand.range(0, 6) == 0) { // the mood (+0x0d) drifts back towards 100 const int d = std::abs(100 - g.tactics.at(b + 0xd)); if (int16_t(d) != 0) { int16_t step = int16_t(d) < 0xb ? 1 : 10; if (g.tactics.at(b + 0xd) > 100) step = int16_t(-step); g.tactics.at(b + 0xd) = uint8_t(std::clamp(step + g.tactics.at(b + 0xd), 0, 0xff)); } } if (g.tactics.at(b + 0x43) != 0) { g.tactics.at(b + 0x43)--; if ((g.tactics.at(b + 0x43) & 0x3f) == 0) g.tactics.at(b + 0x43) = 0; } if (g.tactics.at(b + 0xc) != 0xFF) g.tactics.at(b + 0xc)--; // contract months (BalancePlan_BalanceFromGame_RuntimeField is 0) if (g.tactics.at(b + 0xc) <= 1) { if (g.tactics.at(b + 0xc) != 0) { // "'s Vertrag läuft in einem Monat ab. ..." (string at ContractExpiryWarningText) post_composed(g, m, g.player_name(player) + kContractEndsSoonText); } else if (!(g.tactics.at(b + 0xb) & 0x20)) { // the contract has ended: "... Vertrag ist ausgelaufen" (Month_BoardMonth_TextPointer4) and the // contracts screen; without a renewal the message is posted and he goes const std::string text = g.player_name(player) + message_text(g, ::bmh::layout::Month_BoardMonth_TextPointer4); const int renewed = g.contract_screen ? g.contract_screen(g, m, s) : -2; if (renewed == -2) { report.fail("month change: a contract ends (the contracts screen InstallDefaultHooks)"); return; } if (renewed < 0) return; if (renewed == 0) { post_composed(g, m, text); if (!game) { report.fail("month change: a player goes (MonthChange) without the game generator"); return; } if (!modern::release_player(g, int(range.first) + s, *game, rand, report)) return; s = 0; goto next_player; } } else { // he ends his career (flag 0x20, see above): Month_BoardMonth_TextPointer2, then his club gets // a compensation, Month_BoardMonth_TextPointer3 + the amount (AddToSquad with W(15, 30) // percent, 1 year, rounded down to 10000) post_composed(g, m, g.player_name(player) + message_text(g, ::bmh::layout::Month_BoardMonth_TextPointer2)); const int percent = rand.range(0xf, 0x1e); uint32_t fee = 0, salary = 0; modern::market_value(g, int(range.first) + s, 0, percent, fee, salary, 1, 0, rand); fee = fee / 10000 * 10000; post_composed(g, m, message_text(g, ::bmh::layout::Month_BoardMonth_TextPointer3) + format_amount(g, int32_t(fee)) + "."); add32(r, rec + 0x314, int32_t(fee)); // MonthRuntimeField9: the balance, not booked if (!game) { report.fail("month change: a player retires (MonthChange) without the game generator"); return; } if (!modern::release_player(g, int(range.first) + s, *game, rand, report)) return; goto next_player; } } // the value history of the month uint32_t fee = 0, salary = 0; modern::market_value(g, int(range.first) + s, 0, 100, fee, salary, 0, 0, rand); const size_t h = b + size_t(month); g.tactics.at(h + 0x19) = uint8_t(std::min(fee / 8000, 0xff)); const uint32_t w = g.players.at(size_t(player)).w35c; g.tactics.at(h + 0x25) = uint8_t((((((w >> 14) & 0x7F) + ((w >> 7) & 0x7F)) * 3 >> 1) * 0xff) / 300); g.tactics.at(h + 0x31) = uint8_t(std::min(((w & 0x7F) * 0x8c) / 0x5a, 0xff)); } for (int s = 0; s < 24; s++) g.tactics.at(board(s) + 0xb) &= 0x7F; } // MonthChange2: share prices grow by 2.5 %, dividends, loans between the managers. void shares_and_loans(ModernState& g) { StaticMemory& mem = g.memory; std::vector& r = g.manager_records; static const int kShareFactor[6] = {15, 18, 21, 24, 27, 30}; // MonthRuntimeField10 const int managers = int(g.manager_teams.size()); for (int k = 0; k < 6; k++) { const uint32_t at = ::bmh::layout::FundBlock + uint32_t(k) * 0x1c; uint32_t price = mem.u32(at); price += ((price / 10000) * 0x19 / 10) * 10; mem.set32(at, price); // Modern deviates from Classic: every manager receives the dividend of his own shares. // (Classic keeps the original's slip: only the last manager's dividend is computed and // it is booked for the slot after the last manager, so nobody ever receives it.) // The price product is kept in 64 bits until the division. const uint64_t unit_dividend = (uint64_t(price) * uint32_t(kShareFactor[k])) / 10000; for (int m = 0; m < managers; m++) { const uint32_t held = mem.u16(::bmh::layout::Advertising_OriginalShareAdjustment_RuntimeField + uint32_t(m) * 2 + uint32_t(k) * 0x1c); if (held == 0) continue; const int32_t dividend = int32_t(std::min(held * unit_dividend, 0x7fffffffu)); modern::book_money(g, m, -dividend, true); add32(r, size_t(m) * kRecord + 0x870, dividend); } } for (int m = 0; m < managers; m++) for (int l = 0; l <= managers; l++) { const uint32_t e = ::bmh::layout::Loans + uint32_t(l) * 0x18 + uint32_t(m) * 0x78; const int32_t rate = int32_t(mem.u32(e + 8)); if (rate == 0) continue; modern::book_money(g, m, rate, true); add32(r, size_t(m) * kRecord + 0x89c, rate); if (l != 0) { add32(r, size_t(l - 1) * kRecord + 0x870, rate); modern::book_money(g, l - 1, -rate, true); } mem.set32(e + 0x14, mem.u32(e + 0x14) + uint32_t(rate)); mem.set32(e + 0x10, mem.u32(e + 0x10) + 1); if (int32_t(mem.u32(e + 0xc)) <= int32_t(mem.u32(e + 0x10))) for (uint32_t i = 0; i < 0x18; i++) mem.set8(e + i, 0); } } } // namespace bool list_transfer_player(ModernState& g, int slot, WatcomRandom& rand, MinuteReport& report) { return list_player(g, slot, rand, report); } void new_transfer_list_entries(ModernState& g, WatcomRandom& rand, MinuteReport& report) { new_list_entries(g, rand, report); } void market_value(const ModernState& g, int slot, int loan, int percent, uint32_t& fee, uint32_t& salary, int years, int extra, WatcomRandom& rand) { if (years > 4) years = 4; const int player = g.squad_slots.at(size_t(slot)) & 0xFFF; const Player& p = g.players.at(size_t(player)); int age = int((p.w364 >> 21) & 0x1F) + 1; // local_24 if (age > 0x14) age = 0x14; const int position = int(p.w364 & 3); uint16_t value[2] = {uint16_t((p.w35c >> 7) & 0x7F), uint16_t((p.w35c >> 14) & 0x7F)}; // technique, condition uint8_t growth = 100; // local_14 if (age > 10) growth = uint8_t(age * -10 - 0x38); for (int k = 0; k < 2; k++) for (int s = 0; s < years - 1; s++) value[k] = uint16_t((uint32_t(growth) * kDevelopment[int16_t(value[k]) / 10]) / 100 + value[k]); const int ad = std::abs(0xb - age) & 0xFF; int points = ((int16_t(value[0]) + int16_t(value[1])) * 5) / 2 + 0x96 - ad * 2; // local_2c points = std::clamp(points, 0xc, 0x26c); if (points > 500) points += points < 600 ? kDevelopment[10 + (points - 500) / 10] : 100; points = (((points >> 2) + 1) * points * ((points >> 3) + 100)) / 10; int16_t factor = int16_t(((p.w364 >> 26) & 0x3F) >> 2); // experience if (position == 0) { factor = int16_t(factor + 0x6e); } else { const int16_t skill = int16_t((int((p.w364 >> 10) & 0x3F) * 3 + int((p.w368 >> 7) & 0x3F)) >> 1); const int t = (position * skill) / 3; factor = int16_t(factor + 100 + (int16_t(t) >> 1)); } fee = uint32_t((percent * ((factor * points) / 100)) / 100); if (fee < 50000) fee = uint32_t(rand.range(50000, 80000)); salary = fee / 0x28; // (local_24 holds 11 - age by now, the variable of the age difference above: younger // players ask for more per extra year, older ones for less) salary = ((uint32_t(extra * (0xb - age) + 100) * salary) / 10000) * 100; if (loan == 1) fee >>= 2; // BMH_MARKET_TRACE=1: the factors of one valuation (diagnosis of #40; no state, no draws) if (const char* trace = std::getenv("BMH_MARKET_TRACE"); trace && trace[0] == '1') std::fprintf(stderr, "[market_value player %d (%s) pos %d age_raw %d TE %d KO %d -> points %d factor %d percent %d years %d extra %d: fee %u salary %u]\n", player, g.player_name(player).c_str(), position, age, int((p.w35c >> 7) & 0x7F), int((p.w35c >> 14) & 0x7F), points, int(factor), percent, years, extra, fee, salary); } std::array contract_demands(ModernState& g, int manager, int row, bool from_desk, WatcomRandom& rand) { const SquadRange range = squad_range(g.manager_teams.at(size_t(manager))); const int slot = int(range.first) + row; const size_t b = size_t(manager) * kBoard + size_t(row) * kBoardSlot; const int player = g.squad_slots.at(size_t(slot)) & 0xFFF; const int age = int((g.players.at(size_t(player)).w364 >> 21) & 0x1F) + 1; // local_24 // Difficulty (Range3 always returns 1, so the level is used) const int percent = g.level + 100; std::array demand{}; for (int k = 0; k < 4; k++) { // per year beyond the current contract the salary changes by 11 - age percent const int extra = int8_t(uint8_t(k - (g.tactics.at(b + 0xc) + 6) / 0xc + 1)); uint32_t fee = 0, salary = 0; modern::market_value(g, slot, 0, percent, fee, salary, k + 1, extra, rand); salary = (g.tactics.at(b + 0xd) * salary) / 100; // his mood const bool refuses = age + k >= 0x24 || (g.tactics.at(b + 0xb) & 0x60); if (const char* trace = std::getenv("BMH_MARKET_TRACE"); trace && trace[0] == '1') std::fprintf(stderr, "[contract_demands player %d years %d: mood +0x0d %d, flags +0x0b %02x, refuses %d -> %u]\n", player, k + 1, int(g.tactics.at(b + 0xd)), int(g.tactics.at(b + 0xb)), int(refuses), salary); demand[size_t(k)] = refuses && from_desk ? 0xFFFFFFFFu : salary; } return demand; } bool contract_offer(ModernState& g, int manager, int row, int column, uint32_t offer, uint32_t demand, bool request, bool screen_row, WatcomRandom& rand, const std::array* proposed_bonuses) { const int team = g.manager_teams.at(size_t(manager)); const SquadRange range = squad_range(team); const int slot = int(range.first) + row; const size_t b = size_t(manager) * kBoard + size_t(row) * kBoardSlot; const int player = g.squad_slots.at(size_t(slot)) & 0xFFF; const size_t bonus_at = b + 0x12; std::array current_bonuses{}; for (size_t i = 0; i < current_bonuses.size(); ++i) { current_bonuses[i] = g.tactics.at(bonus_at + i); if (proposed_bonuses && (*proposed_bonuses)[i] > (i < 3 ? 20 : 200)) return false; } // the longer he is at the club (+0x11, months), the less he insists int loyalty = g.tactics.at(b + 0x11) / rand.range(8, 0xc); // local_3c if (int16_t(loyalty) > 6) loyalty = 6; // the offer counts with 80 % of the bonus he can expect (ContractOffer with the fitness // correction on a copy of his board row whose salary is the offer: its +0x50 is the // offer variable local_f0 that follows the copy on the stack) std::array buf; const int predicted = modern::table_prediction(g, team, 4, buf); const int rank = predicted == 0 ? 0xB : predicted + 1; uint8_t saved[4]; std::copy(g.tactics.begin() + long(b + 0x50), g.tactics.begin() + long(b + 0x54), saved); for (int i = 0; i < 4; i++) g.tactics.at(b + 0x50 + size_t(i)) = uint8_t(offer >> (8 * i)); if (proposed_bonuses) std::copy(proposed_bonuses->begin(), proposed_bonuses->end(), g.tactics.begin() + long(bonus_at)); const uint32_t bonus = modern::expected_bonus(g, manager, rank, row, player, true); std::copy(saved, saved + 4, g.tactics.begin() + long(b + 0x50)); if (proposed_bonuses) std::copy(current_bonuses.begin(), current_bonuses.end(), g.tactics.begin() + long(bonus_at)); const uint32_t worth = offer + (bonus * 0x50) / 100; // uVar12 if (std::getenv("BMH_TRACE")) std::printf(" [offer %u: loyalty %d, rank %d, bonus %u, worth %u, demand %u]\n", offer, loyalty, rank, bonus, worth, demand); // what he wants: W(80, 100) - 2 x loyalty percent of his demand (a request of his own: // the whole demand) const uint32_t wanted = (request ? 100u : uint32_t(rand.range(0x50, 100) - 2 * int16_t(loyalty))) * demand; if (std::getenv("BMH_TRACE")) std::printf(" [wanted %u / 100]\n", wanted); if ((offer * 100u) / demand < 0x3d || worth < wanted / 100) { // "Der Spieler lehnt ab" (CareerSession_Reject_TextPointer6, a message box): he is offended (+0x4f bit 7) // and in a worse mood g.tactics.at(b + 0x4f) |= 0x80; if (g.tactics.at(b + 0xd) < 0xfb) g.tactics.at(b + 0xd) = uint8_t(g.tactics.at(b + 0xd) + 5); if (screen_row) g.tactics.at(b + 0xb) |= 0x40; // he will not talk again return false; } // accepted (CareerSession_Reject_TextPointer5): the new salary and term; his mood is what the offer is worth // against his market salary for that term for (int i = 0; i < 4; i++) g.tactics.at(b + 0x50 + size_t(i)) = uint8_t(offer >> (8 * i)); g.tactics.at(b + 0xc) = uint8_t((column + 1) * 0xc); uint32_t fee = 0, salary = 0; modern::market_value(g, slot, 0, 100, fee, salary, column, 0, rand); g.tactics.at(b + 0xd) = uint8_t(std::clamp((worth * 100) / salary, 100, 0xff)); if (proposed_bonuses) std::copy(proposed_bonuses->begin(), proposed_bonuses->end(), g.tactics.begin() + long(bonus_at)); return true; } bool contract_bonuses(ModernState& g, int manager, int row, const std::array& rates) { if (manager < 0 || size_t(manager) >= g.manager_teams.size()) return false; const int team = g.manager_teams[size_t(manager)]; if (team == no_team()) return false; const SquadRange range = squad_range(team); if (row < -1 || (row >= 0 && size_t(row) >= range.count) || range.first + range.count > g.squad_slots.size()) return false; for (size_t i = 0; i < rates.size(); ++i) if (rates[i] > (i < 3 ? 20 : 200)) return false; const size_t board = size_t(manager) * 0x840; if (board + size_t(range.count) * 0x58 > g.tactics.size()) return false; bool changed = false; const size_t first_row = row < 0 ? 0 : size_t(row); const size_t end_row = row < 0 ? range.count : size_t(row) + 1; // The original checks the whole selected scope before committing any of it. for (size_t r = first_row; r < end_row; ++r) { const int player = g.squad_slots.at(range.first + r) & 0x0fff; if (player == 0x0fff) continue; if (size_t(player) >= g.players.size()) return false; const size_t b = board + r * 0x58; for (size_t i = 0; i < rates.size(); ++i) { const uint8_t old = g.tactics.at(b + 0x12 + i); changed |= rates[i] > old; } } for (size_t i = 0; i < rates.size(); ++i) { bool found = false; uint8_t minimum = 0xff; for (size_t r = first_row; r < end_row; ++r) { if ((g.squad_slots.at(range.first + r) & 0x0fff) == 0x0fff) continue; found = true; minimum = std::min(minimum, g.tactics.at(board + r * 0x58 + 0x12 + i)); } if (found && rates[i] < minimum) return false; } if (!changed) return false; for (size_t r = first_row; r < end_row; ++r) { const int player = g.squad_slots.at(range.first + r) & 0x0fff; if (player == 0x0fff) continue; const size_t b = board + r * 0x58; for (size_t i = 0; i < rates.size(); ++i) if (rates[i] > g.tactics.at(b + 0x12 + i)) g.tactics.at(b + 0x12 + i) = rates[i]; } return true; } ContractInsuranceResult contract_insurance(ModernState& g, int manager, int row, int insurance_type, uint8_t months) { ContractInsuranceResult out; if (manager < 0 || size_t(manager) >= g.manager_teams.size() || insurance_type < 0 || insurance_type >= 4 || months < 1 || months > 60) return out; const int team = g.manager_teams[size_t(manager)]; if (team == no_team()) return out; const SquadRange range = squad_range(team); if (row < 0 || size_t(row) >= range.count || range.first + size_t(row) >= g.squad_slots.size()) return out; const int player = g.squad_slots.at(range.first + size_t(row)) & 0x0fff; if (player == 0x0fff || size_t(player) >= g.players.size()) return out; const size_t b = size_t(manager) * 0x840 + size_t(row) * 0x58; if (b + 0x54 > g.tactics.size() || (g.tactics.at(b + 0x0b) & 0x60) != 0 || g.tactics.at(b + 0x43) != 0 || (g.players[size_t(player)].w35c >> 27) != 0) return out; const uint32_t salary = uint32_t(g.tactics.at(b + 0x50)) | (uint32_t(g.tactics.at(b + 0x51)) << 8) | (uint32_t(g.tactics.at(b + 0x52)) << 16) | (uint32_t(g.tactics.at(b + 0x53)) << 24); const uint32_t fee = (((uint32_t(insurance_type * 10 + 10) * salary) / 1000) * 10); const uint16_t old_fee = uint16_t(g.tactics.at(b + 0x4e) | (uint16_t(g.tactics.at(b + 0x4f)) << 8)); g.tactics.at(b + 0x43) = uint8_t(months | uint8_t(insurance_type << 6)); // The original clears the old amount but preserves the high flag before adding the // term's monthly premium into the 16-bit field. const uint16_t base = uint16_t(old_fee & 0x8000); const uint16_t stored = uint16_t(base + uint16_t(fee)); g.tactics.at(b + 0x4e) = uint8_t(stored); g.tactics.at(b + 0x4f) = uint8_t(stored >> 8); out.accepted = true; out.monthly_fee = uint16_t(fee); return out; } void search_profile_news(ModernState& g, int manager, uint32_t list, int player) { const StaticMemory& mem = g.memory; const size_t rec = size_t(manager) * kRecord; auto b = [&](size_t off) { return int(g.manager_records.at(rec + off)); }; const int team = g.manager_teams.at(size_t(manager)); player &= 0xFFF; if (team == no_team() || (mem.u16(list + 8) & 0x7FFF) == team || (b(0x1f6) & 0x40)) return; const uint32_t w364 = g.players.at(size_t(player)).w364, w35c = g.players.at(size_t(player)).w35c; // position wanted (or none selected) and age within the range if (b(0x1f6 + (w364 & 3)) == 0 && b(0x1f9) + b(0x1f8) + b(0x1f7) + b(0x1f6) != 0) return; const int age = int((w364 >> 21) & 0x1F); if (age < b(0x1fa) || age > b(0x1fb)) return; // strength by the selected attributes (condition, technique, form; none = all three) int8_t selected = int8_t(b(0x200) + b(0x1fe) + b(0x1ff)); if (selected == 0) selected = 3; int sum = 0, n = 0, form = 0; if (b(0x1fe) != 0 || selected == 3) sum = int((w35c >> 14) & 0x7F), n = 1; if (b(0x1ff) != 0 || selected == 3) sum = int16_t(sum) + int((w35c >> 7) & 0x7F), n++; if (b(0x200) != 0 || selected == 3) form = int(w35c & 0x7F); int16_t strength; if (n == 0) { strength = int16_t((form - 0x23) * 3 + 10); } else { strength = int16_t(uint32_t(sum) / uint32_t(n)); if (form != 0) strength = int16_t(uint32_t(strength * int16_t((int16_t(form) >> 3) + 0x5e)) / 100); } if (strength < b(0x1fc) || strength > b(0x1fd)) return; // left / right foot and wing preferences (w35c bits 21-23 and 24-26) const int lane = int((w35c >> 21) & 7), foot = int((w35c >> 24) & 7); bool low_foot = b(0x201) || b(0x203), high_foot = b(0x202) || b(0x204); if (low_foot && high_foot) low_foot = high_foot = false; bool low_lane = b(0x201) || b(0x202), high_lane = b(0x203) || b(0x204); if (low_lane && high_lane) low_lane = high_lane = false; if ((low_lane && lane >= 3) || (high_lane && lane <= 4) || (low_foot && foot >= 3) || (high_foot && foot <= 4)) return; // the price class (asking price 70..130 %) against the classes wanted int8_t price_class = int8_t((mem.u8(list + 0x54) - 0x46) / 0x14); price_class = std::clamp(price_class, 0, 2); const int8_t classes = int8_t(b(0x207) + b(0x205) + b(0x206)); int highest = 2; while (highest >= 0 && b(0x205 + size_t(highest)) == 0) highest--; if (classes == 0 || price_class <= highest) post_composed(g, manager, message_text(g, ::bmh::layout::Month_SearchProfileNews_TextPointer) + g.player_name(player) + message_text(g, ::bmh::layout::Month_SearchProfileNews_TextPointer2)); } void month_change(ModernState& g, WatcomRandom& rand, MinuteReport& report, GameRandom* game) { StaticMemory& mem = g.memory; std::vector& r = g.manager_records; const int managers = int(g.manager_teams.size()); // 1. advertising contracts turn_step = "month_change: advertising"; if (mem.u8(::bmh::layout::GameMode) != 1 && mem.u8(::bmh::layout::CareerDuration) != 1) for (int m = 0; m < managers; m++) for (int k = 0; k < 0x12; k++) { const size_t c = size_t(m) * kRecord + 0xa34 + size_t(k) * 0xc; if (r.at(c + 5) == 0 && (r.at(c + 6) & 0x80)) { wr32(r, c, 0); r.at(c + 6) = 0; } if (r.at(c + 5) != 0 && --r.at(c + 5) == 0) { if ((r.at(c + 6) & 0x7F) == 0) wr32(r, c, 0); else turn_step = "month_change: advertising text", post_text(g, m, text_id(::bmh::layout::Month_MonthChange_TextPointer)); // the contract can be renewed } } // Modern: a queued exclusive sponsor starts once its place is free (trainingslager.md) for (int m = 0; m < managers; m++) modern::start_queued_exclusive_sponsor(g, m); // 2. new players on the transfer list turn_step = "month_change: new list entries"; new_list_entries(g, rand, report); if (report.unsupported) return; // 3. loans turn_step = "month_change: loans"; return_loans(g, rand, game, report); if (report.unsupported) return; // 4. the human managers turn_step = "month_change: managers"; for (int m = 0; m < managers && !report.unsupported; m++) { const size_t rec = size_t(m) * kRecord; for (int k = 0; k < 3; k++) modern::rate_manager(g, m, uint8_t(int8_t(int32_t(mem.u32(::bmh::layout::Month_MonthChange_RuntimeField + uint32_t(k) * 4 + uint32_t(m) * 0x24)) / 0x96)), k + 1); const int32_t expenses = monthly_expenses(g, m); const int32_t income = monthly_income(g, m); modern::book_money(g, m, expenses - income, true); for (int k = 0; k < 2; k++) modern::rate_manager(g, m, uint8_t(int8_t(((rd32(r, rec + 0x854 + size_t(k) * 4) / 5000) * 200) / 7)), k + 4); board_month(g, m, rand, report, game); } if (report.unsupported) return; // 5. shares and loans turn_step = "month_change: shares"; shares_and_loans(g); } } // namespace bmh::modern