6a3804addc
## Summary Replaces `FastAStarAlgorithm` with `BitmapAStarAlgorithm`: one cache lookup per cell expansion (8-direction mask + per-direction destination Z) instead of 8 separate `MovementImpl.CheckMovement` calls. Adds the supporting cache infrastructure to back it. Public API unchanged — `MovementPath` / `Mobile.Move` / `CalcMoves.Find` return the same shapes; the algorithm swap is internal. ## What's in this PR - **`BitmapAStarAlgorithm`** — A* that issues one `StepCache.TryGetMask` call per cell expansion. Inline fallthrough to the per-cell slow path for multi-Z, off-map, source-Z mismatch, and non-default walkers. - **`StepCache`** — singleton chunk store keyed by `(mapId, chunkX, chunkY)`. Lazily built on first query, invalidated by `Sector.MultisVersion` mismatch, memory-bounded by sampled probabilistic LRU. - **`StepProbe`** — computes static-only walkability for a single cell, mirroring `MovementImpl.Check` minus the item / mobile collision phases. - **`StepMask` / `StepChunk`** — value / storage types for the per-cell results. - **`CacheEvictionTimer`** — periodic cap backstop (60s interval; early-returns when not over cap). - **`Map.Sector.MultisVersion`** promoted to `public` so the cache can detect dynamic-static invalidations cheaply. ## Eviction strategy Sampled probabilistic LRU (Redis-style). Per eviction, sample 5 random keys from a parallel `List<long>` kept in lockstep with the chunk dictionary; evict the oldest of the sample via swap-and-pop. O(1) per eviction regardless of resident count, so sustained cap pressure has no perpetual perf hit. ## Capability handling (interim) Non-default walkers (non-GM players, creatures with `CanSwim` / `CanFly` / `CanOpenDoors` / `CanMoveOverObstacles`) route entirely through the per-cell slow path via `BitmapAStarAlgorithm.GetSuccessorsSlowPath`. The 2-pass design (cache + capability overlay + dynamic-obstacle pass) lands in the follow-up PR.
50 lines
2.2 KiB
C#
50 lines
2.2 KiB
C#
namespace Server.Engines.Pathing.Cache;
|
|
|
|
/// <summary>
|
|
/// Per-chunk storage backing StepCache. Holds raw walkability 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 Mask[c] = "can step from cell c to neighbor (Direction)i". Raw — no diagonal corner-cut applied here.</summary>
|
|
public readonly byte[] Mask = new byte[CellsPerChunk];
|
|
|
|
public readonly sbyte[] SourceZ = new sbyte[CellsPerChunk];
|
|
|
|
public readonly sbyte[] DestZN = new sbyte[CellsPerChunk];
|
|
public readonly sbyte[] DestZNE = new sbyte[CellsPerChunk];
|
|
public readonly sbyte[] DestZE = new sbyte[CellsPerChunk];
|
|
public readonly sbyte[] DestZSE = new sbyte[CellsPerChunk];
|
|
public readonly sbyte[] DestZS = new sbyte[CellsPerChunk];
|
|
public readonly sbyte[] DestZSW = new sbyte[CellsPerChunk];
|
|
public readonly sbyte[] DestZW = new sbyte[CellsPerChunk];
|
|
public readonly sbyte[] DestZNW = new sbyte[CellsPerChunk];
|
|
|
|
/// <summary>
|
|
/// 32 bytes = 256 bits. Bit set = cell has >1 walkable surface; route to slow path.
|
|
/// TODO(PR2): lazy-init this. The vast majority of chunks are entirely single-Z, so
|
|
/// allocating 32 bytes per chunk wastes ~256KB at full cap. Make nullable; allocate
|
|
/// on first MarkCellMultiZ; IsCellMultiZ short-circuits to false when null.
|
|
/// </summary>
|
|
public readonly byte[] MultiZCells = new byte[32];
|
|
|
|
/// <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;
|
|
|
|
/// <summary>True if any cell in this chunk has more than one walkable surface (set during build).</summary>
|
|
public bool HasAnyMultiZ;
|
|
|
|
public bool IsCellMultiZ(int cellIndex) => (MultiZCells[cellIndex >> 3] & (1 << (cellIndex & 7))) != 0;
|
|
|
|
public void MarkCellMultiZ(int cellIndex)
|
|
{
|
|
MultiZCells[cellIndex >> 3] |= (byte)(1 << (cellIndex & 7));
|
|
HasAnyMultiZ = true;
|
|
}
|
|
}
|