Files
Dreierpack-Manager/tests/human_buyer_market_tests.cpp
T
ClaudeandClaude Sonnet 5.5 0a95dbcba6 Transfer market: the search dialog behind Suchen and Vorschlag; asking fee display follows Diamond 3.7
TransferMarketScreen gets the dialog of the original (KB/69.VGA panel at 184,20, seven bar rows from the
EXE table, click rules of sub_19409, confirm button, price estimate). Suchen opens it with the stored
profile, Vorschlag with the suggestion the squad asks for (computed in the projection). Closing posts a
store_search_profile request; the controller stores it and announces the matching listings through the
notice presenter, like the original's message boxes. Right button or Esc leaves with the search switched
off. Controller test drives the whole route.

The market list showed the asking fee scaled by 0x30d4 (older Diamond); 3.7 rounds to 10000
(sub_3C940), now also in the projection. Four tests computed the old base and follow.

Fixes #79

Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2026-11-07 22:04:33 +01:00

1352 lines
91 KiB
C++

// SPDX-License-Identifier: GPL-3.0-only
#include "formats/executable_layout.hpp"
#include <algorithm>
#include <array>
#include <cstdio>
#include <cstring>
#include <filesystem>
#include <stdexcept>
#include <string>
#include <vector>
#include "formats/fbm.hpp"
#include "formats/savestate.hpp"
#include "formats/textd.hpp"
#include "game/desk_actions.hpp"
#include "game/human_buyer_sale.hpp"
#include "game/lineup.hpp"
#include "game/matchday.hpp"
#include "game/messages.hpp"
#include "game/month.hpp"
#include "game/national.hpp"
#include "game/prediction.hpp"
#include "game/save.hpp"
using namespace bmh;
namespace {
constexpr uint32_t list_start = ::bmh::layout::EditorList;
constexpr size_t pool_start = 0xb70, record_size = 0xb0c, board_size = 0x840, row_size = 0x58;
void check(bool yes, const std::string& why) { if (!yes) throw std::runtime_error(why); }
uint32_t rd(const std::vector<uint8_t>& b, size_t at) {
uint32_t n = 0; for (size_t i = 0; i < 4; ++i) n |= uint32_t(b.at(at+i)) << (8*i); return n;
}
void wr(std::vector<uint8_t>& b, size_t at, uint32_t n) {
for (size_t i = 0; i < 4; ++i) b.at(at+i) = uint8_t(n >> (8*i));
}
void optional_byte(GameState& g, uint32_t at, uint8_t n) {
if (g.memory.has(at)) g.memory.set8(at,n);
}
size_t find_player(const GameState& g, int team, int player) {
const auto r = squad_range(team);
for (size_t n = 0; n < r.count; ++n)
if ((g.squad_slots.at(r.first+n)&0xfff)==player) return r.first+n;
throw std::runtime_error("expected concrete source squad owner");
}
bool contains(const GameState& g, int team, int player) {
const auto r = squad_range(team);
for (size_t n = 0; n < r.count; ++n)
if ((g.squad_slots.at(r.first+n)&0xfff)==player) return true;
return false;
}
struct Boundary {
std::string point, text;
int manager=-1, entry=-1, raw=-1;
uint32_t address=0; uint16_t flags=0;
Bytes native;
uint32_t w_seed=0; int32_t g_seed=0;
uint64_t w_calls=0, g_calls=0;
int active=-1, bdb7e=-1, bdb8c=-1, bdb93=-1;
bool suppressed=false;
};
Boundary capture(const GameState& g, const WatcomRandom& w, const GameRandom& game,
std::string point, int entry, int manager=-1,
uint32_t address=0, std::string text={}, uint16_t flags=0) {
Boundary b;
b.point=std::move(point); b.entry=entry; b.manager=manager; b.address=address;
b.text=std::move(text); b.flags=flags;
b.w_seed=w.seed(); b.w_calls=w.calls(); b.g_seed=game.seed(); b.g_calls=game.calls();
b.active=g.memory.u8(::bmh::layout::ActiveManager); b.suppressed=g.transfer_notice_suppressed;
const auto transient=[&](uint32_t at){return g.memory.has(at)?int(g.memory.u8(at)):-1;};
b.bdb7e=transient(::bmh::layout::FinanceStatisticsEnabled); b.bdb8c=transient(::bmh::layout::DeskActions_EditorFail_RuntimeField2); b.bdb93=transient(::bmh::layout::Weekly_PendingSettleHumanBuyer_RuntimeField);
b.native=save_stream(g); // Native only: no encryption and no clock/RNG draw.
check(w.seed()==b.w_seed&&w.calls()==b.w_calls&&game.seed()==b.g_seed&&game.calls()==b.g_calls,
"capture must not consume either RNG stream");
return b;
}
void compare(const Boundary& actual, const Boundary& expected, const std::string& label) {
check(actual.point==expected.point&&actual.entry==expected.entry&&actual.raw==expected.raw&&
actual.manager==expected.manager&&actual.address==expected.address&&actual.flags==expected.flags&&
actual.text==expected.text, label+": Source callback identity/text/flags");
check(actual.native==expected.native, label+": full Native checkpoint");
check(actual.w_seed==expected.w_seed&&actual.w_calls==expected.w_calls&&
actual.g_seed==expected.g_seed&&actual.g_calls==expected.g_calls,
label+": W/G checkpoint");
check(actual.active==expected.active&&actual.bdb7e==expected.bdb7e&&
actual.bdb8c==expected.bdb8c&&actual.bdb93==expected.bdb93&&actual.suppressed==expected.suppressed,
label+": runtime/checkpoint ownership");
}
// Independent composition of SettleHumanBuyerSale -> PendingOfferAnswer -> 42707 -> ReleasePlayer/PoolString.
// Only reviewed small primitives are shared: book_money, new_board_entry,
// market_value, expected_bonus and auto_lineup. Never call production settlement,
// move_player, remove_from_seller, pending adapters or source history helpers here.
// Scope: declared ordinary 0..39 SALE control, valid 24-word human buyer,
// explicit observed allocator gate; no loan, targeted entry or runtime-PC claim.
void source_history(GameState& g, int manager, int other, int player, uint32_t fee, bool buyer) {
const size_t base=size_t(manager)*record_size;
for (size_t n=29;n>0;--n) {
wr(g.manager_records,base+0x760+n*4,rd(g.manager_records,base+0x760+(n-1)*4));
wr(g.manager_records,base+0x7d8+n*4,rd(g.manager_records,base+0x7d8+(n-1)*4));
}
wr(g.manager_records,base+0x760,g.date*4u+uint32_t(buyer)+(fee/10000u)*0x80000u);
wr(g.manager_records,base+0x7d8,uint32_t(g.player_name_offsets.at(size_t(player)))+
(other==0x0fff?0xffffu:uint32_t(g.club_ids.at(size_t(other))))*0x10000u);
auto& n=g.manager_records.at(base+0x21d); if(n<25) ++n;
}
void source_remove(GameState& g, int seller, int seller_manager, int player) {
if(seller==0x0fff) {
// format field free-agent branch covers the entire free-player pool,
// including aliases beyond the 44 ordinary/special list slots.
for(size_t at=pool_start;at<3072;++at)
if((g.squad_slots.at(at)&0xfff)==player) g.squad_slots.at(at)=0x0fff;
return;
}
const auto r=squad_range(seller); const size_t found=find_player(g,seller,player);
// ReleasePlayer removes every matching pool occurrence, including special rows,
// independently of each list's retained bidder words.
for(size_t at=pool_start;at<pool_start+44;++at)
if((g.squad_slots.at(at)&0xfff)==player) g.squad_slots.at(at)=0x0fff;
for(size_t at=found;at+1<r.first+r.count;++at) g.squad_slots.at(at)=g.squad_slots.at(at+1);
g.squad_slots.at(r.first+r.count-1)=0x0fff;
if(seller_manager>=0&&found-r.first!=23) {
const size_t row=found-r.first, start=size_t(seller_manager)*board_size+row*row_size;
std::memmove(g.tactics.data()+start,g.tactics.data()+start+row_size,(23-row)*row_size);
}
auto_lineup(g,seller,100); // embedded ReleasePlayer call, followed by caller's second seller call.
}
struct SourceResult {
HumanBuyerSaleStatus status=HumanBuyerSaleStatus::unsupported;
uint32_t adjusted=0;
std::vector<Boundary> observations;
};
SourceResult source_settle(GameState& g, const HumanBuyerSaleRequest& request,
HumanBuyerSaleAllocatorGate gate, WatcomRandom& w,
GameRandom& game, bool direct_ack, bool paid_checkpoint) {
SourceResult result;
const uint32_t list=request.list_address;
const int player=g.squad_slots.at(request.source_pool_slot)&0xfff;
const int seller=g.memory.u16(list+8)&0x7fff;
const int buyer=g.memory.u16(list+uint32_t(request.bid_slot)*2);
const int seller_manager=g.manager_of(seller), buyer_manager=g.manager_of(buyer);
const uint32_t fee=g.memory.u32(list+0x1c+uint32_t(request.bid_slot)*4);
const uint32_t salary=g.memory.u32(list+0x0c+uint32_t(request.bid_slot)*4);
const uint8_t term=g.memory.u8(list+0x34+uint32_t(request.bid_slot));
check(request.list_entry>=0&&request.list_entry<40&&request.raw_offer_slot==-1&&
request.list_address==list_start+uint32_t(request.list_entry)*row_size&&
request.source_pool_slot==pool_start+size_t(request.list_entry),"oracle only ordinary explicit coordinates");
check(gate!=HumanBuyerSaleAllocatorGate::unsupported&&buyer_manager>=0&&
squad_range(buyer).count==24&&term<=127,"oracle requires supported Source scope");
const size_t seller_slot=seller==0x0fff?0:find_player(g,seller,player);
const auto notice=[&](int manager,uint32_t at,std::string text={},uint16_t flags=0){
result.observations.push_back(capture(g,w,game,"notice",request.list_entry,manager,at,
text.empty()?message_text(g,at):std::move(text),flags));
};
if(direct_ack) notice(g.memory.u8(::bmh::layout::ActiveManager),::bmh::layout::DeskActions_SubmitTransferBidImpl_ExecutableField,{},0x80);
const size_t br=size_t(buyer_manager)*record_size;
result.adjusted=fee;
const uint8_t subsidy=g.manager_records.at(br+0x170);
if(fee<=rd(g.manager_records,br+0x314)&&subsidy!=0&&
(subsidy&3)==(g.players.at(size_t(player)).w364&3)) {
uint32_t league=g.manager_records.at(br+0x210); if(league>2) --league;
const uint32_t limit=(((uint32_t(subsidy)>>2)&7u)*50000u+150000u)*(4u-league);
if(fee<limit) {
const uint32_t discount=(((uint32_t(subsidy)>>5)+3u)*fee*10u)/100u;
notice(buyer_manager,::bmh::layout::PendingOffer_ConstructionNoticeDialog_TextPointer,message_text(g,::bmh::layout::PendingOffer_ConstructionNoticeDialog_TextPointer)+format_amount(g,int32_t(discount))+
message_text(g,::bmh::layout::Weekly_Fail_TextPointer)+format_amount(g,int32_t(fee))+").");
result.adjusted-=discount;
} else notice(buyer_manager,::bmh::layout::PendingOffer_FormatError_ExecutableField3);
g.manager_records.at(br+0x170)=0;
}
const uint8_t old_active=g.memory.u8(::bmh::layout::ActiveManager);
optional_byte(g,::bmh::layout::FinanceStatisticsEnabled,1);
if(!book_money(g,buyer_manager,int32_t(result.adjusted),false,true)) {
g.memory.set8(::bmh::layout::ActiveManager,uint8_t(buyer_manager)); notice(buyer_manager,::bmh::layout::Advertising_FormatError_TextPointer18);
if(g.level!=0) optional_byte(g,::bmh::layout::FinanceStatisticsEnabled,0);
g.memory.set8(::bmh::layout::ActiveManager,old_active);
result.status=HumanBuyerSaleStatus::funds_refused; return result;
}
if(g.level!=0) optional_byte(g,::bmh::layout::FinanceStatisticsEnabled,0);
wr(g.manager_records,br+0x330,rd(g.manager_records,br+0x330)+result.adjusted);
if(seller_manager>=0) {
const size_t sr=size_t(seller_manager)*record_size;
optional_byte(g,::bmh::layout::FinanceStatisticsEnabled,1);
book_money(g,seller_manager,int32_t(0u-result.adjusted),true,true);
if(g.level!=0) optional_byte(g,::bmh::layout::FinanceStatisticsEnabled,0);
wr(g.manager_records,sr+0x330,rd(g.manager_records,sr+0x330)-result.adjusted);
}
if(paid_checkpoint) result.observations.push_back(capture(g,w,game,"paid",request.list_entry));
if(gate==HumanBuyerSaleAllocatorGate::blocked) {
result.status=HumanBuyerSaleStatus::allocator_blocked; return result;
}
const auto buyer_range=squad_range(buyer);
size_t destination=buyer_range.first;
// format field scans exactly 24 FULL words, not masked IDs or squad_count.
while(destination<buyer_range.first+24&&g.squad_slots.at(destination)!=0x0fff) ++destination;
if(destination==buyer_range.first+24) {
notice(g.memory.u8(::bmh::layout::ActiveManager),::bmh::layout::PendingOffer_FormatError_ExecutableField);
result.status=HumanBuyerSaleStatus::no_room; return result;
}
const size_t row=destination-buyer_range.first;
const size_t board=size_t(buyer_manager)*board_size+row*row_size;
g.squad_slots.at(destination)=g.squad_slots.at(request.source_pool_slot);
new_board_entry(g,buyer_manager,int(row),int(destination),w);
if(seller_manager>=0) {
const size_t seller_board=size_t(seller_manager)*board_size+
(seller_slot-squad_range(seller).first)*row_size;
std::copy_n(g.tactics.begin()+std::ptrdiff_t(seller_board),row_size,
g.tactics.begin()+std::ptrdiff_t(board));
}
wr(g.tactics,board+0x50,salary);
uint32_t reference_fee=0,reference_salary=0;
market_value(g,int(request.source_pool_slot),0,100,reference_fee,reference_salary,term&127,0,w);
check(reference_salary!=0,"oracle excludes Original divide-by-zero boundary");
for(size_t n=0;n<7;++n)
g.tactics.at(board+0x12+n)=g.memory.u8(list+0x38+uint32_t(request.bid_slot)*7+uint32_t(n));
const uint32_t bonus=expected_bonus(g,buyer_manager,0xff,int(row),player,true);
// EXE4292c..42949: wrap32 IMUL, signed bonus IDIV, unsigned final DIV,
// then signed legacy routine clamp. No 64-bit widening or signed final divide.
const int32_t part=int32_t(bonus*80u)/100;
const uint32_t numerator=(salary+uint32_t(part))*100u;
g.tactics.at(board+0x0d)=uint8_t(std::clamp(int32_t(numerator/reference_salary),0,255));
wr(g.tactics,board+0x54,fee); g.tactics.at(board+0x0c)=term;
if(seller_manager>=0) source_history(g,seller_manager,buyer,player,fee,false);
source_history(g,buyer_manager,seller,player,fee,true);
source_remove(g,seller,seller_manager,player);
if(seller!=0x0fff) auto_lineup(g,seller,100);
auto_lineup(g,buyer,100);
result.status=HumanBuyerSaleStatus::moved;
return result;
}
struct Control {
HumanBuyerSaleRequest request;
int player=-1, seller=-1, buyer=-1, seller_manager=-1, buyer_manager=1, destination=-1;
uint32_t fee=250000,salary=70000;
uint8_t term=24;
};
Control make_control(GameState& g, bool human_seller=false, int first_free=-1,
bool full=false, int bid=0, uint32_t fee=250000, uint32_t salary=70000,
bool formed_bid=true, int selected_seller=-1, int selected_player=-1) {
check(g.manager_teams.size()==2&&g.manager_teams[0]==1&&g.manager_teams[1]==54,
"unchanged genuine 2PNWK001 manager identity");
Control c; c.buyer=g.manager_teams[1]; c.fee=fee; c.salary=salary;
WatcomRandom listing_w(37); MinuteReport listing_report;
int entry=-1;
if(human_seller) {
const auto listing=list_manager_player(g,0,5,listing_w,listing_report);
check(listing.status==TransferActionStatus::accepted&&!listing_report.unsupported,
"actual Source human listing control");
c.player=listing.player; c.seller=g.manager_teams[0]; c.seller_manager=0; entry=listing.list_entry;
} else {
// Genuine fixture has only free agents on its original ordinary list.
// Generate an AI club listing through the existing reviewed Source
// primitive, preserving real unique players; no special-row promotion.
const int first_team=selected_seller<0?0:selected_seller;
const int last_team=selected_seller<0?90:selected_seller+1;
for(int team=first_team;team<last_team&&entry<0;++team) {
if(g.manager_of(team)>=0) continue;
const auto r=squad_range(team);
for(size_t row=selected_player<0?(r.count==16?11:16):0;row<r.count&&entry<0;++row) {
const int player=g.squad_slots.at(r.first+row)&0xfff;
if(player==0xfff||(selected_player>=0&&player!=selected_player)) continue;
auto candidate=g; WatcomRandom candidate_w(37); MinuteReport candidate_report;
if(!list_transfer_player(candidate,int(r.first+row),candidate_w,candidate_report)||candidate_report.unsupported)
continue;
for(int n=0;n<40;++n) if((candidate.squad_slots.at(pool_start+size_t(n))&0xfff)==player){entry=n;break;}
if(entry>=0){g=std::move(candidate);c.seller=team;c.player=player;listing_w=candidate_w;}
}
}
check(entry>=0&&c.seller>=0&&g.manager_of(c.seller)<0,"actual Source AI listing control");
}
check(entry>=0&&entry<40,"control remains ordinary list 0..39");
const uint32_t list=list_start+uint32_t(entry)*row_size;
c.request.list_entry=entry; c.request.bid_slot=bid; c.request.list_address=list;
c.request.source_pool_slot=pool_start+size_t(entry);
c.request.expected_seller=c.seller; c.request.expected_buyer=c.buyer;
c.request.expected_active_manager=1; c.request.raw_offer_slot=-1;
const auto buyer_range=squad_range(c.buyer);
check(buyer_range.count==24,"genuine ordinary 24-slot buyer");
size_t original_hole=24;
for(size_t n=0;n<24;++n) if(g.squad_slots.at(buyer_range.first+n)==0x0fff){original_hole=n;break;}
check(original_hole<24,"genuine fixture buyer capacity");
if(full) {
// 0xffff has a masked empty ID but is NOT the allocator's full 0x0fff.
// This exact distinction creates no duplicate player IDs.
for(size_t n=0;n<24;++n) if(g.squad_slots.at(buyer_range.first+n)==0x0fff)
g.squad_slots.at(buyer_range.first+n)=0xffff;
} else {
const size_t target=first_free<0?original_hole:size_t(first_free);
check(target<24,"declared allocator destination");
if(target!=original_hole) {
std::swap(g.squad_slots.at(buyer_range.first+target),g.squad_slots.at(buyer_range.first+original_hole));
for(size_t n=0;n<row_size;++n)
std::swap(g.tactics.at(board_size+target*row_size+n),g.tactics.at(board_size+original_hole*row_size+n));
}
for(size_t n=0;n<target;++n) if(g.squad_slots.at(buyer_range.first+n)==0x0fff)
g.squad_slots.at(buyer_range.first+n)=0xffff;
c.destination=int(target); g.tactics.at(board_size+target*row_size+6)=0x73;
}
if(human_seller) {
const size_t seller_row=find_player(g,c.seller,c.player)-squad_range(c.seller).first;
g.tactics.at(seller_row*row_size+6)=0x6d;
}
g.memory.set8(::bmh::layout::ActiveManager,1);
g.level=1; // declared scalar control: actual debit/refusal rather than free-play no-op.
wr(g.manager_records,record_size+0x314,10000000);
wr(g.manager_records,record_size+0x31c,0);
g.manager_records.at(record_size+0x170)=0;
if(formed_bid) {
g.memory.set16(list+uint32_t(bid)*2,uint16_t(c.buyer));
g.memory.set32(list+0x1c+uint32_t(bid)*4,c.fee);
g.memory.set32(list+0x0c+uint32_t(bid)*4,c.salary);
g.memory.set8(list+0x34+uint32_t(bid),c.term);
for(uint32_t n=0;n<7;++n) g.memory.set8(list+0x38+uint32_t(bid)*7+n,uint8_t(n+3));
}
return c;
}
Control make_reverse_human_control(GameState& g) {
// Same untouched2PN manager/player ownership; Source listing by manager1
// sells his actual row5 to manager0. No AI/free-player relabelling.
Control c;c.seller_manager=1;c.seller=g.manager_teams.at(1);
c.buyer_manager=0;c.buyer=g.manager_teams.at(0);
WatcomRandom listing_w(37);MinuteReport listing_report;
const auto listed=list_manager_player(g,1,5,listing_w,listing_report);
check(listed.status==TransferActionStatus::accepted&&!listing_report.unsupported,
"reverse actual Source human listing control");
c.player=listed.player;
c.request.list_entry=listed.list_entry;c.request.bid_slot=0;
c.request.list_address=list_start+uint32_t(listed.list_entry)*row_size;
c.request.source_pool_slot=pool_start+size_t(listed.list_entry);
c.request.expected_seller=c.seller;c.request.expected_buyer=c.buyer;
c.request.expected_active_manager=0;c.request.raw_offer_slot=-1;
const auto range=squad_range(c.buyer);
for(size_t row=0;row<24;++row)if(g.squad_slots.at(range.first+row)==0x0fff){c.destination=int(row);break;}
check(c.destination>=0,"reverse genuine human buyer capacity");
g.tactics.at(size_t(c.destination)*row_size+6)=0x73;
const size_t seller_row=find_player(g,c.seller,c.player)-squad_range(c.seller).first;
g.tactics.at(board_size+seller_row*row_size+6)=0x6d;
g.memory.set8(::bmh::layout::ActiveManager,0);g.level=1;
wr(g.manager_records,0x314,10000000);wr(g.manager_records,0x31c,0);
g.manager_records.at(0x170)=0;
return c;
}
Control make_free_control(GameState& g,bool formed_bid=true) {
Control c; c.seller=0x0fff; c.seller_manager=-1;
c.buyer_manager=g.memory.u8(::bmh::layout::ActiveManager); c.buyer=g.manager_teams.at(size_t(c.buyer_manager));
int entry=-1;
for(int n=0;n<40;++n) {
const uint32_t list=list_start+uint32_t(n)*row_size;
const int player=g.squad_slots.at(pool_start+size_t(n))&0xfff;
if(player!=0xfff&&g.memory.u16(list+8)==0x0fff&&g.memory.u16(list)==0xffff){entry=n;c.player=player;break;}
}
check(entry>=0,"untouched genuine Native input contains a canonical free-agent ordinary listing");
const uint32_t list=list_start+uint32_t(entry)*row_size;
c.request.list_entry=entry; c.request.bid_slot=0; c.request.list_address=list;
c.request.source_pool_slot=pool_start+size_t(entry);
c.request.expected_seller=0x0fff;c.request.expected_buyer=c.buyer;
c.request.expected_active_manager=c.buyer_manager;c.request.raw_offer_slot=-1;
c.fee=((g.memory.u32(list+0x2c)/10000u)*12500u)*2u;
c.salary=((100u*g.memory.u32(list+0x30))/10000u)*200u;c.term=12;
check(c.fee>0&&c.salary>0&&rd(g.manager_records,size_t(c.buyer_manager)*record_size+0x314)>c.fee,
"genuine free-agent quote and buyer allowance support ordinary purchase");
check(g.manager_records.at(size_t(c.buyer_manager)*record_size+0x170)==0,
"genuine Native free-agent buyer has no subsidy in this scenario");
for(int team=0;team<138;++team) check(!contains(g,team,c.player),"genuine free agent is not an owned AI/human squad player");
const auto range=squad_range(c.buyer);
for(size_t row=0;row<24;++row) if(g.squad_slots.at(range.first+row)==0xfff){c.destination=int(row);break;}
check(c.destination>=0,"genuine free-agent buyer has allocator capacity");
// Opaque marker is a declared allocator-board control, separate from the
// untouched Native free-agent identity/listing and App-flow fixture below.
g.tactics.at(size_t(c.buyer_manager)*board_size+size_t(c.destination)*row_size+6)=0x73;
if(formed_bid) {
g.memory.set16(list,uint16_t(c.buyer)); g.memory.set32(list+0x1c,c.fee);
g.memory.set32(list+0x0c,c.salary);g.memory.set8(list+0x34,c.term);
for(uint32_t n=0;n<7;++n) g.memory.set8(list+0x38+n,uint8_t(n+3));
}
return c;
}
HumanBuyerSaleHooks observing_hooks(HumanBuyerSaleAllocatorGate gate,
std::vector<Boundary>& observations, WatcomRandom& w, GameRandom& game,
bool paid_checkpoint) {
HumanBuyerSaleHooks h; h.allocator_gate=gate;
h.notice=[&](const GameState& g,const HumanBuyerSaleNotice& n){
auto b=capture(g,w,game,"notice",n.list_entry,n.manager,n.source_text_address,n.original_message,n.source_flags);
b.raw=n.raw_offer_slot; observations.push_back(std::move(b));
};
if(paid_checkpoint) h.after_paid_accounts=[&](GameState& g,const HumanBuyerSalePaid& paid){
check(paid.raw_offer_slot==-1&&paid.buyer_manager>=0&&paid.buyer_manager<4&&paid.bid_slot>=0&&paid.bid_slot<4,
"shared paid callback ordinary source identity");
observations.push_back(capture(g,w,game,"paid",paid.list_entry));
};
return h;
}
void check_bids(const GameState& after,const GameState& before,uint32_t list) {
for(uint32_t n=0;n<4;++n)
check(after.memory.u16(list+n*2)==before.memory.u16(list+n*2),"shared/direct settlement preserves all four bid words");
}
void settlement_case(GameState input,const Control& c,HumanBuyerSaleAllocatorGate gate,
HumanBuyerSaleStatus wanted,const std::string& label) {
auto source=input,product=input;
WatcomRandom source_w(0x13579),product_w(0x13579); GameRandom source_g(73),product_g(73);
const auto expected=source_settle(source,c.request,gate,source_w,source_g,false,true);
std::vector<Boundary> observed; auto hooks=observing_hooks(gate,observed,product_w,product_g,true);
MinuteReport report;
const auto actual=settle_human_buyer_sale(product,c.request,hooks,product_w,report);
check(!report.unsupported&&actual.status==wanted&&expected.status==wanted,label+": actual/Source outcome");
check(actual.player==c.player&&actual.seller==c.seller&&actual.buyer==c.buyer&&
actual.seller_manager==c.seller_manager&&actual.buyer_manager==c.buyer_manager&&
actual.raw_fee==c.fee&&actual.adjusted_fee==expected.adjusted,label+": result identity/raw/adjusted fee");
compare(capture(product,product_w,product_g,"final",c.request.list_entry),
capture(source,source_w,source_g,"final",c.request.list_entry),label);
check(observed.size()==expected.observations.size(),label+": notice/paid checkpoint count");
for(size_t n=0;n<observed.size();++n) compare(observed[n],expected.observations[n],label+" checkpoint "+std::to_string(n));
check_bids(product,input,c.request.list_address);
check(product_g.seed()==73&&product_g.calls()==0,label+": Source settlement never consumes G");
if(wanted==HumanBuyerSaleStatus::moved) {
check(contains(product,c.buyer,c.player)&&!contains(product,c.seller,c.player),label+": actual ownership move");
check((product.squad_slots.at(find_player(product,c.buyer,c.player))&0x2000)==
(input.squad_slots.at(c.request.source_pool_slot)&0x2000),label+": full pool word flag follows player");
const size_t row=find_player(product,c.buyer,c.player)-squad_range(c.buyer).first;
const size_t board=size_t(c.buyer_manager)*board_size+row*row_size;
check(product.tactics.at(board+6)==(c.seller_manager<0?0x73:0x6d),
label+": AI keeps initialized buyer board, human inherits seller board");
check(rd(product.tactics,board+0x54)==c.fee&&rd(product.tactics,board+0x50)==c.salary&&
product.tactics.at(board+0xc)==c.term,label+": raw fee/salary/sale term survive lineup");
check(product.squad_slots.at(c.request.source_pool_slot)==0x0fff,label+": Source success removes ordinary pool");
if(c.seller==0x0fff) {
const size_t base=size_t(c.buyer_manager)*record_size;
check(rd(product.manager_records,base+0x7d8)==uint32_t(product.player_name_offsets.at(size_t(c.player)))+0xffff0000u,
label+": format field free-agent counterpart is FFFF sentinel");
for(size_t at=pool_start;at<3072;++at) {
check((product.squad_slots.at(at)&0xfff)!=c.player,label+": all free-pool aliases removed through final slot3071");
if((input.squad_slots.at(at)&0xfff)!=c.player)
check(product.squad_slots.at(at)==input.squad_slots.at(at),label+": unrelated free-pool words retained");
}
}
if(c.seller_manager<0) {
check(std::equal(product.manager_records.begin()+std::ptrdiff_t(size_t(1-c.buyer_manager)*record_size),
product.manager_records.begin()+std::ptrdiff_t(size_t(2-c.buyer_manager)*record_size),
input.manager_records.begin()+std::ptrdiff_t(size_t(1-c.buyer_manager)*record_size)),label+": unrelated human manager gets no AI seller accounting/history");
}
} else {
check(product.squad_slots.at(c.request.source_pool_slot)==input.squad_slots.at(c.request.source_pool_slot)&&
product.squad_slots==input.squad_slots&&product.tactics==input.tactics,
label+": expected non-move retains pool, squads and boards");
check(product_w.calls()==0,label+": expected refusal/blocked/no-room has no allocator W draws");
if(wanted!=HumanBuyerSaleStatus::funds_refused)
check(rd(product.manager_records,size_t(c.buyer_manager)*record_size+0x330)==rd(input.manager_records,size_t(c.buyer_manager)*record_size+0x330)+expected.adjusted,
label+": allocator refusal retains already-paid ledger");
}
std::printf("PASS %s W=%llu G=%llu checkpoints=%zu\n",label.c_str(),
static_cast<unsigned long long>(product_w.calls()),static_cast<unsigned long long>(product_g.calls()),observed.size());
}
// Independent legacy routine qualifier for the genuine opening-season Native
// controls used below. No production rating/bonus/settlement API is an oracle.
// The independently composed settlement below remains its original contract.
struct SourcePcts { uint32_t fee=0,salary=0; };
SourcePcts source_direct_rating(const GameState& g,const HumanBuyerSaleRequest& request,WatcomRandom& w) {
const uint32_t list=request.list_address,b=uint32_t(request.bid_slot);
const uint8_t term=g.memory.u8(list+0x34+b);
const uint8_t q=uint8_t((int(term&127)-1)/12);
uint32_t fee_base=(g.memory.u32(list+0x2c)/10000u)*12500u;
if(term&128)fee_base>>=2;
const uint32_t salary_base=(((uint32_t(q)*20u+100u)*g.memory.u32(list+0x30))/10000u)*100u;
check(fee_base!=0&&salary_base!=0,"independent direct Source denominators");
SourcePcts result;
result.fee=(g.memory.u32(list+0x1c+b*4)*100u)/fee_base;
uint32_t salary=g.memory.u32(list+0x0c+b*4);
const int bidder=int(int16_t(g.memory.u16(list+b*2)));
int manager=-1;
for(size_t m=0;m<g.manager_teams.size();++m)if(g.manager_teams[m]==bidder)manager=int(m);
if(manager>=0) {
// Source opening-day fallback rank11. Nonopening mode4 results have
// separate full result-composition coverage in qualification_tests.
check(bidder>=0&&bidder<90&&g.league_rounds.at(size_t(bidder/18))<2,
"direct oracle explicitly bounded to genuine opening Native prediction fallback");
const int player=g.squad_slots.at(request.source_pool_slot)&0xfff;
const auto& p=g.players.at(size_t(player));
int sum=0;
for(size_t slot=size_t(bidder)*24;slot<size_t(bidder+1)*24;++slot) {
const uint16_t word=g.squad_slots.at(slot);
if(word==0x0fff||!(word&0x8000))continue;
const auto& member=g.players.at(word&0xfff);
sum+=int(member.w35c>>7&127)+int(member.w35c>>14&127);
}
const int average=std::max(1,std::clamp((sum/2)/11,0,99));
const int strength=int(((p.w35c>>7&127)+(p.w35c>>14&127))>>1);
const int gap=std::max(-1,int(int16_t(average-strength)));
const int goals[]={0,2,4,8};
const int times[]={std::max(0,goals[p.w364&3]-gap),34,std::max(0,25-gap*5)};
uint32_t bonus=0;
for(uint32_t k=0;k<3;++k) {
const uint32_t rate=g.memory.u8(list+0x38+b*7+k);
bonus+=(((rate*salary)/100u)*uint32_t(times[k]))/12u;
}
// In all five18-team leagues rank11 selects the staying-up prämie6
// (18-relegation is14..16). All seven source bytes remain staged.
const uint32_t season=(5u*uint32_t(g.memory.u8(list+0x38+b*7+6))*salary)/100u;
bonus+=season/12u;
salary+=bonus;
}
result.salary=(salary*100u)/salary_base;
if(result.fee<uint32_t(w.range(90,100)))result.fee=0;
if(result.salary<g.memory.u8(list+0x55))result.salary=0;
return result;
}
int source_capacity_count(const GameState& g,int buyer) {
int count=0;const auto range=squad_range(buyer);
for(size_t at=range.first;at<range.first+range.count;++at)
if((g.squad_slots.at(at)&0xfff)!=0xfff)++count;
for(uint32_t n=0;n<200;++n) {
const uint32_t loan=g.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField+n*4);
if(loan!=0&&int(loan>>12&0x3ff)==buyer)++count;
}
return count&255;
}
// Direct format field ordinary caller: editor values -> exact425ee -> mode
// salary threshold -> strict fee threshold -> DeskActions_SubmitTransferBidImpl_ExecutableField -> unchanged settlement.
// Full1b556 display/redraw/quote is owned by its UI caller, not manufactured here.
void direct_case(GameState input,const Control& c,HumanBuyerSaleAllocatorGate gate,
TransferActionStatus wanted,const std::string& label,
const std::vector<uint32_t>& wanted_notices={}, uint32_t wanted_adjusted=0,
bool cheap_fee_override=false) {
TransferBidRequest bid; bid.manager=c.buyer_manager; bid.list_entry=c.request.list_entry; bid.player=c.player;
bid.source_slot=int(c.request.source_pool_slot);
bid.contract_years=c.seller==0x0fff?1:2;
const uint32_t list=c.request.list_address;
const uint32_t fee_base=(input.memory.u32(list+0x2c)/10000u)*12500u;
const uint32_t salary_base=((uint32_t((bid.contract_years-1)*20+100)*input.memory.u32(list+0x30))/10000u)*100u;
check(fee_base>0&&salary_base>0,"direct real listing denominator");
bid.fee=int32_t(cheap_fee_override?(fee_base*90u)/100u:fee_base*2u);
bid.annual_salary=int32_t(salary_base*2u);
for(size_t n=0;n<7;++n) bid.bonuses[n]=uint32_t(n+3);
// The previous pure-settlement FULLWORD control used FFFF. Real425ee
// fitness must not read its flagged Player4095. This separately declared
// qualification control uses nonlineup7FFF for masked-empty full words;
// the1c7df exact0FFF allocator still has no room. No duplicate real player.
const auto buyer_range=squad_range(c.buyer);
for(size_t at=buyer_range.first;at<buyer_range.first+buyer_range.count;++at)
if(input.squad_slots.at(at)==0xffff)input.squad_slots.at(at)=0x7fff;
auto source=input,product=input; auto request=c.request;
check(source_capacity_count(source,c.buyer)+int(int8_t(source.memory.u8(::bmh::layout::DeskActions_Unsupported_RuntimeField+uint32_t(c.buyer_manager))))!=23,
"direct successful controls pass exact Source capacity equality gate");
request.bid_slot=0;
while(request.bid_slot<4&&source.memory.u16(list+uint32_t(request.bid_slot)*2)!=0xffff) ++request.bid_slot;
check(request.bid_slot<4,"direct free raw bid slot");
WatcomRandom source_w(0x13579),product_w(0x13579); GameRandom source_g(73),product_g(73);
const uint32_t b=uint32_t(request.bid_slot);
source.memory.set16(list+b*2,uint16_t(c.buyer));
source.memory.set32(list+0x1c+b*4,uint32_t(bid.fee));
source.memory.set32(list+0x0c+b*4,uint32_t(bid.annual_salary));
source.memory.set8(list+0x34+b,uint8_t(bid.contract_years*12));
for(uint32_t n=0;n<7;++n) source.memory.set8(list+0x38+b*7+n,uint8_t(bid.bonuses[n]));
auto percentages=source_direct_rating(source,request,source_w);
const int mode=source.memory.u8(::bmh::layout::GameMode);
check(mode>=1&&mode<=3,"actual saved Source career mode");
const uint32_t salary_threshold=mode==1?100u:uint32_t(source_w.range(mode==2?90:120,mode==2?110:190));
check(percentages.salary>=salary_threshold,"direct successful Source salary gate");
if(mode!=3)percentages.fee=200;
check(uint32_t(source_w.range(92,150))<percentages.fee,"direct successful strict Source fee gate");
const uint64_t qualification_calls=source_w.calls();
check(qualification_calls==uint64_t(mode==1?2:3),"hard mode-dependent Source qualification draw count");
const auto expected=source_settle(source,request,gate,source_w,source_g,true,false);
std::vector<Boundary> observed; auto hooks=observing_hooks(gate,observed,product_w,product_g,false);
hooks.direct_mode=HumanBuyerSaleDirectMode::ordinary_ai_purchase;
MinuteReport report;
const auto actual=submit_transfer_bid_source_human_buyer(product,bid,product_w,hooks,report);
check(!report.unsupported&&actual.status==wanted,label+": direct typed result");
compare(capture(product,product_w,product_g,"final",c.request.list_entry),
capture(source,source_w,source_g,"final",c.request.list_entry),label);
check(observed.size()==expected.observations.size()&&!observed.empty()&&observed[0].address==::bmh::layout::DeskActions_SubmitTransferBidImpl_ExecutableField,
label+": caller ACK precedes shared account notices");
for(size_t n=0;n<observed.size();++n) compare(observed[n],expected.observations[n],label+" checkpoint "+std::to_string(n));
check_bids(product,source,list);
// Compare the consumed settlement's actual hard Source outcome separately
// from the full snapshot oracle: paid non-moves are expected partials,
// never rollback/unsupported and never blanket list/bid consumption.
const auto source_status = wanted==TransferActionStatus::accepted ? HumanBuyerSaleStatus::moved
: wanted==TransferActionStatus::allocator_blocked ? HumanBuyerSaleStatus::allocator_blocked
: wanted==TransferActionStatus::no_squad_room ? HumanBuyerSaleStatus::no_room
: HumanBuyerSaleStatus::funds_refused;
check(expected.status==source_status,label+": hard Source settlement outcome");
if(!wanted_notices.empty()) {
std::vector<uint32_t> addresses;
for(const auto& n:observed) addresses.push_back(n.address);
check(addresses==wanted_notices,label+": exact direct ACK/account-notice order");
}
if(wanted_adjusted!=0) check(expected.adjusted==wanted_adjusted,label+": exact adjusted amount");
if(wanted_adjusted!=0&&wanted_adjusted!=uint32_t(bid.fee))
check(product.manager_records.at(size_t(c.buyer_manager)*record_size+0x170)==0,
label+": qualifying subsidy consumed even when later payment refuses");
for(const auto& n:observed)
check(n.manager==c.buyer_manager&&n.active==c.buyer_manager,label+": actual active buyer owns direct af304/subsidy/funds/no-room notice");
for(uint32_t n=0;n<4;++n) if(int(n)!=request.bid_slot)
check(product.memory.u16(list+n*2)==input.memory.u16(list+n*2),label+": every competing ordinary bid survives");
check(product.memory.u16(list+b*2)==uint16_t(c.buyer)&&
product.memory.u32(list+0x1c+b*4)==uint32_t(bid.fee)&&
product.memory.u32(list+0x0c+b*4)==uint32_t(bid.annual_salary),
label+": actual submitted ordinary buyer/raw fee/salary retained after settlement");
const size_t br=size_t(c.buyer_manager)*record_size;
if(wanted==TransferActionStatus::accepted) {
check(contains(product,c.buyer,c.player)&&!contains(product,c.seller,c.player)&&
product.squad_slots.at(c.request.source_pool_slot)==0x0fff,label+": format field actual move/pool removal");
check(rd(product.manager_records,br+0x314)==rd(input.manager_records,br+0x314)-expected.adjusted&&
rd(product.manager_records,br+0x330)==rd(input.manager_records,br+0x330)+expected.adjusted,
label+": direct adjusted cash and transfer ledger");
if(c.seller_manager>=0) {
const size_t sr=size_t(c.seller_manager)*record_size;
check(rd(product.manager_records,sr+0x314)==rd(input.manager_records,sr+0x314)+expected.adjusted&&
rd(product.manager_records,sr+0x330)==rd(input.manager_records,sr+0x330)-expected.adjusted,
label+": Source human seller adjusted credit and opposite ledger");
const size_t old_row=find_player(input,c.seller,c.player)-squad_range(c.seller).first;
const size_t new_row=find_player(product,c.buyer,c.player)-squad_range(c.buyer).first;
check(product.tactics.at(size_t(c.buyer_manager)*board_size+new_row*row_size+6)==
input.tactics.at(size_t(c.seller_manager)*board_size+old_row*row_size+6),
label+": human seller board marker inherited after allocator initializer");
check(rd(product.manager_records,sr+0x760)==product.date*4u+(uint32_t(bid.fee)/10000u)*0x80000u,
label+": human seller history uses raw sale fee and sale flag");
}
const size_t row=find_player(product,c.buyer,c.player)-squad_range(c.buyer).first;
check(rd(product.tactics,size_t(c.buyer_manager)*board_size+row*row_size+0x54)==uint32_t(bid.fee)&&
rd(product.manager_records,br+0x760)==product.date*4u+1u+(uint32_t(bid.fee)/10000u)*0x80000u,
label+": direct board/history retain RAW fee despite subsidy");
} else {
check(product.squad_slots==input.squad_slots&&product.tactics==input.tactics&&
product.squad_slots.at(c.request.source_pool_slot)==input.squad_slots.at(c.request.source_pool_slot),
label+": expected direct non-move retains ordinary pool/squads/boards");
check(product_w.calls()==qualification_calls&&product_g.calls()==0,
label+": exact Source qualification W sequence, no allocator W or G");
const bool funds=wanted==TransferActionStatus::insufficient_funds;
check(rd(product.manager_records,br+0x314)==rd(input.manager_records,br+0x314)-(funds?0u:expected.adjusted)&&
rd(product.manager_records,br+0x330)==rd(input.manager_records,br+0x330)+(funds?0u:expected.adjusted),
label+": expected funds versus paid-allocator partial accounting");
check(rd(product.manager_records,br+0x760)==rd(input.manager_records,br+0x760)&&
rd(product.manager_records,br+0x7d8)==rd(input.manager_records,br+0x7d8),
label+": non-move has no buyer transfer history");
}
for(const auto& n:observed) check(n.address!=::bmh::layout::PendingOffer_FormatError_ExecutableField2&&n.address!=::bmh::layout::Weekly_PendingSettle_TextPointer&&n.address!=::bmh::layout::PendingOffer_PendingOfferNoticeDialog_ExecutableField4,
label+": direct caller has no pending buyer-success/severance notice");
check(!product.memory.has(::bmh::layout::DeskActions_EditorFail_RuntimeField2)&&!product.memory.has(::bmh::layout::Weekly_PendingSettleHumanBuyer_RuntimeField)&&!product.memory.has(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField2),
label+": normal runtime proof does not invent Native BSS bytes");
std::printf("PASS %s W=%llu notices=%zu\n",label.c_str(),static_cast<unsigned long long>(product_w.calls()),observed.size());
}
// Independently composed legacy routine branches that retain the ordinary bid.
// Editor staging is explicit and compared as a complete Native snapshot; no
// production qualification or settlement helper supplies the expected state.
enum class RetainedKind { salary_refused, fee_refused, existing_bid, capacity };
void retained_case(GameState input,const Control& c,int mode,RetainedKind kind,const std::string& label) {
input.memory.set8(::bmh::layout::GameMode,uint8_t(mode));
if(kind==RetainedKind::capacity) {
const int missing=23-source_capacity_count(input,c.buyer);
check(missing>=0&&missing<=3,"declared valid saved loan-counter capacity control");
input.memory.set8(::bmh::layout::DeskActions_Unsupported_RuntimeField+uint32_t(c.buyer_manager),uint8_t(missing));
}
const uint32_t list=c.request.list_address;
TransferBidRequest bid;bid.manager=c.buyer_manager;bid.list_entry=c.request.list_entry;bid.player=c.player;
bid.source_slot=int(c.request.source_pool_slot);bid.contract_years=2;
const uint32_t fee_base=(input.memory.u32(list+0x2c)/10000u)*12500u;
const uint32_t salary_base=((120u*input.memory.u32(list+0x30))/10000u)*100u;
check(fee_base&&salary_base,"retained real Source listing denominators");
bid.fee=int32_t(kind==RetainedKind::fee_refused?(fee_base*90u)/100u:fee_base*2u);
bid.annual_salary=int32_t(kind==RetainedKind::salary_refused?salary_base/2u:salary_base*2u);
// All seven editor bytes are meaningful even in modes1/2. Salary-refusal
// vectors have zero premiums so no extra projected pay rescues the offer.
if(kind!=RetainedKind::salary_refused)
bid.bonuses={11,22,33,44,55,66,77};
if(kind==RetainedKind::salary_refused)input.memory.set8(list+0x55,100);
auto request=c.request;request.bid_slot=0;
if(kind==RetainedKind::existing_bid) {
request.bid_slot=2;
input.memory.set16(list+4,uint16_t(c.buyer));
input.memory.set32(list+0x24,17);input.memory.set32(list+0x14,19);
input.memory.set8(list+0x36,12);
for(uint32_t n=0;n<7;++n)input.memory.set8(list+0x46+n,1);
} else {
while(request.bid_slot<4&&input.memory.u16(list+uint32_t(request.bid_slot)*2)!=0xffff)++request.bid_slot;
check(request.bid_slot<4,"retained Source free bidder slot");
}
auto source=input,product=input;
WatcomRandom source_w(0x13579),product_w(0x13579);GameRandom source_g(73),product_g(73);
std::vector<Boundary> expected,observed;
const auto notice=[&](uint32_t address,std::string text={},uint16_t flags=0x80) {
expected.push_back(capture(source,source_w,source_g,"notice",request.list_entry,c.buyer_manager,
address,text.empty()?message_text(source,address):std::move(text),flags));
};
const bool capacity=source_capacity_count(source,c.buyer)+int(int8_t(source.memory.u8(::bmh::layout::DeskActions_Unsupported_RuntimeField+uint32_t(c.buyer_manager))))==23;
if(capacity) {
check(kind==RetainedKind::capacity,"only capacity vector stops before editor writes");
notice(::bmh::layout::DeskActions_Unsupported_ExecutableField,{},0x40);
} else {
const uint32_t b=uint32_t(request.bid_slot);
source.memory.set16(list+b*2,uint16_t(c.buyer));
source.memory.set32(list+0x1c+b*4,uint32_t(bid.fee));
source.memory.set32(list+0x0c+b*4,uint32_t(bid.annual_salary));
source.memory.set8(list+0x34+b,uint8_t(bid.contract_years*12));
for(uint32_t n=0;n<7;++n)source.memory.set8(list+0x38+b*7+n,uint8_t(bid.bonuses[n]));
if(kind!=RetainedKind::existing_bid) {
auto pct=source_direct_rating(source,request,source_w);
const uint32_t threshold=mode==1?100u:uint32_t(source_w.range(mode==2?90:120,mode==2?110:190));
if(pct.salary<threshold) {
check(kind==RetainedKind::salary_refused,"independent Source salary short circuit");
notice(::bmh::layout::DeskActions_Unsupported_ExecutableField3,source.player_name(c.player)+message_text(source,::bmh::layout::DeskActions_Unsupported_ExecutableField3));
} else {
if(mode!=3)pct.fee=200;
if(uint32_t(source_w.range(92,150))>=pct.fee) {
check(kind==RetainedKind::fee_refused,"independent strict Source fee failure");
const bool free=source.memory.u16(list+8)==0x0fff;
notice(free?::bmh::layout::DeskActions_Unsupported_ExecutableField2 : ::bmh::layout::DeskActions_Unsupported_TextPointer3,free?message_text(source,::bmh::layout::DeskActions_Unsupported_ExecutableField2):source.club_name(c.seller)+message_text(source,::bmh::layout::DeskActions_Unsupported_TextPointer3));
} else {
check(false,"retained oracle must not invent a pending branch after a passed ordinary fee gate");
}
}
}
}
auto hooks=observing_hooks(HumanBuyerSaleAllocatorGate::zero,observed,product_w,product_g,false);
hooks.direct_mode=HumanBuyerSaleDirectMode::ordinary_ai_purchase;
MinuteReport report;
const auto result=submit_transfer_bid_source_human_buyer(product,bid,product_w,hooks,report);
check(!report.unsupported&&result.status==(capacity?TransferActionStatus::no_squad_room:TransferActionStatus::pending),
label+": expected retained typed result");
compare(capture(product,product_w,product_g,"final",request.list_entry),
capture(source,source_w,source_g,"final",request.list_entry),label);
check(observed.size()==expected.size(),label+": exact Source notice count");
for(size_t n=0;n<observed.size();++n)compare(observed[n],expected[n],label+" notice "+std::to_string(n));
const uint64_t wanted_calls=kind==RetainedKind::capacity||kind==RetainedKind::existing_bid?0u:
kind==RetainedKind::salary_refused?uint64_t(mode==1?1:2):uint64_t(mode==1?2:3);
check(product_w.calls()==wanted_calls&&product_g.calls()==0,label+": hard Source short-circuit RNG count");
check(product.squad_slots==input.squad_slots&&product.tactics==input.tactics&&
product.manager_records==input.manager_records,label+": retained bid has no accounts/allocation/history/board mutation");
for(uint32_t n=0;n<4;++n)if(capacity||int(n)!=request.bid_slot)
for(uint32_t at:{n*2,n*2+1,0x0c+n*4,0x0d+n*4,0x0e + n*4,0x0f+n*4,
0x1c+n*4,0x1d+n*4,0x1e + n*4,0x1f+n*4,0x34+n})
check(product.memory.u8(list+at)==input.memory.u8(list+at),label+": competing or capacity-blocked bid retained");
if(!capacity) {
const uint32_t b=uint32_t(request.bid_slot);
check(product.memory.u16(list+b*2)==uint16_t(c.buyer)&&
product.memory.u32(list+0x1c+b*4)==uint32_t(bid.fee)&&
product.memory.u32(list+0x0c+b*4)==uint32_t(bid.annual_salary)&&
product.memory.u8(list+0x34+b)==24,label+": exact posted fee/salary/months persist");
for(uint32_t n=0;n<7;++n)
check(product.memory.u8(list+0x38+b*7+n)==bid.bonuses[n],label+": all seven posted bonuses persist");
}
std::printf("PASS %s W=%llu notices=%zu\n",label.c_str(),static_cast<unsigned long long>(product_w.calls()),observed.size());
}
void unsupported_case(GameState input,HumanBuyerSaleRequest request,HumanBuyerSaleHooks hooks,const std::string& label) {
const auto before=save_stream(input); const auto before_suppressed=input.transfer_notice_suppressed;
WatcomRandom w(0x13579); size_t callbacks=0;
hooks.notice=[&](const GameState&,const HumanBuyerSaleNotice&){++callbacks;};
hooks.before_accounts=[&](const GameState&,const HumanBuyerSaleRequest&){++callbacks;};
hooks.after_paid_accounts=[&](GameState&,const HumanBuyerSalePaid&){++callbacks;};
MinuteReport report;
const auto result=settle_human_buyer_sale(input,request,hooks,w,report);
check(result.status==HumanBuyerSaleStatus::unsupported&&report.unsupported&&callbacks==0&&
w.seed()==0x13579&&w.calls()==0&&save_stream(input)==before&&
input.transfer_notice_suppressed==before_suppressed,label+": deterministic unsupported before mutation/presentation");
// Transactional owner rollback belongs to actual CareerSession/App tests;
// this is common deterministic preflight, not a synthetic owner test.
}
GameState pitch_fixture(GameState g) {
constexpr int manager=0, team=1;
g.memory.add_block(::bmh::layout::ActiveManager,1); g.memory.set8(::bmh::layout::ActiveManager,uint8_t(manager));
g.memory.add_block(::bmh::layout::GameMode,1); g.memory.set8(::bmh::layout::GameMode,2);
g.manager_teams.at(manager)=team;
g.manager_records.at(size_t(manager)*record_size+0x290)=uint8_t(team);
g.manager_records.at(size_t(manager)*record_size+0x291)=0;
g.manager_records.at(size_t(manager)*record_size+0x218)=0;
g.manager_records.at(size_t(manager)*record_size+0x288)=0;
g.manager_options.at(size_t(manager)*5)=0;
g.indoor=false; g.lineups_frozen=false; g.level=0;
const size_t badge=size_t(team)*2;
g.club_heap_78.at(badge+1)&=uint8_t(~0x02u);
const auto range=squad_range(team);
for(size_t row=0;row<11;++row) {
auto& slot=g.squad_slots.at(range.first+row);
slot=uint16_t((slot&0x0fff)|0x8000);
const size_t id=slot&0x0fff;
g.players.at(id).w364&=~(uint32_t(0x1f)<<16);
}
const size_t board=size_t(manager)*board_size;
for(size_t row=0;row<24;++row) g.tactics.at(board+row*row_size+0x3f)=0xff;
for(size_t row=0;row<11;++row) {
g.tactics.at(board+row*row_size+0x41)=uint8_t(row);
g.tactics.at(board+row*row_size+0x42)=4;
}
return g;
}
void pitch_engine_cases(const GameState& original) {
constexpr int manager=0, team=1;
const size_t record=size_t(manager)*record_size, board=size_t(manager)*board_size;
const auto range=squad_range(team);
// Controlled mode cross-product: the same manager owns independent
// outdoor/indoor masks and formation tables, while the badge follows the
// live runtime mode exactly as legacy routine does on a qualified entry.
{
auto g=pitch_fixture(original);
g.indoor=true;
g.club_heap_78.at(size_t(team)*2+1)|=0x02;
g.manager_records.at(record+0x218)=0x80;
g.manager_records.at(record+0x219)=0x01;
const size_t indoor_table=size_t(manager)*0x160+0xb0+4*0x16;
const size_t outdoor_table=size_t(manager)*0x160+4*0x16;
for(size_t row=0;row<11;++row) {
g.formations.at(indoor_table+row)=uint8_t(row+1);
g.formations.at(indoor_table+11+row)=uint8_t(8-row%8);
}
const auto positions=std::array<uint8_t,22>{
0,1,2,3,4,5,6,7,8,9,10, 4,4,4,4,4,4,4,4,4,4,4};
auto expected=g;
std::copy(positions.begin(),positions.end(),expected.formations.begin()+std::ptrdiff_t(indoor_table));
expected.manager_records.at(record+0x219)|=0x10;
expected.manager_options.at(0)=5; auto_lineup(expected,team,0xe4);
check(save_pitch_formation_source(g,manager,team,4,g.manager_records.at(record+0x288),positions),
"indoor own formation saves through manager*0x160+0xb0 and mask+0x219");
check(save_stream(g)==save_stream(expected)&&g.manager_records.at(record+0x218)==0x80&&
std::any_of(g.formations.begin()+std::ptrdiff_t(outdoor_table),
g.formations.begin()+std::ptrdiff_t(outdoor_table+22),
[](uint8_t v){return v!=0;}),
"indoor own save/optimizer preserves outdoor mask and formation bytes");
auto applied=pitch_fixture(original); applied.indoor=true;
applied.club_heap_78.at(size_t(team)*2+1)|=0x02;
applied.manager_records.at(record+0x218)=1; applied.manager_records.at(record+0x219)=1;
std::copy(positions.begin(),positions.end(),applied.formations.begin()+std::ptrdiff_t(size_t(manager)*0x160+0xb0));
auto apply_expected=applied; apply_expected.manager_options.at(0)=1; auto_lineup(apply_expected,team,0xe4);
check(apply_pitch_formation_source(applied,manager,team,0,applied.manager_records.at(record+0x288))&&
save_stream(applied)==save_stream(apply_expected)&&applied.manager_records.at(record+0x218)==1,
"indoor preset selects its own mask/table and leaves outdoor availability intact");
auto mismatched=pitch_fixture(original); mismatched.indoor=true;
auto mismatch_expected=mismatched;
mismatch_expected.manager_records.at(record+0x288)=1;
check(set_pitch_automatic_weight_source(mismatched,manager,team,0,0,1)&&save_stream(mismatched)==save_stream(mismatch_expected),
"Source-valid indoor assistant state accepts a weight action without badge normalization");
}
{
auto indoor=pitch_fixture(original); indoor.indoor=true;
indoor.club_heap_78.at(size_t(team)*2+1)|=0x02;
const size_t candidate=board+5*row_size;
indoor.tactics.at(candidate+0x41)=2; indoor.tactics.at(candidate+0x42)=5;
// Seed a valid old pair and a 12th-row reference to the new Source partner.
indoor.tactics.at(board+0x3f)=7; indoor.tactics.at(board+7*row_size+0x3f)=0;
indoor.tactics.at(board+12*row_size+0x3f)=5;
const uint16_t slot=indoor.squad_slots.at(range.first); const int id=slot&0x0fff;
check(move_pitch_player_source(indoor,manager,team,0,id,slot,0,4,1,5),
"indoor Source move accepts the adjacent free target");
check(indoor.tactics.at(board+0x41)==1&&indoor.tactics.at(board+0x42)==5&&
indoor.tactics.at(board+0x3f)==5&&indoor.tactics.at(candidate+0x3f)==0,
"indoor move installs reciprocal partner rows");
check(indoor.tactics.at(board+7*row_size+0x3f)==0xff&&
indoor.tactics.at(board+12*row_size+0x3f)==0xff,
"indoor move clears selected/new partner links across all 24 rows before reassignment");
auto outdoor=pitch_fixture(original);
outdoor.tactics.at(candidate+0x41)=2; outdoor.tactics.at(candidate+0x42)=5;
const auto unchanged=save_stream(outdoor); const auto board_before=outdoor.tactics;
const auto outdoor_slot=outdoor.squad_slots.at(range.first);
check(!move_pitch_player_source(outdoor,manager,team,0,outdoor_slot&0x0fff,outdoor_slot,0,4,1,5)&&
save_stream(outdoor)==unchanged&&outdoor.tactics==board_before,
"the same adjacent move remains a neutral outdoor rejection");
}
{
auto g=pitch_fixture(original);
const uint8_t before=0xff;
for(int field=0;field<3;++field) {
g.manager_records.at(record+0x288)=before;
auto expected_state=g;
const unsigned shift=unsigned(field*2);
const uint8_t expected=uint8_t(before&uint8_t(~(3u<<shift)));
expected_state.manager_records.at(record+0x288)=expected;
check(set_pitch_automatic_weight_source(g,manager,team,field,before,expected),
"pitch weight cycles selected 3 field to 0");
check(g.manager_records.at(record+0x288)==expected&&save_stream(g)==save_stream(expected_state),
"pitch weight changes only selected field and preserves reserved bits");
}
const auto native=save_stream(g); const auto records=g.manager_records;
check(!set_pitch_automatic_weight_source(g,manager,team,0,0xff,0xfe)&&
save_stream(g)==native&&g.manager_records==records,"pitch weight stale byte refusal is neutral");
g.memory.set8(::bmh::layout::GameMode,1);
const auto mode_one=save_stream(g); const auto mode_records=g.manager_records;
check(!set_pitch_automatic_weight_source(g,manager,team,0,g.manager_records.at(record+0x288),
uint8_t(g.manager_records.at(record+0x288)+1))&&save_stream(g)==mode_one&&
g.manager_records==mode_records,"pitch automatic weight refuses Source mode I neutrally");
}
{
auto g=pitch_fixture(original);
g.tactics.at(board+0x3f)=1; g.tactics.at(board+row_size+0x3f)=0;
g.tactics.at(board+2*row_size+0x3f)=1;
const auto chosen=g.squad_slots.at(range.first); const int id=chosen&0x0fff;
check(move_pitch_player_source(g,manager,team,0,id,chosen,0,4,19,8),
"pitch move accepts free boundary coordinate");
check(g.tactics.at(board+0x41)==19&&g.tactics.at(board+0x42)==8&&
g.manager_options.at(size_t(manager)*5)==0,"pitch free move sets coordinates and manual AA");
check(g.tactics.at(board+row_size+0x3f)==0xff&&g.tactics.at(board+0x3f)==0xff,
"pitch free move clears selected partner references");
check(g.tactics.at(board+2*row_size+0x3f)==1,
"pitch outdoor free move leaves unrelated references to old partner intact");
auto injured_overlap=pitch_fixture(original);
injured_overlap.players.at(injured_overlap.squad_slots.at(range.first+10)&0x0fff).w364|=(1u<<16);
injured_overlap.tactics.at(board+10*row_size+0x41)=19;
injured_overlap.tactics.at(board+10*row_size+0x42)=8;
const auto overlap_slot=injured_overlap.squad_slots.at(range.first);
check(move_pitch_player_source(injured_overlap,manager,team,0,overlap_slot&0x0fff,
overlap_slot,0,4,19,8),"pitch fit player may move onto an injured row's coordinate");
check(injured_overlap.tactics.at(board+0x41)==19&&injured_overlap.tactics.at(board+0x42)==8&&
int8_t(injured_overlap.tactics.at(board+10*row_size+0x41))==19,
"pitch injured overlap retains both Source coordinates");
check(set_pitch_automatic_weight_source(injured_overlap,manager,team,0,0,1)&&
injured_overlap.manager_records.at(record+0x288)==1,
"pitch injured overlap remains valid for a subsequent Source action");
auto stale=pitch_fixture(original); const auto stale_native=save_stream(stale);
const auto stale_tactics=stale.tactics; const auto stale_options=stale.manager_options;
check(!move_pitch_player_source(stale,manager,team,0,id,chosen,1,4,19,8)&&
save_stream(stale)==stale_native&&stale.tactics==stale_tactics&&
stale.manager_options==stale_options,"pitch stale old coordinate refusal is neutral");
auto adjacent=pitch_fixture(original);
adjacent.tactics.at(board+5*row_size+0x41)=1;
adjacent.tactics.at(board+5*row_size+0x42)=5;
const auto adjacent_before=save_stream(adjacent);
const auto adjacent_tactics=adjacent.tactics;
check(!move_pitch_player_source(adjacent,manager,team,0,id,chosen,0,4,1,5)&&
save_stream(adjacent)==adjacent_before&&adjacent.tactics==adjacent_tactics,
"pitch row-order move refuses earlier adjacent player before later exact occupant");
auto exact_first=pitch_fixture(original);
exact_first.tactics.at(board+row_size+0x41)=1; exact_first.tactics.at(board+row_size+0x42)=5;
exact_first.tactics.at(board+5*row_size+0x41)=2; exact_first.tactics.at(board+5*row_size+0x42)=5;
check(move_pitch_player_source(exact_first,manager,team,0,id,chosen,0,4,1,5)&&
int8_t(exact_first.tactics.at(board+0x41))==1&&
int8_t(exact_first.tactics.at(board+row_size+0x41))==0,
"pitch row-order move takes earlier exact occupant before later adjacent player");
auto occupied=pitch_fixture(original); const auto second=occupied.squad_slots.at(range.first+5)&0x0fff;
occupied.tactics.at(board+4*row_size+0x42)=0; // avoid an earlier adjacent refusal
check(move_pitch_player_source(occupied,manager,team,0,id,chosen,0,4,5,4),
"pitch move accepts exact occupied target");
check((occupied.squad_slots.at(range.first)&0x0fff)==id&&
(occupied.squad_slots.at(range.first+5)&0x0fff)==second&&
int8_t(occupied.tactics.at(board+0x41))==5&&
int8_t(occupied.tactics.at(board+5*row_size+0x41))==0,
"pitch occupied move swaps coordinates without players");
}
{
auto g=pitch_fixture(original); const uint8_t weights=g.manager_records.at(record+0x288);
g.manager_records.at(record+0x218)=1;
auto expected=g; expected.manager_options.at(0)=1; auto_lineup(expected,team,0xe4);
check(apply_pitch_formation_source(g,manager,team,0,weights),
"pitch apply accepts available formation and runs Source optimizer");
check(save_stream(g)==save_stream(expected),"pitch apply matches AA then optimizer Native result");
auto unavailable=pitch_fixture(original); const auto unavailable_native=save_stream(unavailable);
const auto unavailable_slots=unavailable.squad_slots;
check(!apply_pitch_formation_source(unavailable,manager,team,0,
unavailable.manager_records.at(record+0x288))&&save_stream(unavailable)==unavailable_native&&
unavailable.squad_slots==unavailable_slots,"pitch apply refuses unavailable formation neutrally");
auto detailed=pitch_fixture(original); detailed.level=6;
detailed.manager_records.at(record+0x288)=4;
detailed.manager_records.at(record+0x218)=1;
auto detailed_expected=detailed; detailed_expected.manager_options.at(0)=1;
auto_lineup(detailed_expected,team,0xe4);
check(apply_pitch_formation_source(detailed,manager,team,0,4),
"pitch apply accepts the high-level detailed optimizer");
check(save_stream(detailed)==save_stream(detailed_expected)&&
detailed.manager_options==detailed_expected.manager_options,
"detailed pitch apply matches AA then optimizer Native result");
}
{
auto g=pitch_fixture(original); std::array<uint8_t,22> positions{};
const size_t table=size_t(manager)*0x160+4*0x16;
for(size_t row=0;row<11;++row) { positions[row]=uint8_t(row); positions[11+row]=4; }
auto expected=g; std::copy(positions.begin(),positions.end(),expected.formations.begin()+std::ptrdiff_t(table));
expected.manager_records.at(record+0x218)|=uint8_t(1u<<4);
expected.manager_options.at(0)=5; auto_lineup(expected,team,0xe4);
check(save_pitch_formation_source(g,manager,team,4,g.manager_records.at(record+0x288),positions),
"pitch save accepts exact current eleven into own slot 4");
check(save_stream(g)==save_stream(expected),"pitch save matches 22-byte table/mask/AA/optimizer sequence");
auto forged=pitch_fixture(original); auto bad=positions; bad[0]=19;
const auto forged_native=save_stream(forged); const auto forged_formations=forged.formations;
check(!save_pitch_formation_source(forged,manager,team,4,
forged.manager_records.at(record+0x288),bad)&&save_stream(forged)==forged_native&&
forged.formations==forged_formations,"pitch save rejects forged image neutrally");
auto built_in=pitch_fixture(original); const auto built_native=save_stream(built_in);
check(!save_pitch_formation_source(built_in,manager,team,0,
built_in.manager_records.at(record+0x288),positions)&&save_stream(built_in)==built_native,
"pitch save refuses non-owned built-in slot");
}
std::puts("PASS bounded Source pitch Engine actions (genuine Native base with explicit runtime gates)");
}
} // namespace
int main(int argc,char** argv) try {
check(argc==3||argc==5,"usage: human_buyer_market_tests DATA_DIR genuine_2PNWK001.FBM [RESERVED.FBM FULL.FBM]");
if(!*argv[1]) { std::puts("human buyer market tests: skipped (Original data not configured)"); return 77; }
const auto fbm=load_savegame(argv[2]); auto texts=load_textd(std::filesystem::path(argv[1])/"TEXTD.BLK");
auto original=GameState::from_save(SaveState(fbm.stream)); original.texts=&texts;
// These are unchanged normal saves from the M139 CLI playthrough, not
// artificial roster/counter controls. Original's equality lets the22-player
// case bypass its reservation limit and eventually fill all24 physical rows.
for(int a=3;a<argc;++a) {
const auto file=load_savegame(argv[a]);
check(file.checksum_ok&&file.version=="V2.24","natural capacity input checksum/version");
auto g=GameState::from_save(SaveState(file.stream));g.texts=&texts;
check(g.date==311&&g.memory.u8(::bmh::layout::ActiveManager)==0&&g.manager_teams.at(0)==1,
"natural capacity input desk/date/owner");
const auto range=squad_range(1);int active=0;
for(size_t n=range.first;n<range.first+range.count;++n)
if((g.squad_slots.at(n)&0x0fff)!=0x0fff)++active;
check(active==(a==3?22:24)&&g.memory.u8(::bmh::layout::DeskActions_Unsupported_RuntimeField)==1&&
(g.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField)&0x0fff)==118&&
((g.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField)>>12)&0x3ff)==1&&g.memory.u8(::bmh::layout::ClubPlayerDetail_InvalidArgument_RuntimeField)==2,
"natural capacity input preserves outgoing loan and real roster");
int entry=-1,player=-1;
for(int e=0;e<40&&entry<0;++e) {
const uint32_t row=list_start+uint32_t(e)*row_size;
const int p=g.squad_slots.at(pool_start+size_t(e))&0x0fff;
if(p==0x0fff||(g.memory.u16(row+8)&0x7fff)==1)continue;
bool own=false,free=false;
for(int b=0;b<4;++b) {
own=own||g.memory.u16(row+uint32_t(b)*2)==1;
free=free||g.memory.u16(row+uint32_t(b)*2)==0xffff;
}
if(!own&&free){entry=e;player=p;}
}
check(entry>=0,"natural capacity input has ordinary new bid candidate");
const auto before=save_stream(g);WatcomRandom w(0x13579);MinuteReport report;int notices=0;
TransferBidRequest bid;bid.manager=0;bid.list_entry=entry;bid.player=player;
bid.source_slot=int(pool_start)+entry;bid.fee=100;bid.annual_salary=100;
HumanBuyerSaleHooks hooks;hooks.allocator_gate=HumanBuyerSaleAllocatorGate::zero;
hooks.direct_mode=HumanBuyerSaleDirectMode::ordinary_ai_purchase;
hooks.notice=[&](const auto&,const HumanBuyerSaleNotice& notice){
check(notice.manager==0&&notice.source_text_address==::bmh::layout::DeskActions_Unsupported_ExecutableField&&notice.source_flags==0x40,
"capacity overflow uses existing Source board refusal");++notices;
};
const auto result=submit_transfer_bid_source_human_buyer(g,bid,w,hooks,report);
check(!report.unsupported&&result.status==TransferActionStatus::no_squad_room&&
notices==1&&w.calls()==0&&w.seed()==0x13579&&save_stream(g)==before,
"natural capacity overflow refuses before bid/account/loan/RNG changes");
std::printf("PASS natural %d-player roster reserves loan118 without mutation or RNG\n",active);
}
check(original.manager_teams.size()==2&&original.manager_teams[0]==1&&original.manager_teams[1]==54&&
original.memory.u8(::bmh::layout::ManagerCount)==2,"genuine Native 2PNWK001 identity/count");
check(!original.memory.has(::bmh::layout::MatchEventsDisabled)&&!original.memory.has(::bmh::layout::DeskActions_EditorFail_RuntimeField2)&&!original.memory.has(::bmh::layout::Weekly_PendingSettleHumanBuyer_RuntimeField)&&
!original.memory.has(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_ExecutableField2),"genuine Native lacks unsaved Source runtime gates");
pitch_engine_cases(original);
{
auto g=original; const auto c=make_free_control(g);
const uint16_t source_word=uint16_t(g.squad_slots.at(c.request.source_pool_slot)|0x2000);
g.squad_slots.at(c.request.source_pool_slot)=source_word;
for(size_t at:{pool_start+39,pool_start+43,size_t(2972),size_t(3028),size_t(3071)})
g.squad_slots.at(at)=source_word; // declared matching aliases, not AI-player relabelling
settlement_case(g,c,HumanBuyerSaleAllocatorGate::zero,HumanBuyerSaleStatus::moved,
"genuine free-agent allocation/sentinel history/full-pool alias removal");
}
{
auto g=original; const auto c=make_free_control(g,false);
direct_case(g,c,HumanBuyerSaleAllocatorGate::zero,TransferActionStatus::accepted,
"genuine free-agent ordinary direct agreement/Source settlement",{::bmh::layout::DeskActions_SubmitTransferBidImpl_ExecutableField});
}
// Existing outgoing-offer loan checkbox/term survives editor submission,
// direct qualification, fee booking, and AI-owner -> human-borrower expiry.
{
auto g=original;const auto c=make_control(g,false,-1,false,0,250000,70000,false);
const uint32_t list=c.request.list_address;
TransferBidRequest bid;bid.manager=c.buyer_manager;bid.list_entry=c.request.list_entry;
bid.player=c.player;bid.source_slot=int(c.request.source_pool_slot);bid.contract_years=2;bid.loan=true;
const uint32_t fee_base=(g.memory.u32(list+0x2c)/10000u)*10000u;
const uint32_t salary_base=((120u*g.memory.u32(list+0x30))/10000u)*100u;
bid.fee=int32_t(fee_base*2u);bid.annual_salary=int32_t(salary_base*2u);
for(size_t n=0;n<7;++n)bid.bonuses[n]=uint32_t(n+3);
HumanBuyerSaleHooks hooks;hooks.allocator_gate=HumanBuyerSaleAllocatorGate::zero;
hooks.direct_mode=HumanBuyerSaleDirectMode::ordinary_ai_purchase;
std::vector<uint32_t> notices;hooks.notice=[&](const GameState&,const HumanBuyerSaleNotice& n){notices.push_back(n.source_text_address);};
WatcomRandom w(0x13579);MinuteReport report;
const auto result=submit_transfer_bid_source_human_buyer(g,bid,w,hooks,report);
check(!report.unsupported&&result.status==TransferActionStatus::accepted,
"AI-owner loan offer reaches the accepted human-buyer transaction route");
int ledger=-1;for(int n=0;n<200&&ledger<0;++n)if(g.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField+uint32_t(n)*4)!=0&&
int(g.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField+uint32_t(n)*4)&0xfff)==c.player)ledger=n;
int row=-1;const auto buyer_range=squad_range(c.buyer);
for(size_t n=0;n<buyer_range.count;++n)
if((g.squad_slots.at(buyer_range.first+n)&0xfff)==c.player){row=int(n);break;}
check(ledger>=0&&g.memory.u8(::bmh::layout::ClubPlayerDetail_InvalidArgument_RuntimeField+uint32_t(ledger))==24&&row>=0&&
g.tactics.at(board_size+size_t(row)*row_size+0x0c)==0xff,
"AI-owned loan writes 24-month return ledger and human borrower marker");
for(int n=0;n<12;++n)check(g.memory.u16(::bmh::layout::Career_CareerManagersEnd_RuntimeField+uint32_t(n)*2)==0x0fff,
"AI owner does not consume a human-owner board snapshot");
const uint32_t buyer_history=rd(g.manager_records,record_size+0x760);
check((buyer_history&3u)==3u,"buyer history marks both loan and buyer direction");
auto loaded=GameState::from_save(SaveState(save_stream(g)));loaded.texts=&texts;
loaded.memory.set8(::bmh::layout::ClubPlayerDetail_InvalidArgument_RuntimeField+uint32_t(ledger),1);
int dialog_manager=-1;std::string dialog_text;
loaded.loan_return_screen=[&](GameState&,int manager,const std::string& question){
dialog_manager=manager;dialog_text=question;return 1;
};
bool return_editor_opened=false,return_offer_submitted=false;
loaded.loan_return_offer_screen=[&](GameState& staged,GameRandom& editor_game,WatcomRandom& editor_rand,
int manager,int source_slot,int list_entry,const HumanBuyerSaleHooks&)->int {
const uint32_t row=::bmh::layout::EditorList+uint32_t(list_entry)*0x58;
int bid_slot=-1;
for(int i=0;i<4;++i)if(staged.memory.u16(row+uint32_t(i)*2)==0xffff){bid_slot=i;break;}
TransferOfferEditorRequest request{manager,staged.manager_teams.at(size_t(manager)),list_entry,
source_slot,int(staged.squad_slots.at(size_t(source_slot))&0x0fff),staged.memory.u16(row+8),bid_slot};
request.loan_return_entry = true;
auto editor=open_transfer_offer_editor_source(staged,request,editor_game,editor_rand);
if(!editor.supported||!editor.editable)return -1;
return_editor_opened=true;
editor=edit_transfer_offer_editor_source(staged,editor,
{TransferOfferEditorField::fee,staged.memory.u32(row+0x2c),true},editor_game,editor_rand);
editor=edit_transfer_offer_editor_source(staged,editor,
{TransferOfferEditorField::salary,staged.memory.u32(row+0x30),true},editor_game,editor_rand);
HumanBuyerSaleHooks sale; sale.allocator_gate=HumanBuyerSaleAllocatorGate::zero;
sale.direct_mode=HumanBuyerSaleDirectMode::ordinary_ai_purchase;
sale.notice=[](const GameState&,const HumanBuyerSaleNotice&){};
MinuteReport editor_report;
const auto submitted=submit_transfer_offer_editor_source(staged,editor,editor_rand,sale,editor_report);
return_offer_submitted=!editor_report.unsupported &&
(submitted.action.status==TransferActionStatus::accepted ||
submitted.action.status==TransferActionStatus::pending);
return return_offer_submitted?1:-1;
};
GameRandom return_game(73);WatcomRandom return_rand(1);MinuteReport return_report;
month_change(loaded,return_rand,return_report,&return_game);
check(!return_report.unsupported&&contains(loaded,c.seller,c.player)&&!contains(loaded,c.buyer,c.player)&&
loaded.memory.u32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField+uint32_t(ledger)*4)==0,
"AI-owner loan survives save/load and returns from human borrower at expiry");
check(dialog_manager==c.buyer_manager&&dialog_text.ends_with(message_text(loaded,::bmh::layout::Month_ReturnLoans_TextPointer6)),
"human borrower receives exact format field question for AI-owned loan");
check(return_editor_opened&&return_offer_submitted,
"Source YES opens the actual legacy routine editor and submits through shared human-buyer settlement");
}
// Issue34: both ends of the format field sixteen-slot club range are
// legitimate sellers. Use actual unique roster players/listing creation,
// then the existing independently composed qualification/settlement oracle.
for(int seller:{90,137}) {
auto g=original;
const auto c=make_control(g,false,-1,false,0,250000,70000,false,seller);
check(c.seller==seller&&squad_range(seller).count==16,"Source16-slot seller identity");
direct_case(g,c,HumanBuyerSaleAllocatorGate::zero,TransferActionStatus::accepted,
"Source16-slot seller "+std::to_string(seller)+" direct purchase",{::bmh::layout::DeskActions_SubmitTransferBidImpl_ExecutableField});
}
{
// Issue34's named player is in the genuine SSC Neapel sixteen-slot
// squad, not a club >=138. Season initialization reorders runtime
// clubs: this unchanged 2PN input has Napoli126 and OLIVERA slot2738.
// Generate only an ordinary listing through format field, then compare
// the complete purchase against the independent Source composition.
auto g=original;
constexpr int seller=126,player=2012;
check(g.club_name(seller)=="SSC NEAPEL"&&g.player_name(player)=="OLIVERA"&&
find_player(g,seller,player)==2738&&squad_range(seller).count==16,
"Issue34 genuine named OLIVERA/SSC Neapel runtime identity");
const auto c=make_control(g,false,-1,false,0,6000000,200000,false,seller,player);
check(c.seller==seller&&c.player==player&&g.memory.u16(c.request.list_address+8)==seller,
"format field produces Napoli runtime seller, never a name-pool offset or higher metadata identity");
direct_case(g,c,HumanBuyerSaleAllocatorGate::zero,TransferActionStatus::accepted,
"Issue34 OLIVERA/SSC Neapel ordinary full purchase",{::bmh::layout::DeskActions_SubmitTransferBidImpl_ExecutableField});
}
for(uint16_t seller:{uint16_t(138),uint16_t(0x8000|138),uint16_t(167),
uint16_t(168),uint16_t(356),uint16_t(0x165)}) {
auto g=original;const auto c=make_free_control(g,false);
g.memory.set16(c.request.list_address+8,seller);
const auto before=save_stream(g);WatcomRandom w(1);MinuteReport report;size_t notices=0;
HumanBuyerSaleHooks h;h.allocator_gate=HumanBuyerSaleAllocatorGate::zero;
h.direct_mode=HumanBuyerSaleDirectMode::ordinary_ai_purchase;
h.notice=[&](const auto&,const auto&){++notices;};
TransferBidRequest bid;bid.manager=c.buyer_manager;bid.list_entry=c.request.list_entry;bid.player=c.player;
bid.source_slot=int(c.request.source_pool_slot);
bid.fee=int32_t(c.fee);bid.annual_salary=int32_t(c.salary);bid.contract_years=1;
const auto result=submit_transfer_bid_source_human_buyer(g,bid,w,h,report);
check(result.status==TransferActionStatus::unsupported&&report.unsupported&&notices==0&&
w.seed()==1&&w.calls()==0&&save_stream(g)==before&&
report.reason=="seller is outside the Original ordinary club squads (clubs 0..137 or free agents only)",
"seller outside ordinary Source squads rejects before Native/bid/W/notice changes with clear reason");
const TransferOfferEditorRequest editor_request{c.buyer_manager,c.buyer,c.request.list_entry,
int(c.request.source_pool_slot),c.player,seller,0};
GameRandom game(73);
const auto editor=open_transfer_offer_editor_source(g,editor_request,game,w);
check(!editor.supported&&editor.reason==report.reason&&save_stream(g)==before&&
game.seed()==73&&game.calls()==0&&w.seed()==1&&w.calls()==0,
"same clear ordinary-seller boundary at editor opening before Native/W/G changes");
}
for(uint16_t invalid:{uint16_t(0xffff),uint16_t(0x7fff)}) {
auto g=original; const auto c=make_free_control(g);
g.memory.set16(c.request.list_address+8,invalid);
HumanBuyerSaleHooks h;h.allocator_gate=HumanBuyerSaleAllocatorGate::zero;
unsupported_case(g,c.request,h,"free-agent seller must not normalize FFFF/7FFF");
// Direct preflight must reject the same malformed seller before a bid
// or qualification draw, not silently use the legacy mover.
g=original;const auto direct=make_free_control(g,false);
g.memory.set16(direct.request.list_address+8,invalid);
const auto before=save_stream(g);WatcomRandom w(1);MinuteReport report;size_t notices=0;
TransferBidRequest bid;bid.manager=direct.buyer_manager;bid.list_entry=direct.request.list_entry;bid.player=direct.player;
bid.source_slot=int(direct.request.source_pool_slot);
bid.fee=int32_t(direct.fee);bid.annual_salary=int32_t(direct.salary);bid.contract_years=1;
h.direct_mode=HumanBuyerSaleDirectMode::ordinary_ai_purchase;
h.notice=[&](const auto&,const auto&){++notices;};
const auto result=submit_transfer_bid_source_human_buyer(g,bid,w,h,report);
check(result.status==TransferActionStatus::unsupported&&report.unsupported&&notices==0&&
w.calls()==0&&save_stream(g)==before,"invalid free-agent sentinel direct preflight leaves Native/RNG/bids unchanged");
}
for(int row:{0,1,19}) {
auto g=original; const auto c=make_control(g,false,row);
// Preserve a pool flag that Source transfers as a full word. Additional
// ordinary/special occurrences prove ReleasePlayer's 44-slot matching cleanup.
g.squad_slots.at(c.request.source_pool_slot)|=0x2000;
g.squad_slots.at(pool_start+39)=g.squad_slots.at(c.request.source_pool_slot);
g.squad_slots.at(pool_start+43)=g.squad_slots.at(c.request.source_pool_slot);
settlement_case(g,c,HumanBuyerSaleAllocatorGate::zero,HumanBuyerSaleStatus::moved,
"AI sale allocator row "+std::to_string(row));
}
{
auto g=original; const auto c=make_control(g,true,0,false,2);
g.memory.set16(c.request.list_address,3); // unrelated real ordinary bidder must survive.
settlement_case(g,c,HumanBuyerSaleAllocatorGate::zero,HumanBuyerSaleStatus::moved,"human seller shared nonzero bid2");
}
{
auto g=original; const auto c=make_control(g,false,0,false,0,250000,0xf0000000u);
settlement_case(g,c,HumanBuyerSaleAllocatorGate::zero,HumanBuyerSaleStatus::moved,"wrapped salary unsigned final divide");
}
for(int scenario=0;scenario<6;++scenario) {
auto g=original; const bool full=scenario==5;
const auto c=make_control(g,false,-1,full,0,scenario==1?750000u:250000u);
if(scenario<=3) g.manager_records.at(record_size+0x170)=uint8_t(0x1c|(g.players.at(size_t(c.player)).w364&3));
auto gate=HumanBuyerSaleAllocatorGate::zero; auto outcome=HumanBuyerSaleStatus::moved;
std::string label="subsidy adjusted cash/raw history";
if(scenario==1) {
g.manager_records.at(record_size+0x170)=uint8_t(0x04|(g.players.at(size_t(c.player)).w364&3));
g.manager_records.at(record_size+0x210)=3; // fee exceeds threshold; ACK consumes subsidy.
label="subsidy threshold ACK without discount";
} else if(scenario==2) {
wr(g.manager_records,record_size+0x314,c.fee); wr(g.manager_records,record_size+0x31c,uint32_t(-200000));
outcome=HumanBuyerSaleStatus::funds_refused; label="subsidy then funds refusal retains ordinary pool/bids";
} else if(scenario==3) {
g.manager_records.at(record_size+0x170)=uint8_t(0x1c|((g.players.at(size_t(c.player)).w364+1)&3));
label="position mismatch keeps subsidy";
} else if(scenario==4) {
gate=HumanBuyerSaleAllocatorGate::blocked;outcome=HumanBuyerSaleStatus::allocator_blocked;
label="paid allocator blocked retains ordinary pool/bids";
} else if(scenario==5) {
outcome=HumanBuyerSaleStatus::no_room; label="paid full-word no-room retains ordinary pool/bids";
}
settlement_case(g,c,gate,outcome,label);
}
{
auto g=original; const auto c=make_control(g,true,-1,true);
g.memory.set8(::bmh::layout::ActiveManager,0); auto request=c; request.request.expected_active_manager=0;
settlement_case(g,request,HumanBuyerSaleAllocatorGate::zero,HumanBuyerSaleStatus::no_room,
"no-room notice uses current seller rather than buyer");
}
for(bool blocked:{false,true}) {
auto g=original; const auto c=make_control(g,false,-1,false,0,250000,70000,false);
g.memory.set16(c.request.list_address,3); // actual retained competing ordinary buyer.
direct_case(g,c,blocked?HumanBuyerSaleAllocatorGate::blocked:HumanBuyerSaleAllocatorGate::zero,
blocked?TransferActionStatus::allocator_blocked:TransferActionStatus::accepted,
blocked?"direct paid blocked preserves all ordinary bids":"direct AI purchase normal ACK/shared Source settlement");
}
{
auto g=original; const auto c=make_control(g,false,-1,true,0,250000,70000,false);
g.memory.set16(c.request.list_address,3);
direct_case(g,c,HumanBuyerSaleAllocatorGate::zero,TransferActionStatus::no_squad_room,
"direct paid FULLWORD no-room preserves ordinary pool/bids",{::bmh::layout::DeskActions_SubmitTransferBidImpl_ExecutableField,::bmh::layout::PendingOffer_FormatError_ExecutableField});
}
{
auto g=original; const auto c=make_control(g,false,-1,false,0,250000,70000,false);
g.memory.set16(c.request.list_address,3);
// Declared scalar control of the real Source-generated ordinary listing:
// its published qualification bases yield a 250000 bid, below the
// matching position/tier subsidy threshold. No special pending row.
g.memory.set32(c.request.list_address+0x2c,100000);
g.memory.set32(c.request.list_address+0x30,10000);
g.manager_records.at(record_size+0x170)=uint8_t(0x1c|(g.players.at(size_t(c.player)).w364&3));
direct_case(g,c,HumanBuyerSaleAllocatorGate::zero,TransferActionStatus::accepted,
"direct subsidy ACK then adjusted payment/raw history",{::bmh::layout::DeskActions_SubmitTransferBidImpl_ExecutableField,::bmh::layout::PendingOffer_ConstructionNoticeDialog_TextPointer},175000);
}
for(bool subsidy:{false,true}) {
auto g=original; const auto c=make_control(g,false,-1,false,0,250000,70000,false);
g.memory.set16(c.request.list_address,3);
g.memory.set32(c.request.list_address+0x2c,100000);
g.memory.set32(c.request.list_address+0x30,10000);
// Explicit Native financial scalar control, never a mutation by the
// notice observer. The existing ordinary qualification's int64 board
// allowance admits the bid. Original68d06 instead executes ADD32 and
// a signed CMP/JL: data-field offset + 0x100 wraps to negative data-field offset,
// so the later funds notice refuses this positive fee. This probes the
// actual Source signed32 boundary despite the known upstream qualifier
// approximation; it is not claimed as a naturally captured balance.
wr(g.manager_records,record_size+0x314,0x7ffffff0u);
wr(g.manager_records,record_size+0x31c,0x100u);
if(subsidy) g.manager_records.at(record_size+0x170)=uint8_t(0x1c|(g.players.at(size_t(c.player)).w364&3));
direct_case(g,c,HumanBuyerSaleAllocatorGate::zero,TransferActionStatus::insufficient_funds,
subsidy?"direct subsidy then signed32 funds refusal preserves pool/bids"
:"direct signed32 funds refusal preserves pool/bids",
subsidy?std::vector<uint32_t>{::bmh::layout::DeskActions_SubmitTransferBidImpl_ExecutableField,::bmh::layout::PendingOffer_ConstructionNoticeDialog_TextPointer,::bmh::layout::Advertising_FormatError_TextPointer18}
:std::vector<uint32_t>{::bmh::layout::DeskActions_SubmitTransferBidImpl_ExecutableField,::bmh::layout::Advertising_FormatError_TextPointer18},
subsidy?175000u:250000u);
}
for(bool reverse:{false,true}) {
auto g=original;const auto c=reverse?make_reverse_human_control(g):make_control(g,true,-1,false,0,250000,70000,false);
direct_case(g,c,HumanBuyerSaleAllocatorGate::zero,TransferActionStatus::accepted,
reverse?"Source ordinary human seller54 to buyer1 direct full composition":"Source ordinary human seller1 to buyer54 direct full composition",{::bmh::layout::DeskActions_SubmitTransferBidImpl_ExecutableField});
}
for(int mode:{1,2,3}) {
auto g=original;const auto c=make_control(g,false,-1,false,0,250000,70000,false);
g.memory.set8(::bmh::layout::GameMode,uint8_t(mode));
direct_case(g,c,HumanBuyerSaleAllocatorGate::zero,TransferActionStatus::accepted,
"Source mode"+std::to_string(mode)+" all-seven-bonus direct qualification",{::bmh::layout::DeskActions_SubmitTransferBidImpl_ExecutableField});
g=original;const auto refused=make_control(g,false,-1,false,0,250000,70000,false);
retained_case(g,refused,mode,RetainedKind::salary_refused,
"Source mode"+std::to_string(mode)+" salary short circuit/persisted bid");
if(mode!=3) {
g=original;const auto cheap=make_control(g,false,-1,false,0,250000,70000,false);
g.memory.set8(::bmh::layout::GameMode,uint8_t(mode));
direct_case(g,cheap,HumanBuyerSaleAllocatorGate::zero,TransferActionStatus::accepted,
"Source mode"+std::to_string(mode)+" low fee replaced by200 after salary pass",{::bmh::layout::DeskActions_SubmitTransferBidImpl_ExecutableField},0,true);
}
}
for(bool free:{false,true}) {
auto g=original;const auto c=free?make_free_control(g,false):make_control(g,false,-1,false,0,250000,70000,false);
retained_case(g,c,3,RetainedKind::fee_refused,free?"canonical free-agent format field/persisted bid":"AI seller Source name+af30c/persisted bid");
}
for(const auto kind:{RetainedKind::existing_bid,RetainedKind::capacity}) {
auto g=original;const auto c=make_control(g,false,-1,false,0,250000,70000,false);
retained_case(g,c,3,kind,kind==RetainedKind::existing_bid?"existing bidder edits without qualifier/RNG":
"Source capacity equality refusal before bid writes/RNG");
}
{
auto g=original; const auto c=make_control(g);
HumanBuyerSaleHooks hooks; hooks.allocator_gate=HumanBuyerSaleAllocatorGate::zero;
auto request=c.request; request.list_address+=row_size;
unsupported_case(g,request,hooks,"mismatched explicit coordinates");
request=c.request; request.expected_active_manager=0;
unsupported_case(g,request,hooks,"wrong active runtime owner");
hooks.allocator_gate=HumanBuyerSaleAllocatorGate::unsupported;
unsupported_case(g,c.request,hooks,"unknown allocator gate");
hooks.allocator_gate=HumanBuyerSaleAllocatorGate::zero;
auto loan=g;loan.memory.set32(::bmh::layout::Career_RemoveJoinLoans_RuntimeField,uint32_t(c.player)|(uint32_t(c.seller)<<12)|(uint32_t(c.buyer)<<22));
unsupported_case(loan,c.request,hooks,"existing return loan");
auto missing=g; missing.squad_slots.at(find_player(missing,c.seller,c.player))=0xfff;
unsupported_case(missing,c.request,hooks,"missing seller player/error32");
auto small=g; small.manager_teams[1]=90; small.manager_records.at(record_size+0x290)=90;
small.memory.set16(c.request.list_address,90);request=c.request;request.expected_buyer=90;
unsupported_case(small,request,hooks,"16-slot human buyer");
auto direct=g; direct.memory.set16(c.request.list_address,0xffff);
TransferBidRequest bid;bid.manager=1;bid.list_entry=c.request.list_entry;bid.player=c.player;
bid.source_slot=int(c.request.source_pool_slot);
bid.fee=10000000;bid.annual_salary=1000000;bid.contract_years=2;
const auto before=save_stream(direct);WatcomRandom w(1);MinuteReport report;size_t notices=0;
hooks.notice=[&](const GameState&,const HumanBuyerSaleNotice&){++notices;};
const auto result=submit_transfer_bid_source_human_buyer(direct,bid,w,hooks,report);
check(result.status==TransferActionStatus::unsupported&&report.unsupported&&notices==0&&
w.calls()==0&&save_stream(direct)==before,"direct default runtime context unsupported before bid/RNG/ACK");
}
std::puts("PASS human-buyer Source sale/loan settlement, allocator boundaries, and loan calendar expiry");
return 0;
} catch(const std::exception& e) { std::fprintf(stderr,"human_buyer_market_tests: %s\n",e.what()); return 1; }