Files
Viano-Core/tests/clientless/test_adventure_combat_reactions.py
T
Nico 3aa780662e Complete AdventureBot navigation, instance travel and shutdown fixes
Finish capital waiting travel and adaptive flight entry up to 10,000 yards.
Preserve checked vertical climbs, recover blocked ground departures and find
validated dry landings. Retain group routes and Undercity arrival constraints.

Restore defense from native combat references, coordinate instance rendezvous
and browser reentry, finalize clientless sessions before map destruction and
transfer Halaa capture-point ownership safely.

Include the associated regression tests, investigation reports and reusable
diagnostic scripts. Keep generated runtime evidence and server binaries local
through scoped ignore rules. Validation/build/live evidence is recorded in the
session checkpoint and individual reports.
2026-11-05 10:35:34 +01:00

272 lines
21 KiB
Python

"""Execute production reaction/death state machine with native-world adapters."""
from pathlib import Path
import subprocess,tempfile
root=Path(__file__).resolve().parents[2]
source=(root/'src/server/game/World/AdventureCombatMgr.cpp').read_text()
def function(signature):
a=source.index(signature);b=source.index('{',a);e=b+1;depth=1
while depth:depth+=(source[e]=='{')-(source[e]=='}');e+=1
return source[a:e]
header=(root/'src/server/game/World/AdventureCombatMgr.h').read_text()
header='\n'.join(x for x in header.splitlines() if not x.startswith('#include')).replace('private:','public:')
code=r'''
#include "AdventureCombatPolicy.h"
#include "AdventureRecoveryPolicy.h"
#include <cassert>
#include <string>
#include <deque>
#include <vector>
#include <memory>
#include <unordered_map>
#include <algorithm>
#include <ctime>
#include <set>
#include <list>
constexpr int UNIT_STATE_CASTING=1;
using uint32=unsigned;using uint8=unsigned char;
#define TC_GAME_API
#define TC_LOG_INFO(...) ((void)0)
#define TC_LOG_WARN(...) ((void)0)
constexpr int PLAYER_FLAGS=0,PLAYER_FLAGS_GHOST=1,CMSG_REPOP_REQUEST=2,CMSG_RECLAIM_CORPSE=3,CORPSE_RESURRECTABLE_PVP=1;
constexpr float CORPSE_RECLAIM_RADIUS=39,INVALID_HEIGHT=-100000;
struct ObjectGuid{unsigned id=0;unsigned GetCounter()const{return id;}void Clear(){id=0;}std::string ToString()const{return std::to_string(id);}bool operator==(ObjectGuid b)const{return id==b.id;}bool operator!=(ObjectGuid b)const{return id!=b.id;}bool operator<(ObjectGuid b)const{return id<b.id;}};
struct Position{
float x=0,y=0,z=0;void Relocate(float a,float b,float c){x=a;y=b;z=c;}
float GetPositionX()const{return x;}float GetPositionY()const{return y;}float GetPositionZ()const{return z;}
float GetExactDist(Position const& b)const{return std::sqrt((x-b.x)*(x-b.x)+(y-b.y)*(y-b.y)+(z-b.z)*(z-b.z));}
float GetExactDist(Position const* b)const{return GetExactDist(*b);}
};
struct Map{bool IsDungeon(){return false;}float GetHeight(int,float,float,float,bool,float){return 0;}}map;
struct Creature;struct Player;
struct Unit:Position{
ObjectGuid guid;bool valid=true,alive=true,phase=true,visible=true,inWorld=true;
virtual unsigned getLevel(){return 60;}
virtual Creature* ToCreature(){return nullptr;}virtual Player* ToPlayer(){return nullptr;}
virtual bool IsAlive(){return alive;}bool IsInWorld(){return inWorld;}virtual ObjectGuid GetGUID(){return guid;}
Unit*victim=nullptr;float GetOrientation(){return 0;}Unit*GetVictim(){return victim;}Position const& GetPosition()const{return *this;}
void GetNearPoint(Player*,float&a,float&b,float&c,float,float){a=x;b=y;c=z;}float GetAngle(Player*){return 0;}
};
struct Creature:Unit{bool controlled=false,evading=false,boss=false,elite=false;bool isElite(){return elite;}unsigned level=60;std::string script="mob";Creature(unsigned n){guid={n};}ObjectGuid GetGUID(){return guid;}Creature* ToCreature()override{return this;}bool GetControllingPlayer(){return controlled;}bool IsAlive(){return alive;}bool IsInWorld(){return inWorld;}bool IsEvadingAttacks(){return evading;}bool isWorldBoss(){return boss;}unsigned getLevel(){return level;}std::string GetScriptName(){return script;}};
struct Player;
struct Corpse:Position{
time_t released=100;int saves=0;ObjectGuid GetGUID(){return {700};}time_t GetGhostTime(){return released;}int GetType(){return 0;}
unsigned GetMapId(){return 0;}unsigned GetInstanceId(){return 0;}Map* GetMap(){return &map;}bool IsWithinDistInMap(Player*,float,bool);void SaveToDB(){++saves;}
}corpse;
struct WorldPacket{int opcode;WorldPacket(int o,int):opcode(o){}template<class T>WorldPacket&operator<<(T){return *this;}};
struct Session{Player* owner=nullptr;int releases=0,reclaims=0;void HandleRepopRequestOpcode(WorldPacket&);void HandleReclaimCorpseOpcode(WorldPacket&);};
std::vector<Creature*> escapeCreatures;
struct Group{ObjectGuid leader{26};ObjectGuid GetLeaderGUID(){return leader;}}group;
struct CombatRef{Unit*first;Unit*second;bool suppressedFirst=false,suppressedSecond=false;
Unit*GetOther(Unit*p){return p==first?second:first;}bool IsSuppressedFor(Unit*p){return p==first?suppressedFirst:suppressedSecond;}};
struct Combat{std::unordered_map<unsigned,CombatRef*>pve,pvp;auto const&GetPvECombatRefs(){return pve;}auto const&GetPvPCombatRefs(){return pvp;}};
struct Player:Unit{
Combat combatManager;Combat&GetCombatManager(){return combatManager;}
bool IsResurrectRequested(){return false;}void ResurrectUsingRequestData(){}void ClearResurrectRequestData(){}
bool IsWithinLOSInMap(Unit*){return los;}bool IsFlying(){return false;}bool IsFalling(){return false;}bool HasUnitState(int){return false;}void GetPartyMembers(std::list<Unit*>&){}bool IsInMap(Unit*){return true;}
bool grouped=false;float health=100;std::set<Unit*> attackers;
bool alive=true,ghost=false,teleport=false,combat=false,melee=true,los=true;unsigned delay=30;int saves=0,revives=0,bones=0,graveyards=0;bool sickness=false;int durability=75;
Session session;Player(){session.owner=this;guid={26};}ObjectGuid GetGUID(){return guid;}Player* ToPlayer()override{return this;}Group* GetGroup(){return grouped?&group:nullptr;}bool IsAlive(){return alive;}bool IsInWorld(){return true;}bool IsInCombat(){return combat;}bool IsBeingTeleported(){return teleport;}bool GetTransport(){return false;}bool IsInFlight(){return false;}bool IsCharmed(){return false;}
unsigned GetMapId(){return 0;}unsigned GetInstanceId(){return 0;}bool InBattleground(){return false;}bool InArena(){return false;}bool HasFlag(int,int){return ghost;}Session*GetSession(){return &session;}Corpse*GetCorpse(){return &corpse;}
uint32 GetCorpseReclaimDelay(bool){return delay;}Map*GetMap(){return &map;}int GetPhaseShift(){return 0;}
bool IsInPhase(Unit*c){return c->phase;}bool CanSeeOrDetect(Unit*c){return c->visible;}bool IsValidAttackTarget(Unit*c){return c->valid;}unsigned getLevel(){return 60;}unsigned getClass(){return 1;}bool IsWithinMeleeRange(Unit*){return melee;}float GetCombatReach(){return 1;}float GetAngle(Player*){return 0;}
void SaveToDB(){++saves;}void RepopAtGraveyard(){++graveyards;teleport=true;Relocate(-100,0,0);}void ResurrectPlayer(float hp,bool sick){assert(hp==0.5f);sickness=sick;alive=true;ghost=false;++revives;}void SpawnCorpseBones(){++bones;}
bool IsHostileTo(Unit*){return true;}float GetHealthPct(){return health;}
auto const& getAttackers(){return attackers;}
void GetCreatureListWithEntryInGrid(std::vector<Creature*>&v,int,float){v=escapeCreatures;}
void GetPlayerListInGrid(std::vector<Player*>&,float){}
void AttackStop(){}void CastStop(){}void SetStandState(int){}
struct Motion{void Clear(){}}motion;Motion*GetMotionMaster(){return &motion;}
void StopMoving(){}
};
bool Corpse::IsWithinDistInMap(Player*p,float r,bool){return GetExactDist(p)<=r;}
void Session::HandleRepopRequestOpcode(WorldPacket&){++releases;owner->ghost=true;owner->Relocate(-100,0,0);}
void Session::HandleReclaimCorpseOpcode(WorldPacket&){++reclaims;assert(corpse.IsWithinDistInMap(owner,39,true));owner->alive=true;owner->ghost=false;}
// Update's local combat approach adapter.
void nearPoint(Creature*,Player*,float&,float&,float&,float,float){}
struct FakeCreature:Creature{using Creature::Creature;void GetNearPoint(Player*,float&x,float&y,float&z,float,float){x=this->x;y=this->y;z=this->z;}float GetAngle(Player*){return 0;}};
namespace GameTime{time_t now=100;time_t GetGameTime(){return now;}}
namespace ObjectAccessor{std::unordered_map<unsigned,Unit*> objects;Unit* GetUnit(Player&,ObjectGuid g){auto i=objects.find(g.id);return i==objects.end()?nullptr:i->second;}}
struct ClientlessPathDiagnostics{bool Complete=true,Suspicious=false;float PathLength=100;};
enum class ClientlessTravelState{Moving,Arrived,Stuck,PathRejected};
struct TravelStatus{ClientlessTravelState State=ClientlessTravelState::Arrived;Position Target;};
struct Travel{
TravelStatus status;bool present=false,path=true,nearOnly=false;int starts=0,analyses=0;
auto GetStatus(uint32)->TravelStatus*{return present?&status:nullptr;}
void CancelTravel(uint32){present=false;}
bool AnalyzePath(Player*p,Position const&end,ClientlessPathDiagnostics& d){++analyses;d.PathLength=p->GetExactDist(end);return path && (!nearOnly || end.x<-15);}
bool StartTravel(Player*,Position const&end){++starts;present=true;status.State=ClientlessTravelState::Moving;status.Target=end;return true;}
}travel;auto sClientlessTravelMgr=&travel;
struct Behavior{int interrupts=0;void InterruptForCombat(Player*){++interrupts;}}behavior;auto sAdventureBehaviorMgr=&behavior;
'''
code+=r'''
struct Profile{bool AllowRetreat=true;unsigned Class=0,Specialization=0,SoloSpecialization=0;std::string SourcePath;};
struct Lua{Profile* profile=nullptr;Profile*GetAdventureProfile(unsigned){return profile;}void DismountGroundMount(Player*,char const*){}}lua;auto sClientlessLuaEngine=&lua;
'''
# production Update uses direct Position members and creature near point.
code=code.replace('float x=0,y=0,z=0;','union{float x=0;float m_positionX;};union{float y=0;float m_positionY;};union{float z=0;float m_positionZ;};',1)
code=code.replace('bool GetControllingPlayer(){return controlled;}bool IsAlive(){return alive;}bool IsInWorld(){return inWorld;}bool IsEvadingAttacks(){return evading;}bool isWorldBoss(){return boss;}unsigned getLevel(){return level;}std::string GetScriptName(){return script;}};', 'bool GetControllingPlayer(){return controlled;}bool IsAlive(){return alive;}bool IsInWorld(){return inWorld;}bool IsEvadingAttacks(){return evading;}bool isWorldBoss(){return boss;}unsigned getLevel(){return level;}std::string GetScriptName(){return script;}float GetAngle(Player*){return 0;}void GetNearPoint(Player*,float&a,float&b,float&c,float,float){a=x;b=y;c=z;}};')
# Forward declaration needed in Creature's adapter.
code=code.replace('struct Creature;','struct Creature;struct Player;',1)
code+=r'''
struct Encounter{bool Death(Player*){return false;}bool Update(Player*,unsigned){return false;}}encounter;auto sAdventureEncounterMgr=&encounter;
struct Generator{bool PrepareCombat(Player*,std::string&){return true;}}generator;auto sAdventureGeneratorMgr=&generator;
namespace AdventureRotationPolicy{unsigned SoloSpec(unsigned,unsigned){return 0;}}
bool AdventureTank(Unit*){return false;}
struct PlayerAI{static unsigned GetPlayerSpec(Player*){return 0;}};
'''
code+=header+r'''
class AdventureCombatMgr::Fighter{public:bool Ranged(){return false;}int ticks=0;void Tick(Unit*,uint32){++ticks;}};
bool AdventureCombatMgr::GroupHeal(Player*,Record&){return false;}
Unit* groupChoice=nullptr;
bool AdventureCombatMgr::GroupTarget(Player*p,Record&r){return groupChoice?Start(p,r,groupChoice,false,true,0):false;}
bool AdventureCombatMgr::Reachable(Player*p,Unit*)const{return p->los;}
Unit* AdventureCombatMgr::PvPTarget(Player*)const{return nullptr;}
Creature* AdventureCombatMgr::Proactive(Player*)const{return nullptr;}
bool AdventureCombatMgr::Start(Player*,Record&r,Unit*c,bool train,bool defense,time_t until){r.AI=std::make_shared<Fighter>();r.Target=c->GetGUID();r.Training=train;r.Defending=defense;r.Until=until;return true;}
void AdventureCombatMgr::Finish(Player*,Record&r){r.AI.reset();r.Target.Clear();r.Defending=false;r.Training=false;r.Cooldown=10000;}
'''
for name in ('bool AdventureCombatMgr::Valid(', 'void AdventureCombatMgr::DamageTaken(', 'bool AdventureCombatMgr::Flee(', 'void AdventureCombatMgr::Revived(', 'bool AdventureCombatMgr::Death(', 'bool AdventureCombatMgr::Update('):code+='\n'+function(name)
code+=r'''
int main(){
using namespace AdventureCombatPolicy;
assert(SafeFirstAttack(60,62,60,false,false,1,false,0));
assert(!SafeFirstAttack(60,63,100,false,false,1,false,0));
assert(!SafeFirstAttack(60,60,59,false,false,1,false,0));
assert(!SafeFirstAttack(60,60,100,true,false,1,false,0));
assert(!SafeFirstAttack(60,60,100,false,true,1,false,0));
assert(!SafeFirstAttack(60,60,100,false,false,2,false,0));
assert(!SafeFirstAttack(60,60,100,false,false,1,true,29));
assert(!CemeteryFallback(399,100,true));assert(CemeteryFallback(400,100,true));
assert(!CemeteryFallback(5000,100,false));assert(!CemeteryFallback(99,100,true));
assert(SegmentDistance(5,3,0,0,0,0,10,0,0)==3);
AdventureCombatMgr mgr;Player p;Creature a(1),b(2),c(3);ObjectAccessor::objects={{1,&a},{2,&b},{3,&c}};
Player enemy;enemy.guid={99};ObjectAccessor::objects[99]=&enemy;
assert(mgr.Valid(&p,&enemy,false));assert(!mgr.Valid(&p,&enemy,true));
enemy.valid=false;assert(!mgr.Valid(&p,&enemy,false));enemy.valid=true;
assert(mgr.Valid(&p,&a,false));assert(!mgr.Valid(&p,&a,true));
Creature dummy(4);dummy.script="npc_training_dummy";assert(mgr.Valid(&p,&dummy,true));assert(!mgr.Valid(&p,&dummy,false));
dummy.level=63;assert(!mgr.Valid(&p,&dummy,true));dummy.level=60;
dummy.boss=true;assert(!mgr.Valid(&p,&dummy,true));dummy.boss=false;
dummy.phase=false;assert(!mgr.Valid(&p,&dummy,true));dummy.phase=true;
dummy.visible=false;assert(!mgr.Valid(&p,&dummy,true));dummy.visible=true;
dummy.controlled=true;assert(!mgr.Valid(&p,&dummy,true));dummy.controlled=false;
dummy.valid=false;assert(!mgr.Valid(&p,&dummy,true));
auto&r=mgr._records[26];
mgr.DamageTaken(&p,&enemy,1);assert(r.Damagers.front().id==99);r.Damagers.clear();
mgr.DamageTaken(&p,&a,0);assert(r.Damagers.empty());
mgr.DamageTaken(&p,&a,5);mgr.DamageTaken(&p,&b,5);mgr.Update(&p,500);
assert(r.Target.id==1 && r.Defending); // first actual damager
mgr.DamageTaken(&p,&c,5);mgr.Update(&p,500);assert(r.Target.id==1);
a.alive=false;mgr.Update(&p,500);assert(!r.AI);mgr.Update(&p,500);assert(r.Target.id==2);
mgr.Finish(&p,r);r.Damagers.clear();mgr.Start(&p,r,&c,true,false,500);
mgr.DamageTaken(&p,&b,1);mgr.Update(&p,500);assert(r.Target.id==2 && r.Defending && !r.Training);
// Actual player attackers use the same first-damager focus and native PvP permission.
mgr.Finish(&p,r);r.Damagers.clear();mgr.DamageTaken(&p,&enemy,1);mgr.Update(&p,500);
assert(r.Target.id==99 && r.Defending);mgr.DamageTaken(&p,&c,1);mgr.Update(&p,500);assert(r.Target.id==99);
enemy.valid=false;mgr.Update(&p,500);assert(!r.AI);r.Damagers.clear();
// Native combat bindings alone must start defence before the first hit.
// This reproduces Rixzek/Lisaile's available zero-threat/no-damage deadlock.
p.combat=true;p.health=100;p.melee=true;p.Relocate(0,0,0);a.alive=a.valid=true;a.level=60;a.Relocate(11,0,0);
CombatRef refA{&p,&a},refB{&p,&b},refPlayer{&p,&enemy};p.combatManager.pve={{1,&refA}};
r={};mgr.Update(&p,500);assert(r.AI&&r.Defending&&!r.Training&&r.Target.id==1&&r.AI->ticks==1);
// A running target and the first actual damager retain priority over refs.
r={};mgr.Start(&p,r,&b,false,true,0);mgr.Update(&p,500);assert(r.Target.id==2);
r={};mgr.DamageTaken(&p,&b,1);mgr.Update(&p,500);assert(r.Target.id==2&&r.Defending);
// Suppression on either side, native invalidity, phase/visibility, evade,
// death and training dummies must not be turned into a fresh attack.
for(unsigned mode=0;mode<8;++mode){
r={};refA.suppressedFirst=mode==0;refA.suppressedSecond=mode==1;
a.valid=mode!=2;a.phase=mode!=3;a.visible=mode!=4;a.evading=mode==5;a.alive=mode!=6;a.script=mode==7?"npc_training_dummy":"mob";
mgr.Update(&p,500);assert(!r.AI);
}
refA.suppressedFirst=refA.suppressedSecond=false;a.valid=a.phase=a.visible=a.alive=true;a.evading=false;a.script="mob";
r={};a.Relocate(81,0,0);mgr.Update(&p,500);assert(!r.AI);a.Relocate(11,0,0);
// Failed-target/death cooldowns remain effective for the no-damage fallback.
r={};r.Cooldown=1000;mgr.Update(&p,500);assert(!r.AI);mgr.Update(&p,500);assert(r.AI);
// Prefer somebody actually attacking us; ties use a stable GUID order.
a.Relocate(2,0,0);b.Relocate(15,0,0);b.victim=&p;p.combatManager.pve[2]=&refB;
r={};mgr.Update(&p,500);assert(r.Target.id==2);b.victim=nullptr;a.Relocate(11,0,0);b.Relocate(-11,0,0);
r={};mgr.Update(&p,500);assert(r.Target.id==1);
// PvP uses the same native permission check, without creating new combat.
p.combatManager.pve.clear();p.combatManager.pvp={{99,&refPlayer}};enemy.valid=true;
r={};mgr.Update(&p,500);assert(r.Target.id==99&&r.Defending);
enemy.valid=false;r={};mgr.Update(&p,500);assert(!r.AI);p.combatManager.pvp.clear();
// Group coordination/healing runs first; if it finds no target, a grouped
// bot can still defend against its own established combat opponent.
p.grouped=true;p.combatManager.pve={{1,&refA}};r={};mgr.Update(&p,500);assert(r.Target.id==1);
groupChoice=&b;r={};mgr.Update(&p,500);assert(r.Target.id==2);groupChoice=nullptr;p.grouped=false;
p.combatManager.pve.clear();r={};mgr.Update(&p,500);assert(!r.AI); // no attacking arbitrary nearby creatures
p.combat=false;p.combatManager.pve={{1,&refA}};r={};mgr.Update(&p,500);assert(!r.AI);
p.combatManager.pve.clear();r={};
// Release through native handler and save ghost plus corpse timestamp.
mgr.Finish(&p,r);p.alive=false;p.ghost=false;r.Dead=false;mgr.Death(&p,r);
assert(p.ghost && p.session.releases==1 && p.saves==1 && corpse.saves==1);
// Native reclaim radius and native delay both apply.
p.Relocate(38,0,0);GameTime::now=129;mgr.Death(&p,r);assert(p.session.reclaims==0);
GameTime::now=130;mgr.Death(&p,r);assert(p.alive && p.session.reclaims==1);
// Exact corpse point inaccessible, near-side point in legal radius reachable.
p.alive=false;p.ghost=true;p.Relocate(-100,0,0);travel={};travel.nearOnly=true;r.NextCorpseSearch=0;
GameTime::now=500;mgr.Death(&p,r);assert(travel.starts==1 && travel.status.Target.x<-15);
assert(p.graveyards==0 && !p.alive); // time alone never revives reachable ghost
GameTime::now=900;mgr.Death(&p,r);assert(p.graveyards==0);
// No path: wait all five minutes from original native persisted ghost time.
travel={};travel.path=false;r.NextCorpseSearch=0;GameTime::now=399;mgr.Death(&p,r);assert(!p.alive && p.graveyards==0);
// Simulate process restart: volatile record gone; corpse timestamp survives.
AdventureCombatMgr::Record resumed;resumed.Dead=true;GameTime::now=400;mgr.Death(&p,resumed);
assert(p.graveyards==1 && p.teleport && !p.alive && resumed.CemeteryPending);
p.teleport=false;mgr.Death(&p,resumed);assert(p.alive && !p.sickness && p.revives==1 && p.bones==1 && p.durability==75);
// Flight boundaries, actual threats, group override and blocked fallback.
assert(!ShouldFlee(false,20,60,65,false,false));
assert(ShouldFlee(false,19,60,60,false,false));
assert(ShouldFlee(false,100,60,66,false,false));
assert(ShouldFlee(false,100,60,60,true,false));
assert(!ShouldFlee(false,100,60,59,true,false));
assert(!ShouldFlee(true,1,60,90,true,true));
p.alive=true;p.ghost=false;p.Relocate(0,0,0);p.combat=true;p.health=100;
r={};a.alive=true;a.valid=true;a.level=66;a.Relocate(1,0,0);p.attackers={&a};travel={};GameTime::now=1000;
mgr.Start(&p,r,&a,false,true,0);
assert(mgr.Flee(&p,r)&&r.Fleeing&&travel.starts==1);
assert(travel.status.Target.GetExactDist(a)>p.GetExactDist(a)+3);
// Reject the direct escape corridor if an additional hostile blocks it.
Creature obstacle(100);obstacle.Relocate(-15,0,0);escapeCreatures={&obstacle};
GameTime::now=1002;mgr.Flee(&p,r);
assert(SegmentDistance(-15,0,0,0,0,0,travel.status.Target.x,travel.status.Target.y,travel.status.Target.z)>=12);
escapeCreatures.clear();
// Group join aborts immediately, even while critically injured.
p.grouped=true;p.health=1;assert(!mgr.Flee(&p,r)&&!r.Fleeing&&!travel.present);
assert(!mgr.Flee(&p,r));p.grouped=false;p.health=100;
// Explicit profile refusal cancels retreat without suppressing combat.
Profile steadfast;steadfast.AllowRetreat=false;lua.profile=&steadfast;
p.health=1;r.Fleeing=true;travel.present=true;
assert(!mgr.Flee(&p,r)&&!r.Fleeing&&!travel.present&&r.AI);
lua.profile=nullptr;p.health=100;
// Blocked paths preserve native self-defence; no teleport/resurrection.
travel={};travel.path=false;GameTime::now=1004;
int ticks=r.AI->ticks;assert(mgr.Flee(&p,r)&&r.Fleeing&&travel.starts==0&&r.AI->ticks>ticks);
int oldRevives=p.revives,oldGraves=p.graveyards;
// Ending native combat alone is insufficient while still close to danger.
p.combat=false;p.attackers.clear();r.Defending=false;
GameTime::now=1006;assert(mgr.Flee(&p,r)&&r.Fleeing);
p.Relocate(-60,0,0);GameTime::now=1008;assert(mgr.Flee(&p,r)&&!r.Fleeing&&!r.AI);
assert(p.revives==oldRevives&&p.graveyards==oldGraves);
// Observe actual resurrection events, including a redeath BEFORE an alive poll.
r={};p.teleport=false;p.grouped=false;int beforeGraves=p.graveyards;
for(unsigned i=1;i<=5;++i){mgr.Revived(&p,2000+i*100);p.alive=false;p.ghost=false;GameTime::now=2001+i*100;mgr.Death(&p,r);assert(!r.ForceGraveyard&&p.graveyards==beforeGraves);}
assert(r.DeathChain.NextGraveyard);
mgr.Revived(&p,2600);p.alive=false;p.ghost=false;GameTime::now=2601;
mgr.Death(&p,r);assert(r.ForceGraveyard);mgr.Death(&p,r);
assert(p.graveyards==beforeGraves+1&&r.CemeteryPending);
p.teleport=false;mgr.Death(&p,r);assert(p.alive&&!p.sickness);
// No aggression means no flight solely from low health.
r={};p.health=1;assert(!mgr.Flee(&p,r));
}
'''
with tempfile.TemporaryDirectory() as d:
p=Path(d);(p/'test.cpp').write_text(code)
subprocess.run(['g++','-std=c++17','-I'+str(root/'src/server/game/World'),str(p/'test.cpp'),'-o',str(p/'test')],check=True)
subprocess.run([str(p/'test')],check=True)
print('Production combat bindings (PvE/PvP/group), suppression/permission/distance/cooldown guards, focus/damage priority, risk filters, corpse radius/delay, flight/group override, blocked escape, danger avoidance and malus-free persisted fallback passed.')