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

using AcDream.Core.Physics;
using Xunit;

namespace AcDream.Core.Tests.Physics;

/// <summary>
/// Unit tests for <see cref="CollisionExemption"/> — Commit C of the
/// 2026-04-29 live-entity collision port. Covers retail's
/// <c>CPhysicsObj::FindObjCollisions</c> exemption block, ported
/// line-for-line from
/// <c>docs/research/named-retail/acclient_2013_pseudo_c.txt:276782-276839,276971</c>.
///
/// <para>
/// Behaviour matrix (target / mover columns):
/// </para>
/// <list type="table">
///   <listheader><term>Mover</term><term>Target</term><description>Skip?</description></listheader>
///   <item><term>any</term><term>ETHEREAL+IGNORE_COLLISIONS</term><description>YES (early-out)</description></item>
///   <item><term>IsViewer</term><term>IsCreature</term><description>YES (camera ray-test passes through)</description></item>
///   <item><term>IGNORE_CREATURES</term><term>IsCreature</term><description>YES (mover walks through creatures)</description></item>
///   <item><term>IsPlayer</term><term>IsPlayer (no PK)</term><description>YES (non-PK pair walks through)</description></item>
///   <item><term>IsPlayer + IsPK</term><term>IsPlayer + IsPK</term><description>NO (PK pair collides)</description></item>
///   <item><term>IsPlayer + IsPKLite</term><term>IsPlayer + IsPKLite</term><description>NO (PKLite pair collides)</description></item>
///   <item><term>IsPlayer</term><term>IsPlayer + IsImpenetrable</term><description>NO (Impenetrable target always collides)</description></item>
///   <item><term>IsPlayer + IsPK</term><term>IsPlayer (no PK)</term><description>YES (mismatched PK skip)</description></item>
///   <item><term>IsPlayer</term><term>IsCreature (NPC)</term><description>NO (player vs NPC always collides)</description></item>
/// </list>
/// </summary>
public class CollisionExemptionTests
{
    private const uint ETHEREAL_PS = 0x4u;
    private const uint IGNORE_COLLISIONS_PS = 0x10u;

    [Fact]
    public void EtherealAndIgnoreCollisions_AlwaysSkipped()
    {
        // Target with both bits set is exempted from any mover.
        Assert.True(CollisionExemption.ShouldSkip(
            targetState: ETHEREAL_PS | IGNORE_COLLISIONS_PS,
            targetFlags: EntityCollisionFlags.None,
            moverState: ObjectInfoState.IsPlayer));
    }

    [Fact]
    public void EtherealOnly_NotInstantSkipped()
    {
        // Task 3 (2026-06-24): AD-7 shim retired. ETHEREAL alone (0x4) no
        // longer instant-skips — retail requires BOTH ETHEREAL_PS (0x4) AND
        // IGNORE_COLLISIONS_PS (0x10) for the Gate-1 early-out.
        // ETHEREAL-alone takes the obstruction_ethereal path: ShouldSkip
        // returns false → sp.ObstructionEthereal = true → BSP Path 1 fires
        // (sphere_intersects_solid) → open door is passable because its BSP
        // has no solid leaf at the opening. Retail pc:276782 / 0x0050f067.
        Assert.False(CollisionExemption.ShouldSkip(
            targetState: ETHEREAL_PS,
            targetFlags: EntityCollisionFlags.None,
            moverState: ObjectInfoState.IsPlayer));
    }

    [Fact]
    public void Viewer_VsCreature_Skipped()
    {
        // Camera-ray viewer transitions through creatures.
        Assert.True(CollisionExemption.ShouldSkip(
            targetState: 0u,
            targetFlags: EntityCollisionFlags.IsCreature,
            moverState: ObjectInfoState.IsViewer));
    }

    [Fact]
    public void Viewer_VsNonCreature_NotSkipped()
    {
        Assert.False(CollisionExemption.ShouldSkip(
            targetState: 0u,
            targetFlags: EntityCollisionFlags.None,
            moverState: ObjectInfoState.IsViewer));
    }

    [Fact]
    public void IgnoreCreatures_VsCreature_Skipped()
    {
        // Per acclient_2013_pseudo_c.txt:276971 — an arrow with
        // IGNORE_CREATURES doesn't get blocked by the very monster it's
        // tracking towards (until missile_ignore filters its target).
        Assert.True(CollisionExemption.ShouldSkip(
            targetState: 0u,
            targetFlags: EntityCollisionFlags.IsCreature,
            moverState: ObjectInfoState.IgnoreCreatures));
    }

