acdream/tests/AcDream.Core.Tests/Physics/ShadowObjectRegistryMultiPartTests.cs

using System.Collections.Generic;
using System.Linq;
using System.Numerics;
using AcDream.Core.Physics;
using Xunit;

namespace AcDream.Core.Tests.Physics;

public class ShadowObjectRegistryMultiPartTests
{
    private const uint LbId = 0xA9B40000u;
    private const float OffX = 0f;
    private const float OffY = 0f;

    private static IReadOnlyList<ShadowShape> DoorShapes() => new[]
    {
        new ShadowShape(
            GfxObjId:      0u,
            LocalPosition: new Vector3(0f, 0f, 0.018f),
            LocalRotation: Quaternion.Identity,
            Scale:         1.0f,
            CollisionType: ShadowCollisionType.Cylinder,
            Radius:        0.100f,
            CylHeight:     0.200f),
        new ShadowShape(
            GfxObjId:      0x010044B5u,
            LocalPosition: Vector3.Zero,
            LocalRotation: Quaternion.Identity,
            Scale:         1.0f,
            CollisionType: ShadowCollisionType.BSP,
            Radius:        2.0f,
            CylHeight:     0f),
        new ShadowShape(
            GfxObjId:      0x010044B6u,
            LocalPosition: Vector3.Zero,
            LocalRotation: Quaternion.Identity,
            Scale:         1.0f,
            CollisionType: ShadowCollisionType.BSP,
            Radius:        2.0f,
            CylHeight:     0f),
        new ShadowShape(
            GfxObjId:      0x010044B6u,
            LocalPosition: Vector3.Zero,
            LocalRotation: Quaternion.Identity,
            Scale:         1.0f,
            CollisionType: ShadowCollisionType.BSP,
            Radius:        2.0f,
            CylHeight:     0f)
    };

    [Fact]
    public void RegisterMultiPart_FourShapes_AllShareEntityId()
    {
        var reg = new ShadowObjectRegistry();
        const uint doorEntityId = 0x000F4244u;

        reg.RegisterMultiPart(
            entityId:        doorEntityId,
            entityWorldPos:  new Vector3(132.6f, 17.1f, 94.08f),
            entityWorldRot:  Quaternion.Identity,
            shapes:          DoorShapes(),
            state:           0x10008u,
            flags:           EntityCollisionFlags.None,
            worldOffsetX:    OffX,
            worldOffsetY:    OffY,
            landblockId:     LbId);

        int found = 0;
        foreach (var entry in reg.AllEntriesForDebug())
        {
            if (entry.EntityId == doorEntityId) found++;
        }
        Assert.True(found >= 4,
            $"Expected at least 4 entries for door entity (one per shape); found {found}");
    }

    [Fact]
    public void RegisterMultiPart_EmptyShapeList_NoOp()
    {
        var reg = new ShadowObjectRegistry();
        reg.RegisterMultiPart(
            entityId:       0x1u,
            entityWorldPos: Vector3.Zero,
            entityWorldRot: Quaternion.Identity,
            shapes:         System.Array.Empty<ShadowShape>(),
            state:          0u,
            flags:          EntityCollisionFlags.None,
            worldOffsetX:   OffX, worldOffsetY: OffY, landblockId: LbId);

        Assert.Equal(0, reg.TotalRegistered);
    }

    [Fact]
    public void Deregister_RemovesAllParts()
    {
        var reg = new ShadowObjectRegistry();
        const uint doorEntityId = 0x000F4244u;
        reg.RegisterMultiPart(doorEntityId, new Vector3(132.6f, 17.1f, 94.08f),
                               Quaternion.Identity, DoorShapes(), 0x10008u,
                               EntityCollisionFlags.None, OffX, OffY, LbId);

        reg.Deregister(doorEntityId);

        Assert.Equal(0, reg.TotalRegistered);
        foreach (var entry in reg.AllEntriesForDebug())
            Assert.NotEqual(doorEntityId, entry.EntityId);
    }

    [Fact]
    public void UpdatePhysicsState_PropagatesEtherealToAllParts()
    {
        var reg = new ShadowObjectRegistry();
        const uint doorEntityId = 0x000F4244u;
        reg.RegisterMultiPart(doorEntityId, new Vector3(132.6f, 17.1f, 94.08f),
                               Quaternion.Identity, DoorShapes(), 0x10008u,
                               EntityCollisionFlags.None, OffX, OffY, LbId);

        reg.UpdatePhysicsState(doorEntityId, 0x1000Cu); // 0x10008 | 0x4

        int updated = 0;
        foreach (var entry in reg.AllEntriesForDebug())
        {
            if (entry.EntityId != doorEntityId) continue;
            Assert.Equal(0x1000Cu, entry.State);
            updated++;
        }
        Assert.True(updated >= 4, $"Expected all parts updated, only {updated} were");
    }

