ModernUO/Projects/UOContent/Engines/Pathing/Cache/StepProbe.cs

using System;
using CalcMoves = Server.Movement.Movement;

namespace Server.Engines.Pathing.Cache;

/// <summary>
/// Computes static-only walkability for a single cell — the per-cell, per-direction
/// "can step" mask and destination Z, based purely on land + statics.mul tiles (NOT
/// multis). Mirrors <see cref="MovementImpl"/>.Check minus the item and mobile collision
/// phases. Multis (houses, boats) are intentionally excluded: they're dynamic content, so
/// cells they cover route to the live movement path via <see cref="StepCache"/>'s
/// multi-halo fallthrough rather than being baked into the static chunk cache.
/// </summary>
/// <remarks>
/// Bakes two rule sets per cell: walker (canSwim=false, cantWalk=false) and swim-only
/// (canSwim=true, cantWalk=true). Item / mobile collision phases are omitted (they're
/// the dynamic-obstacle pass's job). Diagonal corner-cut is NOT applied here; callers
/// must AND the partner-cell results at query time.
/// </remarks>
public static class StepProbe
{
    private const int PersonHeight = 16;
    private const int StepHeight = 2;

    public readonly struct ComputedStratum(sbyte zCenter, StepMask mask)
    {
        public readonly sbyte ZCenter = zCenter;
        public readonly StepMask Mask = mask;
    }

    /// <summary>
    /// Tier 4 strata builder: enumerates the distinct walkable standing-Zs at (x, y)
    /// — one per land surface plus one per walkable static — and runs
    /// <see cref="ComputeMaskAt"/> at each, producing a per-stratum walkability snapshot.
    /// Returns null when the cell has 0 or 1 strata (single-Z; the caller should use
    /// the chunk's main mask).
    /// </summary>
    public static ComputedStratum[] ComputeStrataAt(Map map, int x, int y)
    {
        if (map == null || map == Map.Internal)
        {
            return null;
        }
        if (x < 0 || y < 0 || x >= map.Width || y >= map.Height)
        {
            return null;
        }

        // Collect candidate Zs. 16 slots is generous — multi-Z cells in practice rarely
        // exceed 3-4 surfaces (bridge over land, paver-over-ground, multi-floor stairs).
        Span<int> zs = stackalloc int[16];
        var count = 0;

        var landTile = map.Tiles.GetLandTile(x, y);
        var landFlags = TileData.LandTable[landTile.ID & TileData.MaxLandValue].Flags;
        if (!landTile.Ignored && (landFlags & TileFlag.Impassable) == 0)
        {
            map.GetAverageZ(x, y, out _, out var landCenter, out _);
            zs[count++] = landCenter;
        }

        foreach (var tile in map.Tiles.GetStaticTiles(x, y))
        {
            if (count >= zs.Length)
            {
                break;
            }
            var data = TileData.ItemTable[tile.ID & TileData.MaxItemValue];
            if (!data.Surface || data.Impassable)
            {
                continue;
            }
            zs[count++] = tile.Z + data.CalcHeight;
        }

        if (count <= 1)
        {
            return null;
        }

        // Sort and merge near-equal Zs. Two Zs separated by less than 2*StepHeight collapse
        // into a single stratum — the slow path's tolerance treats them as the same surface.
        zs[..count].Sort();
        Span<int> distinct = stackalloc int[16];
        var distinctCount = 0;
        for (var i = 0; i < count; i++)
        {
            if (distinctCount == 0 || zs[i] - distinct[distinctCount - 1] > 2 * StepHeight)
            {
                distinct[distinctCount++] = zs[i];
            }
        }

        if (distinctCount <= 1)
        {
            return null;
        }

        var strata = new ComputedStratum[distinctCount];
        for (var i = 0; i < distinctCount; i++)
        {
            var z = (sbyte)Math.Clamp(distinct[i], sbyte.MinValue, sbyte.MaxValue);
            strata[i] = new ComputedStratum(z, ComputeMaskAt(map, x, y, z));
        }
        return strata;
    }

