Bind the transfer market to world-relative Modern data (by Codex)

This commit is contained in:
Codex committed 2026-10-29 09:00:21 +01:00
1 parent e559e84a69
commit 1e88304019
23 files changed
+1230 -76

No files matched your search

+128
View File
@@ -0,0 +1,128 @@
// SPDX-License-Identifier: GPL-3.0-only
#include "modern/content/transfer_market.hpp"
#include "formats/executable_layout.hpp"
#include <algorithm>
#include <limits>
namespace bmh::modern {
ui::TransferMarketState project_transfer_market(const ModernState &g,
uint64_t revision) {
ui::TransferMarketState out;
const auto active = int(g.memory.u8(::bmh::layout::ActiveManager));
if (active < 0 || size_t(active) >= g.manager_teams.size())
throw FormatError("invalid transfer manager");
out.manager_slot = active;
out.runtime_club = g.manager_teams[size_t(active)];
out.revision = revision;
if (out.runtime_club < 0 || out.runtime_club >= modern::league_clubs())
throw FormatError("transfers require a club manager");
const size_t record = size_t(active) * 0xb0c;
const auto word32 = [&](size_t at) {
return int32_t(uint32_t(g.manager_records.at(at)) |
uint32_t(g.manager_records.at(at + 1)) << 8 |
uint32_t(g.manager_records.at(at + 2)) << 16 |
uint32_t(g.manager_records.at(at + 3)) << 24);
};
out.balance = word32(record + 0x314);
out.credit_line = word32(record + 0x31c);
out.club_name = g.club_name(out.runtime_club);
out.source = "modern_world_projection";
const auto range = bmh::squad_range(out.runtime_club);
out.roster.squad_start_offset = int(range.first);
std::vector<bool> listed(g.players.size(), false);
for (int i = 0; i < 40; ++i) {
const size_t slot = modern::transfer_list_slot() + size_t(i);
const int player = g.squad_slots.at(slot) & 0xfff;
if (player == 0xfff)
continue;
const auto &p = g.players.at(size_t(player));
const uint32_t entry = ::bmh::layout::EditorList + uint32_t(i) * 0x58;
ui::TransferMarketItem item;
item.list_entry = i;
item.source_slot = int(slot);
item.player = player;
item.attributes = p;
item.age = p.age();
item.position = p.position();
item.strength = p.strength();
item.name = g.player_name(player);
item.source_word = g.squad_slots[slot];
const auto seller = g.memory.u16(entry + 8);
item.seller = seller == 0xffff ? -1 : int(seller & 0x7fff);
item.seller_name = g.club_name(item.seller < 0 ? 0xfff : item.seller);
item.own_listing = item.seller == out.runtime_club;
const auto fee = uint64_t(g.memory.u32(entry + 0x2c) / 10000) * 12500;
if (fee > uint64_t(INT32_MAX))
throw FormatError("transfer asking fee overflow");
item.asking_fee = int32_t(fee);
item.salary_reference = g.memory.u32(entry + 0x30);
item.salary_demand_percent = g.memory.u8(entry + 0x55);
for (int n = 0; n < 4; ++n) {
const auto buyer = g.memory.u16(entry + uint32_t(n) * 2);
if (buyer == 0xffff)
continue;
++item.offers;
if (buyer != out.runtime_club)
continue;
TransferBidRequest bid;
bid.manager = active;
bid.list_entry = i;
bid.source_slot = int(slot);
bid.player = player;
bid.fee = int32_t(g.memory.u32(entry + 0x1c + uint32_t(n) * 4));
bid.annual_salary = int32_t(g.memory.u32(entry + 0x0c + uint32_t(n) * 4));
const auto term = g.memory.u8(entry + 0x34 + uint32_t(n));
bid.contract_years = uint8_t((int(term & 0x7f) - 1) / 12 + 1);
bid.loan = (term & 0x80) != 0;
for (size_t k = 0; k < 7; ++k)
bid.bonuses[k] =
g.memory.u8(entry + 0x38 + uint32_t(n) * 7 + uint32_t(k));
item.own_bid = bid;
item.own_bid_pending = true;
}
listed.at(size_t(player)) = true;
out.items.push_back(std::move(item));
}
size_t borrowed = 0;
for (int i = 0; i < 12; ++i)
if (g.memory.has(::bmh::layout::Career_CareerManagersEnd_RuntimeField +
uint32_t(i) * 2 + 1) &&
g.memory.has(::bmh::layout::ClubInfo_FormatError_RuntimeField2 +
uint32_t(i)) &&
g.memory.u16(::bmh::layout::Career_CareerManagersEnd_RuntimeField +
uint32_t(i) * 2) != 0xfff &&
g.memory.u8(::bmh::layout::ClubInfo_FormatError_RuntimeField2 +
uint32_t(i)) == active)
++borrowed;
if (borrowed > range.count)
throw FormatError("transfer borrowed rows exceed squad");
for (size_t row = 0; row < range.count - borrowed; ++row) {
const auto slot = g.squad_slots.at(range.first + row);
const int player = slot & 0xfff;
if (player == 0xfff)
continue;
const auto &p = g.players.at(size_t(player));
out.squad.push_back({int(row), player, slot, g.player_name(player), p.age(),
p.position(), p.strength(),
listed.at(size_t(player))});
}
for (int all = 0; all < 2; ++all) {
std::array<uint32_t, 5> count{}, sum{};
for (size_t row = 0; row < std::min(range.count, size_t(all ? 24 : 11));
++row) {
const int player = g.squad_slots.at(range.first + row) & 0xfff;
if (player == 0xfff)
continue;
const auto &p = g.players.at(size_t(player));
const auto pos = size_t(p.position());
++count[pos];
++count[4];
sum[pos] += p.strength();
sum[4] += p.strength();
}
auto &strength = all ? out.team_strengths : out.active_strengths;
for (size_t i = 0; i < 5; ++i)
strength[i] = count[i] ? uint16_t(sum[i] / count[i]) : 0;
}
return out;
}
} // namespace bmh::modern
+9
View File
@@ -0,0 +1,9 @@
// SPDX-License-Identifier: GPL-3.0-only
#pragma once
#include "modern/game/modern_state.hpp"
#include "ui/transfer_market.hpp"
namespace bmh::modern {
// Modern pool identities are world-relative, never Classic's fixed 0xb70.
ui::TransferMarketState project_transfer_market(const ModernState &,
uint64_t revision);
} // namespace bmh::modern