    [Fact]
    public void RegisterMultiPart_PartsAcrossMultipleCells_AllCellsListed()
    {
        var reg = new ShadowObjectRegistry();
        // Two shapes 30m apart in X — must span two outdoor 24m cells.
        var shapes = new[]
        {
            new ShadowShape(0u, new Vector3(  0f, 0f, 0f), Quaternion.Identity, 1f,
                            ShadowCollisionType.Cylinder, 1f, 2f),
            new ShadowShape(0u, new Vector3(30f, 0f, 0f), Quaternion.Identity, 1f,
                            ShadowCollisionType.Cylinder, 1f, 2f),
        };
        reg.RegisterMultiPart(0x1u, new Vector3(12f, 12f, 50f), Quaternion.Identity,
                               shapes, 0u, EntityCollisionFlags.None, OffX, OffY, LbId);

        // Part 1 at world (12, 12) → cell (0,0) = LbId | 1
        // Part 2 at world (42, 12) → cell (1,0) = LbId | 9
        var entriesIn1 = reg.GetObjectsInCell(LbId | 1u);
        var entriesIn9 = reg.GetObjectsInCell(LbId | 9u);
        Assert.Contains(entriesIn1, e => e.EntityId == 0x1u);
        Assert.Contains(entriesIn9, e => e.EntityId == 0x1u);
    }

    [Fact]
    public void Register_SingleShapeCompat_Unchanged()
    {
        var reg = new ShadowObjectRegistry();
        reg.Register(42u, 0x01000001u, new Vector3(12f, 12f, 50f),
                     Quaternion.Identity, 1f, OffX, OffY, LbId);

        Assert.Equal(1, reg.TotalRegistered);
        Assert.Single(reg.GetObjectsInCell(LbId | 1u),
                      e => e.EntityId == 42u);
    }

    [Fact]
    public void UpdatePosition_MovesAllPartsWithEntity()
    {
        var reg = new ShadowObjectRegistry();
        const uint movingEntityId = 0xA1u;

        var shapes = new[]
        {
            new ShadowShape(0u, new Vector3(0f, 0f, 0f), Quaternion.Identity, 1f,
                            ShadowCollisionType.Cylinder, 0.5f, 1f),
            new ShadowShape(0u, new Vector3(1f, 0f, 0f), Quaternion.Identity, 1f,
                            ShadowCollisionType.Cylinder, 0.5f, 1f),
        };
        reg.RegisterMultiPart(movingEntityId, new Vector3(10f, 10f, 50f),
                               Quaternion.Identity, shapes, 0u,
                               EntityCollisionFlags.None, OffX, OffY, LbId);

        // Move entity to (50, 10, 50). Parts should be at (50, 10, 50) and (51, 10, 50).
        reg.UpdatePosition(movingEntityId,
                           new Vector3(50f, 10f, 50f), Quaternion.Identity,
                           OffX, OffY, LbId);

        Vector3 expectedPart0 = new(50f, 10f, 50f);
        Vector3 expectedPart1 = new(51f, 10f, 50f);
        var atNew = reg.AllEntriesForDebug().Where(e => e.EntityId == movingEntityId).ToList();
        Assert.Equal(2, atNew.Count);
        bool found0 = atNew.Any(e => Vector3.Distance(e.Position, expectedPart0) < 0.01f);
        bool found1 = atNew.Any(e => Vector3.Distance(e.Position, expectedPart1) < 0.01f);
        Assert.True(found0 && found1,
            "Expected both parts at new world positions (50, 10, 50) and (51, 10, 50)");
    }

    [Fact]
    public void Deregister_ClearsEntityShapesCache_NoStaleUpdatePositionRebuild()
    {
        // A6.P4 door fix (2026-05-24) regression: after Deregister, a stray
        // UpdatePosition with the same entityId must NOT resurrect the entity
        // via the _entityShapes path. The Deregister cleanup added in Task 4
        // (which folded Task 6 into the multi-part registration commit) clears
        // _entityShapes[entityId] alongside the cell-list cleanup.
        var reg = new ShadowObjectRegistry();
        const uint doorEntityId = 0x000F4244u;
        reg.RegisterMultiPart(doorEntityId, new Vector3(132.6f, 17.1f, 94.08f),
                               Quaternion.Identity, DoorShapes(), 0x10008u,
                               EntityCollisionFlags.None, OffX, OffY, LbId);

        reg.Deregister(doorEntityId);

        // Stray UpdatePosition should be a no-op now (no entry to find AND
        // no _entityShapes entry to rebuild from).
        reg.UpdatePosition(doorEntityId, new Vector3(200f, 200f, 50f),
                           Quaternion.Identity, OffX, OffY, LbId);

        Assert.Equal(0, reg.TotalRegistered);
    }

    // ---------------------------------------------------------------------
    // AP-152 — cross-cell dispatch. CPhysicsObj::calc_cross_cells @0x00515230
    // tests HAS_PHYSICS_BSP_PS at 0x00515285 and routes a BSP-bearing object
    // to CPhysicsObj::find_bbox_cell_list @0x00510fc0 through
    // 0x0051528f jne 0x515305. The cylsphere branch (0x005152d1
    // CObjCell::find_cell_list @0x0052b9f0) and the sorting-sphere branch
    // (0x005152fb ... @0x0052b990) are BOTH below that jump and unreachable
    // from it. BuildFloodSpheres used to prefer Cylinders over everything
    // whenever any Cylinder was present, which is retail's SECOND priority
    // applied ahead of its first.
    // ---------------------------------------------------------------------

