Files
Dreierpack-Manager/src/modern/game/month.cpp
T
MichaelandClaude Fable 5.2 9e92d07b03 Port overflow fixes for daily interest and dividends; pay Modern dividends per manager
Daily interest and share dividends are computed in 64 bits before the
division (ported from OpenBMH 1.0.3). In Modern each manager now receives
the dividend of his own shares instead of the original's lost booking.

Co-Authored-By: Claude Fable 5.2 <noreply@anthropic.com>
2026-11-13 23:47:09 +01:00

999 lines
54 KiB
C++

// 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 <algorithm>
#include <array>
#include <cstdio>
#include <cstdlib>
#include <optional>
#include <string>
#include <vector>
#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<uint8_t>& 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<uint8_t>& 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<uint8_t>& 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<int> 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<int16_t> teams(static_cast<size_t>(league_clubs()));
std::vector<uint32_t> keys(static_cast<size_t>(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<GameRandom> 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<uint8_t>& 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<uint8_t>& 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<uint8_t>& 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<uint32_t>(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<uint32_t>(((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<uint8_t>& 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<uint64_t>(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<uint32_t, 4> 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<uint32_t, 4> 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<uint8_t, 7>* 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<uint8_t, 7> 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<uint8_t, 24> 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<uint32_t>((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<uint8_t, 7>& 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<int8_t>(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<uint8_t>& 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