1352 lines
91 KiB
C++
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&¬ice.source_text_address==::bmh::layout::DeskActions_Unsupported_ExecutableField&¬ice.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)*0x30d4u;
|
|
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&¬ices==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&¬ices==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&¬ices==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; }
|