    /// <summary>
    /// Writes the distinct surface Zs at (x, y) that a default walker (PersonHeight envelope)
    /// can actually STAND on — each candidate surface (walkable land center + every walkable
    /// static top) that has PersonHeight of vertical clearance free of impassable statics —
    /// into <paramref name="zs"/>, ascending, and returns the count.
    ///
    /// This is the clearance-aware counterpart to <see cref="ComputeStrataAt"/>'s candidate
    /// gather: it drops surfaces a creature cannot occupy (land under a sewer walkway, ground
    /// under a low bridge), so the result is exactly the set of standing Zs the slow path can
    /// resolve to. Two standable surfaces are inherently &gt;= PersonHeight apart (an upper
    /// surface within PersonHeight of a lower one removes the lower one's clearance), so a
    /// single ascending pass with an exact-duplicate skip is sufficient.
    ///
    /// Used by the baker to capture walkable static-over-land surfaces (sewer/dungeon
    /// walkways, bridges, raised foundations, upper building floors) that the land-anchored
    /// main mask would otherwise miss.
    /// </summary>
    public static int ComputeStandableSurfaceZs(Map map, int x, int y, Span<sbyte> zs)
    {
        if (map == null || map == Map.Internal)
        {
            return 0;
        }
        if (x < 0 || y < 0 || x >= map.Width || y >= map.Height)
        {
            return 0;
        }

        Span<int> cand = stackalloc int[16];
        var count = 0;

        var landTile = map.Tiles.GetLandTile(x, y);
        var landFlags = TileData.LandTable[landTile.ID & TileData.MaxLandValue].Flags;
        if (!landTile.Ignored && (landFlags & TileFlag.Impassable) == 0)
        {
            map.GetAverageZ(x, y, out _, out var landCenter, out _);
            cand[count++] = landCenter;
        }

        foreach (var tile in map.Tiles.GetStaticTiles(x, y))
        {
            if (count >= cand.Length)
            {
                break;
            }
            var data = TileData.ItemTable[tile.ID & TileData.MaxItemValue];
            if (!data.Surface || data.Impassable)
            {
                continue;
            }
            cand[count++] = tile.Z + data.CalcHeight;
        }

        if (count == 0)
        {
            return 0;
        }

        cand[..count].Sort();

        var n = 0;
        for (var i = 0; i < count && n < zs.Length; i++)
        {
            var cz = (sbyte)Math.Clamp(cand[i], sbyte.MinValue + 1, sbyte.MaxValue);
            if (n > 0 && zs[n - 1] == cz)
            {
                continue;
            }
            // Standable iff the creature's PersonHeight body envelope above this surface is
            // free of impassable statics. The surface itself never blocks (its top == cz,
            // which is the envelope floor, not inside it).
            if (StaticsBlockAt(map, x, y, cz, cz + PersonHeight))
            {
                continue;
            }
            zs[n++] = cz;
        }

        return n;
    }

    public static StepMask ComputeMaskAt(Map map, int x, int y, sbyte sourceZ) =>
        ComputeMaskCore(map, x, y, sourceZ, includeMultis: false);

    /// <summary>
    /// Multi-aware counterpart to <see cref="ComputeMaskAt"/>: synthesizes the full 8-direction
    /// walkability mask for a cell covered by (or adjacent to) a multi, folding house/boat component
    /// tiles into the surface/step logic via GetStaticAndMultiTiles. Replaces the slow path's 8x
    /// per-cell CheckMovement for Fallthrough_Multi cells. Item/mobile collision is still handled by
    /// the caller's dynamic-obstacle pass.
    /// </summary>
    public static StepMask ComputeMultiMaskAt(Map map, int x, int y, sbyte sourceZ) =>
        ComputeMaskCore(map, x, y, sourceZ, includeMultis: true);

    /// <summary>
    /// Shared per-cell 8-direction mask builder. With includeMultis=false this reproduces the
    /// static-only bake (land + statics.mul). With includeMultis=true it also folds in multi
    /// (house/boat) component tiles via GetStaticAndMultiTiles — the multi-aware synthesizer used
    /// for Fallthrough_Multi cells. Item/mobile collision phases are still omitted (the dynamic pass
    /// owns them).
    /// </summary>
    private static StepMask ComputeMaskCore(Map map, int x, int y, sbyte sourceZ, bool includeMultis)
    {
        if (map == null || map == Map.Internal)
        {
            return default;
        }

        var srcTiles = includeMultis ? map.Tiles.GetStaticAndMultiTiles(x, y) : map.Tiles.GetStaticTiles(x, y);

        GetStaticStartZ(map, x, y, sourceZ, srcTiles, canSwim: false, cantWalk: false,
            out var walkStartZ, out var walkStartTop, out _);
        GetStaticStartZ(map, x, y, sourceZ, srcTiles, canSwim: true, cantWalk: true,
            out var swimStartZ, out var swimStartTop, out _);

        byte walkMask = 0;
        byte wetMask = 0;
        Span<sbyte> walkZs = stackalloc sbyte[8];
        Span<sbyte> swimZs = stackalloc sbyte[8];
        // stackalloc is NOT zero-initialized — unwritten slots hold whatever was on the
        // stack. Clear before use; the loop only writes slots where the step succeeds.
        walkZs.Clear();
        swimZs.Clear();

        for (var d = 0; d < 8; d++)
        {
            var dx = x;
            var dy = y;
            CalcMoves.Offset((Direction)d, ref dx, ref dy);

            var dTiles = includeMultis ? map.Tiles.GetStaticAndMultiTiles(dx, dy) : map.Tiles.GetStaticTiles(dx, dy);

            if (CheckStaticStep(map, dx, dy, dTiles, walkStartZ, walkStartTop,
                    canSwim: false, cantWalk: false, out var walkZ))
            {
                walkMask |= (byte)(1 << d);
                walkZs[d] = (sbyte)walkZ;
            }

            if (CheckStaticStep(map, dx, dy, dTiles, swimStartZ, swimStartTop,
                    canSwim: true, cantWalk: true, out var swimZ))
            {
                wetMask |= (byte)(1 << d);
                swimZs[d] = (sbyte)swimZ;
            }
        }

        return new StepMask(
            walkMask, wetMask,
            walkZs[0], walkZs[1], walkZs[2], walkZs[3],
            walkZs[4], walkZs[5], walkZs[6], walkZs[7],
            swimZs[0], swimZs[1], swimZs[2], swimZs[3],
            swimZs[4], swimZs[5], swimZs[6], swimZs[7]
        );
    }

