Files
Dreierpack-Manager/tests/transfer_bid_qualification_tests.cpp
T

343 lines
19 KiB
C++

#include "test_inputs.hpp"
// SPDX-License-Identifier: GPL-3.0-only
#include "formats/executable_layout.hpp"
#include <algorithm>
#include <array>
#include <bit>
#include <cstdio>
#include <filesystem>
#include <optional>
#include <stdexcept>
#include <string>
#include <vector>
#include "formats/fbm.hpp"
#include "formats/savestate.hpp"
#include "formats/textd.hpp"
#include "game/save.hpp"
#include "game/match_engine.hpp"
#include "game/transfer_bid.hpp"
using namespace bmh;
namespace {
constexpr uint32_t list_start=::bmh::layout::EditorList;
constexpr size_t pool_start=2928, record_size=0xb0c, board_size=0x840;
void require(bool yes,const std::string& why) { if(!yes)throw std::runtime_error(why); }
void put32(std::vector<uint8_t>& bytes,size_t at,uint32_t n) {
for(size_t k=0;k<4;++k)bytes.at(at+k)=uint8_t(n>>(8*k));
}
const GameState* drawing_state=nullptr;
const std::vector<uint8_t>* drawing_board=nullptr;
bool board_restored_at_draw=true;
void observe_draw(int generator) {
if(generator!=1 || !drawing_state || !drawing_board || drawing_state->tactics!=*drawing_board)
board_restored_at_draw=false;
}
struct OracleW {
uint32_t seed; uint64_t calls=0;
int range(int lo,int hi) {
seed=seed*0x41c64e6du+0x3039u;++calls;
return lo+int(((seed>>16)&0x7fffu)*uint32_t(hi-lo+1)>>15);
}
};
// Source round strings CareerSession_RuntimeError_ExecutableField, first eight rounds. Independent of production
// fixtures/tables/prediction/bonus/rating; controls deliberately remain here.
const std::string& rounds18(size_t round) {
return bmh::test::expected_text("transfer-pairing-row-"+std::to_string(round));
}
constexpr int sizes[]={18,18,18,18,18,12,12,12,12};
constexpr int relegation[]={3,4,2,2,3,0,0,0,0};
int league(int team) {
int end=0;for(int l=0;l<9;++l){end+=sizes[l];if(team<end)return l;}
throw std::runtime_error("oracle requires genuine league club");
}
// legacy routine mode4 composition, bounded to genuine 18-team league0 and declared
// rounds0/1/end or first8 complete result rounds. No production helper calls.
int predicted_rank(const GameState& g,int team) {
const int l=league(team), n=sizes[l], played=int(int8_t(g.league_rounds.at(size_t(l))));
if(played<2 || played>=n*2-2)return 11;
require(l==0&&played<=8,"independent prediction controls use league0 first8 rounds");
std::array<int,18> points{},recent_points{},games{},recent_games{};
const int from=std::max(0,played-5);
for(int r=0;r<played;++r)for(int m=0;m<9;++m) {
const int h=rounds18(size_t(r))[m*2]-'a',a=rounds18(size_t(r))[m*2+1]-'a';
const uint8_t v=g.results.at(size_t(r)*10+size_t(m));
require((v&0xcc)!=0xcc,"prediction control must contain complete results");
const int hg=v>>4,ag=v&15;
const int hp=hg>ag?2:hg==ag?1:0,ap=ag>hg?2:ag==hg?1:0;
points[size_t(h)]+=hp;points[size_t(a)]+=ap;++games[size_t(h)];++games[size_t(a)];
if(r>=from) {
recent_points[size_t(h)]+=hp;recent_points[size_t(a)]+=ap;
++recent_games[size_t(h)];++recent_games[size_t(a)];
}
}
for(size_t m=0;m<g.manager_teams.size();++m) {
const int t=g.manager_teams[m];if(t>=18)continue;
const uint8_t d=g.manager_records.at(m*record_size+0x220);
if((d>>5)==3)points[size_t(t)]=std::max(0,points[size_t(t)]-(d&31));
}
require(recent_games[size_t(team)]!=0,"Source prediction division must be valid");
const int rate=recent_points[size_t(team)]*500/recent_games[size_t(team)];
const uint16_t own=uint16_t(points[size_t(team)]*500+(34-games[size_t(team)])*rate);
int behind=0;
for(int t=0;t<18;++t)if(t!=team) {
require(recent_games[size_t(t)]!=0,"Source opponent rate division must be valid");
const int other_rate=recent_points[size_t(t)]*500/recent_games[size_t(t)];
if(uint16_t(points[size_t(t)]*500+(34-games[size_t(t)])*other_rate)<own)++behind;
}
// mode4 starts with18 zero entries and marks18-behind-1 as the first1;
// returned best-rank is that index+1, then5fc59 increments once again.
return 18-behind+1;
}
int average499(const GameState& g,int team) {
require(team>=0&&team<90,"independent fitness oracle requires actual24-slot club");
int sum=0;
for(size_t s=size_t(team)*24;s<size_t(team+1)*24;++s) {
const uint16_t word=g.squad_slots.at(s);
if(word==0xfff || !(word&0x8000))continue;
const auto& p=g.players.at(word&0xfff);
sum+=int(p.w35c>>14&127)+int(p.w35c>>7&127);
}
// legacy routine flags499 selects lineup/all positions/both attrs, fixed divisor11.
return std::max(1,std::clamp((sum/2)/11,0,99));
}
uint32_t source_bonus(const GameState& g,int manager,int player,uint32_t salary,
const std::array<uint8_t,7>& bonuses) {
const int team=g.manager_teams.at(size_t(manager)),l=league(team);
const auto& p=g.players.at(size_t(player));
const int strength=int(((p.w35c>>14&127)+(p.w35c>>7&127))>>1);
const int gap=std::max(-1,int(int16_t(average499(g,team)-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 total=0;
for(size_t k=0;k<3;++k) {
const uint32_t first=(uint32_t(bonuses[k])*salary)/100u;
total+=(first*uint32_t(times[k]))/12u;
}
const int rank=predicted_rank(g,team);
uint32_t season=0;
for(int k=3;k<7;++k) {
const bool qualifies=k==3 ? l==0&&rank==0 : k==4 ? rank<5 : k==5 ? rank<10
:rank<sizes[l]-relegation[l];
if(qualifies&&season==0)season=(5u*uint32_t(bonuses[size_t(k)])*salary)/100u;
}
return total+season/12u;
}
struct Expected { uint32_t fee=0,salary=0; };
Expected source_rating(const GameState& g,const TransferBidRatingRequest& r,OracleW& w) {
const uint32_t at=list_start+uint32_t(r.list_entry)*0x58;
const uint8_t term=g.memory.u8(at+0x34+uint32_t(r.bid_slot));
const uint8_t years=uint8_t((int(term&127)-1)/12);
uint32_t fee_base=(g.memory.u32(at+0x2c)/10000u)*12500u;
if(term&128)fee_base>>=2;
const uint32_t salary_base=(((uint32_t(years)*20u+100u)*g.memory.u32(at+0x30))/10000u)*100u;
require(fee_base!=0&&salary_base!=0,"valid Source scalar oracle denominators");
Expected out;
out.fee=(g.memory.u32(at+0x1c+uint32_t(r.bid_slot)*4)*100u)/fee_base;
uint32_t salary=g.memory.u32(at+0x0c+uint32_t(r.bid_slot)*4);
const int bidder=int(int16_t(g.memory.u16(at+uint32_t(r.bid_slot)*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) {
std::array<uint8_t,7> bonuses{};
for(size_t k=0;k<7;++k)bonuses[k]=g.memory.u8(at+0x38+uint32_t(r.bid_slot)*7+uint32_t(k));
salary+=source_bonus(g,manager,int(g.squad_slots.at(size_t(r.source_slot))&0xfff),salary,bonuses);
}
out.salary=(salary*100u)/salary_base;
const uint32_t threshold=uint32_t(w.range(90,100));
if(out.fee<threshold)out.fee=0;
if(out.salary<g.memory.u8(at+0x55))out.salary=0;
return out;
}
TransferBidRatingRequest control(GameState& g,int bidder=1,int entry=0,int bid=0) {
// Frozen genuine Native foundation; these listing scalars form a declared
// evaluation control, not an Original negotiation/runtime/clock recording.
TransferBidRatingRequest r;
r.source_slot=int(pool_start);r.list_entry=entry;r.bid_slot=bid;
r.expected_bidder=bidder;r.expected_player=g.squad_slots.at(pool_start)&0xfff;
const uint32_t at=list_start+uint32_t(entry)*0x58;
g.memory.set16(at+uint32_t(bid)*2,uint16_t(bidder));
g.memory.set32(at+0x2c,1234567);g.memory.set32(at+0x30,9876);
g.memory.set32(at+0x1c+uint32_t(bid)*4,1537500);
g.memory.set32(at+0x0c+uint32_t(bid)*4,9800);
g.memory.set8(at+0x34+uint32_t(bid),12);g.memory.set8(at+0x55,100);
for(int k=0;k<7;++k)g.memory.set8(at+0x38+uint32_t(bid)*7+uint32_t(k),0);
for(auto& n:g.league_rounds)n=0;
return r;
}
void compare_rating(GameState g,const TransferBidRatingRequest& r,const std::string& label,
uint32_t seed=37,std::optional<Expected> hard={}) {
const auto native=save_stream(g),boards=g.tactics;
const GameRandom game(765432);const auto gs=game.seed();const auto gc=game.calls();
OracleW expected_w{seed};const auto expected=source_rating(g,r,expected_w);
if(hard)require(expected.fee==hard->fee&&expected.salary==hard->salary,label+": independent hard Source vector");
WatcomRandom actual_w(seed);MinuteReport report;
require(draw_hook==nullptr,"rating draw observer must have sole ownership");
drawing_state=&g;drawing_board=&boards;board_restored_at_draw=true;draw_hook=observe_draw;
struct ResetObserver { ~ResetObserver(){draw_hook=nullptr;drawing_state=nullptr;drawing_board=nullptr;} } reset_observer;
const auto actual=rate_transfer_bid_source(g,r,actual_w,report);
require(actual.supported&&!report.unsupported,label+": supported rating");
require(actual.fee_pct==expected.fee&&actual.salary_pct==expected.salary,label+": exact Source32 percentages");
require(actual_w.seed()==expected_w.seed&&actual_w.calls()==1,label+": exactly one Source thresholdW");
require(board_restored_at_draw,label+": full borrowed board restored before threshold callback");
require(game.seed()==gs&&game.calls()==gc,label+": independent G stream unchanged");
require(g.tactics==boards,label+": every board row restored after temporary bonus rating");
require(save_stream(g)==native,label+": complete Native unchanged by scalar rating");
}
void unsupported(GameState g,TransferBidRatingRequest r,const std::string& label) {
const auto native=save_stream(g),boards=g.tactics;
WatcomRandom w(37);MinuteReport report;const auto actual=rate_transfer_bid_source(g,r,w,report);
require(!actual.supported&&report.unsupported,label+": typed unsupported");
require(w.seed()==37&&w.calls()==0&&save_stream(g)==native&&g.tactics==boards,
label+": reject before Native/board/RNG mutation");
}
void set_strength(GameState& g,int player,int strength,int position) {
auto& p=g.players.at(size_t(player));
p.w35c=(p.w35c&~((127u<<7)|(127u<<14)))|(uint32_t(strength)<<7)|(uint32_t(strength)<<14);
p.w364=(p.w364&~3u)|uint32_t(position);
}
void fitness_control(GameState& g,int manager,int strength) {
const int team=g.manager_teams.at(size_t(manager));int selected=0;
for(size_t at=size_t(team)*24;at<size_t(team+1)*24;++at) {
auto& word=g.squad_slots.at(at);
if((word&0xfff)==0xfff)continue;
word=uint16_t(word&~0x8000u);
if(selected<11) {
word|=0x8000;set_strength(g,word&0xfff,strength,selected==0?0:1);++selected;
}
}
require(selected==11,"genuine buyer has11 actual players for declared fitness control");
}
void result_control(GameState& g,bool own_wins) {
g.league_rounds[0]=8;
g.manager_records.at(0x220)=0;
for(int r=0;r<8;++r)for(int m=0;m<9;++m) {
const int home=rounds18(size_t(r))[m*2]-'a',away=rounds18(size_t(r))[m*2+1]-'a';
g.results.at(size_t(r)*10+size_t(m))=uint8_t(own_wins&&home==1?0x20:own_wins&&away==1?0x02:0);
}
}
} // namespace
int main(int argc,char** argv) try {
require(argc==3,"usage: transfer_bid_qualification_tests DATA_DIR genuine_2PNWK001.FBM");
if(!*argv[1]){std::puts("transfer bid qualification tests: skipped (Original data not configured)");return 77;}
const auto fbm=load_savegame(argv[2]);require(fbm.checksum_ok,"genuine Native checksum");
auto texts=load_textd(std::filesystem::path(argv[1])/"TEXTD.BLK");
auto original=GameState::from_save(SaveState(fbm.stream));original.texts=&texts;
require(original.manager_teams==std::vector<int>{1,54},"genuine2PN manager identities");
require((original.squad_slots.at(pool_start)&0xfff)!=0xfff,"genuine ordinary free-agent source player");
for(int bidder:{0,1,54})for(int bid:{0,3}) {
auto g=original;auto r=control(g,bidder,0,bid);
compare_rating(g,r,"AI and both genuine human bidders/basic scalar",37,Expected{100,100});
}
for(uint8_t term:{uint8_t(0),uint8_t(1),uint8_t(12),uint8_t(24),uint8_t(48),uint8_t(0x80),
uint8_t(0x81),uint8_t(0x8c),uint8_t(0x98)}) {
auto g=original;auto r=control(g);const uint32_t at=list_start;
g.memory.set8(at+0x34,term);
g.memory.set32(at+0x1c,(term&128)?384375u:1537500u);
g.memory.set32(at+0x0c,term==24||term==0x98?11800u:term==48?15800u:9800u);
compare_rating(g,r,"signed term quotient and separate loan fee basis",37,Expected{100,100});
}
for(const auto& v:std::array<std::array<uint32_t,4>,4>{{
{1383750,9800,90,100},{1368375,9800,0,100},{1537500,9702,100,0},{1537500,9800,100,100}}}) {
auto g=original;auto r=control(g);g.memory.set32(list_start+0x1c,v[0]);g.memory.set32(list_start+0x0c,v[1]);
compare_rating(g,r,"threshold equality and short independent fee/salary filters",37,Expected{v[2],v[3]});
}
{
auto g=original;auto r=control(g);g.memory.set32(list_start+0x1c,1383750);
// This controlled starting W state produces threshold100. Equality90
// passed at seed37 above, but must now fail without any extra draw.
compare_rating(g,r,"higher real W threshold rejects fee90",0x81a985fau,Expected{0,100});
}
{
auto g=original;auto r=control(g);g.memory.set32(list_start+0x2c,80000);
g.memory.set32(list_start+0x1c,0x40000001u);g.memory.set8(list_start+0x55,1);
compare_rating(g,r,"fee IMUL32 before unsignedDIV",37,Expected{0,100});
g.memory.set32(list_start+0x1c,100000);g.memory.set32(list_start+0x0c,0x40000001u);
compare_rating(g,r,"human salary ADD/IMUL32 before unsignedDIV",37,Expected{100,0});
}
// Exact all7/fitness/rankFF controls: player strength50, actual11-player
// buyer lineup of strength50/58/49, with known Source bonus checkpoints.
for(const auto& v:std::array<std::array<int,3>,5>{{{0,50,17800},{3,50,18600},{0,58,10300},{0,49,19400},{3,49,20200}}}) {
auto g=original;auto r=control(g);fitness_control(g,0,v[1]);
set_strength(g,r.expected_player,50,v[0]);g.memory.set32(list_start+0x0c,12000);
const std::array<uint8_t,7> bonuses={10,20,30,40,50,60,70};
for(size_t k=0;k<7;++k)g.memory.set8(list_start+0x38+uint32_t(k),bonuses[k]);
require(source_bonus(g,0,r.expected_player,12000,bonuses)==uint32_t(v[2]),"hard Source fitness and all7 bonus vector");
compare_rating(g,r,"all7 bonuses, fitness and prediction fallback",37,
Expected{100,uint32_t((12000+v[2])*100/9800)});
}
for(bool wins:{false,true}) {
auto g=original;auto r=control(g);fitness_control(g,0,50);set_strength(g,r.expected_player,50,0);
result_control(g,wins);
require(predicted_rank(g,1)==(wins?2:19),"independent mode4 result-composed rank");
g.memory.set32(list_start+0x0c,12000);
for(size_t k=0;k<7;++k)g.memory.set8(list_start+0x38+uint32_t(k),uint8_t((k+1)*10));
compare_rating(g,r,"rankFF predicts actual Native results without rating oracle reuse",37,
Expected{100,uint32_t((12000+(wins?16800:14300))*100/9800)});
}
{
auto g=original;auto r=control(g);fitness_control(g,0,50);set_strength(g,r.expected_player,50,0);
result_control(g,false);
// A separate declared result-byte generator; this is not a Source RNG
// or clock seed. The resulting actual Native standings predict rank9.
uint32_t recipe=4;
for(int round=0;round<8;++round)for(int m=0;m<9;++m) {
recipe=recipe*1664525u+1013904223u;
const uint32_t outcome=recipe%3u;
g.results.at(size_t(round)*10+size_t(m))=uint8_t(outcome==0?0x20:outcome==1?0:0x02);
}
require(predicted_rank(g,1)==9,"independent controlled Native prediction selects top10 bonus");
g.memory.set32(list_start+0x0c,12000);
for(size_t k=0;k<7;++k)g.memory.set8(list_start+0x38+uint32_t(k),uint8_t((k+1)*10));
compare_rating(g,r,"all7 top10 season branch from actual result bytes",37,Expected{100,298});
}
{
auto g=original;auto r=control(g);fitness_control(g,0,50);set_strength(g,r.expected_player,50,3);
g.memory.set32(list_start+0x0c,10000000u);
for(uint32_t k=0;k<7;++k)g.memory.set8(list_start+0x38+k,100);
compare_rating(g,r,"bonus products and total salary wrap at Source32 boundaries",37);
}
{
auto g=original;auto r=control(g);fitness_control(g,0,50);
set_strength(g,r.expected_player,50,0);const int pool_player=r.expected_player;
// Explicit SourceSlot points at a different actual owned player while
// the list's ordinary pool word retains its genuine free-agent player.
r.source_slot=24;r.expected_player=g.squad_slots.at(24)&0xfff;
require(r.expected_player!=pool_player&&r.expected_player!=0xfff,"actual distinct squad-index source");
set_strength(g,r.expected_player,50,3);g.memory.set32(list_start+0x0c,12000);
g.memory.set8(list_start+0x38,100);
compare_rating(g,r,"Sourceparam1 is absolute squad slot and never silently listpool",37);
}
for(int mode:{1,2,3}) {
auto g=original;auto r=control(g);g.memory.set8(::bmh::layout::GameMode,uint8_t(mode));
compare_rating(g,r,"425ee does not own career mode or extra modeRNG",37,Expected{100,100});
}
{
auto g=original;auto r=control(g);
auto bad=r;bad.expected_player^=1;unsupported(g,bad,"wrong explicit player identity");
bad=r;bad.expected_bidder=54;unsupported(g,bad,"wrong explicit bidder identity");
bad=r;bad.source_slot=-1;unsupported(g,bad,"negative SourceSlot");
bad=r;bad.source_slot=int(g.squad_slots.size());unsupported(g,bad,"SourceSlot past native storage");
bad=r;bad.list_entry=-1;unsupported(g,bad,"negative list entry");
bad=r;bad.list_entry=44;unsupported(g,bad,"list entry past ordinary+special range");
bad=r;bad.bid_slot=4;unsupported(g,bad,"invalid bid index");
auto inconsistent=g;inconsistent.manager_records.at(0x290)=54;
unsupported(inconsistent,r,"Native bidder record disagrees with runtime team");
auto invalid_lineup=g;invalid_lineup.squad_slots.at(24)=0xffff;
unsupported(invalid_lineup,r,"FULLWORD FFFF lineup references player4095");
auto missing_results=g;missing_results.league_rounds[0]=8;
std::fill(missing_results.results.begin(),missing_results.results.begin()+8*10,0xcc);
unsupported(missing_results,r,"Source prediction cannot divide by zero recent games");
auto empty=g;empty.squad_slots.at(size_t(r.source_slot))=0xfff;unsupported(empty,r,"missing Sourceplayer");
auto zero=g;zero.memory.set32(list_start+0x2c,9999);unsupported(zero,r,"zero rounded fee basis");
zero=g;zero.memory.set32(list_start+0x30,0);unsupported(zero,r,"zero salary basis");
zero=g;zero.memory.set32(list_start+0x30,99);unsupported(zero,r,"nonzero salary rounds to zero basis");
zero=g;zero.memory.set32(list_start+0x2c,30000);zero.memory.set8(list_start+0x34,0x80);
// 37500>>2 is9375, not0: loan should still be supported here.
compare_rating(zero,r,"small nonzero loan basis is not synthesized/rounded",37);
}
std::puts("PASS independent legacy routine Native/board/Source32/W vectors; caller flow remains separately bounded");
return 0;
} catch(const std::exception& e) {std::fprintf(stderr,"transfer_bid_qualification_tests: %s\n",e.what());return 1;}