From bc621c1d74f82ee4cffb43ec09cfb76956c33029 Mon Sep 17 00:00:00 2001 From: nico Date: Fri, 6 Nov 2026 00:23:12 +0100 Subject: [PATCH] Enable Vashjir bot travel and fix walkable adventure outings --- doc/clientless/2026-11-05-vashjir.md | 86 +++ doc/clientless/2026-11-06-leisure-walk.md | 61 ++ doc/clientless/SESSION-RESUME.md | 312 ++++++++ .../2026-11-05-2300-vashjir-test/.gitignore | 1 + .../apply_midnight.py | 43 ++ .../midnight-result.json | 71 ++ .../verified-2300.json | 72 ++ .../checkpoints/2026-11-05-kordra/.gitignore | 1 + .../2026-11-05-kordra/diagnosis.json | 11 + .../2026-11-05-kordra/ground-result.json | 248 ++++++ .../2026-11-05-kordra/probe-ground-paths.lua | 17 + .../2026-11-05-kordra/probe-native-paths.lua | 22 + .../2026-11-05-kordra/probe_terrain.py | 33 + .../2026-11-05-kordra/terrain-summary.json | 49 ++ .../checkpoints/2026-11-05-vashjir/.gitignore | 1 + .../2026-11-05-vashjir/gateways-result.json | 207 +++++ .../2026-11-05-vashjir/live-gateway-areas.lua | 13 + .../2026-11-05-vashjir/live-result.json | 722 ++++++++++++++++++ .../live-vashjir-open-water.lua | 52 ++ .../2026-11-05-vashjir/live-vashjir.lua | 42 + .../2026-11-05-vashjir/result.json | 29 + .../2026-11-06-leisure-walk/.gitignore | 1 + .../live-completed.json | 24 + .../2026-11-06-leisure-walk/result.json | 31 + .../2026-11-06-leisure-walk/test-profile.lua | 7 + .../2026_11_05_00_adventure_seahorse.sql | 6 + .../world/2026_11_05_01_adventure_vashjir.sql | 12 + src/server/game/World/AdventureAreaMgr.cpp | 29 +- .../game/World/AdventureBehaviorMgr.cpp | 32 +- .../game/World/AdventureGeneratorMgr.cpp | 7 + src/server/game/World/AdventureVashjir.h | 17 + src/server/game/World/ClientlessFlightMgr.cpp | 7 +- src/server/game/World/ClientlessLuaEngine.cpp | 19 + src/server/game/World/ClientlessLuaEngine.h | 1 + .../game/World/ClientlessMountPreparation.h | 4 +- .../game/World/ClientlessTravelGraphMgr.cpp | 14 +- src/server/game/World/ClientlessTravelMgr.cpp | 15 +- tests/clientless/test_adventure_area_node.py | 7 +- tests/clientless/test_adventure_leisure.py | 22 +- tests/clientless/test_free_flight_planner.py | 20 +- tests/clientless/test_group_flight_mount.py | 2 + tests/clientless/test_outing_history.py | 36 + tests/clientless/test_swimming.py | 10 +- tests/clientless/test_vashjir.py | 67 ++ 44 files changed, 2450 insertions(+), 33 deletions(-) create mode 100644 doc/clientless/2026-11-05-vashjir.md create mode 100644 doc/clientless/2026-11-06-leisure-walk.md create mode 100644 doc/clientless/checkpoints/2026-11-05-2300-vashjir-test/.gitignore create mode 100644 doc/clientless/checkpoints/2026-11-05-2300-vashjir-test/apply_midnight.py create mode 100644 doc/clientless/checkpoints/2026-11-05-2300-vashjir-test/midnight-result.json create mode 100644 doc/clientless/checkpoints/2026-11-05-2300-vashjir-test/verified-2300.json create mode 100644 doc/clientless/checkpoints/2026-11-05-kordra/.gitignore create mode 100644 doc/clientless/checkpoints/2026-11-05-kordra/diagnosis.json create mode 100644 doc/clientless/checkpoints/2026-11-05-kordra/ground-result.json create mode 100644 doc/clientless/checkpoints/2026-11-05-kordra/probe-ground-paths.lua create mode 100644 doc/clientless/checkpoints/2026-11-05-kordra/probe-native-paths.lua create mode 100644 doc/clientless/checkpoints/2026-11-05-kordra/probe_terrain.py create mode 100644 doc/clientless/checkpoints/2026-11-05-kordra/terrain-summary.json create mode 100644 doc/clientless/checkpoints/2026-11-05-vashjir/.gitignore create mode 100644 doc/clientless/checkpoints/2026-11-05-vashjir/gateways-result.json create mode 100644 doc/clientless/checkpoints/2026-11-05-vashjir/live-gateway-areas.lua create mode 100644 doc/clientless/checkpoints/2026-11-05-vashjir/live-result.json create mode 100644 doc/clientless/checkpoints/2026-11-05-vashjir/live-vashjir-open-water.lua create mode 100644 doc/clientless/checkpoints/2026-11-05-vashjir/live-vashjir.lua create mode 100644 doc/clientless/checkpoints/2026-11-05-vashjir/result.json create mode 100644 doc/clientless/checkpoints/2026-11-06-leisure-walk/.gitignore create mode 100644 doc/clientless/checkpoints/2026-11-06-leisure-walk/live-completed.json create mode 100644 doc/clientless/checkpoints/2026-11-06-leisure-walk/result.json create mode 100644 doc/clientless/checkpoints/2026-11-06-leisure-walk/test-profile.lua create mode 100644 sql/custom/characters/2026_11_05_00_adventure_seahorse.sql create mode 100644 sql/custom/world/2026_11_05_01_adventure_vashjir.sql create mode 100644 src/server/game/World/AdventureVashjir.h create mode 100644 tests/clientless/test_outing_history.py create mode 100644 tests/clientless/test_vashjir.py diff --git a/doc/clientless/2026-11-05-vashjir.md b/doc/clientless/2026-11-05-vashjir.md new file mode 100644 index 0000000000..18543e79b0 --- /dev/null +++ b/doc/clientless/2026-11-05-vashjir.md @@ -0,0 +1,86 @@ +# Vashj'ir: Schwimmreittier und kontrollierte Gebietsanbindung + +Die Gebietssperre der AdventureBots für Vashj'ir (5146 und seine Untergebiete) +wird durch die World-Migration aufgehoben. Zutritt gilt ab Stufe80 für beide +Fraktionen. Fraktionsregeln einzelner Untergebiete bleiben erhalten. Die Region +bevorzugt keinen Freiflug. Normale Netzwerkspieler werden dadurch nicht geändert. + +Generierte AdventureBots erhalten ab Stufe80 den nativen Zauber75207 +„Abyssisches Seepferdchen“. Die Charakter-Migration versorgt bestehende generierte +Bots offline; Generator und Laufzeitabstimmung lernen den Zauber auch ohne +Questabschluss. Reitfähigkeit und weitere native Mount-Capabilities bleiben nötig. +Es werden keine Quests automatisch abgeschlossen und keine künstlichen Schwimm- +Geschwindigkeiten gesetzt. Der native Mount-Typ232 liefert den Geschwindigkeits- +Zauber86510. In Vashj'ir wird beim neuen Aufsitzen das Seepferdchen gewählt; +auf trockenem Boden bleibt der Bot zu Fuß. Bereits aktive Reittiere oder Flüge +werden nicht beim Gebietswechsel zwangsweise entfernt. Sichere schwimmende +Druiden dürfen ihre Gestalt für den Wechsel ins Wasserreittier verlassen. + +Die allgemeine Schwimmlogik erhält native Wasserreittiere anhand ihrer +Mount-Capability (FLOAT/UNDERWATER). Normale Bodenreittiere werden beim +Wassereintritt weiter abgesattelt. Lokale Wassersplines nutzen MOVE_SWIM und +übernehmen dadurch das native Schwimmtempo des aktiven Reittiers. + +## Der Sandstrand + +Die lokalen DBCs und die Testdatenbank enthalten vier gleichnamige Nodes: + +| Node | Funktion | Flugmeister-Spawn | Fraktion | +| --- | --- | --- | --- | +| taxi_606 | Festlandanbindung |342102 Francis Greene|Allianz| +| taxi_608 | Festlandanbindung |341915 Briglar|Horde| +| taxi_607 | Unterwassertaxi |342107 Swift Seahorse|Allianz| +| taxi_609 | Unterwassertaxi |341916 Swift Seahorse|Horde| + +Die Zugangsbindungen werden explizit mit diesen vorhandenen NPCs verknüpft. +Die normalen Fraktions- und nativen Taxipfadprüfungen bleiben aktiv. + +Weltreisen dürfen die Gebietsgrenze ausschließlich über native Taxi-Kanten mit +Vashj'ir-Endpunkt606 oder608 überschreiten. Andere Portale, Transportkanten, +Bodenabkürzungen und virtuelle Ein-/Ausstiege sind dafür nicht zulässig. +Auch geschätzte letzte Wegstrecken zu Locations dürfen die Grenze nicht umgehen. +Interne Schwimmwege und Unterwassertaxis bleiben möglich. Instanzportale werden +nicht als Festland-Gebietswechsel behandelt, damit vorhandene Dungeonwege erhalten +bleiben. Geplante Freiflüge zu oder von Vashj'ir-Positionen werden nicht angeboten; +ein bestehender Flug wird nicht durch eine neue Zonenprüfung abgebrochen. + +Die bestehende Übernahme der Route eines Bot-Gruppenanführers bleibt unverändert. + +## Prüfung + +Native Vashj'ir-Policy und Mount-Boarding unter ASan/UBSan geprüft, einschließlich +Stufe79/80, aktiver Flug bleibt erhalten, ungeeignete Zustände, Mount-Capability +und sicherer Druidenwechsel. Der echte adaptive Graphplaner enthält einen Test +mit billigerer scheinbarer Festland-Endstrecke: die gültige Route verwendet +trotzdem die Taxi-Kante nach606. Schwimmen, Gruppenreisen, Flug-Mounts und lokale +Splines wurden als Regression geprüft. Installations- und Live-Status stehen im +Session-Checkpoint und in checkpoints/2026-11-05-vashjir/. + +## Installierter und geprüfter Stand + +World- und Charakter-Migration angewandt; alle24 bestehenden generierten Bots +ab Stufe80 haben75207 gelernt. Build/Installation/regulärer Neustart erfolgreich; +PID104568, frisches READY und Ports8085/8087 geprüft. Loader und alle120 zuvor +aktiven AdventureBots sind wieder online. + +Live in offenem Wasser: PASS4/0. Testaria ritt das native Seepferdchen automatisch, +schwamm40 Yards über fünf lokale Segmente mit nativer Geschwindigkeit25,972yd/s +(+450% auf die Schwimmgrundgeschwindigkeit), blieb über alle Segmente aufgesessen +und erreichte das Ziel. Eine neue Fluganforderung wurde abgewiesen. Die erste +Stelle war eine trockene Unterwasserhöhle, daher als ungültiger Wasser-Testpunkt +verworfen; dieser Fehlversuch wurde aufbewahrt. Der endgültige Test wählte das +Wasser zuvor mit nativen Flüssigkeitsproben aus. + +Separater Live-Lauf PASS4/0: alle vier Sandstrand-Nodes gehören zur Zone5144 +und damit zu Vashj'ir. Testaria ist wieder Stufe10 an ihrer Originalposition, +offline; temporärer Mountzauber, Reitfähigkeit und Atem-Einstellungsdatei sind +entfernt. Das für den Test ausdrücklich geladene generische, nicht autonome +Adventure-Profil bleibt lediglich im normalen Laufzeitcache bis zum Neustart; +es wurde kein Testaria-Profil in Dateien oder Datenbank angelegt. + +Neun relevante Regressionstestdateien bestanden. Die alte AreaNode-Testhülle +benötigte dabei den bereits vorhandenen Unterstadt-Helper; sie lädt nun dessen +echte Implementierung und prüft die bestehende Taxi11-Ausnahme mit. Keine Änderung +am Unterstadt-Produktionsverhalten. Ein kompletter Live-Taxiflug samt anschließender +Reise zu einer tiefen Location wurde noch nicht durchgeführt; der Gebietsübergang +und die Ankerwahl wurden im nativen Graphplaner automatisiert geprüft. diff --git a/doc/clientless/2026-11-06-leisure-walk.md b/doc/clientless/2026-11-06-leisure-walk.md new file mode 100644 index 0000000000..597973602d --- /dev/null +++ b/doc/clientless/2026-11-06-leisure-walk.md @@ -0,0 +1,61 @@ +# Begehbare Ausflüge auf unebenem und begrenztem Gelände + +Kordra stand an Socrethars Sitz im Abenteuer-Intent. Erkundung und Patrouille +scheiterten bereits vor dem Start: der Planer suchte ausschließlich in80 bis150 +Yards Entfernung, verlangte dabei aber praktisch gleiche Endhöhe (maximal3Yards). +Das abfallende Gelände bot vollständig begehbare MMAP-Wege, die diese Regel +verwarf. Nah gelegene Flächen wurden gar nicht berücksichtigt. Native Proben +mit registriertem Testrion zeigten zwölf vollständige MMAP-Wege bei20/40/80Yards. + +Die Auswahl bevorzugt weiterhin lange Rundgänge. Erst wenn ein Ring keinen +akzeptierten Weg liefert, werden kleinere Ringe mit40,20 und10Yards geprüft. +Pro Ring gibt es acht Richtungen. Die Mindestspanne beträgt8 statt65Yards. +Gruppenbildung behält die bisherigen bevorzugten110/70-Yard-Ringe und erhält +anschließend dieselben kleineren Ersatzringe. Der erste erfolgreiche Ring beendet +die Suche; es werden nicht bei jedem Erfolg alle40 Kandidaten abgearbeitet. + +Vollständige native MMAP-Korridore bestimmen die Begehbarkeit. Pauschale Grenzen +für gesamte Endhöhe, Höhe zwischen einzelnen Pfadpunkten und deren Abstand +werden hier nicht zusätzlich als Steigungsgrenzen verwendet. Die Bodenabfrage +sucht passend zum Ringradius auch ober- und unterhalb des Starts. Ungültige +Höhen, unvollständige Pfade, Gebiets-/Außenbereichsgrenzen, maximale Entfernung +vom Anker, Wegbudget und extreme Umwege werden weiterhin abgewiesen. Die lokale +Ausführung und ihre Sicherheitsprüfungen bleiben unverändert. Hin- und Rückweg +folgen den ermittelten beziehungsweise bereits tatsächlich besuchten Wegpunkten. + +Eine gescheiterte Ausflugswahl zählt weiter für die Variantenabwechslung, aber +nicht als gestarteter Ausflug in der Aktionshistorie. Dadurch erhält sie keinen +vierfachen Ruhebonus für nachfolgendes Essen, Trinken oder Sitzen. + +Die Produktionsfunktionen werden durch die erweiterten Freizeit-Regressionen +geprüft: gültige Auf-/Abstiege,40-/10-Yard-Ersatzrunden, tatsächlich unerreichbare +Wege, Gebietsgrenzen, Rückweg und Unterbrechungen. Ein eigener Test führt die +Produktionsanweisungen zur Aktionshistorie unter ASan/UBSan aus. Mikroaktions- +Reset, Freizeitkatalog und Gruppenreisen bestanden ebenfalls. + +Build-, Installations- und Live-Ergebnisse stehen im Session-Checkpoint und unter +`checkpoints/2026-11-06-leisure-walk/`. Der erste Build fand einen Scopefehler in +der Logausgabe; behoben, danach erfolgreicher Build. Die Testhülle wertet nun auch +Logargumente aus, statt diese durch einen leeren Präprozessormakro zu verdecken. + +## Installiert und live geprüft + +Build und regulärer Neustart erfolgreich; frisches READY, laufender Prozess115099 +und Ports8085/8087 bestätigt. Loader und vorherige Population wurden wieder aktiv. +Die zehn Vashj'ir-Intents für00:00 blieben erhalten; der Mitternachtsauftrag war +bereits vor dem Build erfolgreich angewandt. + +Der registrierte Testbot Testrion148 lief am ursprünglichen Standort von Kordra +vollständig hinaus und zurück: native Ausflugsspanne138,85Yards, Zielhöhe197,96 +gegenüber Start223,38, sieben ausgehende und sieben rückkehrende Wegpunkte. +`LEISURE_COMPLETE ... legs=14` bestätigt den tatsächlich ausgeführten Rundgang. +Der vorhandene Makroplaner führte zuvor eine zusätzliche Anreise über einen +Flugknoten aus; diese wurde natürlich abgeschlossen und nicht als Teil der +Fußrundgang-Korrektur verändert. + +Testrion wurde wieder ausgeloggt. Charakterzeile, Zauberbuch, Fähigkeiten, +Inventar und Versorgungszustand entsprechen den gesicherten Originaldaten. +Das temporäre Profil wurde entfernt und zuvor nativ durch das generische Profil +ersetzt. Automatisch beim Login gelernte Sekundärberufe und deren unbenutzte +Archäologie-Ausgrabungsplätze wurden bereinigt. Kordras Intent und Position wurden +für diesen Test nicht manuell verändert. diff --git a/doc/clientless/SESSION-RESUME.md b/doc/clientless/SESSION-RESUME.md index b59df90814..29d104c5e6 100644 --- a/doc/clientless/SESSION-RESUME.md +++ b/doc/clientless/SESSION-RESUME.md @@ -1,3 +1,315 @@ +# 2026-11-06 – Vashj’ir und Ausflugsfix zum lokalen Commit abgeschlossen + +Nutzer hat den Commit aller bekannten offenen Änderungen beauftragt. Enthalten +sind Vashj’ir-Freigabe, Seepferdchen-Versorgung und Sandstrand-Routing sowie die +Kordra-Ausflugsplanung mit kurzen Ersatzrunden und korrekter Aktionshistorie. +Source, beide bereits angewandten SQL-Migrationen, Dokumentation, Tests und +reproduzierbare Test-/Diagnoseskripte werden zusammen committed. Ausgewählte +abschließende Ergebnisdateien belegen die Live-Prüfungen und den erledigten +Mitternachtsauftrag. Generierte Build-/Runtime-Logs und vollständige Betriebs- +snapshots bleiben lokal. Installierter und geprüfter Stand ist unverändert; +kein weiterer Build/Neustart für diesen Commit nötig. Kein Push beauftragt. + +--- + +# 2026-11-06 – Kordras Ausflugsplanung fertig und live geprüft + +Der beauftragte Fix ist installiert und abgeschlossen. Vorhandene Vashj’ir-WIP +wurde beibehalten; kein Commit oder Push beauftragt. Neuer Code ausschließlich +in AdventureBehaviorMgr.cpp: abgestufte Suchradien bis 10 Yards, Mindestspanne +8 statt 65, vollständige native MMAP-Korridore statt pauschaler Endhöhen-/Punkt- +Höhen-/Abstandsgrenzen. Radiusgerechte Bodenabfrage, Gebiets-/Außenbereichs- +grenzen, Anker250, Wegbudget/Umweggrenze und sicherer Rückweg bleiben erhalten. +Aktionshistorie erhält einen Ausflug erst nach erfolgreichem Start; Varianten- +Novelty berücksichtigt Fehlversuche weiter, aber kein falscher vierfacher Ruhebonus. + +Fünf relevante Regressionstestdateien bestanden: leisure (Rampen, kurze40/10- +Runden, Grenzen, Rückwege, Unterbrechung), outing_history mit echten Produktions- +anweisungen ASan/UBSan, micro_reset, leisure_catalog und group_travel. +Erster Build hatte einen Scopefehler beim Logargument best; korrigiert. Die +Testhülle wertet Logargumente jetzt aus (zuvor wegpräprozessiert). Finaler Build +PASS, jeweils Loader config/runtime0 + safeall vor -j10/Pool4. Danach regulärer +Shutdown104568 mit safe grace/finalize0, exited normally. Install PASS, bounded +GDB-PID115099, frisches READY +8085/8087 geprüft. Loader1 und alle120 zuvor +aktiven AdventureBots wiederhergestellt, missing0 im finalen Snapshot. + +LIVE: registrierter Testrion148 an Kordras alter Position Socrethars Sitz, +map530(4810.01,3843.66,223.38), manueller Adventure-Intent zur gleichen Location. +Nativer Fußausflug138.85yd, Ziel(4806.92,3707.19,197.96), also25.42yd tiefer. +Sieben Hin- und sieben Rückwegpunkte tatsächlich erlaufen; LEISURE_COMPLETE +kindexplore legs14 bestätigt vollständigen Rundgang. Kein bloßer Pfadproben- +Erfolg. Vorher führte der bestehende Makroplaner trotz bereits erreichter +Location eine Anreise über taxi139 aus (PreferredFlight); natürlich beendet, +kein zusätzlicher Navigationsfix dafür vorgenommen. Als möglichen separaten +Punkt merken, nicht als Teil dieses Fixes behaupten. + +Test148 wieder offline, gesamte Charakterzeile, Zauberbuch, alle Skills, +Inventar und supply_state exakt gegen Vorher-Snapshots restauriert/verifiziert. +Temporäres testrion.lua entfernt, vorher normal per luareload wieder generisches +Profil geladen. Supply-Daily wurde fürs Testen vorab auf heute gesetzt, damit +keine Inventaränderungen; Supply-Onlinetraining änderte Sekundärskills, diese +sowie automatisch erzeugte unbenutzte Archäologiesites (allefinds0, kein vorheriger +Skill794) wurden rückgängig gemacht. Keine regulären AdventureBots als Testbots +umgenutzt, Kordras Intent/Position nicht manuell verändert. Es bleibt lediglich +das übliche nichtautonome generische148-Profil im Laufzeitcache bis Neustart. + +Vashj’ir-Mitternachtsauftrag lief bereits00:00:17 vor Buildbeginn erfolgreich; +alle10 Slots heute20261106 00 adventure poi_tele_1512 nach Neustart erneut geprüft. +Kein Mitternachtstimer mehr offen. Dieser Fix benötigt keine weitere Beobachtung. +Doku2026-11-06-leisure-walk.md und vollständige Artefakte/Snapshots/Tests/Live- +Logs unter checkpoints/2026-11-06-leisure-walk/. Alte unabhängige Crashes bleiben +unverändert. Kein Kordra-WIP mehr offen; Sourceänderungen uncommitted. + +--- + +# 2026-11-06 00:07 – Kordra-Ausflugsfix gebaut, Shutdown läuft + +Nutzer hat Korrektur beauftragt. Bekannte Vashjir-WIP unverändert beibehalten, +weiterhin keinCommit/Push beauftragt. AdventureBehaviorMgr::PlanLeisureWalk: +Ringe primary(105..150/formation110),80/70,40,20,10; ersteRingstufemitgültigem +MMAP-Korridorbevorzugen, achtWinkeljeRing. MinSpan8 statt65, keinpauschales +Endhöhen3/20 oder4ydPfadpunkt-Zlimit/12ydPunktdistanz. NativevollständigeMMAP, +finiteWerte,Zone/Outdoors,Anchor250,Weglängenbudget/Detourlimit/Rückweg bleiben. +GetHeightSuchfenster anRingradius angepasst (up radius+2/down2radius+4), damit +nativeRampen nichtschon vorMMAP aufgleicheHöheeingeschränkt. History: Variant- +NoveltyfürFehlversuchbleibt, ActionHistoryoutingerstnachStartLeisureerfolgreich, +kein4xRuhebonusfürgescheitertenStart. + +TestsPASStest_adventure_leisure (neuevalideRampen+Short40/10-Runden,unreachable, +Boundary,Return etc.), test_outing_history echteMicroDispatchStatements ASan/UBSan, +micro_reset,leisure_catalog,group_travel. Test-LeisureLogargumentejetztmittyp- +geprüftemTestLog stattweggepreprocesst; MockCreatureHasAuraergänzt. ErsterBuild +scheiterteamLogbestscope(behoben), finalbuild-final.log PASS -j10/Pool4. Jeder +BuildstartLoaderconfig/runtime0+safeall, keinShutdownvorSuccess. + +PID104568 nunregulärer server shutdown10, Begin00:06:00 sessions10grace60s, +nochWARTENProzess+tmuxweg.DANN cmakeinstall,boundedGDBLauncher1812-instance- +crash mitLogcheckpoints/2026-11-06-leisure-walk/startup.log,READY/8085/8087 prüfen, +Loaderprevious1+Roster120 ausbefore.json wiederherstellen. NeuerFixnochNICHT +installiert. Vashjir00Timerwarbereits00:00:17 SUCCESSalle10vorBuildstart; +keinTimerpausiert, keineMitternachtstestpläneverloren. + +Liveverifikation geplant: dedizierterTestrion148, Original10/map0(-8912,-138,80.9) +offline; Vollsnapshots characters/character_spell/character_skills/inventory/ +supply_state in test-actor-before.json. NochKEINLive-Setupausgeführt. Zielnative +AdventureController mit manuellerIntent adventure poi_tele_896, dann native +`clientless adventure micro148 adventure_explore` OnSite; komplettenHin-/Rückweg +anKordrasalterPositionbeobachten (nichtKordrasneuenIntentändern). +Setup-Vorschlag: OfflineTest148level85/map530(4810.01,3843.66,223.377),skill762225 +undSpell32235 fürGebiets-Flugberechtigung; TEMPprofiles/testrion.lua mitnur +movement.can_free_fly=true flight_mounts[32235]=1 und behavior.enabled=false/ +daily_schedule=false (keinGeneratorMaintain). Native `clientless login148` +AdventureController.Update läuft auch ohneAutonomous; manuellerIntent erstellt +aktivenBehaviorrecord. Supply.Online lerntSekundärskills, daherSnapshotsamEnde +exaktwiederherstellen. VorLogin supply_state148last_day=20261106 vorseeden, +damitkeinDailyStockInventarverändert! LeerernesInventarnichtblindrestaurieren, +vorher/aftervergleichen. NativeGenericProfilehatCanFreeFlyfalse, daherTempProfil +nötigfürNetherstormAllowedPosition, keinePlayerTeleportsglobal.Regulierter +Testbotregistriert148 bleibtTestchar, keinregulärerAdventureBotumgenutzt. +NachRundgang: nativeStop/Logout, OfflineSessionbestätigen,TempProfilentfernen, +Charrow+Spell/Skills+SupplyState ausSnapshotsnur148restaurieren,Inventaridentisch +prüfen. KeineechtenSpieler/sonstigenBotsverändern. SonstigeRuntimecasesnotieren. + +Buildsessions: final4265 fertigPASS, Shutdownwait86143 könntefertigsein. +Artifactscheckpoints/2026-11-06-leisure-walk/, keineabgeschlosseneLivebehaupten. + +--- + +# 2026-11-05 23:57 – Kordra-Ursache ohne Diagnosebuild eingegrenzt + +Nutzer: mehruntersuchen, keinDiagnosecodevorIntentwechsel. ZustandKoordinaten/ +Logs gesichert, Kordra201NICHT geändert. RegistrierterTestbot Testrion148 an +exakterStelle SocretharsSitz/map530(4810.01,3843.66,223.377) für bestehende +nativeTravelproben verwendet; Level85 nurfürTests, wiederOriginal10/map0 +(-8912,-138,80.9)/offline. KeineMount-/Spell-/IntentänderungenanKordra. + +WesentlicheUrsache: PlanLeisureWalk wählt ausschließlich80 bzw.105..150yd Ziele, +fordertjedoch<=3ydEndhöhenunterschied zurStartposition. DasGeländefällt ab; +OfflineADTGridMap-InterpolationverifiziertSource223.37722 zuPlayer223.377. +360WinkelproRadius:80yd höchsterTerrainboden215.7946 (mind7.58ydtiefer), +105/140/150ebenfalls0/360mit<=3ydDifferenz. 20yd196/360und40yd96/360passen, +werdenabernichtprobiert; minSpan65schließtkurzeRundenzusätzlich aus. +ADT-Probe umfasstKEINEVMAPGebäude-/Höhlen-/Holes-/LOS-Daten, allein nichtals +vollständigerNativeGetHeight-Tracedeutieren. ZusätzlicherNATIVERBeleg: +12/12vollständigeunverdächtigeMMAPPfade vomselbenUrsprungzuberechnetem +Terrainbodenbei20/40/80yd in4Himmelsrichtungen. Beispiel40ydWestZ221.667 +(delta-1.71)path40.09;80ydWestZ210.843(delta-12.53)path81.85,beideComplete +FinalDistance0. NativeMMAPhatalsoausreichendebegehbareWege,Ausflugsfilter +verwirftsie. PfadprobenwurdennachBerechnungsofortgestoppt,nichtalsvollständig +gelaufeneRundgängebehaupten. Vorher16ProbenmitfälschlichfestgehaltenerQuell-Z +warenincomplete/nopath,ebenweilZieleüberTerrainlagen; BelegebeideRunsaufbewahrt. + +Nochmehrzueng: east40/80Nativepfade habenMaxZDelta5.32zwischenPunkten bei +validemMMAP; separateWalkGuardmax4würdedieseauchverwerfen. Empfehlung: +mehrstufigkleinereRadien/kurzeRundenzulassen,NativeMMAP-Begehbarkeitstatt +pauschalerEndhöhen3/unnötigerzusätzlicherHöhenlimits;ErfolgsHistory/4xRuhebonus +erstbeiwirklichgestartetemAusflugsetzen. NOCHKEINFixbeauftragt/implementiert. +KeineSource-/Build-/Restartänderung. Belege/SkripteJsonNativeLogsunter +checkpoints/2026-11-05-kordra/:probe-manifest,probe-result,ground-result, +terrain-summary,probe_terrain.py,ground-targets,probe-actor-after. +Vashjir00SystemdTimerweiteraktiv,nichtgeändert,nichtbereitsausgeführtbehaupten. + +--- + +# 2026-11-05 – Kordra201 untersucht, keine Änderung + +NutzervermutetverdächtigwenigAktivität. Kordra201 Lv76Orc, OnSiteAdventure +poi_tele_896 SocretharsSeat / SocretharsSitz, map530 zone3523area3742, +(4810.01,3843.66,223.377). NativeAction travel_to_location Completed arrived, +keinaktiverTravelRecord. Mikroaktionenwechseln normal (Scout/Vista/look/Drink/ +Eat/Fire). ABER explore/patrol werdenwiederholt mit3000msFallback gestartet, +keineLEISURE_WALK_PLAN/LEISURE_START201imaktuellenStartup. PlanLeisureWalk +findetkeinenakzeptiertenWeg; genaueverletzteBedingungwirdnichtgeloggt. +KonservativeGuards: nur16Ziele,80..150ydRadius,min65ydSpan,max3ydEndhöhen- +differenz,max4ydzwischenPfadpunkten,PATHFIND_NORMALnur,gleicheZone/outdoors, +AnchorRadius250,begrenzteWeglänge. KeinekonkreteHöhen-/MMAPUrsachebehaupten. +ZusätzlicherMechanismus: erfolgloserOutingversuchwirdvorStartinActionHistory +alsoutingexplore/patrolverbucht; nachdiesemEintragwerdenEat/Drink/Sit4fach +gewichtet,auchwennkeinWeggelaufenwurde. DaherstationärePausennachFehlversuchen. +DiagnoseohneCode/Intent/Teleportänderung;Belegecheckpoints/2026-11-05-kordra/. +Vashjir23/00Testplan+aktiverMitternachtsTimerunverändert,Detailsunten. + +--- + +# 2026-11-05 23:46 – Zehn Vashjir-Testbots: 23 Uhr gesetzt, Mitternacht geplant + +Nutzerauftrag: vorige10Bastion-Testbots für23:00 und00:00 Adventure zu beliebiger +VashjirLocation. NativeEligibilityfüralle10 content/own/invitation1 bestätigt. +Guids159Renren/160Marndra/161Marnda/162Aruendas/163Winienwi/164Taliaarnora/ +165Brynda/166Corric/169Bromdan/176Ashaelri, alle85online. Gemeinsames neutrales +Ziel poi_tele_1512 SilverTideHollow (Silberfluthöhle), Zone5144 Vashjir. +Allezehn23-UhrSlots heute20261105 mitnativem `adventure editplan` gesetzt und +DBverified10/10. KeineTeleports/Gruppenresets/zwanghaftenTransitunterbrechungen. +NativeStatus: achtbereitsintentadventure/Target1512; Winienwi wartete nochauf +Kampfreaktion, Brynda auf sicherenZustandswechsel, Sollplan auchfürbeidekorrekt. +DieseStatusaufnahmeistkeinBeleg,dassspäterallebereitsaufgebrochensind. + +Mitternacht: nativerEditPlan kannnurheutigeSlots. KeinefremdenTagesplänekopiert. +Einmaliger aktiver SYSTEMD-USER-TIMER `vcore-vashjir-20261106-0000.timer`, nächste +Auslösung2026-11-06 00:00:02CET, Accuracy1s, zugehörigerServiceTimeout240s. +Script checkpoints/2026-11-05-2300-vashjir-test/apply_midnight.py führt dann +nativeTagesplaninitialisierungfallsnötig und editplan00 adventure1512 fürdieselben10 +aus, verifiziertalle10DBslots, beschränkteWiederholungenbis180s. FallsBotsoffline, +fordertderJobderenLoginan. Resultatspäterinmidnight-result.json, Journal: +`journalctl --user -u vcore-vashjir-20261106-0000.service`. KeinpermanenterObserver, +keineMitternachtsausführungbereitsbehaupten. Timeristaktiv/verifiziert, Script- +Syntaxgeprüft. NichtbenötigtaktivbisMitternachtwarten. KeineweiterenCode-/Build- +änderungen; bekannteVashjirWIPvollständigbehalten, weiterhinuncommitted. +Snapshots/Manifest/verified-2300/status/timer-statusimgenanntenCheckpoint. + +--- + +# 2026-11-05 23:32 – Vashjir fertig, installiert und live geprüft + +Nutzerauftrag umgesetzt. Baseline30d606cb92, neueVashjirÄnderungen uncommitted, +keinCommit/Push beauftragt. Region5146 inklusive4815/5144/5145 ab80gap0 beide +Fraktionen freigegeben, preferFlight0; Untergebietsfraktionen bleiben erhalten. +Alle24 vorhandenen generierten readyBots>=80 haben nativenSpell75207 gelernt +(CharacterMigration offline angewandt). GeneratorCreate+Reconcile lernen ihn ab80. +Keine Questabschlüsse oder künstlichen Geschwindigkeiten/Flugflags. + +AdventureVashjir.h + NamespaceinAreaMgr: DBC-Hierarchie root5146, lokale +Gebietsübergänge verboten; Weltgrenze nur nativeTaxi-Kanten mitinside606/608, +normaleInstanzportaleausgenommen. PlannerStartNodes/PositionProbes/virtuelleExits/ +geschätzteLocation-Endstrecken beachtenGrenze. FlightEstimate bietetkeineVashjir- +Endpunkte, Begin/PrepareFollowingMount blockierenneuesAufsitzen, aktiveFlüge +werdennichtbeimGebietswechselabgebrochen. Aquatic nativeCast75207/Type232/ +Capability86510. PrepareGroundMount inVashnurSeepferdchen, aufLandzuFuß; +vorhandeneMounts/Flüge nichtgezwungenermaßenentfernen. GenericSwimmingDismount +behält echteFLOAT/UNDERWATER-MountCapabilities. MountPreparation optionalaquatic +lässt sicherenWasser-Gestaltwechselzu, übrigeDruid-Sicherungenweiteraktiv. + +WorldSQL2026_11_05_01_adventure_vashjir.sql undCharacterSQL +2026_11_05_00_adventure_seahorse.sql ANGEWANDT. Dateien wegen globalemSQL-Ignore +explizit intent-to-add, beimCommitbeachten. SandstrandDBC+NPC geprüft: +606Alli342102FrancisGreene,608Horde341915Briglar (Festland); +607Alli342107/609Horde341916SwiftSeahorse (Unterwasser). NativeFraktions-/Taxi- +Pfadberechtigungenbleiben. Gruppenroutenübernahmeunverändert. + +AlleBuilds-j10/bestehenderPool4 PASS, jeweilskonfig+runtimeLoader0/safeall zuerst, +ShutdownerstnachFinalBuildSuccess (build-boundary-final.log). PID95021 normal +exited, integratedFINALIZE0. SQL+cmakeinstall, boundedGDBneuerPID104568, +frischesREADY/8085/8087 geprüft. Loader1+alle120vorherigenBots online,missing0. + +NeunRegressionstestdateienPASS, darunter echteVashjirPolicy/AquaticBoarding mit +ASan/UBSan, echterGraphplaner mit günstigerer unerlaubterFestland-Endstrecke +nimmt dennoch606Taxi; Swimming erhältWassermount; Gruppe/Flugmount/lokaleSpline/ +AreaPolicy/Segment/AreaNode. AlterAreaNodeTestharnessfehlteUnterstadtHelper; +HülleliestnundessenProduktionscode undprüftTaxi11, keineProduktionsänderungdort. + +LiveOpenWater PASS4/0 in8s: nativeWasserprobe bei(-4800,3800,-20),nativeSeepferd- +Mount,40yd/fünfSegmente bis(-4760,3800,-20),nativeSwimSpeed25.9722 (+450%), +Mountbleibt,Arrived; neueFlightAnforderungabgewiesen. VorherigerersterLiveversuch +war versehentlich trockeneLufthöhle bei(-4580,3490,-90),invalidWassertestpunkt, +FAIL2/4aufbewahrt; keineCodeänderungdafürnotwendig. GatewayLive PASS4/0: +alle606/608/607/609 sind tatsächlichZone5144(Vashjir). Keine vollständigeLive- +TaxianreiseinsTiefland behaupten; diePlanerauswahl automatisiert geprüft. + +Testaria149 vollständigOriginal10/map0(-8912,-138,80.9)/offline, temporäre +Spell75207+Skill762 entfernt, .breathing-Dateiwiederfehlend/DefaultLimited. +Keine normalenBots teleportiert. FürMount-LiveTest `clientless luareload149` +lädt explizit generisches nichtautonomesProfil in normalenLaufzeitcache bis +Neustart; keinFile/DB-ProfilfürTestariaangelegt. BekanntertransienterTestcache. +Doku2026-11-05-vashjir.md. AlleSnapshots/Live-Skripte/Ergebnisse/Logs unter +checkpoints/2026-11-05-vashjir/. OffeneältereCrashs unverändert, keinVashjirWIP. + +--- + +# 2026-11-05 23:21 – Vashjir WIP: final gebaut, regulärer Shutdown läuft + +Nutzer: Vashjir freigeben; alle AdventureBots>=80 Seepferdchen75207, +Generator anpassen; dort nur Aquatic neu mounten, aktive Flüge nicht erzwingen; +Locations nur über Sandstrand-Taxi ein-/ausreisen. Baseline clean30d606cb92. +Implementiert AdventureVashjir.h/AreaMgrnamespace: DBCManager::IsInArea root5146, +World-Grenze nur Taxi mit insideKey606/608. Normale Instanzportale ausgenommen. +LocalLinkAllowed verhindert Groundstart/Probe/Locationfinish/virtualexit-Schlupf- +löcher; FlightEstimate bietet keine Vashjir-Endpunkte, Begin/FollowMount blockieren +neues Flugaufsitzen in Region, laufendes Update nicht verändert. Aquatic native +cast75207/type232/capability86510; neue Bodenmounts durch Aquatic ersetzen. Native +Wasserreittiere generisch im SwimmingDismount erhalten (FLOAT/UNDERWATER). +Druid MountPreparation optionalaquaticMount=true erlaubt Wasser-Gestaltwechsel +mit den übrigen Sicherheitsprüfungen. Generator Create+Reconcile lernt75207>=80. +WorldSQL2026_11_05_01_adventure_vashjir.sql öffnet root für beide, min80gap0, +bevorzugtkeinFlug, bindet606Alli342102/608Horde341915 sowie607/609Seahorse. +CharacterSQL2026_11_05_00_adventure_seahorse.sql gibt vorhandenen generierten +readyBots>=80 Zauber offline. SQL-Dateien force intent-to-add (global ignoriert), +noch NICHT auf DB angewandt! Noch kein Commit beauftragt. + +Drei Builds PASS (letzter build-boundary-final.log), alle jeweilsLoaderconfig+ +runtime0/safeall, -j10/bestehenderPool4. Letzter Build enthält auch alle +Locationfinish/virtualexit-Guards. Regulärer server shutdown10 jetzt angefordert +für PID95021, Begin23:20:21 sessions7/grace60s. Noch warten bis Prozess UND tmux +weg. Dann SQLs mit live_support.write anwenden, cmakeinstall, boundedGDBLauncher +1812-instance-crash/start-bounded-diagnostic.sh mit Log im neuenVashjirCheckpoint, +frischesREADY/Prozess/8085/8087 prüfen. Loaderoriginal1+vorherRoster120 aus +checkpoints/2026-11-05-vashjir/before.json wiederherstellen. Keine Zwangslogouts. + +Tests nativeVashjir+AquaticBoarding ASan/UBSan PASS; echterGraphplaner zusätzlicher +Boundary-/Finish-Test PASS, sowieSwimming (aquatic mount bleibt), groupflightmount, +grouptravel, localsplines PASS. Testslog enthält ersten Satz, letzteGraphprüfung +noch ggf inTestslog nachtragen. build-final war vor locationfinishguards, daher +NUR build-boundary-final installieren! AktuelleSource finalbuilt, keine späteren +C++ Änderungen. Doku2026-11-05-vashjir.md vorhanden. + +Nächster Live-Test: registrierteTestaria149 (original10/map0 -8912,-138,80.9, +offline; vorher KEIN Spell75207/33388/33391/34090/Skill762). Script +checkpoints/2026-11-05-vashjir/live-vashjir.lua: login,85,learn75207,skill762225, +breathfalse,wait20s für kontrollierten `clientless luareload149`, dann teleport +(-4580,3490,-90) echte4815; travel40yd nativeSeahorse+swimSpeed+SegmentRetention, +neuerFlightreject, restore10pose/breathtrue/skill0/offline. Generisches Adventure- +Profil durch `clientless luareload149` während20sWait laden; Testcontroller +behältOwnership, genericLua hat nurlog, keineAutonomous-Aktivität. KeinneuesProfil +nötig. LiveRequest erst nachREADY+Populationstartsettled umLoginTimeout zuvermeiden. +NachScriptende offline temporären Spell75207 auscharacter_spell149 entfernen, +.breathingDatei entfernen (vorherfehlend), Skills/Auren/LevelPose prüfen. FallsTest +scheitertcleanup separat absichern. NichtnormalenAdventureBot zumTester umnutzen. +Taxirouten vorher DB/DBC genau geprüft, Samplesinlocations.json/mounts-before.json. +Vorher alle80generierten mountSpells sichernliegtmounts-before.json. NachAnwendung +undRestore queryalleeligiblemissing0 prüfen. LivegesamteTaxiAnreise nichtbehaupten +fallsnichtausgeführt; konkreteMount/Swim+nativePolicyTests dokumentieren. + +--- + # 2026-11-05 – Schwimmen und Atemluft zum Commit abgeschlossen Nutzer hat den lokalen Commit beauftragt. Gesamter bekannter offener Stand diff --git a/doc/clientless/checkpoints/2026-11-05-2300-vashjir-test/.gitignore b/doc/clientless/checkpoints/2026-11-05-2300-vashjir-test/.gitignore new file mode 100644 index 0000000000..397b4a7624 --- /dev/null +++ b/doc/clientless/checkpoints/2026-11-05-2300-vashjir-test/.gitignore @@ -0,0 +1 @@ +*.log diff --git a/doc/clientless/checkpoints/2026-11-05-2300-vashjir-test/apply_midnight.py b/doc/clientless/checkpoints/2026-11-05-2300-vashjir-test/apply_midnight.py new file mode 100644 index 0000000000..82e2d08abf --- /dev/null +++ b/doc/clientless/checkpoints/2026-11-05-2300-vashjir-test/apply_midnight.py @@ -0,0 +1,43 @@ +#!/usr/bin/env python3 +"""One-shot native plan edit after natural day rollover; no travel observation.""" +from pathlib import Path +import datetime,json,sys,time +from zoneinfo import ZoneInfo +REPO=Path('/home/wow_admin/wow_cata_server/source/TrinityCore') +sys.path.insert(0,str(REPO/'doc/clientless/checkpoints/2026-11-02-0600-group-test')) +import test_driver as d +BASE=Path(__file__).resolve().parent +GUIDS=[159,160,161,162,163,164,165,166,169,176] +LOCATION='poi_tele_1512' +DATE=20261106 + +def apply(): + now=datetime.datetime.now(ZoneInfo('Europe/Berlin')) + if int(now.strftime('%Y%m%d'))!=DATE or now.hour!=0: + raise RuntimeError('Refusing to alter a different date/hour') + ids=','.join(map(str,GUIDS)) + before=d.query('World',f'SELECT * FROM vcore_adventure_day WHERE character_guid IN({ids}) AND local_date={DATE} AND hour_slot=0;') + (BASE/'midnight-before.json').write_text(json.dumps(before,indent=2)) + deadline=time.monotonic()+180 + while time.monotonic()v else (h5-h1-h3,h3-h1,h1) + else:a,b,c=(h2+h4-h5,h4-h2,h5-h4) if u>v else (h4-h3,h3+h4-h5,h5-h4) + raw=a*u+b*v+c + return lo+raw*(hi-lo)/(65535 if flags&2 else 255) if flags&(2|4) else raw +if __name__=='__main__': + x,y,z=4810.01,3843.66,223.377 + targets=[] + for radius in [20,40,80]: + for angle in [0,90,180,270]: + gx=x+math.cos(math.radians(angle))*radius;gy=y+math.sin(math.radians(angle))*radius + targets.append({'radius':radius,'angle':angle,'x':gx,'y':gy,'z':height(gx,gy)}) + Path(__file__).with_name('ground-targets.json').write_text(json.dumps(targets,indent=2)) diff --git a/doc/clientless/checkpoints/2026-11-05-kordra/terrain-summary.json b/doc/clientless/checkpoints/2026-11-05-kordra/terrain-summary.json new file mode 100644 index 0000000000..63d502d858 --- /dev/null +++ b/doc/clientless/checkpoints/2026-11-05-kordra/terrain-summary.json @@ -0,0 +1,49 @@ +{ + "note": "ADT terrain only, not native VMAP building/LOS or hole checks", + "source_terrain": 223.37721984276072, + "source_z": 223.377, + "radii": { + "20": { + "min": 213.20110941835378, + "max": 223.7870039398831, + "within_3_yards": 196, + "samples": 360 + }, + "40": { + "min": 206.9973472657498, + "max": 222.03959316757368, + "within_3_yards": 96, + "samples": 360 + }, + "60": { + "min": 196.8564721464761, + "max": 219.32726123154248, + "within_3_yards": 0, + "samples": 360 + }, + "80": { + "min": 182.66075519701621, + "max": 215.79459005599165, + "within_3_yards": 0, + "samples": 360 + }, + "105": { + "min": 103.23141833952945, + "max": 215.43877048156787, + "within_3_yards": 0, + "samples": 360 + }, + "140": { + "min": -1004.771274617039, + "max": 211.98563169674094, + "within_3_yards": 0, + "samples": 360 + }, + "150": { + "min": -1004.8065188627271, + "max": 212.39589492593632, + "within_3_yards": 0, + "samples": 360 + } + } +} \ No newline at end of file diff --git a/doc/clientless/checkpoints/2026-11-05-vashjir/.gitignore b/doc/clientless/checkpoints/2026-11-05-vashjir/.gitignore new file mode 100644 index 0000000000..397b4a7624 --- /dev/null +++ b/doc/clientless/checkpoints/2026-11-05-vashjir/.gitignore @@ -0,0 +1 @@ +*.log diff --git a/doc/clientless/checkpoints/2026-11-05-vashjir/gateways-result.json b/doc/clientless/checkpoints/2026-11-05-vashjir/gateways-result.json new file mode 100644 index 0000000000..f8d6d7fb2c --- /dev/null +++ b/doc/clientless/checkpoints/2026-11-05-vashjir/gateways-result.json @@ -0,0 +1,207 @@ +{ + "schema": 1, + "run_id": "vashjir_gateways_20261105_232712", + "state": "passed", + "started_unix_ms": 1793917633128, + "elapsed_ms": 4288, + "checks": 4, + "failures": 0, + "error": "", + "bots": [ + 149 + ], + "events": [ + { + "label": "taxi_606", + "value": { + "swim_speed": 4.722221851348877, + "max_health": 231, + "breath_remaining_ms": -1, + "guid": 149, + "stamina": 31, + "in_water": 0, + "mover_guid": "149", + "level": 10, + "alive": 1, + "transport": 0, + "combat": 0, + "vehicle_entry": 0, + "swimming": 0, + "health": 231, + "mounted": 0, + "x": -5310.85009765625, + "falling": 0, + "hover_animation": 0, + "power": 0, + "underwater": 0, + "map": 0, + "area": 5144, + "flying": 0, + "zone": 5144, + "spirit": 24, + "z": 103.2243270874023, + "y": 3914.419921875, + "moving": 0, + "animation_tier": 0, + "vehicle_guid": "", + "strength": 33, + "movement_flags": 0, + "loot_guid": "", + "max_power": 1000, + "agility": 26, + "breath_max_ms": 180000, + "intellect": 21, + "breathing_limited": 1, + "can_swim": 1 + } + }, + { + "check": "Sandstrand node 606 is inside Vashjir", + "passed": true + }, + { + "label": "taxi_608", + "value": { + "swim_speed": 4.722221851348877, + "max_health": 231, + "breath_remaining_ms": -1, + "guid": 149, + "stamina": 31, + "in_water": 0, + "mover_guid": "149", + "level": 10, + "alive": 1, + "transport": 0, + "combat": 0, + "vehicle_entry": 0, + "swimming": 0, + "health": 231, + "mounted": 0, + "x": -5671.02001953125, + "falling": 0, + "hover_animation": 0, + "power": 0, + "underwater": 0, + "map": 0, + "area": 5144, + "flying": 0, + "zone": 5144, + "spirit": 24, + "z": 101.9156875610352, + "y": 3720.070068359375, + "moving": 0, + "animation_tier": 0, + "vehicle_guid": "", + "strength": 33, + "movement_flags": 0, + "loot_guid": "", + "max_power": 1000, + "agility": 26, + "breath_max_ms": 180000, + "intellect": 21, + "breathing_limited": 1, + "can_swim": 1 + } + }, + { + "check": "Sandstrand node 608 is inside Vashjir", + "passed": true + }, + { + "label": "taxi_607", + "value": { + "swim_speed": 4.722221851348877, + "max_health": 231, + "breath_remaining_ms": -1, + "guid": 149, + "stamina": 31, + "in_water": 0, + "mover_guid": "149", + "level": 10, + "alive": 1, + "transport": 0, + "combat": 0, + "vehicle_entry": 0, + "swimming": 0, + "health": 231, + "mounted": 0, + "x": -5267.35009765625, + "falling": 0, + "hover_animation": 0, + "power": 0, + "underwater": 0, + "map": 0, + "area": 5144, + "flying": 0, + "zone": 5144, + "spirit": 24, + "z": 100.9749069213867, + "y": 3900.27001953125, + "moving": 0, + "animation_tier": 0, + "vehicle_guid": "", + "strength": 33, + "movement_flags": 0, + "loot_guid": "", + "max_power": 1000, + "agility": 26, + "breath_max_ms": 180000, + "intellect": 21, + "breathing_limited": 1, + "can_swim": 1 + } + }, + { + "check": "Sandstrand node 607 is inside Vashjir", + "passed": true + }, + { + "label": "taxi_609", + "value": { + "swim_speed": 4.722221851348877, + "max_health": 231, + "breath_remaining_ms": -1, + "guid": 149, + "stamina": 31, + "in_water": 0, + "mover_guid": "149", + "level": 10, + "alive": 1, + "transport": 0, + "combat": 0, + "vehicle_entry": 0, + "swimming": 0, + "health": 231, + "mounted": 0, + "x": -5669.18994140625, + "falling": 0, + "hover_animation": 0, + "power": 0, + "underwater": 0, + "map": 0, + "area": 5144, + "flying": 0, + "zone": 5144, + "spirit": 24, + "z": 101.1627807617188, + "y": 3711.81005859375, + "moving": 0, + "animation_tier": 0, + "vehicle_guid": "", + "strength": 33, + "movement_flags": 0, + "loot_guid": "", + "max_power": 1000, + "agility": 26, + "breath_max_ms": 180000, + "intellect": 21, + "breathing_limited": 1, + "can_swim": 1 + } + }, + { + "check": "Sandstrand node 609 is inside Vashjir", + "passed": true + } + ] +} \ No newline at end of file diff --git a/doc/clientless/checkpoints/2026-11-05-vashjir/live-gateway-areas.lua b/doc/clientless/checkpoints/2026-11-05-vashjir/live-gateway-areas.lua new file mode 100644 index 0000000000..a4fd90477c --- /dev/null +++ b/doc/clientless/checkpoints/2026-11-05-vashjir/live-gateway-areas.lua @@ -0,0 +1,13 @@ +local g=testbot.login(149) +local before=testbot.state(g) +for _,n in ipairs({{606,-5310.85,3914.42,3.22433},{608,-5671.02,3720.07,1.91569},{607,-5267.35,3900.27,0.974906},{609,-5669.19,3711.81,1.16278}})do + assert(testbot.teleport(g,0,n[2],n[3],n[4]+100,0)) + testbot.await(function()return testbot.online(g)end,15000,'node sample') + testbot.wait(500) + local at=testbot.state(g) + testbot.record('taxi_'..n[1],at) + testbot.check(at.zone==4815 or at.zone==5144 or at.zone==5145 or at.zone==5146,'Sandstrand node '..n[1]..' is inside Vashjir') +end +assert(testbot.teleport(g,before.map,before.x,before.y,before.z,0)) +testbot.await(function()return testbot.online(g)end,15000,'restore') +testbot.wait(500) diff --git a/doc/clientless/checkpoints/2026-11-05-vashjir/live-result.json b/doc/clientless/checkpoints/2026-11-05-vashjir/live-result.json new file mode 100644 index 0000000000..70a3bc7dc1 --- /dev/null +++ b/doc/clientless/checkpoints/2026-11-05-vashjir/live-result.json @@ -0,0 +1,722 @@ +{ + "schema": 1, + "run_id": "vashjir_water_20261105_232541", + "state": "passed", + "started_unix_ms": 1793917542179, + "elapsed_ms": 8024, + "checks": 4, + "failures": 0, + "error": "", + "bots": [ + 149 + ], + "events": [ + { + "label": "before", + "value": { + "max_power": 1000, + "underwater": 0, + "can_swim": 1, + "power": 0, + "swimming": 0, + "moving": 0, + "breath_max_ms": 180000, + "falling": 0, + "alive": 1, + "movement_flags": 0, + "vehicle_guid": "", + "in_water": 0, + "transport": 0, + "mover_guid": "149", + "mounted": 0, + "vehicle_entry": 0, + "hover_animation": 0, + "map": 0, + "guid": 149, + "health": 231, + "max_health": 231, + "breathing_limited": 1, + "animation_tier": 0, + "y": -138, + "x": -8912, + "combat": 0, + "z": 80.9000015258789, + "spirit": 24, + "zone": 12, + "stamina": 31, + "strength": 33, + "intellect": 21, + "level": 10, + "area": 9, + "loot_guid": "", + "flying": 0, + "swim_speed": 4.722221851348877, + "breath_remaining_ms": -1, + "agility": 26 + } + }, + { + "label": "surface_probe", + "value": { + "x": -5000, + "y": 4000, + "water": { + "status": 0, + "liquid": 0, + "swimming": 0, + "safe": 1, + "surface": 0, + "bottom": 0 + } + } + }, + { + "label": "surface_probe", + "value": { + "x": -5200, + "y": 4000, + "water": { + "status": 0, + "liquid": 0, + "swimming": 0, + "safe": 1, + "surface": 0, + "bottom": 0 + } + } + }, + { + "label": "surface_probe", + "value": { + "x": -5000, + "y": 4200, + "water": { + "status": 0, + "liquid": 0, + "swimming": 0, + "safe": 1, + "surface": 0, + "bottom": 0 + } + } + }, + { + "label": "surface_probe", + "value": { + "x": -4800, + "y": 3800, + "water": { + "status": 1, + "liquid": 0, + "swimming": 0, + "safe": 1, + "surface": 0, + "bottom": -130.9990234375 + } + } + }, + { + "label": "surface_probe", + "value": { + "x": -5600, + "y": 4000, + "water": { + "status": 1, + "liquid": 0, + "swimming": 0, + "safe": 1, + "surface": 0, + "bottom": -191.7648010253906 + } + } + }, + { + "label": "surface_probe", + "value": { + "x": -5800, + "y": 4000, + "water": { + "status": 1, + "liquid": 0, + "swimming": 0, + "safe": 1, + "surface": 0, + "bottom": -215.8117980957031 + } + } + }, + { + "label": "surface_probe", + "value": { + "x": -6000, + "y": 4000, + "water": { + "status": 1, + "liquid": 0, + "swimming": 0, + "safe": 1, + "surface": 0, + "bottom": -511.456298828125 + } + } + }, + { + "label": "surface_probe", + "value": { + "x": -5200, + "y": 4500, + "water": { + "status": 1, + "liquid": 0, + "swimming": 0, + "safe": 1, + "surface": 0, + "bottom": -59.439697265625 + } + } + }, + { + "label": "selected_water", + "value": { + "x": -4800, + "y": 3800, + "z": -20 + } + }, + { + "label": "vashjir_start", + "value": { + "max_power": 1000, + "underwater": 1, + "can_swim": 1, + "power": 0, + "swimming": 1, + "moving": 0, + "breath_max_ms": -1, + "falling": 0, + "alive": 1, + "movement_flags": 1048576, + "vehicle_guid": "", + "in_water": 1, + "transport": 0, + "mover_guid": "149", + "mounted": 0, + "vehicle_entry": 0, + "hover_animation": 0, + "map": 0, + "guid": 149, + "health": 45447, + "max_health": 45447, + "breathing_limited": 0, + "animation_tier": 0, + "y": 3800, + "x": -4800, + "combat": 0, + "z": -20, + "spirit": 65, + "zone": 4815, + "stamina": 173, + "strength": 189, + "intellect": 37, + "level": 85, + "area": 5030, + "loot_guid": "", + "flying": 0, + "swim_speed": 4.722221851348877, + "breath_remaining_ms": -1, + "agility": 123 + } + }, + { + "label": "water", + "value": { + "status": 8, + "liquid": 1, + "swimming": 1, + "safe": 1, + "surface": 0, + "bottom": -130.9990234375 + } + }, + { + "check": "actual Vashjir region reached", + "passed": true + }, + { + "label": "travel_request", + "value": { + "why": "large-segment", + "ok": true + } + }, + { + "label": "swim_segment", + "value": { + "max_power": 1000, + "underwater": 1, + "can_swim": 1, + "power": 0, + "swimming": 1, + "moving": 0, + "travel_state": "Moving", + "breath_max_ms": -1, + "falling": 0, + "alive": 1, + "movement_flags": 1048576, + "vehicle_guid": "", + "in_water": 1, + "transport": 0, + "mover_guid": "149", + "mounted": 1, + "vehicle_entry": 0, + "hover_animation": 0, + "map": 0, + "guid": 149, + "animation_tier": 0, + "max_health": 45447, + "breathing_limited": 0, + "agility": 123, + "y": 3800, + "x": -4792, + "combat": 0, + "z": -20, + "spirit": 65, + "intellect": 37, + "stamina": 173, + "strength": 189, + "swim_speed": 25.97221946716309, + "level": 85, + "area": 4953, + "loot_guid": "", + "zone": 4815, + "flying": 0, + "breath_remaining_ms": -1, + "health": 45447 + } + }, + { + "label": "swim_segment", + "value": { + "max_power": 1000, + "underwater": 1, + "can_swim": 1, + "power": 0, + "swimming": 1, + "moving": 1, + "travel_state": "Moving", + "breath_max_ms": -1, + "falling": 0, + "alive": 1, + "movement_flags": 1048577, + "vehicle_guid": "", + "in_water": 1, + "transport": 0, + "mover_guid": "149", + "mounted": 1, + "vehicle_entry": 0, + "hover_animation": 0, + "map": 0, + "guid": 149, + "animation_tier": 0, + "max_health": 45447, + "breathing_limited": 0, + "agility": 123, + "y": 3800, + "x": -4788.763671875, + "combat": 0, + "z": -20, + "spirit": 65, + "intellect": 37, + "stamina": 173, + "strength": 189, + "swim_speed": 25.97221946716309, + "level": 85, + "area": 4953, + "loot_guid": "", + "zone": 4815, + "flying": 0, + "breath_remaining_ms": -1, + "health": 45447 + } + }, + { + "label": "swim_segment", + "value": { + "max_power": 1000, + "underwater": 1, + "can_swim": 1, + "power": 0, + "swimming": 1, + "moving": 0, + "travel_state": "Moving", + "breath_max_ms": -1, + "falling": 0, + "alive": 1, + "movement_flags": 1048576, + "vehicle_guid": "", + "in_water": 1, + "transport": 0, + "mover_guid": "149", + "mounted": 1, + "vehicle_entry": 0, + "hover_animation": 0, + "map": 0, + "guid": 149, + "animation_tier": 0, + "max_health": 45447, + "breathing_limited": 0, + "agility": 123, + "y": 3800, + "x": -4784, + "combat": 0, + "z": -20, + "spirit": 65, + "intellect": 37, + "stamina": 173, + "strength": 189, + "swim_speed": 25.97221946716309, + "level": 85, + "area": 4953, + "loot_guid": "", + "zone": 4815, + "flying": 0, + "breath_remaining_ms": -1, + "health": 45447 + } + }, + { + "label": "swim_segment", + "value": { + "max_power": 1000, + "underwater": 1, + "can_swim": 1, + "power": 0, + "swimming": 1, + "moving": 1, + "travel_state": "Moving", + "breath_max_ms": -1, + "falling": 0, + "alive": 1, + "movement_flags": 1048577, + "vehicle_guid": "", + "in_water": 1, + "transport": 0, + "mover_guid": "149", + "mounted": 1, + "vehicle_entry": 0, + "hover_animation": 0, + "map": 0, + "guid": 149, + "animation_tier": 0, + "max_health": 45447, + "breathing_limited": 0, + "agility": 123, + "y": 3800, + "x": -4781.9287109375, + "combat": 0, + "z": -20, + "spirit": 65, + "intellect": 37, + "stamina": 173, + "strength": 189, + "swim_speed": 25.97221946716309, + "level": 85, + "area": 4953, + "loot_guid": "", + "zone": 4815, + "flying": 0, + "breath_remaining_ms": -1, + "health": 45447 + } + }, + { + "label": "swim_segment", + "value": { + "max_power": 1000, + "underwater": 1, + "can_swim": 1, + "power": 0, + "swimming": 1, + "moving": 0, + "travel_state": "Moving", + "breath_max_ms": -1, + "falling": 0, + "alive": 1, + "movement_flags": 1048576, + "vehicle_guid": "", + "in_water": 1, + "transport": 0, + "mover_guid": "149", + "mounted": 1, + "vehicle_entry": 0, + "hover_animation": 0, + "map": 0, + "guid": 149, + "animation_tier": 0, + "max_health": 45447, + "breathing_limited": 0, + "agility": 123, + "y": 3800, + "x": -4776, + "combat": 0, + "z": -20, + "spirit": 65, + "intellect": 37, + "stamina": 173, + "strength": 189, + "swim_speed": 25.97221946716309, + "level": 85, + "area": 4953, + "loot_guid": "", + "zone": 4815, + "flying": 0, + "breath_remaining_ms": -1, + "health": 45447 + } + }, + { + "label": "swim_segment", + "value": { + "max_power": 1000, + "underwater": 1, + "can_swim": 1, + "power": 0, + "swimming": 1, + "moving": 0, + "travel_state": "Moving", + "breath_max_ms": -1, + "falling": 0, + "alive": 1, + "movement_flags": 1048576, + "vehicle_guid": "", + "in_water": 1, + "transport": 0, + "mover_guid": "149", + "mounted": 1, + "vehicle_entry": 0, + "hover_animation": 0, + "map": 0, + "guid": 149, + "animation_tier": 0, + "max_health": 45447, + "breathing_limited": 0, + "agility": 123, + "y": 3800, + "x": -4768, + "combat": 0, + "z": -20, + "spirit": 65, + "intellect": 37, + "stamina": 173, + "strength": 189, + "swim_speed": 25.97221946716309, + "level": 85, + "area": 4953, + "loot_guid": "", + "zone": 4815, + "flying": 0, + "breath_remaining_ms": -1, + "health": 45447 + } + }, + { + "label": "swim_segment", + "value": { + "max_power": 1000, + "underwater": 1, + "can_swim": 1, + "power": 0, + "swimming": 1, + "moving": 1, + "travel_state": "Moving", + "breath_max_ms": -1, + "falling": 0, + "alive": 1, + "movement_flags": 1048577, + "vehicle_guid": "", + "in_water": 1, + "transport": 0, + "mover_guid": "149", + "mounted": 1, + "vehicle_entry": 0, + "hover_animation": 0, + "map": 0, + "guid": 149, + "animation_tier": 0, + "max_health": 45447, + "breathing_limited": 0, + "agility": 123, + "y": 3800, + "x": -4768, + "combat": 0, + "z": -20, + "spirit": 65, + "intellect": 37, + "stamina": 173, + "strength": 189, + "swim_speed": 25.97221946716309, + "level": 85, + "area": 4953, + "loot_guid": "", + "zone": 4815, + "flying": 0, + "breath_remaining_ms": -1, + "health": 45447 + } + }, + { + "label": "swim_segment", + "value": { + "max_power": 1000, + "underwater": 1, + "can_swim": 1, + "power": 0, + "swimming": 1, + "moving": 0, + "travel_state": "Moving", + "breath_max_ms": -1, + "falling": 0, + "alive": 1, + "movement_flags": 1048576, + "vehicle_guid": "", + "in_water": 1, + "transport": 0, + "mover_guid": "149", + "mounted": 1, + "vehicle_entry": 0, + "hover_animation": 0, + "map": 0, + "guid": 149, + "animation_tier": 0, + "max_health": 45447, + "breathing_limited": 0, + "agility": 123, + "y": 3800, + "x": -4760, + "combat": 0, + "z": -20, + "spirit": 65, + "intellect": 37, + "stamina": 173, + "strength": 189, + "swim_speed": 25.97221946716309, + "level": 85, + "area": 4953, + "loot_guid": "", + "zone": 4815, + "flying": 0, + "breath_remaining_ms": -1, + "health": 45447 + } + }, + { + "label": "swim_segment", + "value": { + "max_power": 1000, + "underwater": 1, + "can_swim": 1, + "power": 0, + "swimming": 1, + "moving": 0, + "travel_state": "Arrived", + "breath_max_ms": -1, + "falling": 0, + "alive": 1, + "movement_flags": 1048576, + "vehicle_guid": "", + "in_water": 1, + "transport": 0, + "mover_guid": "149", + "mounted": 1, + "vehicle_entry": 0, + "hover_animation": 0, + "map": 0, + "guid": 149, + "animation_tier": 0, + "max_health": 45447, + "breathing_limited": 0, + "agility": 123, + "y": 3800, + "x": -4760, + "combat": 0, + "z": -20, + "spirit": 65, + "intellect": 37, + "stamina": 173, + "strength": 189, + "swim_speed": 25.97221946716309, + "level": 85, + "area": 4953, + "loot_guid": "", + "zone": 4815, + "flying": 0, + "breath_remaining_ms": -1, + "health": 45447 + } + }, + { + "check": "native seahorse mount and native swimming speed selected", + "passed": true + }, + { + "check": "seahorse retained across water segments until arrival", + "passed": true + }, + { + "label": "new_flight", + "value": { + "why": "free flight unavailable in current player/location state", + "ok": false + } + }, + { + "check": "new flight rejected in Vashjir", + "passed": true + }, + { + "label": "restored", + "value": { + "max_power": 1000, + "underwater": 0, + "can_swim": 1, + "power": 0, + "swimming": 0, + "moving": 0, + "travel_state": "Arrived", + "breath_max_ms": 180000, + "falling": 0, + "alive": 1, + "movement_flags": 0, + "vehicle_guid": "", + "in_water": 0, + "transport": 0, + "mover_guid": "149", + "mounted": 0, + "vehicle_entry": 0, + "hover_animation": 0, + "map": 0, + "guid": 149, + "animation_tier": 0, + "max_health": 231, + "breathing_limited": 1, + "agility": 26, + "y": -138, + "x": -8912, + "combat": 0, + "z": 80.9000015258789, + "spirit": 24, + "intellect": 21, + "stamina": 31, + "strength": 33, + "swim_speed": 4.722221851348877, + "level": 10, + "area": 9, + "loot_guid": "", + "zone": 12, + "flying": 0, + "breath_remaining_ms": -1, + "health": 231 + } + } + ] +} \ No newline at end of file diff --git a/doc/clientless/checkpoints/2026-11-05-vashjir/live-vashjir-open-water.lua b/doc/clientless/checkpoints/2026-11-05-vashjir/live-vashjir-open-water.lua new file mode 100644 index 0000000000..7c89773d83 --- /dev/null +++ b/doc/clientless/checkpoints/2026-11-05-vashjir/live-vashjir-open-water.lua @@ -0,0 +1,52 @@ +local g=testbot.login(149) +local before=testbot.state(g) +testbot.record('before',before) +testbot.level(g,85) +testbot.learn(g,75207) +testbot.skill(g,762,225,225) +testbot.breathing(g,false) +local selected=nil +for _,at in ipairs({{-5000,4000},{-5200,4000},{-5000,4200},{-4800,3800},{-5600,4000},{-5800,4000},{-6000,4000},{-5200,4500}}) do + local w=testbot.liquid(g,at[1],at[2],20) + testbot.record('surface_probe',{x=at[1],y=at[2],water=w}) + if not selected and w.surface>=-1 and w.surface-w.bottom>30 then + local z=w.surface-20 + local n=testbot.liquid(g,at[1],at[2],z) + local t=testbot.liquid(g,at[1]+40,at[2],z) + if n.safe==1 and n.swimming==1 and t.safe==1 and t.swimming==1 then selected={x=at[1],y=at[2],z=z} end + end +end +assert(selected,'no open-water sample found') +testbot.record('selected_water',selected) +assert(testbot.teleport(g,0,selected.x,selected.y,selected.z,0)) +testbot.await(function()return testbot.online(g)end,20000,'Vashjir map ready') +testbot.wait(1000) +local start=testbot.state(g) +testbot.record('vashjir_start',start) +testbot.record('water',testbot.liquid(g,start.x,start.y,start.z)) +testbot.check(start.zone==4815 or start.zone==5144 or start.zone==5145 or start.zone==5146,'actual Vashjir region reached') +local ok,why=testbot.travel(g,start.x+40,start.y,start.z) +testbot.record('travel_request',{ok=ok,why=why}) +local mounted=false +local arrived=false +for i=1,30 do + testbot.wait(500) + local n=testbot.state(g) + testbot.record('swim_segment',n) + if testbot.has_aura(g,75207) and n.mounted==1 and n.swim_speed>10 then mounted=true end + if n.travel_state=='Arrived' then arrived=true;break end +end +local n=testbot.state(g) +testbot.check(ok and mounted,'native seahorse mount and native swimming speed selected') +testbot.check(arrived and testbot.has_aura(g,75207),'seahorse retained across water segments until arrival') +local flight,error=testbot.flight(g,n.x+80,n.y,n.z+50) +testbot.record('new_flight',{ok=flight,why=error}) +testbot.check(not flight,'new flight rejected in Vashjir') +testbot.remove_aura(g,75207) +assert(testbot.teleport(g,before.map,before.x,before.y,before.z,0)) +testbot.await(function()return testbot.online(g)end,20000,'cleanup') +testbot.level(g,before.level) +testbot.breathing(g,true) +testbot.skill(g,762,0,0) +testbot.wait(500) +testbot.record('restored',testbot.state(g)) diff --git a/doc/clientless/checkpoints/2026-11-05-vashjir/live-vashjir.lua b/doc/clientless/checkpoints/2026-11-05-vashjir/live-vashjir.lua new file mode 100644 index 0000000000..9e0235af8f --- /dev/null +++ b/doc/clientless/checkpoints/2026-11-05-vashjir/live-vashjir.lua @@ -0,0 +1,42 @@ +local g=testbot.login(149) +local before=testbot.state(g) +testbot.record('before',before) +testbot.level(g,85) +testbot.learn(g,75207) +testbot.skill(g,762,225,225) +testbot.breathing(g,false) +-- Operator reloads this registered actor's generic Adventure profile here. +-- Its TestController keeps ownership; no normal AdventureBot is displaced. +testbot.wait(20000) +assert(testbot.teleport(g,0,-4580,3490,-90,0)) +testbot.await(function()return testbot.online(g)end,20000,'Vashjir map ready') +testbot.wait(1000) +local start=testbot.state(g) +testbot.record('vashjir_start',start) +testbot.record('water',testbot.liquid(g,start.x,start.y,start.z)) +testbot.check(start.zone==4815 or start.zone==5144 or start.zone==5145 or start.zone==5146,'actual Vashjir region reached') +local ok,why=testbot.travel(g,start.x+40,start.y,start.z) +testbot.record('travel_request',{ok=ok,why=why}) +local mounted=false +local arrived=false +for i=1,30 do + testbot.wait(500) + local n=testbot.state(g) + testbot.record('swim_segment',n) + if testbot.has_aura(g,75207) and n.mounted==1 and n.swim_speed>10 then mounted=true end + if n.travel_state=='Arrived' then arrived=true;break end +end +local n=testbot.state(g) +testbot.check(ok and mounted,'native seahorse mount and native swimming speed selected') +testbot.check(arrived and testbot.has_aura(g,75207),'seahorse retained across water segments until arrival') +local flight,error=testbot.flight(g,n.x+80,n.y,n.z+50) +testbot.record('new_flight',{ok=flight,why=error}) +testbot.check(not flight,'new flight rejected in Vashjir') +testbot.remove_aura(g,75207) +assert(testbot.teleport(g,before.map,before.x,before.y,before.z,0)) +testbot.await(function()return testbot.online(g)end,20000,'cleanup') +testbot.level(g,before.level) +testbot.breathing(g,true) +testbot.skill(g,762,0,0) +testbot.wait(500) +testbot.record('restored',testbot.state(g)) diff --git a/doc/clientless/checkpoints/2026-11-05-vashjir/result.json b/doc/clientless/checkpoints/2026-11-05-vashjir/result.json new file mode 100644 index 0000000000..e5b49ccc0c --- /dev/null +++ b/doc/clientless/checkpoints/2026-11-05-vashjir/result.json @@ -0,0 +1,29 @@ +{ + "verified_at": "2026-11-05T23:32:33.148070", + "server_pid": 104568, + "installed": true, + "loader": 1, + "previous_bots_restored": 120, + "eligible_bots_with_seahorse": 24, + "water_live_checks": 4, + "water_live_failures": 0, + "gateway_live_checks": 4, + "gateway_live_failures": 0, + "native_swim_speed": 25.97222137451172, + "native_speed_modifier_percent": 450, + "water_path_yards": 40, + "water_path_segments": 5, + "regression_suites": [ + "test_vashjir", + "test_free_flight_planner", + "test_swimming", + "test_group_flight_mount", + "test_adventure_group_travel", + "test_local_spline_segments", + "test_adventure_area_policy", + "test_adventure_area_segment", + "test_adventure_area_node" + ], + "full_live_taxi_journey_verified": false, + "first_live_attempt": "dry cave location, rejected as water test; kept in live-first-result.json" +} \ No newline at end of file diff --git a/doc/clientless/checkpoints/2026-11-06-leisure-walk/.gitignore b/doc/clientless/checkpoints/2026-11-06-leisure-walk/.gitignore new file mode 100644 index 0000000000..397b4a7624 --- /dev/null +++ b/doc/clientless/checkpoints/2026-11-06-leisure-walk/.gitignore @@ -0,0 +1 @@ +*.log diff --git a/doc/clientless/checkpoints/2026-11-06-leisure-walk/live-completed.json b/doc/clientless/checkpoints/2026-11-06-leisure-walk/live-completed.json new file mode 100644 index 0000000000..885550ab77 --- /dev/null +++ b/doc/clientless/checkpoints/2026-11-06-leisure-walk/live-completed.json @@ -0,0 +1,24 @@ +{ + "completed_at": "2026-11-06T00:15:23.935721+01:00", + "guid": 148, + "result": "native outing completed", + "events": [ + "LEISURE_WALK_PLAN guid=148 kind='explore' span=138.85 outbound=7 origin=(4810.01 3843.66 223.38) goal=(4806.92 3707.19 197.96)", + "LEISURE_START guid=148 kind='explore' waypoints=14", + "LEISURE_WAYPOINT guid=148 kind='explore' reached=1/14", + "LEISURE_WAYPOINT guid=148 kind='explore' reached=2/14", + "LEISURE_WAYPOINT guid=148 kind='explore' reached=3/14", + "LEISURE_WAYPOINT guid=148 kind='explore' reached=4/14", + "LEISURE_WAYPOINT guid=148 kind='explore' reached=5/14", + "LEISURE_WAYPOINT guid=148 kind='explore' reached=6/14", + "LEISURE_WAYPOINT guid=148 kind='explore' reached=7/14", + "LEISURE_WAYPOINT guid=148 kind='explore' reached=8/14", + "LEISURE_WAYPOINT guid=148 kind='explore' reached=9/14", + "LEISURE_WAYPOINT guid=148 kind='explore' reached=10/14", + "LEISURE_WAYPOINT guid=148 kind='explore' reached=11/14", + "LEISURE_WAYPOINT guid=148 kind='explore' reached=12/14", + "LEISURE_WAYPOINT guid=148 kind='explore' reached=13/14", + "LEISURE_WAYPOINT guid=148 kind='explore' reached=14/14", + "LEISURE_COMPLETE guid=148 kind='explore' legs=14" + ] +} \ No newline at end of file diff --git a/doc/clientless/checkpoints/2026-11-06-leisure-walk/result.json b/doc/clientless/checkpoints/2026-11-06-leisure-walk/result.json new file mode 100644 index 0000000000..69aa64e254 --- /dev/null +++ b/doc/clientless/checkpoints/2026-11-06-leisure-walk/result.json @@ -0,0 +1,31 @@ +{ + "verified_at": "2026-11-06T00:19:07.371850+01:00", + "server_pid": 115099, + "loader": 1, + "installed": true, + "live_actor": 148, + "source_reproduction": "SocretharsSeat, original Kordra coordinates", + "native_outing_span": 138.85, + "native_origin": [ + 4810.01, + 3843.66, + 223.38 + ], + "native_goal": [ + 4806.92, + 3707.19, + 197.96 + ], + "completed_waypoints": 14, + "completed_round_trip": true, + "actor_restored": true, + "regression_suites": [ + "test_adventure_leisure", + "test_outing_history", + "test_adventure_micro_reset", + "test_adventure_leisure_catalog", + "test_adventure_group_travel" + ], + "vashjir_midnight_plans_preserved": 10, + "full_build_initial_error": "logging variable scope corrected before installation" +} \ No newline at end of file diff --git a/doc/clientless/checkpoints/2026-11-06-leisure-walk/test-profile.lua b/doc/clientless/checkpoints/2026-11-06-leisure-walk/test-profile.lua new file mode 100644 index 0000000000..1a30cccded --- /dev/null +++ b/doc/clientless/checkpoints/2026-11-06-leisure-walk/test-profile.lua @@ -0,0 +1,7 @@ +return { + identity={ name=character_name }, + movement={can_ground_mount=false,can_free_fly=true,flight_mounts={[32235]=1}}, + behavior={enabled=false,daily_schedule=false}, + professions={primary={}}, + micro_action_affinity={adventure_explore=10000} +} diff --git a/sql/custom/characters/2026_11_05_00_adventure_seahorse.sql b/sql/custom/characters/2026_11_05_00_adventure_seahorse.sql new file mode 100644 index 0000000000..2d0b3f6769 --- /dev/null +++ b/sql/custom/characters/2026_11_05_00_adventure_seahorse.sql @@ -0,0 +1,6 @@ +-- Apply while AdventureBots are offline. Existing generated bots receive the +-- same native mount spell that generation and runtime reconciliation provision. +INSERT IGNORE INTO character_spell (guid,spell,active,disabled) +SELECT c.guid,75207,1,0 FROM characters c +JOIN vcore_adventure_generated_bot g ON g.character_guid=c.guid +WHERE c.level>=80 AND g.state='ready'; diff --git a/sql/custom/world/2026_11_05_01_adventure_vashjir.sql b/sql/custom/world/2026_11_05_01_adventure_vashjir.sql new file mode 100644 index 0000000000..f411dac990 --- /dev/null +++ b/sql/custom/world/2026_11_05_01_adventure_vashjir.sql @@ -0,0 +1,12 @@ +-- Swimming and unlimited AdventureBot breath now permit the Vashj'ir region. +-- Restrict world entry/exit in code to the faction-specific Sandy Beach taxis. +UPDATE vcore_adventure_area_catalog +SET allowed_factions=3,min_level=80,max_level=85,max_level_gap=0,prefer_flight=0, + notes='AdventureBots: aquatic travel; world entry/exit via Sandy Beach taxi only' +WHERE area_id=5146; +UPDATE vcore_adventure_area_catalog SET min_level=80,max_level_gap=0,prefer_flight=0 +WHERE area_id IN (4815,5144,5145); +-- DBC nodes 606/608 are the mainland flightmasters; 607/609 are underwater taxis. +INSERT INTO vcore_clientless_node_access (node_key,allowed_factions,flightmaster_spawn_id) +VALUES ('taxi_606',1,342102),('taxi_608',2,341915),('taxi_607',1,342107),('taxi_609',2,341916) +ON DUPLICATE KEY UPDATE allowed_factions=VALUES(allowed_factions),flightmaster_spawn_id=VALUES(flightmaster_spawn_id); diff --git a/src/server/game/World/AdventureAreaMgr.cpp b/src/server/game/World/AdventureAreaMgr.cpp index b33ed09be0..46644873b3 100644 --- a/src/server/game/World/AdventureAreaMgr.cpp +++ b/src/server/game/World/AdventureAreaMgr.cpp @@ -1,4 +1,5 @@ #include "AdventureAreaMgr.h" +#include "AdventureVashjir.h" #include "ClientlessLuaEngine.h" #include "ClientlessFlightMgr.h" #include "ClientlessTravelGraphMgr.h" @@ -15,6 +16,26 @@ #include #include +namespace AdventureVashjir +{ + bool ContainsArea(uint32 area) { return DBCManager::IsInArea(area,5146); } + bool Contains(Player const* player, uint32 map, Position const& point) + { return map==0 && ContainsArea(sAdventureAreaMgr->AreaAt(player,map,point)); } + bool Contains(Player const* player) + { return player && player->GetMapId()==0 && ContainsArea(player->GetAreaId()); } + bool LocalLinkAllowed(Player const* player, uint32 map, Position const& from, Position const& to) + { + return !sAdventureAreaMgr->Applies(player) || Contains(player,map,from)==Contains(player,map,to); + } + bool EdgeAllowed(bool fromInside, bool toInside, std::string const& type, + std::string const& fromKey, std::string const& toKey) + { + if (fromInside==toInside) return true; + auto const& insideKey=fromInside?fromKey:toKey; + return type=="taxi" && (insideKey=="taxi_606" || insideKey=="taxi_608"); + } +} + AdventureAreaMgr* AdventureAreaMgr::instance() { static AdventureAreaMgr mgr; @@ -207,6 +228,10 @@ bool AdventureAreaMgr::AllowsEdge(Player const* player,ClientlessTravelEdge cons if(!Applies(player))return true; auto from=sClientlessTravelGraphMgr->FindNode(edge.FromNode),to=sClientlessTravelGraphMgr->FindNode(edge.ToNode); if(!from || !to || !AllowsNode(player,*from) || !AllowsNode(player,*to))return false; + Position source(from->X,from->Y,from->Z),target(to->X,to->Y,to->Z); + if(_mapTypes.at(from->MapId)==0 && _mapTypes.at(to->MapId)==0 && + !AdventureVashjir::EdgeAllowed(AdventureVashjir::Contains(player,from->MapId,source), + AdventureVashjir::Contains(player,to->MapId,target),edge.Type,from->Key,to->Key))return false; // Items/quests/spells may change without a catalog reload; never cache // actor prerequisites as geography or test them only after reaching a portal. if(edge.Type=="portal_use" && !sClientlessTravelGraphMgr->PortalPrerequisites(player,edge.DatabaseId))return false; @@ -241,10 +266,10 @@ bool AdventureAreaMgr::AllowsEdge(Player const* player,ClientlessTravelEdge cons for(std::size_t i=0;isize() && allowed;++i) { auto const& p=(*points)[edge.Reverse?points->size()-1-i:i];Position next;next.Relocate(p.X,p.Y,p.Z); - allowed=p.MapId==from->MapId && AllowsSegment(player,p.MapId,previous,next);previous=next; + allowed=p.MapId==from->MapId && AdventureVashjir::LocalLinkAllowed(player,p.MapId,previous,next) && AllowsSegment(player,p.MapId,previous,next);previous=next; } Position end;end.Relocate(to->X,to->Y,to->Z); - allowed=allowed && from->MapId==to->MapId && AllowsSegment(player,to->MapId,previous,end); + allowed=allowed && from->MapId==to->MapId && AdventureVashjir::LocalLinkAllowed(player,to->MapId,previous,end) && AllowsSegment(player,to->MapId,previous,end); } if(_edgeAccess.size()>=100000)_edgeAccess.clear(); _edgeAccess.emplace(std::move(key),allowed);return allowed; diff --git a/src/server/game/World/AdventureBehaviorMgr.cpp b/src/server/game/World/AdventureBehaviorMgr.cpp index 54b2a93b36..33c8d5bac8 100644 --- a/src/server/game/World/AdventureBehaviorMgr.cpp +++ b/src/server/game/World/AdventureBehaviorMgr.cpp @@ -831,21 +831,24 @@ bool AdventureBehaviorMgr::PlanLeisureWalk(Player* p, Record& r) auto& s=r.Leisure; auto location=sAdventureLocationMgr->Find(r.State==Phase::WaitingGroup?r.WaitingLocation:r.Location); uint32 const boundary=location->IsArea?location->AreaId:location->ZoneId; - // Choose one substantial destination, then follow its actual ground corridor. - // Randomness selects the outing, never the next individual footstep. + // Prefer a substantial native corridor, but try smaller rings when the + // surrounding terrain or available space cannot support a long outing. float const offset=std::uniform_real_distribution(0,6.2831853f)(r.Random); - float const budget=(r.Intent=="groupformation" || r.State==Phase::WaitingGroup)?220.0f:std::min(220.0f,std::max(100.0f,float(r.MicroTimer)*0.001f*1.0f)); + bool const formation=r.Intent=="groupformation" || r.State==Phase::WaitingGroup; + float const budget=formation?220.0f:std::min(220.0f,std::max(100.0f,float(r.MicroTimer)*0.001f)); float best=0; - for (unsigned i=0;i<16;++i) + for (float const radius : {formation?110.0f:std::min(150.0f,budget*0.7f),formation?70.0f:80.0f,40.0f,20.0f,10.0f}) { - float const angle=offset+float(i%8)*6.2831853f/8; - float const radius=(r.Intent=="groupformation" || r.State==Phase::WaitingGroup)?(i<8?110.0f:70.0f):(i<8?std::min(150.0f,budget*0.7f):80.0f); + best=0; + for (unsigned i=0;i<8;++i) + { + float const angle=offset+float(i)*6.2831853f/8; Position goal; goal.Relocate(s.Origin.GetPositionX()+std::cos(angle)*radius, s.Origin.GetPositionY()+std::sin(angle)*radius,s.Origin.GetPositionZ()); float const z=p->GetMap()->GetHeight(p->GetPhaseShift(),goal.GetPositionX(),goal.GetPositionY(), - s.Origin.GetPositionZ()+2,true,15); - if (!std::isfinite(z) || z<=INVALID_HEIGHT+1 || std::fabs(z-s.Origin.GetPositionZ())>((r.Intent=="groupformation" || r.State==Phase::WaitingGroup)?20.0f:3.0f)) continue; + s.Origin.GetPositionZ()+radius+2,true,2*radius+4); + if (!std::isfinite(z) || z<=INVALID_HEIGHT+1) continue; goal.m_positionZ=z; PathGenerator navigation(p); navigation.SetPathLengthLimit(240); @@ -860,7 +863,9 @@ bool AdventureBehaviorMgr::PlanLeisureWalk(Player* p, Record& r) { Position target;target.Relocate(point.x,point.y,point.z); float const step=last.GetExactDist(target); - if (!std::isfinite(step) || step>12 || std::fabs(point.z-last.GetPositionZ())>4 || r.Anchor.GetExactDist(target)>250) + // A complete native MMAP corridor establishes walkability even + // when a ramp changes height or its straight-path samples are far apart. + if (!std::isfinite(step) || r.Anchor.GetExactDist(target)>250) {valid=false;break;} PositionFullTerrainStatus terrain; p->GetMap()->GetTerrain()->GetFullTerrainStatusForPosition(p->GetPhaseShift(),p->GetMapId(),point.x,point.y,point.z,terrain); @@ -872,13 +877,15 @@ bool AdventureBehaviorMgr::PlanLeisureWalk(Player* p, Record& r) if (section>=20) {outbound.push_back(target);section=0;} } float const span=s.Origin.GetExactDist(last); - if (!valid || length>budget || span<65.0f || ((r.Intent=="groupformation" || r.State==Phase::WaitingGroup) && !endsOutdoors) || length>span*2.5f || last.GetExactDist(goal)>1.5f) continue; + if (!valid || length>budget || span<8.0f || ((r.Intent=="groupformation" || r.State==Phase::WaitingGroup) && !endsOutdoors) || length>span*2.5f || last.GetExactDist(goal)>1.5f) continue; if (outbound.empty() || outbound.back().GetExactDist(last)>2) outbound.push_back(last); else outbound.back()=last; if (span>best) { best=span;s.Route=std::move(outbound); } + } + if (!s.Route.empty()) break; } if (s.Route.empty()) return false; s.PlannedWalk=true;s.OutboundSteps=s.Route.size();s.WalkTrace={s.Origin}; @@ -1387,7 +1394,9 @@ void AdventureBehaviorMgr::Micro(Player * player, Record & r) auto const a = ResolvedAction(*choices[n]); r.Micro = a.Key; r.MicroTimer = std::uniform_int_distribution < uint32 >(a.MinSeconds, a.MaxSeconds)(r.Random) * 1000; - Remember(r.ActionHistory, a.Kind+":"+a.Requirement); + bool const outing=a.Kind=="leisure" || a.Kind=="outing"; + if (!outing) Remember(r.ActionHistory, a.Kind+":"+a.Requirement); + // Failed variants still lose novelty, but never count as a started outing. Remember(r.VariantHistory, "action:" + a.Key); if(r.Intent=="social"&&(a.Kind=="drink"||a.Kind=="eat"||(a.Kind=="sit"&&a.Requirement.empty()))) { @@ -1399,6 +1408,7 @@ void AdventureBehaviorMgr::Micro(Player * player, Record & r) if (a.Kind=="leisure" || a.Kind=="outing") { if (!StartLeisure(player,r,a)) r.MicroTimer=3000; + else Remember(r.ActionHistory, a.Kind+":"+a.Requirement); } else if (a.Kind=="recovery") { diff --git a/src/server/game/World/AdventureGeneratorMgr.cpp b/src/server/game/World/AdventureGeneratorMgr.cpp index 358eb2de05..0699cc9c02 100644 --- a/src/server/game/World/AdventureGeneratorMgr.cpp +++ b/src/server/game/World/AdventureGeneratorMgr.cpp @@ -1,3 +1,4 @@ +#include "AdventureVashjir.h" #include "AdventureGeneratorMgr.h" #include "AdventureCombatPreparationPolicy.h" #include "AdventureTalentPolicy.h" @@ -62,6 +63,11 @@ namespace } bool ProvisionFlight(Player* player,ClientlessAdventureProfile const& profile,std::string& error) { + if(player->getLevel()>=80 && !player->HasSpell(AdventureVashjir::Seahorse)) + { + if(Learnable(player,AdventureVashjir::Seahorse))player->LearnSpell(AdventureVashjir::Seahorse,false); + if(!player->HasSpell(AdventureVashjir::Seahorse)){error="mandatory aquatic mount unavailable";return false;} + } if(!profile.AutonomousBehavior || player->getLevel()<60)return true; for(auto spell:{33388u,33391u,34090u,90267u,54197u}) { @@ -509,6 +515,7 @@ bool AdventureGeneratorMgr::Create(ChatHandler* handler,uint32 account,uint32 se if(!sAdventureGeneratorMgr->Prepare(player,a,error) || !Equip(player,a,*rng,error))return false; if(player->getLevel()>=20)player->SetSkill(SKILL_RIDING,player->getLevel()>=60?3:player->getLevel()>=40?2:1, player->getLevel()>=60?225:player->getLevel()>=40?150:75,player->getLevel()>=60?225:player->getLevel()>=40?150:75); + if(player->getLevel()>=80 && Learnable(player,AdventureVashjir::Seahorse))player->LearnSpell(AdventureVashjir::Seahorse,false); if(player->getLevel()>=60 && Learnable(player,90267))player->LearnSpell(90267,false); if(player->getLevel()>=68 && Learnable(player,54197))player->LearnSpell(54197,false); if(player->getLevel()>=60)for(auto id:AdventureGeneratorPolicy::Faction(player->getRace())==1? diff --git a/src/server/game/World/AdventureVashjir.h b/src/server/game/World/AdventureVashjir.h new file mode 100644 index 0000000000..30d39af86a --- /dev/null +++ b/src/server/game/World/AdventureVashjir.h @@ -0,0 +1,17 @@ +#ifndef VCORE_ADVENTURE_VASHJIR_H +#define VCORE_ADVENTURE_VASHJIR_H +#include "Common.h" +#include +class Player; +struct Position; +namespace AdventureVashjir +{ + constexpr uint32 Seahorse = 75207; + bool TC_GAME_API ContainsArea(uint32 area); + bool TC_GAME_API Contains(Player const* player, uint32 map, Position const& point); + bool TC_GAME_API Contains(Player const* player); + bool TC_GAME_API LocalLinkAllowed(Player const* player, uint32 map, Position const& from, Position const& to); + bool TC_GAME_API EdgeAllowed(bool fromInside, bool toInside, std::string const& type, + std::string const& fromKey, std::string const& toKey); +} +#endif diff --git a/src/server/game/World/ClientlessFlightMgr.cpp b/src/server/game/World/ClientlessFlightMgr.cpp index 6d691fbbdc..87bce21aab 100644 --- a/src/server/game/World/ClientlessFlightMgr.cpp +++ b/src/server/game/World/ClientlessFlightMgr.cpp @@ -1,3 +1,4 @@ +#include "AdventureVashjir.h" #include "AdventureAreaMgr.h" #include "ClientlessTravelTelemetry.h" #include "ClientlessFlightMgr.h" @@ -152,6 +153,8 @@ bool ClientlessFlightMgr::Preferred(Player const * player, uint32 map, Position float ClientlessFlightMgr::Estimate(Player const * player, uint32 map, Position const & from, Position const & to, bool recovery) const { + if (sAdventureAreaMgr->Applies(player) && + (AdventureVashjir::Contains(player,map,from) || AdventureVashjir::Contains(player,map,to))) return Infinity(); auto const * entry = sMapStore.LookupEntry(map); if(RejectedApproach(player,map,from,to))return Infinity(); bool planning=_planningPlayer==player; @@ -231,7 +234,7 @@ bool ClientlessFlightMgr::Start(Player* player,Position const& target,std::strin } bool ClientlessFlightMgr::PrepareFollowingMount(Player* player) { - if(!Enabled(player) || !player->IsAlive() || player->IsInCombat() || player->IsBeingTeleported() || + if(AdventureVashjir::Contains(player) || !Enabled(player) || !player->IsAlive() || player->IsInCombat() || player->IsBeingTeleported() || player->GetTransport() || player->IsInFlight() || player->IsFalling() || player->IsInWater() || !player->IsOutdoors() || player->GetMap()->GetEntry()->MapType!=MAP_COMMON)return false; if(player->IsMounted() && player->CanFly())return false; @@ -444,6 +447,8 @@ bool ClientlessFlightMgr::Begin(Player * player, Position const & target, std::s if(player)ClientlessTravelTelemetry::Note(player,"flight-state-rejected",ClientlessTravelTelemetry::State(player)); return false; } + if (AdventureVashjir::Contains(player) && !(player->IsMounted() && player->CanFly())) + {error="Vashjir permits only aquatic mount boarding";return false;} if (!sAdventureAreaMgr->AllowsSegment(player,player->GetMapId(),*player,target)) {error="flight corridor denied by area catalog";return false;} auto * vmaps = VMAP::VMapFactory::createOrGetVMapManager(); diff --git a/src/server/game/World/ClientlessLuaEngine.cpp b/src/server/game/World/ClientlessLuaEngine.cpp index 83c15bb359..251d1ed444 100644 --- a/src/server/game/World/ClientlessLuaEngine.cpp +++ b/src/server/game/World/ClientlessLuaEngine.cpp @@ -1,3 +1,4 @@ +#include "AdventureVashjir.h" #include "AdventureProfessionPolicy.h" #include "ClientlessLuaEngine.h" #include "ClientlessMountPreparation.h" @@ -639,11 +640,28 @@ void ClientlessLuaEngine::UpdateWorldPresence(Player* player, std::string const& TC_LOG_INFO("server.adventurebot","WORGEN_FORM guid=%u intent='%s' desired=%u arrived=%u",guid,intent.c_str(),wanted->second,arrived); } +bool ClientlessLuaEngine::PrepareAquaticMount(Player* player) +{ + if (!player || !GetAdventureProfile(player->GetGUID().GetCounter()) || !AdventureVashjir::Contains(player))return false; + // Boarding policy only: do not strip an existing mount or interrupt flight. + if (player->IsMounted())return player->HasAura(AdventureVashjir::Seahorse); + if (player->getLevel()<80 || !player->HasSpell(AdventureVashjir::Seahorse) || !player->IsInWater() || + !player->IsAlive() || player->IsInCombat() || player->IsBeingTeleported() || player->IsInFlight() || + player->IsFlying() || player->IsFalling() || player->GetTransport() || player->GetVehicle() || + player->HasUnitState(UNIT_STATE_CASTING) || !player->GetMountCapability(232))return false; + if (!ClientlessMountPreparation::LeaveDruidForm(player,true))return false; + // Native mount spell/capability supplies the model and swimming speed. + player->CastSpell(player,AdventureVashjir::Seahorse,true); + return player->HasAura(AdventureVashjir::Seahorse) && player->IsMounted(); +} + bool ClientlessLuaEngine::PrepareGroundMount(Player* player, float travelDistance, char const* context) { if (!player || !player->IsInWorld()) return false; + if (AdventureVashjir::Contains(player))return PrepareAquaticMount(player); + ClientlessAdventureProfile const* profile = GetAdventureProfile(player->GetGUID().GetCounter()); if (!profile || !profile->CanGroundMount || (profile->GroundMounts.empty() && player->getRace()!=RACE_WORGEN)) return false; @@ -687,6 +705,7 @@ void ClientlessLuaEngine::DismountGroundMount(Player* player, char const* reason return; uint32 const oldDisplay = player->GetMountID(); + player->RemoveAurasDueToSpell(AdventureVashjir::Seahorse); player->RemoveAurasDueToSpell(87840); player->Dismount(); player->UpdateSpeed(MOVE_RUN); diff --git a/src/server/game/World/ClientlessLuaEngine.h b/src/server/game/World/ClientlessLuaEngine.h index cf64c1c6d1..152fc7a09f 100644 --- a/src/server/game/World/ClientlessLuaEngine.h +++ b/src/server/game/World/ClientlessLuaEngine.h @@ -74,6 +74,7 @@ public: uint32 SelectCompanionSpell(uint32 characterGuid) const; void ForgetWorldPresence(uint32 guid) { _worgenForms.erase(guid); _worgenNextAttempt.erase(guid); } void UpdateWorldPresence(Player* player, std::string const& intent, bool arrived = false); + bool PrepareAquaticMount(Player* player); bool PrepareGroundMount(Player* player, float travelDistance, char const* context); void DismountGroundMount(Player* player, char const* reason); diff --git a/src/server/game/World/ClientlessMountPreparation.h b/src/server/game/World/ClientlessMountPreparation.h index 994bde30c2..b7c6968286 100644 --- a/src/server/game/World/ClientlessMountPreparation.h +++ b/src/server/game/World/ClientlessMountPreparation.h @@ -7,7 +7,7 @@ namespace ClientlessMountPreparation { // Cancel the aura category, not individual spell IDs: covers every druid // form and its ranks, including travel, aquatic, flight and talent forms. - inline bool LeaveDruidForm(Player* player) + inline bool LeaveDruidForm(Player* player, bool aquaticMount = false) { if (player->getClass() != CLASS_DRUID || !player->HasAuraType(SPELL_AURA_MOD_SHAPESHIFT)) return true; @@ -15,7 +15,7 @@ namespace ClientlessMountPreparation // Never drop a flying/swimming druid out of a form in mid-transition. // The normal landing/transport owner must finish before mounting. if (!player->IsAlive() || player->IsInCombat() || player->IsFlying() || player->IsFalling() || - player->IsInWater() || player->IsInFlight() || player->GetTransport() || player->GetVehicle() || + (player->IsInWater() && !aquaticMount) || player->IsInFlight() || player->GetTransport() || player->GetVehicle() || player->IsBeingTeleported()) return false; diff --git a/src/server/game/World/ClientlessTravelGraphMgr.cpp b/src/server/game/World/ClientlessTravelGraphMgr.cpp index 22f62da1d4..678f99815d 100644 --- a/src/server/game/World/ClientlessTravelGraphMgr.cpp +++ b/src/server/game/World/ClientlessTravelGraphMgr.cpp @@ -1,3 +1,4 @@ +#include "AdventureVashjir.h" #include "AdventureAreaMgr.h" #include "ConditionMgr.h" #include "ClientlessTravelGraphMgr.h" @@ -891,6 +892,8 @@ bool ClientlessTravelGraphMgr::PlanAdaptiveRoute( auto const& node=pair.second; if(node.MapId!=player->GetMapId() || !RescueNodeAllowed(node) || !sAdventureAreaMgr->AllowsNode(player,node))continue; + Position localFrom,localTo;localFrom.Relocate(player->GetPositionX(),player->GetPositionY(),player->GetPositionZ());localTo.Relocate(node.X,node.Y,node.Z); + if(!AdventureVashjir::LocalLinkAllowed(player,node.MapId,localFrom,localTo))continue; float dx=node.X-player->GetPositionX(),dy=node.Y-player->GetPositionY(),dz=node.Z-player->GetPositionZ(); startNodes.emplace_back(std::sqrt(dx*dx+dy*dy+dz*dz),pair.first); } @@ -1239,7 +1242,7 @@ bool ClientlessTravelGraphMgr::PlanAdaptiveRoute( for(std::size_t i=1;iAllowsSegment(player,from.MapId,p,q))return false; + if(!AdventureVashjir::LocalLinkAllowed(player,from.MapId,p,q) || !sAdventureAreaMgr->AllowsSegment(player,from.MapId,p,q))return false; } return true; }; @@ -1359,7 +1362,9 @@ bool ClientlessTravelGraphMgr::PlanAdaptiveRoute( candidate.Point = point; bool const groundExitExhausted = blockedBridgeKeys && blockedBridgeKeys->count("ground_exit_edge:" + identity); - candidate.LocalCost = locationGoal && !groundExitExhausted && dsq <= locationAccessRadius*locationAccessRadius + Position exitPosition,goalPosition;exitPosition.Relocate(point.X,point.Y,point.Z);goalPosition.Relocate(goalX,goalY,goalZ); + candidate.LocalCost = locationGoal && !groundExitExhausted && dsq <= locationAccessRadius*locationAccessRadius && + AdventureVashjir::LocalLinkAllowed(player,goalMap,exitPosition,goalPosition) ? groundCost(std::sqrt(dsq)) : std::numeric_limits::infinity(); // A recorded edge can contain hundreds of samples. Calling @@ -1544,7 +1549,10 @@ bool ClientlessTravelGraphMgr::PlanAdaptiveRoute( bool const sourcePortal = candidateNode.Key.rfind("portal_at_", 0) == 0 && candidateNode.Key.size() >= 7 && candidateNode.Key.compare(candidateNode.Key.size() - 7, 7, "_source") == 0; - if (!sourcePortal && candidateNode.MapId == locationGoal->MapId) + Position candidatePosition,locationPosition;candidatePosition.Relocate(candidateNode.X,candidateNode.Y,candidateNode.Z); + locationPosition.Relocate(locationGoal->X,locationGoal->Y,locationGoal->Z); + if (!sourcePortal && candidateNode.MapId == locationGoal->MapId && + AdventureVashjir::LocalLinkAllowed(player,candidateNode.MapId,candidatePosition,locationPosition)) { float dx = candidateNode.X - locationGoal->X; float dy = candidateNode.Y - locationGoal->Y; diff --git a/src/server/game/World/ClientlessTravelMgr.cpp b/src/server/game/World/ClientlessTravelMgr.cpp index 111feab12d..f3a69a2118 100644 --- a/src/server/game/World/ClientlessTravelMgr.cpp +++ b/src/server/game/World/ClientlessTravelMgr.cpp @@ -1,3 +1,6 @@ +#include "AdventureVashjir.h" +#include "SpellAuraEffects.h" +#include "DBCStores.h" #include "AdventureAreaMgr.h" #include "ClientlessTravelMgr.h" #include "ClientlessSwimming.h" @@ -99,6 +102,9 @@ void DismountForWater(Player* player, Position const& point) { if (!player->IsMounted() || player->IsFlying() || player->IsInFlight() || player->GetTransport() || player->GetVehicle()) return; + for (auto effect:player->GetAuraEffectsByType(SPELL_AURA_MOUNTED)) + if (auto capability=player->GetMountCapability(uint32(effect->GetMiscValueB()))) + if (capability->Flags & (MOUNT_CAPABILITY_FLAG_FLOAT | MOUNT_CAPABILITY_FLAG_UNDERWATER))return; auto water=Inspect(player,point); if (water.Liquid && water.Safe && water.Surface-water.Bottom>player->GetCollisionHeight()*0.5f) player->RemoveAurasByType(SPELL_AURA_MOUNTED); @@ -329,6 +335,8 @@ bool ClientlessTravelMgr::AnalyzePath( return false; } + if (!AdventureVashjir::LocalLinkAllowed(player,player->GetMapId(),*player,target)) + { diagnostics.Reason="Vashjir entry/exit requires Sandstrand taxi";return false; } float const sx = player->GetPositionX(); float const sy = player->GetPositionY(); float const sz = player->GetPositionZ(); @@ -346,7 +354,7 @@ bool ClientlessTravelMgr::AnalyzePath( Position a,b;a.Relocate(points[i-1].x,points[i-1].y,points[i-1].z);b.Relocate(points[i].x,points[i].y,points[i].z); auto water=ClientlessSwimming::Inspect(player,b); diagnostics.HasWater |= water.Liquid && water.Safe && water.Surface-water.Bottom>player->GetCollisionHeight(); - if(!sAdventureAreaMgr->AllowsSegment(player,player->GetMapId(),a,b)) + if(!AdventureVashjir::LocalLinkAllowed(player,player->GetMapId(),a,b) || !sAdventureAreaMgr->AllowsSegment(player,player->GetMapId(),a,b)) {diagnostics.Calculated=false;diagnostics.Reason="area-catalog-denied";return false;} } @@ -683,7 +691,9 @@ bool ClientlessTravelMgr::LaunchPath(Player* player, TravelRecord& record) record.ActiveSpline = spline; ++record.Status.SegmentIndex; - if (water) + if (water && AdventureVashjir::Contains(player)) + sClientlessLuaEngine->PrepareAquaticMount(player); + else if (water) sClientlessLuaEngine->DismountGroundMount(player, "local-swimming"); else if (record.AllowGroundMount) sClientlessLuaEngine->PrepareGroundMount(player, nav.DirectDistance, "local-ground"); @@ -729,6 +739,7 @@ bool ClientlessTravelMgr::StartTravel(Player* player, Position const& target, bo record.Status.State = ClientlessTravelState::Moving; record.Status.MapId = player->GetMapId(); record.Status.Target = target; + if (allowGroundMount && !walk)sClientlessLuaEngine->PrepareAquaticMount(player); ClientlessSwimming::DismountForWater(player, record.Status.Target); ClientlessSwimming::NormalizeSurface(player, record.Status.Target); record.AllowGroundMount = allowGroundMount && !walk; diff --git a/tests/clientless/test_adventure_area_node.py b/tests/clientless/test_adventure_area_node.py index 2511f5bbcb..ebade1cbe8 100644 --- a/tests/clientless/test_adventure_area_node.py +++ b/tests/clientless/test_adventure_area_node.py @@ -6,6 +6,8 @@ s=(root/'src/server/game/World/AdventureBehaviorMgr.cpp').read_text() a=s.index('std::string AdventureBehaviorMgr::AreaNode(');start=s.index('{',a);b=start+1;depth=1 while depth: depth+=(s[b]=='{')-(s[b]=='}');b+=1 +ha=s.index(' std::string RequiredLocationArrivalNode(');hb=s.index(' AdventureMicroAction ResolvedAction(',ha) +helper=s[ha:hb] code=r''' #include #include @@ -16,7 +18,7 @@ code=r''' using uint32=uint32_t; struct Position {float x=0;void Relocate(float a,float,float){x=a;}float GetPositionX(){return x;}float GetPositionY(){return 0;}}; struct Player{int map=0;int GetPhaseShift(){return 0;}int GetMapId(){return map;}float GetExactDist(Position p){return p.x;}}; -struct AdventureLocation{struct{int MapId=0;float X=0,Y=0;}Point;uint32 AreaId=12;}; +struct AdventureLocation{struct{int MapId=0;float X=0,Y=0;}Point;uint32 AreaId=12,ZoneId=0;}; struct Field{float value=0;std::string text;float GetFloat(){return value;}std::string GetString(){return text;}}; struct Rows{std::vector> data;unsigned row=0;operator bool(){return !data.empty();}Rows* operator->(){return this;}Field* Fetch(){return data[row].data();}bool NextRow(){return ++row tried;bool PlanAdaptiveRoute(Player*,std::string const&key,int,int,std::vector&,bool& complete,std::string&,std::string&){tried.push_back(key);complete=key=="reachable";return true;}}graph;auto sClientlessTravelGraphMgr=&graph; struct AdventureBehaviorMgr{std::string AreaNode(Player*,AdventureLocation const&);}; -'''+s[a:b]+r''' +'''+helper+s[a:b]+r''' int main(){ WorldDatabase.rows.data={{{0,"outside"},{1,""},{},{}},{{0,"blocked"},{2,""},{},{}},{{0,"reachable"},{3,""},{},{}}}; Player p;AdventureLocation l;AdventureBehaviorMgr mgr; assert(mgr.AreaNode(&p,l)=="reachable");assert((graph.tried==std::vector{"blocked","reachable"})); sTerrainMgr.available=false;assert(mgr.AreaNode(&p,l).empty());sTerrainMgr.available=true; l.AreaId=42;graph.tried.clear();assert(mgr.AreaNode(&p,l).empty()&&graph.tried.empty()); + l.ZoneId=1497;assert(mgr.AreaNode(&p,l)=="taxi_11"); } ''' with tempfile.TemporaryDirectory(prefix='vcore-area-node-') as folder: diff --git a/tests/clientless/test_adventure_leisure.py b/tests/clientless/test_adventure_leisure.py index 6a53a41b30..e59113ee94 100644 --- a/tests/clientless/test_adventure_leisure.py +++ b/tests/clientless/test_adventure_leisure.py @@ -16,12 +16,14 @@ code=r''' #include #include #include +#include #include #include #include namespace GameTime{time_t now=100;time_t GetGameTime(){return now;}} using uint32=uint32_t; -#define TC_LOG_INFO(...) ((void)0) +#define TC_LOG_INFO(...) TestLog(__VA_ARGS__) +templatevoid TestLog(Args const&...){} constexpr float INVALID_HEIGHT=-100000; constexpr int BASE_ATTACK=0,ITEM_SUBCLASS_WEAPON_FISHING_POLE=20,UNIT_NPC_EMOTESTATE=0,EMOTE_STATE_FISHING=379; struct Player; @@ -40,7 +42,7 @@ struct Terrain{ struct Map{float water=-1000,ground=0;Terrain* GetTerrain(){return &terrain;}float GetHeight(int,float,float,float,bool,float){return ground;}float GetWaterLevel(int,float,float){return water;}}map; struct Guid{uint32 GetCounter(){return 26;}}; struct Item{struct Template{uint32 GetSubClass(){return 20;}}t;Template* GetTemplate(){return &t;}}rod; -struct Creature:Position{}cat; +struct Creature:Position{templatebool HasAura(uint32,T){return false;}}cat; struct Player:Position{ bool alive=true,combat=false,flying=false,outdoors=true,water=false,falling=false,hasRod=false;uint32 emote=0;int stops=0; uint32 GetMapId(){return 0;}bool IsAlive(){return alive;}bool IsInCombat(){return combat;}bool IsFlying(){return flying;}bool IsInFlight(){return false;}bool GetTransport(){return false;} @@ -55,13 +57,13 @@ bool Unsafe(Player* p){return p->combat||p->flying;} constexpr int PATHFIND_NORMAL=1; struct PathGenerator{ struct Point{float x,y,z;};std::vector path; - static inline bool reachable=true,broken=false;static inline int type=1;static inline float bend=20; + static inline bool reachable=true,broken=false;static inline float maxReach=100000;static inline int type=1;static inline float bend=20; PathGenerator(Player*){}void SetPathLengthLimit(float){} bool CalculatePath(Position const&a,Position const&b){ path.clear();int n=int(a.GetExactDist(b)/4)+1; for(int i=0;i<=n;++i){float t=float(i)/n;path.push_back({a.m_positionX+(b.m_positionX-a.m_positionX)*t,a.m_positionY+(b.m_positionY-a.m_positionY)*t+bend*std::sin(3.14159265f*t),a.m_positionZ+(b.m_positionZ-a.m_positionZ)*t});} - if(broken && path.size()>5) path[5].z+=10; - return reachable; + if(broken && path.size()>5) path[5].z=std::numeric_limits::quiet_NaN(); + return reachable && a.GetExactDist(b)<=maxReach; } int GetPathType(){return type;}auto const& GetPath(){return path;} }; @@ -156,7 +158,15 @@ int main(){ // No route is invented where native terrain rejects every candidate or zone differs. terrain.outdoors=false;assert(!mgr.StartLeisure(&p,r,{"walk"}));terrain.outdoors=true; terrain.zone=12;assert(!mgr.StartLeisure(&p,r,{"walk"}));terrain.zone=1519; - map.ground=8;assert(!mgr.StartLeisure(&p,r,{"walk"}));map.ground=0; // roof is not a ground stroll waypoint + // A complete native ramp may end far above/below the start. + map.ground=25;assert(mgr.StartLeisure(&p,r,{"walk"}));mgr.ResetLeisure(&p,r); + map.ground=-25;assert(mgr.StartLeisure(&p,r,{"walk"}));mgr.ResetLeisure(&p,r);map.ground=0; + // Constrained spaces retain short native round trips, not permanent idling. + PathGenerator::maxReach=45; + assert(mgr.StartLeisure(&p,r,{"walk"}));assert(r.Leisure.Origin.GetExactDist(r.Leisure.Route[r.Leisure.OutboundSteps-1])<45);mgr.ResetLeisure(&p,r); + PathGenerator::maxReach=15;PathGenerator::bend=2; + assert(mgr.StartLeisure(&p,r,{"walk"}));assert(r.Leisure.Origin.GetExactDist(r.Leisure.Route[r.Leisure.OutboundSteps-1])<15);mgr.ResetLeisure(&p,r); + PathGenerator::maxReach=5;assert(!mgr.StartLeisure(&p,r,{"walk"}));PathGenerator::maxReach=100000;PathGenerator::bend=20; // Summon and leash must be ready before owner movement starts. assert(mgr.StartLeisure(&p,r,{"pet_walk"}));ClientlessCompanionMgr::ready=false; int before=mgr.moves;assert(mgr.UpdateLeisure(&p,r,1000)&&mgr.moves==before); diff --git a/tests/clientless/test_free_flight_planner.py b/tests/clientless/test_free_flight_planner.py index 8467f09911..5462b2bab1 100644 --- a/tests/clientless/test_free_flight_planner.py +++ b/tests/clientless/test_free_flight_planner.py @@ -32,7 +32,8 @@ struct Position { float x=0,y=0,z=0;float GetPositionX()const{return x;}float Ge struct Player { float x=0,y=0,z=0; bool IsInWorld() const{return true;} uint32 GetMapId()const{return 0;} uint32 GetInstanceId()const{return 0;} float GetPositionX()const{return x;} float GetPositionY()const{return y;} float GetPositionZ()const{return z;} }; float dist(Position a,Position b){return std::sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y)+(a.z-b.z)*(a.z-b.z));} struct ClientlessPathDiagnostics {bool Calculated=true, Complete=true,Suspicious=false; uint32 PathType=1,PointCount=2; float DirectDistance=0,PathLength=0,MaxSegmentLength=0,MaxZDelta=0,FinalDistance=0; std::string Reason;}; -struct Travel {unsigned calls=0;bool complete=true;void AnalyzePath(Player* p,Position b,ClientlessPathDiagnostics& n){++calls;Position a;a.Relocate(p->x,p->y,p->z);n.PathLength=n.DirectDistance=dist(a,b);n.Complete=complete;}} travel; +bool vashBoundary=false; +struct Travel {unsigned calls=0;bool complete=true;void AnalyzePath(Player* p,Position b,ClientlessPathDiagnostics& n){++calls;Position a;a.Relocate(p->x,p->y,p->z);n.PathLength=n.DirectDistance=dist(a,b);n.Complete=complete && (!vashBoundary || (a.x>=1000)==(b.x>=1000));}} travel; auto sClientlessTravelMgr=&travel; struct Flight { float rejectBelow=-1e9;float closedFromX=1e9;bool rejectNearbyTargets=false;bool enabled=false;float minimumX=-10000;float forbiddenTargetX=1e9; @@ -41,19 +42,21 @@ struct Flight { bool Enabled(Player const*){return enabled;} bool Preferred(Player const*,uint32,Position const&){return false;} float Estimate(Player const*,uint32 map,Position a,Position b,bool recovery=false){ + if(vashBoundary && (a.x>=1000 || b.x>=1000))return std::numeric_limits::infinity(); bool forbiddenPair=std::fabs(a.x-forbiddenPairFromX)<0.1f&&std::fabs(b.x-forbiddenPairTargetX)<0.1f; float d=dist(a,b);return enabled&&b.x>=rejectBelow&&std::fabs(a.x-closedFromX)>0.1f&&!(rejectNearbyTargets&&b.x>1&&b.x<450)&&map==0&&a.x>=minimumX&&std::fabs(b.x-forbiddenTargetX)>0.1f&&!forbiddenPair&&(recovery||d>=60)?(recovery?d:180+d*1.5f):std::numeric_limits::infinity(); } } flight; auto sClientlessFlightMgr=&flight; struct AreaAccess { - bool active=true;std::unordered_set blocked;float forbiddenMin=1e9,forbiddenMax=1e9; + bool active=true;std::unordered_set blocked,insideNodes;float forbiddenMin=1e9,forbiddenMax=1e9; bool Applies(Player const*)const{return active;} templatebool AllowsNode(Player const*,Node const& n)const{return !blocked.count(n.Key);} - templatebool AllowsEdge(Player const*,Edge const& e)const{return !blocked.count(e.FromNode)&&!blocked.count(e.ToNode);} + templatebool AllowsEdge(Player const*,Edge const& e)const{if(vashBoundary && insideNodes.count(e.FromNode)!=insideNodes.count(e.ToNode)){auto k=insideNodes.count(e.FromNode)?e.FromNode:e.ToNode;if(e.Type!="taxi" || (k!="taxi_606" && k!="taxi_608"))return false;}return !blocked.count(e.FromNode)&&!blocked.count(e.ToNode);} bool AllowsPosition(Player const*,uint32,Position const& p)const{return !(p.x>=forbiddenMin&&p.x<=forbiddenMax);} bool AllowsSegment(Player const*,uint32,Position const& a,Position const& b)const{return std::max(a.x,b.x)forbiddenMax;} } access;auto sAdventureAreaMgr=&access; +namespace AdventureVashjir{bool LocalLinkAllowed(Player const*,uint32,Position const&a,Position const&b){return !vashBoundary || (a.x>=1000)==(b.x>=1000);}} struct VcorePositionPathResult {struct Point{float x,y,z;};enum class Status{Complete,Partial};Status Result=Status::Partial;float FinalDistance=0,PathLength=0,DirectDistance=0;std::vector Points;bool IsComplete()const{return Result==Status::Complete;}}; struct PathGenerator {static inline unsigned probes=0;static inline bool available=false; static inline float maxDistance=10000;static VcorePositionPathResult AnalyzePositions(uint32,uint32,uint32,Position a,Position b,uint32){++probes;float d=dist(a,b);return {available && d<=maxDistance?VcorePositionPathResult::Status::Complete:VcorePositionPathResult::Status::Partial,0,d,d,{{a.x,a.y,a.z},{b.x,b.y,b.z}}};}}; std::string MakeLocalBridgeKey(std::string const&a,std::string const&b){return a+"->"+b;} @@ -294,6 +297,17 @@ flight.rejectBelow=-1e9; std::unordered_set failedOrigin{"flight_origin:flight_departure"}; route.clear();assert(!expanded.PlanAdaptiveRoute(&start,"G",500,200,route,done,endKey,why,nullptr,&failedOrigin)); access.blocked.insert("R");route.clear();assert(!expanded.PlanAdaptiveRoute(&start,"G",500,200,route,done,endKey,why));access.blocked.clear(); +// A cheap estimated local finish must not bypass a required island taxi. +vashBoundary=true;flight.enabled=false;PathGenerator::available=true; +access.insideNodes={"taxi_606","I"}; +ClientlessTravelGraphMgr island;node(island,"A",0);node(island,"near",900);node(island,"taxi_606",1200);node(island,"I",1300); +edge(island,"A","near",7001,1);edge(island,"near","I",7002,1);edge(island,"A","taxi_606",7003,10000); +island._edges["A"].back().Type="taxi"; +Player islandStart;ClientlessTravelLocationGoal islandGoal;islandGoal.MapId=0;islandGoal.X=1300;islandGoal.AnchorRadius=2000; +std::vector islandRoute;bool islandComplete=false;std::string islandReached,islandError; +assert(island.PlanAdaptiveRoute(&islandStart,"I",500,200,islandRoute,islandComplete,islandReached,islandError,nullptr,nullptr,&islandGoal)); +assert(islandComplete);assert(std::any_of(islandRoute.begin(),islandRoute.end(),[](auto const&s){return s.NodeKey=="taxi_606" && s.EdgeType=="taxi";})); +vashBoundary=false;access.insideNodes.clear(); std::cout<<"ground planner regressions and dynamic flight/node/location/virtual-exit integration passed\n"; } ''' diff --git a/tests/clientless/test_group_flight_mount.py b/tests/clientless/test_group_flight_mount.py index a34a5f7218..b61899e1f7 100644 --- a/tests/clientless/test_group_flight_mount.py +++ b/tests/clientless/test_group_flight_mount.py @@ -50,12 +50,14 @@ struct Lua{Profile*GetAdventureProfile(unsigned){return &profile;}void DismountG struct Travel{unsigned cancels=0;void CancelTravel(unsigned){++cancels;}}travel;auto sClientlessTravelMgr=&travel; struct SpellMgr{void*GetSpellInfo(unsigned){return nullptr;}}spells;auto sSpellMgr=&spells; unsigned FlightType(void*){return 1;}unsigned urand(unsigned low,unsigned){return low;} +namespace AdventureVashjir{bool inside=false;bool Contains(Player*){return inside;}} struct ClientlessFlightMgr{struct Record{bool Moving=false;unsigned Elapsed=0,HoldSyncAt=0;};bool enabled=true; bool Enabled(Player*){return enabled;}bool PrepareFollowingMount(Player*);bool SetAirbornePresentation(Player*,bool=false);void PublishMovement(Player*);void HoldFollowing(Player*,Record&); }; '''+'\n'.join(v for v in (root/'src/server/game/World/ClientlessMountPreparation.h').read_text().splitlines() if not v.startswith('#'))+method('bool ClientlessFlightMgr::PrepareFollowingMount(')+method('void ClientlessFlightMgr::PublishMovement(')+method('bool ClientlessFlightMgr::SetAirbornePresentation(')+method('void ClientlessFlightMgr::HoldFollowing(')+r''' int main(){ ClientlessFlightMgr m;Player p; + AdventureVashjir::inside=true;assert(!m.PrepareFollowingMount(&p)&&p.casts==0);AdventureVashjir::inside=false; assert(m.PrepareFollowingMount(&p)&&p.casts==1&&p.removals==1&&travel.cancels==1); p.mounted=p.fly=true;assert(!m.PrepareFollowingMount(&p)&&p.casts==1); // retain native flight mount p.fly=false;p.casting=true;assert(m.PrepareFollowingMount(&p)&&p.casts==1);p.casting=false; diff --git a/tests/clientless/test_outing_history.py b/tests/clientless/test_outing_history.py new file mode 100644 index 0000000000..ca29045ebb --- /dev/null +++ b/tests/clientless/test_outing_history.py @@ -0,0 +1,36 @@ +"""Execute production micro-action bookkeeping before/after outing admission.""" +from pathlib import Path +import subprocess,tempfile +root=Path(__file__).resolve().parents[2] +s=(root/'src/server/game/World/AdventureBehaviorMgr.cpp').read_text() +a=s.index(' auto const a = ResolvedAction(*choices[n]);');b=s.index(' else if (a.Kind=="recovery")',a) +code=r''' +#include +#include +#include +#include +#include +using uint32=uint32_t; +struct Action{std::string Kind,Requirement,Key;unsigned MinSeconds=150,MaxSeconds=240;}; +struct Record{std::string Intent="adventure",Micro;unsigned MicroTimer=0;std::mt19937 Random{26};std::vector ActionHistory,VariantHistory;int Social=0;}; +Action ResolvedAction(Action const&a){return a;} +void Remember(std::vector& h,std::string const& x){h.push_back(x);} +struct Player{}; +struct AdventureSocialActions{static bool Available(Player*,Action const&,int){return false;}static bool Start(Player*,int,Action const&,unsigned,int){return false;}}; +bool accepted=false;bool StartLeisure(Player*,Record&,Action const&){return accepted;} +void choose(Record&r,Action const& action){std::vector choices{&action};unsigned n=0;Player*player=nullptr;int social=0; +'''+s[a:b]+r''' +} +int main(){Record r;r.ActionHistory={"social:scout"};Action explore{"outing","explore","adventure_explore"}; + choose(r,explore);assert(r.MicroTimer==3000 && r.ActionHistory==std::vector{"social:scout"}); + assert(r.VariantHistory.back()=="action:adventure_explore"); // failed choice still loses novelty + accepted=true;choose(r,explore);assert(r.ActionHistory.back()=="outing:explore" && r.MicroTimer>=150000); + auto count=r.ActionHistory.size();accepted=false;choose(r,explore);assert(r.ActionHistory.size()==count); + choose(r,{"eat","","eat"});assert(r.ActionHistory.back()=="eat:"); +} +''' +with tempfile.TemporaryDirectory()as d: + p=Path(d);(p/'test.cpp').write_text(code) + subprocess.run(['g++','-std=c++17','-fsanitize=address,undefined',str(p/'test.cpp'),'-o',str(p/'test')],check=True) + subprocess.run([str(p/'test')],check=True) +print('Outing history: failures retain novelty tracking without a false successful-outing rest bonus.') diff --git a/tests/clientless/test_swimming.py b/tests/clientless/test_swimming.py index 6a673a3629..4843b4d217 100644 --- a/tests/clientless/test_swimming.py +++ b/tests/clientless/test_swimming.py @@ -19,6 +19,9 @@ using uint32=unsigned; constexpr uint32 PATHFIND_NORMAL=1,PATHFIND_INCOMPLETE=4,PATHFIND_NOPATH=8,PATHFIND_NOT_USING_PATH=16; constexpr unsigned MOVEMENTFLAG_WATERWALKING=1,MOVEMENTFLAG_SWIMMING=2,FALLING=4; constexpr int SMSG_MOVE_UPDATE=1,SPELL_AURA_MOUNTED=1; +constexpr unsigned MOUNT_CAPABILITY_FLAG_FLOAT=4,MOUNT_CAPABILITY_FLAG_UNDERWATER=8; +struct MountCapabilityEntry{unsigned Flags=0;}; +struct MountAura{int GetMiscValueB()const{return 232;}}; #define TC_LOG_INFO(...) ((void)0) #define TC_LOG_WARN(...) ((void)0) constexpr float INVALID_HEIGHT=-100000;constexpr int LINEOFSIGHT_ALL_CHECKS=0;namespace VMAP{using ModelIgnoreFlags=int;} @@ -38,7 +41,10 @@ struct Map{bool clear=true;unsigned type=1;float floor=0;unsigned queries=0; struct Guid{unsigned GetCounter()const{return 149;}}; struct WorldPacket{explicit WorldPacket(int){}}; namespace GameTime{unsigned GetGameTimeMS(){return 20;}} -struct Player:Position{bool mounted=false;bool IsMounted()const{return mounted;}void RemoveAurasByType(int){mounted=false;} +struct Player:Position{ + MountCapabilityEntry capability;MountAura mountAura;std::vector GetAuraEffectsByType(int){return mounted?std::vector{&mountAura}:std::vector{};} + MountCapabilityEntry const* GetMountCapability(unsigned){return &capability;} + bool mounted=false;bool IsMounted()const{return mounted;}void RemoveAurasByType(int){mounted=false;} bool alive=true,world=true,can=true,water=true,flying=false,taxi=false,transport=false,vehicle=false,teleport=false;unsigned flags=FALLING,updates=0; Map*GetMap()const{return ↦}int GetPhaseShift()const{return 0;}float GetCollisionHeight()const{return mounted?4:2;} bool CanSwim()const{return can;}bool IsInWater()const{return water;}bool HasUnitMovementFlag(unsigned f)const{return flags&f;} @@ -61,6 +67,8 @@ struct ClientlessPathDiagnostics{bool HasWater=true,Calculated=true,Complete=fal namespace ClientlessSwimming{ ''' + contact + '\n}\n' + s[a:b] + '\nstruct AdventureGroupTravelMgr{bool ValidateGroundPath(Player*,std::vector const&,bool)const;};\n' + group + r''' int main(){Player p;p.m_positionX=1;p.m_positionZ=9; + p.mounted=true;p.capability.Flags=MOUNT_CAPABILITY_FLAG_UNDERWATER;ClientlessSwimming::DismountForWater(&p,p);assert(p.mounted); + p.capability.Flags=0;ClientlessSwimming::DismountForWater(&p,p);assert(!p.mounted); AdventureGroupTravelMgr gm;std::vector wet{{1,0,9},{20,0,9}}; assert(gm.ValidateGroundPath(&p,wet,true));map.clear=false;assert(!gm.ValidateGroundPath(&p,wet,true));map.clear=true; map.type=4;assert(!gm.ValidateGroundPath(&p,wet,true));map.type=1; diff --git a/tests/clientless/test_vashjir.py b/tests/clientless/test_vashjir.py new file mode 100644 index 0000000000..f9c28c65eb --- /dev/null +++ b/tests/clientless/test_vashjir.py @@ -0,0 +1,67 @@ +"""Compile real Vashjir boundary policy and aquatic boarding implementation.""" +from pathlib import Path +import subprocess,tempfile +root=Path(__file__).resolve().parents[2] +def function(path,signature): + s=(root/path).read_text();a=s.index(signature);b=s.index('{',a);e=b+1;n=1 + while n:n+=(s[e]=='{')-(s[e]=='}');e+=1 + return s[a:e] +edge=function('src/server/game/World/AdventureAreaMgr.cpp',' bool EdgeAllowed(') +mount=function('src/server/game/World/ClientlessLuaEngine.cpp','bool ClientlessLuaEngine::PrepareAquaticMount(') +prep='\n'.join(x for x in (root/'src/server/game/World/ClientlessMountPreparation.h').read_text().splitlines() if not x.startswith('#')) +code=r''' +#include +#include +using uint32=unsigned; +constexpr unsigned CLASS_DRUID=11,SPELL_AURA_MOD_SHAPESHIFT=1,UNIT_STATE_CASTING=2; +struct Guid{unsigned GetCounter(){return 149;}}; +struct Player{ + bool inside=true,profile=true,mounted=false,spell=true,aura=false,water=true,alive=true,combat=false,teleport=false,taxi=false,fly=false,fall=false,transport=false,vehicle=false,casting=false,cap=true; + unsigned level=80,klass=1,form=0,casts=0; + Guid GetGUID(){return {};} + unsigned getClass(){return klass;}bool HasAuraType(unsigned){return form;}void RemoveAurasByType(unsigned){form=0;} + bool IsMounted(){return mounted;}bool HasAura(unsigned){return aura;}unsigned getLevel(){return level;}bool HasSpell(unsigned){return spell;} + bool IsInWater(){return water;}bool IsAlive(){return alive;}bool IsInCombat(){return combat;}bool IsBeingTeleported(){return teleport;} + bool IsInFlight(){return taxi;}bool IsFlying(){return fly;}bool IsFalling(){return fall;}bool GetTransport(){return transport;}bool GetVehicle(){return vehicle;} + bool HasUnitState(unsigned){return casting;}bool GetMountCapability(unsigned){return cap;} + void CastSpell(Player*,unsigned spell,bool){assert(spell==75207);++casts;mounted=aura=true;} +}; +namespace AdventureVashjir{constexpr unsigned Seahorse=75207;bool Contains(Player*p){return p->inside;} +'''+edge+r''' +} +struct ClientlessLuaEngine{bool profile=true;bool GetAdventureProfile(unsigned){return profile;}bool PrepareAquaticMount(Player*);}; +'''+prep+mount+r''' +int main(){using AdventureVashjir::EdgeAllowed; + assert(EdgeAllowed(false,false,"ground","A","B"));assert(EdgeAllowed(true,true,"ground","A","B")); + for(auto node:{"taxi_606","taxi_608"}){ + assert(EdgeAllowed(false,true,"taxi","taxi_6",node)); + assert(EdgeAllowed(true,false,"taxi",node,"taxi_6")); + assert(!EdgeAllowed(false,true,"ground","A",node)); + assert(!EdgeAllowed(true,false,"portal_use",node,"B")); + } + for(auto node:{"taxi_607","taxi_609","taxi_521","ordinary"}){ + assert(!EdgeAllowed(false,true,"taxi","A",node));assert(!EdgeAllowed(true,false,"taxi",node,"B")); + } + ClientlessLuaEngine mgr;Player p; + assert(mgr.PrepareAquaticMount(&p)&&p.casts==1&&p.mounted); + assert(mgr.PrepareAquaticMount(&p)&&p.casts==1); // retain seahorse + p.aura=false;p.fly=true;assert(!mgr.PrepareAquaticMount(&p)&&p.mounted&&p.casts==1); // no forced dismount + p=Player{};p.level=79;assert(!mgr.PrepareAquaticMount(&p));p.level=80; + p.inside=false;assert(!mgr.PrepareAquaticMount(&p));p.inside=true; + mgr.profile=false;assert(!mgr.PrepareAquaticMount(&p));mgr.profile=true; + for(bool* flag:{&p.combat,&p.teleport,&p.taxi,&p.fly,&p.fall,&p.transport,&p.vehicle,&p.casting}){ + *flag=true;assert(!mgr.PrepareAquaticMount(&p));*flag=false; + } + p.water=false;assert(!mgr.PrepareAquaticMount(&p));p.water=true; + p.cap=false;assert(!mgr.PrepareAquaticMount(&p));p.cap=true; + p.spell=false;assert(!mgr.PrepareAquaticMount(&p));p.spell=true; + p.klass=CLASS_DRUID;p.form=1066; + assert(!ClientlessMountPreparation::LeaveDruidForm(&p)); + assert(mgr.PrepareAquaticMount(&p)&&p.form==0&&p.aura); // safe underwater form transition +} +''' +with tempfile.TemporaryDirectory() as d: + p=Path(d);(p/'test.cpp').write_text(code) + subprocess.run(['g++','-std=c++17','-fsanitize=address,undefined',str(p/'test.cpp'),'-o',str(p/'test')],check=True) + subprocess.run([str(p/'test')],check=True) +print('Native Vashjir boundary and aquatic boarding policy: PASS')