    /// <summary>
    /// Returns the slow path's standing-Z for a default walker at (x, y). Mirrors
    /// MovementImpl.Check's surface-selection — paver Z+1 for paver-over-ground,
    /// landCenter for bare land. Used by <see cref="StepCache"/> to bake SourceZ so
    /// A*'s tracked-per-cell Z matches the cache's bake-time assumption.
    /// </summary>
    public static int ComputeStandingZ(Map map, int x, int y, int locZ)
    {
        GetStaticStartZ(map, x, y, locZ, map.Tiles.GetStaticTiles(x, y), canSwim: false, cantWalk: false, out _, out _, out var zCenter);

        return zCenter;
    }

    /// <summary>
    /// Returns the water-surface standing Z at (x, y) — the Z a swim-only mob would stand
    /// at on this cell — or <see cref="int.MinValue"/> if no water surface exists. Used
    /// by <see cref="StepCache"/> to detect shore cells (cells with both walk and swim
    /// surfaces separated by &gt; StepHeight) and bake their swim layer at swim-perspective Z.
    /// </summary>
    public static int ComputeSwimStandingZ(Map map, int x, int y)
    {
        if (map == null || map == Map.Internal || x < 0 || y < 0 || x >= map.Width || y >= map.Height)
        {
            return int.MinValue;
        }

        // Land tile flagged Wet — its center Z is the swim surface.
        var landTile = map.Tiles.GetLandTile(x, y);
        var landFlags = TileData.LandTable[landTile.ID & TileData.MaxLandValue].Flags;
        if (!landTile.Ignored && (landFlags & TileFlag.Wet) != 0)
        {
            map.GetAverageZ(x, y, out _, out var landCenter, out _);
            return landCenter;
        }

        // Otherwise scan statics for a wet surface.
        foreach (var tile in map.Tiles.GetStaticTiles(x, y))
        {
            var data = TileData.ItemTable[tile.ID & TileData.MaxItemValue];
            if (data.Wet)
            {
                return tile.Z + data.CalcHeight;
            }
        }

        return int.MinValue;
    }

    /// <summary>
    /// Mirrors GetStartZ from MovementImpl, parameterized by canSwim / cantWalk.
    /// </summary>
    private static void GetStaticStartZ(
        Map map, int x, int y, int locZ, Map.StaticTileEnumerable tiles,
        bool canSwim, bool cantWalk, out int zLow, out int zTop, out int zCenter
    )
    {
        var landTile = map.Tiles.GetLandTile(x, y);
        var flags = TileData.LandTable[landTile.ID & TileData.MaxLandValue].Flags;
        var impassable = (flags & TileFlag.Impassable) != 0;

        // Mirrors MovementImpl: impassable + swim on water is OK; otherwise block on
        // cantWalk or impassable.
        var landBlocks = (cantWalk || impassable) && !(impassable && canSwim && (flags & TileFlag.Wet) != 0);

        map.GetAverageZ(x, y, out var landZ, out var landCenter, out var landTop);

        var considerLand = !landTile.Ignored;

        zCenter = zLow = zTop = 0;
        var isSet = false;

        if (considerLand && !landBlocks && locZ >= landCenter)
        {
            zLow = landZ;
            zCenter = landCenter;
            zTop = landTop;
            isSet = true;
        }

        foreach (var tile in tiles)
        {
            var id = TileData.ItemTable[tile.ID & TileData.MaxItemValue];
            var calcTop = tile.Z + id.CalcHeight;

            if (isSet && calcTop < zCenter || locZ < calcTop || !id.Surface && !(canSwim && id.Wet))
            {
                continue;
            }

            zLow = tile.Z;
            zCenter = calcTop;

            var top = tile.Z + id.Height;

            if (!isSet || top > zTop)
            {
                zTop = top;
            }

            isSet = true;
        }

        if (!isSet)
        {
            zLow = zTop = locZ;
        }
        else if (locZ > zTop)
        {
            zTop = locZ;
        }
    }

