Files
Dreierpack-Manager/tests/reality_duel_tests.cpp
T
ClaudeandClaude 9870d90d65 Tests share one check helper; stale references in comments corrected
116 test files had their own identical copy of check(bool, const char*); they
use bmh::test_support::check from src/testing/check.hpp. Seven comments pointed
to documents that no longer exist or named a former author.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-11 14:52:42 +01:00

109 lines
7.8 KiB
C++

// SPDX-License-Identifier: GPL-3.0-only
#include <cstdio>
#include <algorithm>
#include <stdexcept>
#include "game/reality_duel.hpp"
#include "testing/check.hpp"
using namespace bmh;
namespace {
using bmh::test_support::check;
GameState state_fixture() {
GameState s;s.players.resize(22);s.player_bonus.resize(22);s.team_morale={24,24};s.squad_slots.resize(48,kEmptySlot);
for (int i=0;i<22;++i) {
s.players[size_t(i)].w35c=48|(100u<<7)|(100u<<14);s.players[size_t(i)].w368=3u|(3u<<4)|(3u<<6);
s.squad_slots[size_t((i/11)*24+i%11)]=uint16_t(kSlotInLineup|i);
}
return s;
}
void place(RealitySetup& scene,int id,int x,int y) {
check(scene.grid.place(id,x,y,id/11),"fixture placement");scene.motion.figures[size_t(id)]={true,x,y,x,y,0};
scene.players[size_t(id)].player=id;scene.players[size_t(id)].squad_slot=(id/11)*24+id%11;
}
}
int main(int argc,char** argv) {
try {
if (argc!=2) throw std::runtime_error("usage: reality_duel_tests <Original data>");
const auto exe=load_le(std::filesystem::path(argv[1])/"BMH.exe");auto state=state_fixture();
RealitySetup scene;scene.teams={0,1};place(scene,1,20,12);scene.grid.place(22,20,12,2);scene.grid.clear(20,12,0);
RealityBallHistory history;RatingContext rating;WatcomRandom rand(12345);GameRandom game(1);
const auto ball=decide_reality_ball(state,scene,1,history,rating,rand);
check(ball.boundary==RealityBallBoundary::dribble_or_duel,"Source prefers dribble without a viable pass or shot");
const auto before=rand.calls();const auto dribble=continue_reality_dribble(state,scene,exe,ball,0,true,rand);
check(rand.calls()==before+1 && dribble.steps==2 && !dribble.lost_duel,"free dribble only draws its speed once and never asks for forced event");
const auto outcome=apply_reality_dribble(state,scene,dribble,history,rating,0,rand,game);
check(outcome.action==2 && scene.grid.ball()==std::pair{22,12} && scene.grid.position(1)==std::pair{22,12},
"Source free dribble moves actor and ground ball to the same path point");
check(!scene.motion.ball_airborne && !game.calls(),"dribble clears loft and free commit adds no Game draw");
scene={};scene.teams={0,1};place(scene,1,20,12);scene.grid.place(22,20,12,2);scene.grid.clear(20,12,0);
auto wrapped=ball;wrapped.speed_ability=-99;rand=WatcomRandom(12345);
const auto slow=continue_reality_dribble(state,scene,exe,wrapped,0,true,rand);
check(slow.steps==1,"Source signed-char speed overflow chooses one step without normalization");
scene={};scene.teams={0,1};place(scene,1,20,12);place(scene,12,20,12);
scene.grid.place(22,20,12,2);scene.grid.clear(20,12,0);
auto contested=ball;contested.opponent_at_actor=13;
auto weak=state;weak.players[1].w35c=127u<<7;rand=WatcomRandom(1);game=GameRandom(1);history={};
const auto lost=continue_reality_dribble(weak,scene,exe,contested,0,true,rand);
const auto lost_outcome=apply_reality_dribble(weak,scene,lost,history,rating,0,rand,game);
check(lost.lost_duel && lost.steps==1 && lost_outcome.lost_duel &&
scene.grid.position(1)==std::pair{21,12} && scene.grid.ball()==std::pair{20,12} && rand.calls()==4,
"lost Source duel moves actor one step while leaving ball with opponent, without a synthetic card");
scene={};scene.teams={0,1};place(scene,1,36,12);place(scene,12,36,12);scene.grid.place(22,36,12,2);
state.players[12].w35c=127u<<7; // negative balance: Source base foul chance0
rand=WatcomRandom(12345);auto foul=reality_foul(state,scene,12,true,1,0,true,rand,{});
check(!foul.result && rand.calls()==1,"zero foul propensity short-circuits after its single Source Watcom roll");
state.manager_teams={1};state.manager_records.resize(0xb0c);state.tactics.resize(0x840);
state.tactics[5]=239; // PID12 - squad start24 clamps to row0, not offender row1.
bool event_seen=false;
for (int seed=1;seed<=64 && !event_seen;++seed) {
rand=WatcomRandom{uint32_t(seed)};int called=0;
foul=reality_foul(state,scene,12,true,1,0,true,rand,[&](int slot,int side) {
++called;check(slot==25 && side==1,"forced-event callback receives absolute Source slot and offender side");return uint8_t(0x82);
});
if (!called) {
check((foul.result==2 && rand.calls()==3) || (!foul.result && rand.calls()==1),
"Source no-foul or unpunished-foul branches retain their exact draw boundary");continue;
}
event_seen=true;
check(foul.result==3 && foul.restart==2 && foul.event_stops_scene && foul.event_kind==2 && !foul.whistle,
"defensive foul yields penalty, forced-event byte and explicit stop while muted sound draw remains");
check(foul.cues.size()==3 && foul.cues[0].actor==1 && foul.cues[0].code==19 &&
foul.cues[1].actor==-1 && foul.cues[1].code==20 && foul.cues[2].actor==12 && foul.cues[2].code==21,
"Source foul cues preserve the unassigned actor slot for code20");
check(rand.calls()==3 && called==1,"forced callback boundary neither duplicates prefix draws nor adds placeholder randomness");
rand=WatcomRandom{uint32_t(seed)};bool missing=false;
try { reality_foul(state,scene,12,true,1,0,true,rand,{}); } catch(const FormatError&) { missing=true; }
check(missing && rand.calls()==3,"missing real booking engine is explicit at exact Source event boundary");
}
check(event_seen,"human literal board index reaches real forced-event boundary");
bool whistle_seen=false;
for (uint32_t seed=1;seed<=64;++seed) {
WatcomRandom silent(seed),observed(seed);
int plain_events=0,heard_events=0;std::vector<int> order;
const auto plain=reality_foul(state,scene,12,true,1,0,false,silent,
[&](int,int){++plain_events;return uint8_t(0x82);});
const auto heard=reality_foul(state,scene,12,true,1,0,false,observed,
[&](int,int){++heard_events;order.push_back(100);return uint8_t(0x82);},
[&](uint8_t id){check(id==21,"foul emits only the Original whistle");order.push_back(id);});
check(silent.seed()==observed.seed() && silent.calls()==observed.calls() &&
plain_events==heard_events && plain.result==heard.result && plain.restart==heard.restart &&
plain.event_result==heard.event_result && plain.scene_status==heard.scene_status &&
plain.whistle==heard.whistle && plain.cues.size()==heard.cues.size(),
"sound observer preserves foul decisions, callback count and full Watcom state");
check(std::count(order.begin(),order.end(),21)==int(heard.whistle),
"one sound only when the existing qualified whistle draw succeeds");
if(heard.whistle) {
whistle_seen=true;check(order.front()==21,"whistle precedes the forced event UI");
}
WatcomRandom muted(seed);int muted_sounds=0;
const auto quiet=reality_foul(state,scene,12,true,1,0,true,muted,
[](int,int){return uint8_t(0x82);},[&](uint8_t){++muted_sounds;});
check(!muted_sounds && !quiet.whistle && muted.seed()==silent.seed() && muted.calls()==silent.calls(),
"muted foul retains every Original draw without emitting a whistle");
}
check(whistle_seen,"sound observer probe reaches an actual whistle");
std::puts("PASS: Source free dribble, signed speed, foul rolls/board index, penalty, cues and explicit forced-card callback; no Native card integration claimed");return 0;
} catch(const std::exception& e) { std::fprintf(stderr,"FAIL: %s\n",e.what());return 1; }
}