erik/acdream
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions 1

chore: strip world-load deep-dive diagnostic probes

Browse source 
Removes the scenery-frame, building-reach, and stream-resid probes added during the
world-load/FPS deep-dive (all root-caused + fixed). Gated-off diagnostics only; no
behavior change. The fixes they found remain.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
This commit is contained in:
Erik 2026-06-23 00:23:15 +02:00
parent 9945d46280
commit 92e95bea53
4 changed files with 0 additions and 242 deletions
Download patch file Download diff file Expand all files Collapse all files

21
src/AcDream.Core/Physics/CellTransit.cs
View file

@ -859,27 +859,6 @@ public static class CellTransit
if (PhysicsDiagnostics.ProbeCellSetEnabled)
PhysicsDiagnostics.LogCellSetBuild(currentCellId, worldSphereCenter, candidates);
// Lost-collision probe (REMOVABLE): in a landblock that HAS cached buildings,
// report which of them are reachable from the player's swept candidate set.
// reachable=NO while standing at a wall ⇒ the building IS cached but the
// post-teleport cell resolution excludes its landcell (#145); empty cachedInLb
// ⇒ the landblock's CacheBuilding never ran. One line per walk, near buildings.
if (PhysicsDiagnostics.ProbeBuildingReachEnabled)
{
uint prefix = currentCellId & 0xFFFF0000u;
var cachedInLb = new List<uint>();
foreach (var bid in cache.BuildingIds)
if ((bid & 0xFFFF0000u) == prefix) cachedInLb.Add(bid);
var inSet = new List<uint>();
for (int ci = 0; ci < candidates.Count; ci++)
{
uint cid = candidates.OrderedIds[ci];
if ((cid & 0xFFFFu) < 0x0100u && cache.GetBuilding(cid) is not null)
inSet.Add(cid);
}
PhysicsDiagnostics.LogBuildingReach(currentCellId, candidates.Count, cachedInLb, inSet);
}
// THE PICK — verbatim CObjCell::find_cell_list containing-cell pick
// (pseudo_c:308788-308825): iterate the array IN ORDER from index 0; for each
// cell, point_in_cell; set the running result on ANY containing cell;

6
src/AcDream.Core/Physics/PhysicsDataCache.cs
View file

