erik/acdream
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

feat(physics): retail PvP exemption + viewer/creature/missile gates (Commit C)

Browse source 
The retail-faithful exemption block at the top of
CPhysicsObj::FindObjCollisions
(acclient_2013_pseudo_c.txt:276782-276839,276971), ported line-for-
line as a small static helper.

Behaviour now matches retail:
  - Two non-PK players walk through each other.
  - Two PK players collide.
  - Two PKLite players collide.
  - Mismatched PK status (PK vs non-PK, PK vs PKLite) — exempt.
  - Impenetrable target ("Free" PK status) — always collides.
  - Player vs creature/NPC — always collides (this is what closes the
    user-facing complaint that walking into a Holtburg vendor was
    walking through them).
  - Mover with IGNORE_CREATURES — walks through creature targets.
  - Viewer (camera ray) — walks through creatures.
  - Target with ETHEREAL+IGNORE_COLLISIONS — universally exempt.

CollisionExemption.ShouldSkip(targetState, targetFlags, moverState)
  - new file src/AcDream.Core/Physics/CollisionExemption.cs.
  - 13-test matrix covering every documented case
    (CollisionExemptionTests.cs).
  - Static + pure → cheap to call from the hot path.

Wiring:
  - TransitionTypes.FindObjCollisions: after broadphase distance
    reject, call ShouldSkip on the obj and ObjectInfo.State; on true,
    `continue`. Static landblock entries (State=0, Flags=None) fall
    through cheaply — no behavior change for static collision.
  - PhysicsEngine.ResolveWithTransition: new optional moverFlags
    parameter (default None for back-compat). PlayerMovementController
    passes ObjectInfoState.IsPlayer; remote dead-reckoning leaves it
    None (matches non-player movers, no PvP exemption applies).
  - PK/PKLite/Impenetrable bits for the LOCAL player are not yet
    sourced from PlayerDescription's PlayerKillerStatus property —
    that's a follow-up. Default "non-PK player" matches ACE's
    character-creation default and the user's +Acdream test
    character.

Cross-checked against ACE PhysicsObj.cs:381-405 (line-for-line C# port
of the same retail block). Only intentional divergence: ACE adds
state.HasFlag(IsImpenetrable) (mover-impenetrable) to the collide list;
retail's pseudo-C only checks the target — acdream follows retail.

dotnet build green, dotnet test 1467 passing (+13 new). Live test:
+Acdream walking into Holtburg vendors now stops at their cylinder;
walking through small plants still passes (Commit B's phantom skip).

Closes the live-entity collision arc: A (plumbing) + B (registration)
+ C (exemption).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
This commit is contained in:
Erik 2026-04-29 13:21:36 +02:00
parent 46ca3ba26b
commit 7d6fe90607
5 changed files with 319 additions and 2 deletions
Download patch file Download diff file Expand all files Collapse all files

169
tests/AcDream.Core.Tests/Physics/CollisionExemptionTests.cs Normal file
View file

@ -0,0 +1,169 @@
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_NotSkipped()
{
// Target with ETHEREAL but NOT IGNORE_COLLISIONS does not bail
// out at the first gate — collision proceeds. (Step-down marks
// obstruction_ethereal, but does not exempt.)
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));
}
}