9066e8fd00
## Summary Builds on PR #2446's cache-direct A*. The previous PR conservatively routed players + creatures with capability flags entirely through the slow path. This PR pushes that line: most mobile classes now use the cache, with the right rule set layered on top per-mobile, and the cache fast-path now does the dynamic items / mobiles check that PR #2446 had silently skipped. ## What changed - **Non-GM players** now use the cache. Diagonal corner-cut applies the strict AND-rule (BOTH cardinal partners walkable) by reading the same source-cell mask byte the creature OR-rule reads — both rules are evaluable from one byte. - **Creatures with `CanOpenDoors` / `CanMoveOverObstacles`** now use the cache. Reading `MovementImpl` confirmed those flags only affect dynamic items, never static tiles, so they were over-conservatively excluded before. - **Swim creatures** now use the cache via a capability overlay. `StepProbe` bakes a second rule set (`canSwim=true, cantWalk=true`) producing `WetMask` + `SwimZ_*`. The algorithm composes `effectiveMask = (walkMask & !cantWalk) | (wetMask & canSwim)` per direction; walk Z preferred when both apply. - **Dynamic-obstacle pass.** Cache fast-path now mirrors `MovementImpl`'s per-cell items + mobiles collision check (`GetItemsAt` / `GetMobilesAt` at the target cell, with `CanOpenDoors` / `CanMoveOverObstacles` / spell-field overrides). This closes a correctness gap from PR #2446 — the cache fast-path was silently skipping dynamic obstacles entirely. - **`StepCache.TryGetMask` returns `StepMask` struct** instead of 11 out parameters. `HitKind` rolls into the struct with an `IsHit` accessor. Sets up wet/swim without ballooning the call site. - **`StepChunk.MultiZCells` is lazy-init.** Most chunks are entirely single-Z; allocating the 32-byte bitmap up-front wasted ~256KB at full cap. - **Admin commands.** `[PathCacheStats` (resident chunks + hit/miss/eviction counters) and `[PathCacheClear` (drop everything, zero counters). - **Feature flag.** `bitmap_pathfinding_cache` (default true) gates the cache fast-path. Flipped off, every cell expansion routes to `MovementImpl` — equivalent to PR #2446's slow-path-only behavior. Safety net for shipping the new behavior. `RequiresSlowPath` shrinks to just `CanFly` — flying creatures Z-jump arbitrarily, which the cache's static-Z model can't accommodate.
58 lines
2.7 KiB
C#
58 lines
2.7 KiB
C#
namespace Server.Engines.Pathing.Cache;
|
|
|
|
/// <summary>
|
|
/// Per-chunk storage backing StepCache. Holds raw walk + swim masks and destination Z
|
|
/// values for each of 256 cells in a 16x16 chunk, plus build-time metadata (multis
|
|
/// version, multi-Z bitmap) and LRU bookkeeping.
|
|
/// </summary>
|
|
internal sealed class StepChunk
|
|
{
|
|
public const int CellsPerChunk = 256; // 16 x 16
|
|
|
|
/// <summary>Bit i of WalkMask[c] = "default walker can step from cell c to neighbor (Direction)i". Raw — no diagonal corner-cut applied here.</summary>
|
|
public readonly byte[] WalkMask = new byte[CellsPerChunk];
|
|
|
|
/// <summary>Bit i of WetMask[c] = "swim-only mob can step from cell c to neighbor (Direction)i". Layered with WalkMask via canSwim/cantWalk capability flags.</summary>
|
|
public readonly byte[] WetMask = new byte[CellsPerChunk];
|
|
|
|
public readonly sbyte[] SourceZ = new sbyte[CellsPerChunk];
|
|
|
|
public readonly sbyte[] WalkZN = new sbyte[CellsPerChunk];
|
|
public readonly sbyte[] WalkZNE = new sbyte[CellsPerChunk];
|
|
public readonly sbyte[] WalkZE = new sbyte[CellsPerChunk];
|
|
public readonly sbyte[] WalkZSE = new sbyte[CellsPerChunk];
|
|
public readonly sbyte[] WalkZS = new sbyte[CellsPerChunk];
|
|
public readonly sbyte[] WalkZSW = new sbyte[CellsPerChunk];
|
|
public readonly sbyte[] WalkZW = new sbyte[CellsPerChunk];
|
|
public readonly sbyte[] WalkZNW = new sbyte[CellsPerChunk];
|
|
|
|
public readonly sbyte[] SwimZN = new sbyte[CellsPerChunk];
|
|
public readonly sbyte[] SwimZNE = new sbyte[CellsPerChunk];
|
|
public readonly sbyte[] SwimZE = new sbyte[CellsPerChunk];
|
|
public readonly sbyte[] SwimZSE = new sbyte[CellsPerChunk];
|
|
public readonly sbyte[] SwimZS = new sbyte[CellsPerChunk];
|
|
public readonly sbyte[] SwimZSW = new sbyte[CellsPerChunk];
|
|
public readonly sbyte[] SwimZW = new sbyte[CellsPerChunk];
|
|
public readonly sbyte[] SwimZNW = new sbyte[CellsPerChunk];
|
|
|
|
/// <summary>
|
|
/// 32 bytes = 256 bits when allocated. Lazy: most chunks are entirely single-Z,
|
|
/// so we only pay the 32 bytes on chunks that actually need it.
|
|
/// </summary>
|
|
private byte[] _multiZCells;
|
|
|
|
/// <summary>Snapshot of Sector.MultisVersion at the time this chunk was built.</summary>
|
|
public int BuiltMultisVersion;
|
|
|
|
/// <summary>Updated on every cache hit/miss. Used by LRU fallback eviction.</summary>
|
|
public long LastTouchedTicks;
|
|
|
|
public bool IsCellMultiZ(int cellIndex) =>
|
|
_multiZCells != null && (_multiZCells[cellIndex >> 3] & (1 << (cellIndex & 7))) != 0;
|
|
|
|
public void MarkCellMultiZ(int cellIndex)
|
|
{
|
|
_multiZCells ??= new byte[32];
|
|
_multiZCells[cellIndex >> 3] |= (byte)(1 << (cellIndex & 7));
|
|
}
|
|
}
|