@ -441,12 +441,6 @@ public sealed class PhysicsDataCache
public void CacheBuilding(uint landcellId, IReadOnlyList<BldPortalInfo> portals, Matrix4x4 worldTransform,
uint modelId = 0u)
{
// Lost-collision probe (REMOVABLE): record every cache attempt + whether it
// actually took (first-wins) so we can see if/when a landblock's buildings
// get cached after a teleport.
AcDream.Core.Physics.PhysicsDiagnostics.LogBuildingCache(
landcellId, cached: !_buildings.ContainsKey(landcellId));
if (_buildings.ContainsKey(landcellId)) return;
Matrix4x4.Invert(worldTransform, out var inverse);
_buildings[landcellId] = new BuildingPhysics

135
src/AcDream.Core/Physics/PhysicsDiagnostics.cs
View file

@ -448,138 +448,6 @@ public static class PhysicsDiagnostics
$"[tp-probe] {point,-6} id=0x{id:X8} t={Environment.TickCount64} {extra}"));
}
/// <summary>
/// Trees-in-sky frame-split probe (2026-06-22 — REMOVABLE apparatus). The
/// streaming worker bakes each landblock's SCENERY world position against the
/// <c>_liveCenter</c> that is current when it BUILDS the landblock, while the
/// render thread positions that landblock's TERRAIN against the
/// <c>_liveCenter</c> that is current when it APPLIES it. A teleport recenters
/// <c>_liveCenter</c> between those two moments, so a landblock built before the
/// recenter and applied after it has its scenery offset from its terrain by
/// <c>deltaLB × 192m</c> in XY — the "arc of trees floating in the sky" after a
/// teleport. When enabled, <c>BuildSceneryEntitiesForStreaming</c> records the
/// build-time center and <c>ApplyLoadedTerrainLocked</c> emits one
/// <c>[scenery-frame]</c> line per landblock comparing build vs apply center; a
/// non-zero <c>deltaLB</c> on a misplaced landblock confirms the mechanism.
/// Initial state from <c>ACDREAM_PROBE_SCENERY_FRAME=1</c>. Zero cost when off.
/// </summary>
public static bool ProbeSceneryFrameEnabled { get; set; } =
Environment.GetEnvironmentVariable("ACDREAM_PROBE_SCENERY_FRAME") == "1";
/// <summary>
/// One <c>[scenery-frame]</c> line. Self-guards on
/// <see cref="ProbeSceneryFrameEnabled"/>. A non-zero <c>deltaLB</c> means this
/// landblock's scenery was baked against a different streaming center than its
/// terrain was applied against — the trees-in-sky frame split.
/// </summary>
public static void LogSceneryFrame(
uint landblockId, int buildCx, int buildCy, int applyCx, int applyCy)
{
if (!ProbeSceneryFrameEnabled) return;
int dx = buildCx - applyCx, dy = buildCy - applyCy;
Console.WriteLine(System.FormattableString.Invariant(
$"[scenery-frame] lb=0x{landblockId:X8} build=({buildCx},{buildCy}) apply=({applyCx},{applyCy}) deltaLB=({dx},{dy}) offsetM=({dx * 192f:F1},{dy * 192f:F1})"));
}
/// <summary>
/// One <c>[scenery-z-stale]</c> line (self-guards on
/// <see cref="ProbeSceneryFrameEnabled"/>). Emitted when, at scenery build, the
/// physics-engine terrain sample (<c>SampleTerrainZ</c>, which searches ALL
/// registered landblocks) disagrees materially with the landblock's OWN
/// heightmap. That divergence means the physics query resolved the world point
/// into a STALE neighbor landblock — the previous location's terrain, still
/// registered after a teleport recenter (which removes only the single stale
/// center landblock) until streaming unloads it — and returned ITS height. The
/// scenery is then planted at the old location's altitude: trees-in-sky. The
/// own-heightmap value (<paramref name="ownZ"/>) is the correct Z.
/// </summary>
public static void LogSceneryZStale(
uint landblockId, float worldX, float worldY, float physicsZ, float ownZ)
{
if (!ProbeSceneryFrameEnabled) return;
Console.WriteLine(System.FormattableString.Invariant(
$"[scenery-z-stale] lb=0x{landblockId:X8} world=({worldX:F1},{worldY:F1}) physicsZ={physicsZ:F2} ownZ={ownZ:F2} deltaZ={physicsZ - ownZ:F2}"));
}
/// <summary>
/// Lost-building-collision probe (2026-06-22 — REMOVABLE apparatus). Building
/// WALL collision is the dat-baked <c>PhysicsDataCache.CacheBuilding</c> channel
/// (first-wins, never removed), reached at resolve time only when a candidate
/// landcell in the player's swept cell-walk hits <c>GetBuilding(cellId)</c>. When
/// enabled: <c>[bldg-cache]</c> logs each CacheBuilding (CACHED vs first-wins
/// skip) so we can see whether/when a landblock's buildings cache; and
/// <c>[bldg-reach]</c> logs, per cell-walk in a landblock that HAS cached
/// buildings, which of them landed in the player's candidate set
/// (<c>reachable=YES/NO</c>). NO while standing at a wall ⇒ the building is cached
/// but the player's post-teleport cell resolution excludes it (#145 family);
/// empty <c>cachedInLb</c> ⇒ the landblock's CacheBuilding never ran (apply
/// backlog). Initial state from <c>ACDREAM_PROBE_BLDG_REACH=1</c>.
/// </summary>
public static bool ProbeBuildingReachEnabled { get; set; } =
Environment.GetEnvironmentVariable("ACDREAM_PROBE_BLDG_REACH") == "1";
public static void LogBuildingCache(uint landcellId, bool cached)
{
if (!ProbeBuildingReachEnabled) return;
Console.WriteLine(System.FormattableString.Invariant(
$"[bldg-cache] landcell=0x{landcellId:X8} {(cached ? "CACHED" : "skip(first-wins)")}"));
}
public static void LogBuildingReach(
uint seedCell, int candidateCount,
IReadOnlyCollection<uint> cachedInLb, IReadOnlyCollection<uint> inCandidateSet)
{
if (!ProbeBuildingReachEnabled) return;
if (cachedInLb.Count == 0) return; // only interesting in a landblock with buildings
Console.WriteLine(System.FormattableString.Invariant(
$"[bldg-reach] seed=0x{seedCell:X8} cands={candidateCount} cachedInLb=[{HexList(cachedInLb)}] inSet=[{HexList(inCandidateSet)}] reachable={(inCandidateSet.Count > 0 ? "YES" : "NO")}"));
}
private static string HexList(IReadOnlyCollection<uint> ids)
{
var sb = new System.Text.StringBuilder();
bool first = true;
foreach (var id in ids)
{
if (!first) sb.Append(',');
sb.Append(System.FormattableString.Invariant($"0x{id:X8}"));
first = false;
}
return sb.ToString();
}
/// <summary>
/// Floating-terrain probe (2026-06-22 — REMOVABLE apparatus). The thin terrain
/// "traces" at the horizon after rapid multi-hop teleporting are landblocks rendering
/// at a STALE world position — their Chebyshev distance from the current streaming
/// center exceeds the window (FarRadius), so their world origin is off by the teleport
/// distance. When enabled: <c>[apply-oob]</c> fires when a landblock is APPLIED while
/// out-of-window (an in-flight load from a PREVIOUS center, applied against the new one);
/// <c>[resid-audit]</c> (throttled) lists every RESIDENT landblock sitting out-of-window
/// (un-cleared old-location terrain that never unloaded). A persistent non-zero
/// <c>outOfWindow</c> count is the floating terrain; whether it arrives via apply-oob or
/// lingers as residents tells us which mechanism. Initial state from
/// <c>ACDREAM_PROBE_STREAM_RESID=1</c>.
/// </summary>
public static bool ProbeStreamResidEnabled { get; set; } =
Environment.GetEnvironmentVariable("ACDREAM_PROBE_STREAM_RESID") == "1";
public static void LogApplyOob(uint landblockId, int cheby, int farRadius, float ox, float oy)
{
if (!ProbeStreamResidEnabled) return;
Console.WriteLine(System.FormattableString.Invariant(
$"[apply-oob] lb=0x{landblockId:X8} cheby={cheby} (>{farRadius}) origin=({ox:F0},{oy:F0}) — applied OUTSIDE the streaming window (in-flight stale-location apply)"));
}
public static void LogResidentAudit(
int centerX, int centerY, int residentTotal, IReadOnlyCollection<uint> outOfWindow)
{
if (!ProbeStreamResidEnabled) return;
if (outOfWindow.Count == 0) return; // only interesting when stale terrain is resident
Console.WriteLine(System.FormattableString.Invariant(
$"[resid-audit] center=({centerX},{centerY}) resident={residentTotal} outOfWindow={outOfWindow.Count} oob=[{HexList(outOfWindow)}]"));
}
/// <summary>
/// A6.P3 issue #98 step-walk investigation (2026-05-23). When true,
/// emits one <c>[step-walk]</c> line at selected points in the transition
@ -707,9 +575,6 @@ public static class PhysicsDiagnostics
ProbeSweptEnabled = false;
ProbeStepWalkEnabled = false;
ProbeTeleportEnabled = false;
ProbeSceneryFrameEnabled = false;
ProbeBuildingReachEnabled = false;
ProbeStreamResidEnabled = false;
// Side-channel fields
LastBspHitPoly = null;