    /// <summary>Cells of the landblock that hold at least one row for owner.</summary>
    private static List<uint> OutdoorCellsHolding(ShadowObjectRegistry reg, uint ownerId)
    {
        var cells = new List<uint>();
        for (uint index = 1u; index <= 64u; index++)
        {
            uint cellId = LbId | index;
            if (reg.GetObjectsInCell(cellId).Any(e => e.EntityId == ownerId))
                cells.Add(cellId);
        }
        return cells;
    }

    private static ShadowShape Cyl(float radius) => new(
        GfxObjId: 0u, LocalPosition: Vector3.Zero, LocalRotation: Quaternion.Identity,
        Scale: 1f, CollisionType: ShadowCollisionType.Cylinder,
        Radius: radius, CylHeight: radius * 2f);

    private static ShadowShape Bsp(float radius) => new(
        GfxObjId: 0x010044B5u, LocalPosition: Vector3.Zero, LocalRotation: Quaternion.Identity,
        Scale: 1f, CollisionType: ShadowCollisionType.BSP,
        Radius: radius, CylHeight: 0f);

    private static List<uint> FloodCellsFor(params ShadowShape[] shapes)
    {
        var reg = new ShadowObjectRegistry();
        const uint ownerId = 0xBEEF01u;
        // Centre of the landblock's cell (1,1) so a 14 m footprint stays
        // inside the block's own 8x8 outdoor grid on every side.
        reg.RegisterMultiPart(
            ownerId, new Vector3(36f, 36f, 50f), Quaternion.Identity,
            shapes, 0x10008u, EntityCollisionFlags.None, OffX, OffY, LbId);
        return OutdoorCellsHolding(reg, ownerId);
    }

    [Fact]
    public void BuildFloodSpheres_BspBearingOwner_FloodsFromBspNotFromCylinder()
    {
        List<uint> cylinderOnly = FloodCellsFor(Cyl(0.5f));
        List<uint> bspOnly      = FloodCellsFor(Bsp(14f));
        List<uint> mixed        = FloodCellsFor(Cyl(0.5f), Bsp(14f));

        // Controls: the two footprints must actually differ, or the fact below
        // is satisfiable by any dispatch rule at all.
        Assert.Equal([LbId | 10u], cylinderOnly);
        Assert.True(bspOnly.Count > 1,
            $"BSP footprint control failed: expected >1 cell, got {bspOnly.Count}");

        // The fact: a mixed list floods from the BSP shapes, exactly as if the
        // cylinder were not there. Retail 0x0051528f.
        Assert.Equal(bspOnly, mixed);
        Assert.NotEqual(cylinderOnly, mixed);
    }

    /// <summary>
    /// The AP-152 delta end-to-end: a CylSphere+BSP Setup (73 of the 172
    /// affected installed Setups are this shape) registered through the
    /// production builder. Before the fix the emitted list carried both, and
    /// BuildFloodSpheres' cylinder preference confined the owner to the
    /// cylinder's cell while its slab BSP reached further — an object absent
    /// from shadow cells it physically occupies, the #98 / #168 symptom class.
    /// </summary>
    [Fact]
    public void FromSetup_CylSphereAndBspSetup_FloodsTheBspFootprint()
    {
        const uint part = 0x010044B5u;
        var setup = new DatReaderWriter.DBObjs.Setup
        {
            Parts      = { part },
            CylSpheres = { new DatReaderWriter.Types.CylSphere
                { Radius = 0.5f, Height = 1f, Origin = Vector3.Zero } },
        };

        IReadOnlyList<ShadowShape> raw =
            ShadowShapeBuilder.FromSetup(setup, entScale: 1f, hasPhysicsBsp: id => id == part);
        // Production substitutes the real BSP bounding radius at registration
        // time (LiveEntityCollisionBuilder.Build); 14 m stands in for a slab
        // wide enough to leave its own landcell.
        var shapes = raw.Select(s => s.CollisionType == ShadowCollisionType.BSP
            ? s with { Radius = 14f }
            : s).ToList();

        ShadowShape only = Assert.Single(shapes);
        Assert.Equal(ShadowCollisionType.BSP, only.CollisionType);

        var reg = new ShadowObjectRegistry();
        const uint ownerId = 0xBEEF02u;
        reg.RegisterMultiPart(
            ownerId, new Vector3(36f, 36f, 50f), Quaternion.Identity,
            shapes, 0x10008u, EntityCollisionFlags.None, OffX, OffY, LbId);

        List<uint> cells = OutdoorCellsHolding(reg, ownerId);
        Assert.Contains(LbId | 10u, cells);
        Assert.True(cells.Count > 1,
            $"Expected the slab footprint to span more than its own landcell; got {cells.Count}");
    }
}