    /// <summary>
    /// Mirrors MovementImpl.Check for static tiles only, parameterized by canSwim / cantWalk.
    /// Items and mobile collision phases are omitted.
    /// </summary>
    private static bool CheckStaticStep(
        Map map, int x, int y, Map.StaticTileEnumerable tiles, int startZ, int startTop,
        bool canSwim, bool cantWalk, out int newZ
    )
    {
        newZ = 0;

        if (x < 0 || y < 0 || x >= map.Width || y >= map.Height)
        {
            return false;
        }

        var landTile = map.Tiles.GetLandTile(x, y);
        var flags = TileData.LandTable[landTile.ID & TileData.MaxLandValue].Flags;
        var impassable = (flags & TileFlag.Impassable) != 0;

        var landBlocks = (cantWalk || impassable) && !(impassable && canSwim && (flags & TileFlag.Wet) != 0);

        var considerLand = !landTile.Ignored;

        map.GetAverageZ(x, y, out var landZ, out var landCenter, out _);

        var moveIsOk = false;

        var stepTop = startTop + StepHeight;
        var checkTop = startZ + PersonHeight;

        int testTop;

        foreach (var tile in tiles)
        {
            var itemData = TileData.ItemTable[tile.ID & TileData.MaxItemValue];
            var notWater = !itemData.Wet;

            // Mirrors MovementImpl: skip if not a passable surface AND not swimmable water,
            // OR if the mobile can't walk and this isn't water.
            if ((!itemData.Surface || itemData.Impassable) && (!canSwim || notWater)
                || cantWalk && notWater)
            {
                continue;
            }

            var itemZ = tile.Z;
            var itemTop = itemZ;
            var ourZ = itemZ + itemData.CalcHeight;
            testTop = checkTop;

            if (moveIsOk)
            {
                var cmp = Math.Abs(ourZ - startZ) - Math.Abs(newZ - startZ);

                if (cmp > 0 || cmp == 0 && ourZ > newZ)
                {
                    continue;
                }
            }

            if (ourZ + PersonHeight > testTop)
            {
                testTop = ourZ + PersonHeight;
            }

            if (!itemData.Bridge)
            {
                itemTop += itemData.Height;
            }

            if (stepTop < itemTop)
            {
                continue;
            }

            var landCheck = itemZ + Math.Min(itemData.Height, StepHeight);

            if (considerLand && landCheck < landCenter && landCenter > ourZ && testTop > landZ)
            {
                continue;
            }

            if (StaticsBlockAt(map, x, y, ourZ, testTop))
            {
                continue;
            }

            newZ = ourZ;
            moveIsOk = true;
        }

        if (!considerLand || landBlocks || stepTop < landZ)
        {
            return moveIsOk;
        }

        testTop = checkTop;

        if (landCenter + PersonHeight > testTop)
        {
            testTop = landCenter + PersonHeight;
        }

        var shouldCheck = true;

        if (moveIsOk)
        {
            var cmp = Math.Abs(landCenter - startZ) - Math.Abs(newZ - startZ);

            if (cmp > 0 || cmp == 0 && landCenter > newZ)
            {
                shouldCheck = false;
            }
        }

        if (shouldCheck && !StaticsBlockAt(map, x, y, landCenter, testTop))
        {
            newZ = landCenter;
            moveIsOk = true;
        }

        return moveIsOk;
    }

    /// <summary>
    /// Mirrors the static-tile portion of IsOk: returns true if any static tile at (x,y)
    /// has ImpassableSurface and overlaps the vertical range (ourZ, testTop).
    /// </summary>
    private static bool StaticsBlockAt(Map map, int x, int y, int ourZ, int testTop)
    {
        foreach (var check in map.Tiles.GetStaticAndMultiTiles(x, y))
        {
            var itemData = TileData.ItemTable[check.ID & TileData.MaxItemValue];

            if (itemData.ImpassableSurface)
            {
                var checkZ = check.Z;
                var checkTop = checkZ + itemData.CalcHeight;

                if (checkTop > ourZ && testTop > checkZ)
                {
                    return true;
                }
            }
        }

        return false;
    }
}