    [Fact]
    public void NonPkPlayer_VsNonPkPlayer_Skipped()
    {
        // The user-visible payoff: two ordinary players walk through each
        // other instead of blocking.
        Assert.True(CollisionExemption.ShouldSkip(
            targetState: 0u,
            targetFlags: EntityCollisionFlags.IsPlayer,
            moverState: ObjectInfoState.IsPlayer));
    }

    [Fact]
    public void Pk_VsPk_NotSkipped()
    {
        // Two PK players collide.
        Assert.False(CollisionExemption.ShouldSkip(
            targetState: 0u,
            targetFlags: EntityCollisionFlags.IsPlayer | EntityCollisionFlags.IsPK,
            moverState: ObjectInfoState.IsPlayer | ObjectInfoState.IsPK));
    }

    [Fact]
    public void PkLite_VsPkLite_NotSkipped()
    {
        Assert.False(CollisionExemption.ShouldSkip(
            targetState: 0u,
            targetFlags: EntityCollisionFlags.IsPlayer | EntityCollisionFlags.IsPKLite,
            moverState: ObjectInfoState.IsPlayer | ObjectInfoState.IsPKLite));
    }

    [Fact]
    public void Pk_VsNonPk_Skipped()
    {
        // Mismatched PK status: still exempt — only matching pair collides.
        Assert.True(CollisionExemption.ShouldSkip(
            targetState: 0u,
            targetFlags: EntityCollisionFlags.IsPlayer,
            moverState: ObjectInfoState.IsPlayer | ObjectInfoState.IsPK));
    }

    [Fact]
    public void Pk_VsPkLite_Skipped()
    {
        // PK and PKLite are different pools — pair doesn't match.
        Assert.True(CollisionExemption.ShouldSkip(
            targetState: 0u,
            targetFlags: EntityCollisionFlags.IsPlayer | EntityCollisionFlags.IsPKLite,
            moverState: ObjectInfoState.IsPlayer | ObjectInfoState.IsPK));
    }

    [Fact]
    public void ImpenetrableTarget_VsAnyPlayer_NotSkipped()
    {
        // Impenetrable target ("Free" PK status) always collides with
        // any player mover — regardless of mover's PK state.
        Assert.False(CollisionExemption.ShouldSkip(
            targetState: 0u,
            targetFlags: EntityCollisionFlags.IsPlayer | EntityCollisionFlags.IsImpenetrable,
            moverState: ObjectInfoState.IsPlayer));
    }

    [Fact]
    public void Player_VsCreature_NotSkipped()
    {
        // PvP exemption only applies player-on-player. Player vs creature
        // (NPC, monster) is the normal blocking case.
        Assert.False(CollisionExemption.ShouldSkip(
            targetState: 0u,
            targetFlags: EntityCollisionFlags.IsCreature,
            moverState: ObjectInfoState.IsPlayer));
    }

    [Fact]
    public void NonPlayerMover_VsPlayer_NotSkipped()
    {
        // PvP rule requires BOTH to be players. Mover is not a player
        // (e.g., dead-reckoned remote NPC) → no exemption applies.
        Assert.False(CollisionExemption.ShouldSkip(
            targetState: 0u,
            targetFlags: EntityCollisionFlags.IsPlayer,
            moverState: ObjectInfoState.None));
    }

    [Fact]
    public void ImpenetrableMover_VsOrdinaryPlayer_NotSkipped()
    {
        // #299: retail's pseudo-C (acclient_2013_pseudo_c.txt:276824-276827)
        // disqualifies the tentative PvP exemption when the MOVER itself
        // carries state&0x80 (IS_IMPENETRABLE) — not just the target's
        // IsImpenetrable(). Without this branch an Impenetrable ("Free" PK
        // status) mover would incorrectly walk through an ordinary
        // (non-PK, non-Impenetrable) player target, the mirror image of
        // ImpenetrableTarget_VsAnyPlayer_NotSkipped above.
        Assert.False(CollisionExemption.ShouldSkip(
            targetState: 0u,
            targetFlags: EntityCollisionFlags.IsPlayer,
            moverState: ObjectInfoState.IsPlayer | ObjectInfoState.IsImpenetrable));
    }

    [Fact]
    public void ImpenetrableMover_StillCollidesEvenWhenAlsoPk()
    {
        // The mover-impenetrable disqualifier (4a) is checked before the
        // PK/PKLite arms (4b/4c) but must not depend on them — an
        // Impenetrable mover collides with a plain player target even
        // though neither side is PK/PKLite.
        Assert.False(CollisionExemption.ShouldSkip(
            targetState: 0u,
            targetFlags: EntityCollisionFlags.IsPlayer,
            moverState: ObjectInfoState.IsPlayer
                | ObjectInfoState.IsImpenetrable
                | ObjectInfoState.IsPK));
    }
}