2eb39a0250
The two gates that decide whether an accepted remote Position is interpolated
or hard-snapped read `Airborne`, which is `!Body.OnWalkable` — WALKABILITY.
Retail reads CONTACT: InterpolationManager::adjust_offset @0x00555D30 gates its
entire body on `transient_state & 1` @0x00555D52, so a retail body in contact
with a non-walkable face still interpolates.
The two predicates disagree in exactly one state — in contact, not on walkable
ground — which 204d0ae0 turned from unreachable into ordinary. Before it, the
per-tick forge made every non-airborne remote walkable by construction, so the
disagreement could not occur.
Both gates now read `!Body.InContact`: ApplyRemoteContactRouting's flight
carve-out and OnPosition's player-remote arm.
`Airborne` is deliberately NOT re-derived from CONTACT. That would perturb all
five of its writers and contradict a pinned assertion in
RemoteTeleportPlacementTests.Apply_PendingGroundToSteepContact_ (InContact:
true, OnWalkable: false -> Assert.True(remote.Airborne)); a previous
implementer attempted it and correctly backed out rather than editing the
assertion. This narrower shape touches no existing test.
AP-140's register row is retired in this commit, as the row itself specified.
Honest scope: this is a faithfulness fix, not a visible one. ACE derives its
IsGrounded flag with the same floor_z test, so during a slide it almost
certainly reports not-grounded, the classifier returns NoPositionOperation, and
neither arm is taken. Expect no observable change against ACE.
Suite 11,027 passed / 4 skipped / 0 failed (baseline 11,023).
Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
588 lines
24 KiB
C#
588 lines
24 KiB
C#
using System.Numerics;
|
|
using AcDream.App.Physics;
|
|
using AcDream.Core.Net.Messages;
|
|
using AcDream.Core.Physics;
|
|
using AcDream.Runtime;
|
|
using AcDream.Runtime.Entities;
|
|
using AcDream.Runtime.Physics;
|
|
using AcDream.Runtime.Session;
|
|
|
|
namespace AcDream.App.Tests.Physics;
|
|
|
|
/// <summary>
|
|
/// C4 route 4b-2: behavioural acceptance for the remote far snap. Every test
|
|
/// calls the PRODUCTION routing entry point
|
|
/// (<see cref="LiveEntityNetworkUpdateController.ApplyRemoteContactRouting"/>)
|
|
/// against a REAL <see cref="RuntimeRemotePlacementDriveController"/>, a real
|
|
/// canonical <see cref="RuntimeEntityRecord"/>/<see cref="PhysicsBody"/> pair,
|
|
/// and REAL
|
|
/// <see cref="RuntimeAuthoritativePositionRouteClassifier"/> output. Nothing
|
|
/// is re-derived in a test body — that is the #292 gap route 2 left and route
|
|
/// 4a's first attempt repeated.
|
|
///
|
|
/// <para>
|
|
/// The load-bearing discriminator is the <c>worldPos</c> argument: it is
|
|
/// deliberately DIFFERENT from the accepted destination merged onto the
|
|
/// canonical snapshot. The deleted legacy far block wrote
|
|
/// <c>Body.Position = worldPos</c>; the canonical placement writes the
|
|
/// snapshot's destination resolved through Runtime's world frame. Any
|
|
/// regression back to the legacy write therefore fails
|
|
/// <see cref="FarSnap_PlacesTheBodyFromTheCanonicalDestination_NotTheCallersWirePose"/>
|
|
/// on the exact position value.
|
|
/// </para>
|
|
/// </summary>
|
|
public sealed class LiveEntityNetworkRemoteFarSnapIntegrationTests
|
|
{
|
|
private static readonly Vector3 Destination = new(12f, 14f, 7f);
|
|
|
|
/// <summary>A wire pose the caller passes but the far arm must ignore —
|
|
/// distinct from <see cref="Destination"/> in every component.</summary>
|
|
private static readonly Vector3 DecoyWirePose = new(-70f, -80f, -90f);
|
|
|
|
[Fact]
|
|
public void FarSnap_PlacesTheBodyFromTheCanonicalDestination_NotTheCallersWirePose()
|
|
{
|
|
using var fixture = new RemotePlacementDriveFixture();
|
|
fixture.PublishDestinationCollision();
|
|
fixture.AllowDestination();
|
|
(RuntimeEntityRecord record, RemoteMotion remote, PhysicsBody body) =
|
|
fixture.AddRemote(0x70004001u, Destination);
|
|
|
|
LiveEntityNetworkUpdateController.RemoteContactRouting routing =
|
|
LiveEntityNetworkUpdateController.ApplyRemoteContactRouting(
|
|
fixture.Drive,
|
|
record,
|
|
remote,
|
|
Classify(hasContact: true, playerDistance: 200f),
|
|
DecoyWirePose,
|
|
Quaternion.Identity,
|
|
willBeDrTicked: true);
|
|
|
|
Assert.Equal(
|
|
LiveEntityNetworkUpdateController.RemoteContactArm.FarSnapPlacement,
|
|
routing.Arm);
|
|
Assert.Equal(
|
|
RuntimeRemotePlacementExecutionStatus.Committed,
|
|
routing.Placement);
|
|
Assert.Equal(
|
|
Destination + RemotePlacementDriveFixture.DestinationWorldOffset,
|
|
body.Position);
|
|
Assert.NotEqual(DecoyWirePose, body.Position);
|
|
// The canonical placement — not the App — committed residency.
|
|
Assert.Equal(RemotePlacementDriveFixture.DestinationCell, record.FullCellId);
|
|
|
|
fixture.DrainPlacementFifo();
|
|
Assert.Equal(0, fixture.LiveOperationCount);
|
|
Assert.Equal(0, fixture.RemotePlacementLedger);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retail's far branch stops the interpolation queue BEFORE placing
|
|
/// (@0x005163CB precedes @0x005163D9). A stale near waypoint surviving the
|
|
/// snap would drag the freshly placed body back on the next per-tick
|
|
/// catch-up.
|
|
/// </summary>
|
|
[Fact]
|
|
public void FarSnap_ClearsTheInterpolationQueue()
|
|
{
|
|
using var fixture = new RemotePlacementDriveFixture();
|
|
fixture.PublishDestinationCollision();
|
|
fixture.AllowDestination();
|
|
(RuntimeEntityRecord record, RemoteMotion remote, PhysicsBody body) =
|
|
fixture.AddRemote(0x70004002u, Destination);
|
|
remote.Interp.Enqueue(
|
|
new Vector3(40f, 40f, 7f),
|
|
Quaternion.Identity,
|
|
isMovingTo: false,
|
|
currentBodyPosition: body.Position,
|
|
currentBodyOrientation: body.Orientation);
|
|
Assert.True(remote.Interp.IsActive);
|
|
|
|
_ = LiveEntityNetworkUpdateController.ApplyRemoteContactRouting(
|
|
fixture.Drive,
|
|
record,
|
|
remote,
|
|
Classify(hasContact: true, playerDistance: 200f),
|
|
DecoyWirePose,
|
|
Quaternion.Identity,
|
|
willBeDrTicked: true);
|
|
|
|
Assert.False(remote.Interp.IsActive);
|
|
fixture.DrainPlacementFifo();
|
|
}
|
|
|
|
/// <summary>
|
|
/// <b>The inverted test (C4 route 4b-2 review).</b> This used to assert
|
|
/// <c>Assert.Equal(before, body.Position)</c> and so PINNED the defect
|
|
/// both reviews found: a refused far snap left the body at its stale pose
|
|
/// with the interpolation queue already cleared, i.e. a frozen remote
|
|
/// that the next 5-10 Hz packet reproduces identically.
|
|
///
|
|
/// <para>
|
|
/// Retail never leaves the object behind. When
|
|
/// <c>CPhysicsObj::SetPositionInternal</c> @0x00515BD0 resolves no cell,
|
|
/// it takes @0x00515C1D and still commits the destination —
|
|
/// <c>store_position</c> @0x00515CE2 — before <c>GotoLostCell</c>
|
|
/// @0x00515CF2. So a refusal advances the body to the accepted
|
|
/// destination, resolved through Runtime's world frame (NOT the caller's
|
|
/// wire pose), while retaining no operation and committing no cell.
|
|
/// </para>
|
|
/// </summary>
|
|
[Fact]
|
|
public void FarSnap_RefusedDestination_StillAdvancesTheBodyToTheAcceptedDestination()
|
|
{
|
|
using var fixture = new RemotePlacementDriveFixture();
|
|
fixture.PublishDestinationCollision();
|
|
// Deliberately NOT AllowDestination().
|
|
(RuntimeEntityRecord record, RemoteMotion remote, PhysicsBody body) =
|
|
fixture.AddRemote(0x70004003u, Destination);
|
|
Vector3 before = body.Position;
|
|
|
|
LiveEntityNetworkUpdateController.RemoteContactRouting routing =
|
|
LiveEntityNetworkUpdateController.ApplyRemoteContactRouting(
|
|
fixture.Drive,
|
|
record,
|
|
remote,
|
|
Classify(hasContact: true, playerDistance: 200f),
|
|
DecoyWirePose,
|
|
Quaternion.Identity,
|
|
willBeDrTicked: true);
|
|
|
|
Assert.Equal(
|
|
LiveEntityNetworkUpdateController.RemoteContactArm.FarSnapPlacement,
|
|
routing.Arm);
|
|
Assert.Equal(
|
|
RuntimeRemotePlacementExecutionStatus.Refused,
|
|
routing.Placement);
|
|
// store_position: the body TRACKED, and from the canonical
|
|
// destination — not the caller's wire pose, and not its stale pose.
|
|
Assert.Equal(
|
|
Destination + RemotePlacementDriveFixture.DestinationWorldOffset,
|
|
body.Position);
|
|
Assert.NotEqual(before, body.Position);
|
|
Assert.NotEqual(DecoyWirePose, body.Position);
|
|
// …and it is a store_position, NOT a placement: no cell was
|
|
// committed, nothing was retained.
|
|
Assert.Equal(RemotePlacementDriveFixture.SourceCell, record.FullCellId);
|
|
Assert.True(body.InWorld);
|
|
Assert.True(record.ObjectClock.IsActive);
|
|
Assert.Equal(0, fixture.LiveOperationCount);
|
|
Assert.Equal(0, fixture.RemotePlacementLedger);
|
|
}
|
|
|
|
/// <summary>
|
|
/// The same refusal repeated: a remote genuinely beyond the host's
|
|
/// service window keeps TRACKING every packet rather than freezing until
|
|
/// the window opens. This is the reachable production shape the review
|
|
/// named — a remote that is rendered but still streaming, refused while
|
|
/// genuinely beyond 96 m — and it is why the fallback cannot be a
|
|
/// one-shot.
|
|
/// </summary>
|
|
[Fact]
|
|
public void FarSnap_RepeatedRefusals_KeepTrackingEveryPacket()
|
|
{
|
|
using var fixture = new RemotePlacementDriveFixture();
|
|
fixture.PublishDestinationCollision();
|
|
(RuntimeEntityRecord record, RemoteMotion remote, PhysicsBody body) =
|
|
fixture.AddRemote(0x7000400Cu, Destination);
|
|
|
|
foreach (Vector3 step in new[]
|
|
{
|
|
new Vector3(20f, 14f, 7f),
|
|
new Vector3(28f, 14f, 7f),
|
|
new Vector3(36f, 14f, 7f),
|
|
})
|
|
{
|
|
record.Snapshot = record.Snapshot with
|
|
{
|
|
Position = new CreateObject.ServerPosition(
|
|
RemotePlacementDriveFixture.DestinationCell,
|
|
step.X,
|
|
step.Y,
|
|
step.Z,
|
|
1f,
|
|
0f,
|
|
0f,
|
|
0f),
|
|
};
|
|
|
|
LiveEntityNetworkUpdateController.RemoteContactRouting routing =
|
|
LiveEntityNetworkUpdateController.ApplyRemoteContactRouting(
|
|
fixture.Drive,
|
|
record,
|
|
remote,
|
|
Classify(hasContact: true, playerDistance: 200f),
|
|
DecoyWirePose,
|
|
Quaternion.Identity,
|
|
willBeDrTicked: true);
|
|
|
|
Assert.Equal(
|
|
RuntimeRemotePlacementExecutionStatus.Refused,
|
|
routing.Placement);
|
|
Assert.Equal(
|
|
step + RemotePlacementDriveFixture.DestinationWorldOffset,
|
|
body.Position);
|
|
}
|
|
|
|
Assert.Equal(0, fixture.LiveOperationCount);
|
|
Assert.Equal(0, fixture.RemotePlacementLedger);
|
|
}
|
|
|
|
// ── The null / Rejected* / cell-less policy ────────────────────────────
|
|
|
|
/// <summary>
|
|
/// The login-window trap. <c>ClassifyRemoteAcceptedPosition</c> returns
|
|
/// null for EVERY remote packet until the local movement controller
|
|
/// exists, because there is no <c>player_distance</c> to derive. Deleting
|
|
/// the legacy block without a replacement would freeze every remote for
|
|
/// that whole window. The stated policy routes it through AP-87's
|
|
/// catch-up, whose 4 m guard PLACES a body that has drifted.
|
|
/// </summary>
|
|
[Fact]
|
|
public void NoClassificationAtAll_StillTracksTheServer()
|
|
{
|
|
using var fixture = new RemotePlacementDriveFixture();
|
|
(RuntimeEntityRecord record, RemoteMotion remote, PhysicsBody body) =
|
|
fixture.AddRemote(0x70004004u, Destination);
|
|
var target = new Vector3(60f, 10f, 7f); // 50 m from the body.
|
|
|
|
LiveEntityNetworkUpdateController.RemoteContactRouting routing =
|
|
LiveEntityNetworkUpdateController.ApplyRemoteContactRouting(
|
|
fixture.Drive,
|
|
record,
|
|
remote,
|
|
route: null,
|
|
target,
|
|
Quaternion.Identity,
|
|
willBeDrTicked: true);
|
|
|
|
Assert.Equal(
|
|
LiveEntityNetworkUpdateController.RemoteContactArm.UnroutedCatchUp,
|
|
routing.Arm);
|
|
Assert.Equal(target, body.Position);
|
|
// No canonical placement was attempted for an unclassified packet.
|
|
Assert.Equal(0, fixture.LiveOperationCount);
|
|
}
|
|
|
|
/// <summary>
|
|
/// …and the same policy ENQUEUES when the body is already tracking, which
|
|
/// is what proves it is AP-87's catch-up rather than an unconditional
|
|
/// snap bolted on to make the previous test pass.
|
|
///
|
|
/// <para>
|
|
/// R7 review fix: the earlier version asserted only that the body did not
|
|
/// move, which "snap when <c>bodyToTarget > 4 m</c>, else do nothing"
|
|
/// satisfies just as well as an enqueue — it and its sibling both passed
|
|
/// against that regression. The queue assertion below is what actually
|
|
/// distinguishes "enqueued" from "did nothing".
|
|
/// </para>
|
|
/// </summary>
|
|
[Fact]
|
|
public void NoClassificationAtAll_NearAndTicked_EnqueuesInsteadOfSnapping()
|
|
{
|
|
using var fixture = new RemotePlacementDriveFixture();
|
|
(RuntimeEntityRecord record, RemoteMotion remote, PhysicsBody body) =
|
|
fixture.AddRemote(0x70004005u, Destination);
|
|
Vector3 before = body.Position;
|
|
var target = before + new Vector3(0.5f, 0f, 0f);
|
|
|
|
LiveEntityNetworkUpdateController.RemoteContactRouting routing =
|
|
LiveEntityNetworkUpdateController.ApplyRemoteContactRouting(
|
|
fixture.Drive,
|
|
record,
|
|
remote,
|
|
route: null,
|
|
target,
|
|
Quaternion.Identity,
|
|
willBeDrTicked: true);
|
|
|
|
Assert.Equal(
|
|
LiveEntityNetworkUpdateController.RemoteContactArm.UnroutedCatchUp,
|
|
routing.Arm);
|
|
Assert.Equal(before, body.Position);
|
|
Assert.True(remote.Interp.IsActive);
|
|
}
|
|
|
|
[Fact]
|
|
public void RejectedData_TakesTheUnroutedCatchUp_NotTheFarSnap()
|
|
{
|
|
using var fixture = new RemotePlacementDriveFixture();
|
|
fixture.PublishDestinationCollision();
|
|
fixture.AllowDestination();
|
|
(RuntimeEntityRecord record, RemoteMotion remote, PhysicsBody body) =
|
|
fixture.AddRemote(0x70004006u, Destination);
|
|
var target = new Vector3(60f, 10f, 7f);
|
|
|
|
RuntimeAuthoritativePositionRoute rejected =
|
|
Classify(hasContact: true, playerDistance: float.NaN);
|
|
Assert.Equal(
|
|
RuntimeAuthoritativePositionDisposition.RejectedData,
|
|
rejected.Disposition);
|
|
|
|
LiveEntityNetworkUpdateController.RemoteContactRouting routing =
|
|
LiveEntityNetworkUpdateController.ApplyRemoteContactRouting(
|
|
fixture.Drive,
|
|
record,
|
|
remote,
|
|
rejected,
|
|
target,
|
|
Quaternion.Identity,
|
|
willBeDrTicked: true);
|
|
|
|
Assert.Equal(
|
|
LiveEntityNetworkUpdateController.RemoteContactArm.UnroutedCatchUp,
|
|
routing.Arm);
|
|
Assert.Equal(target, body.Position);
|
|
Assert.Equal(0, fixture.LiveOperationCount);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Retail's cell-less body takes <c>this_1->cell == 0</c> @0x00516386
|
|
/// (<c>SetPosition</c>), never the far branch — and route 4b-3, not this
|
|
/// slice, owns it. Claiming it here would be exactly route 4a's
|
|
/// "'not Interpolate' is not 'far'" finding one level up.
|
|
/// </summary>
|
|
[Fact]
|
|
public void CellLessRemote_TakesTheUnroutedCatchUp_AndNeverThePlacementOwner()
|
|
{
|
|
using var fixture = new RemotePlacementDriveFixture();
|
|
fixture.PublishDestinationCollision();
|
|
fixture.AllowDestination();
|
|
(RuntimeEntityRecord record, RemoteMotion remote, PhysicsBody body) =
|
|
fixture.AddRemote(0x70004007u, Destination);
|
|
var target = new Vector3(60f, 10f, 7f);
|
|
|
|
RuntimeAuthoritativePositionRoute cellLess = Classify(
|
|
hasContact: true,
|
|
playerDistance: 200f,
|
|
committedCellId: 0u);
|
|
Assert.Equal(
|
|
RuntimeAuthoritativePositionDisposition.SetPosition,
|
|
cellLess.Disposition);
|
|
|
|
LiveEntityNetworkUpdateController.RemoteContactRouting routing =
|
|
LiveEntityNetworkUpdateController.ApplyRemoteContactRouting(
|
|
fixture.Drive,
|
|
record,
|
|
remote,
|
|
cellLess,
|
|
target,
|
|
Quaternion.Identity,
|
|
willBeDrTicked: true);
|
|
|
|
Assert.Equal(
|
|
LiveEntityNetworkUpdateController.RemoteContactArm.UnroutedCatchUp,
|
|
routing.Arm);
|
|
Assert.Equal(target, body.Position);
|
|
Assert.Equal(0, fixture.LiveOperationCount);
|
|
Assert.Equal(0, fixture.RemotePlacementLedger);
|
|
}
|
|
|
|
/// <summary>
|
|
/// The airborne precedence carve-out still outranks the far snap, not
|
|
/// only the near branch: a remote mid-arc whose packet happens to
|
|
/// classify far must keep the pre-existing authoritative hard-snap rather
|
|
/// than open a canonical placement.
|
|
/// </summary>
|
|
[Fact]
|
|
public void AirborneBody_OutranksTheFarSnap()
|
|
{
|
|
using var fixture = new RemotePlacementDriveFixture();
|
|
fixture.PublishDestinationCollision();
|
|
fixture.AllowDestination();
|
|
(RuntimeEntityRecord record, RemoteMotion remote, PhysicsBody body) =
|
|
fixture.AddRemote(0x70004008u, Destination);
|
|
// AP-140 (retired 2026-08-04): "mid-arc" is retail's CONTACT_TS-clear
|
|
// (`InterpolationManager::adjust_offset` gates on `transient_state & 1`
|
|
// @0x00555D52), not the client `Airborne` walkability flag. Both are
|
|
// set here so the test states free flight in the terms the gate now
|
|
// reads AND the terms it used to.
|
|
remote.Airborne = true;
|
|
remote.Body.TransientState = TransientStateFlags.Active;
|
|
var target = new Vector3(60f, 10f, 7f);
|
|
|
|
LiveEntityNetworkUpdateController.RemoteContactRouting routing =
|
|
LiveEntityNetworkUpdateController.ApplyRemoteContactRouting(
|
|
fixture.Drive,
|
|
record,
|
|
remote,
|
|
Classify(hasContact: true, playerDistance: 200f),
|
|
target,
|
|
Quaternion.Identity,
|
|
willBeDrTicked: true);
|
|
|
|
Assert.Equal(
|
|
LiveEntityNetworkUpdateController.RemoteContactArm.AirborneSnap,
|
|
routing.Arm);
|
|
Assert.Equal(target, body.Position);
|
|
Assert.Equal(0, fixture.LiveOperationCount);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Per-entity independence across the two arms in the same tick: one
|
|
/// remote's committed placement must not touch another's body or leak
|
|
/// into its ledger.
|
|
/// </summary>
|
|
[Fact]
|
|
public void TwoRemotesInTheSameTick_FarAndNear_DoNotContaminateEachOther()
|
|
{
|
|
using var fixture = new RemotePlacementDriveFixture();
|
|
fixture.PublishDestinationCollision();
|
|
fixture.AllowDestination();
|
|
(RuntimeEntityRecord farRecord, RemoteMotion farRemote,
|
|
PhysicsBody farBody) = fixture.AddRemote(0x70004009u, Destination);
|
|
(RuntimeEntityRecord nearRecord, RemoteMotion nearRemote,
|
|
PhysicsBody nearBody) = fixture.AddRemote(0x7000400Au, Destination);
|
|
Vector3 nearBefore = nearBody.Position;
|
|
|
|
Assert.Equal(
|
|
LiveEntityNetworkUpdateController.RemoteContactArm.FarSnapPlacement,
|
|
LiveEntityNetworkUpdateController.ApplyRemoteContactRouting(
|
|
fixture.Drive,
|
|
farRecord,
|
|
farRemote,
|
|
Classify(hasContact: true, playerDistance: 200f),
|
|
DecoyWirePose,
|
|
Quaternion.Identity,
|
|
willBeDrTicked: true).Arm);
|
|
Assert.Equal(
|
|
LiveEntityNetworkUpdateController.RemoteContactArm
|
|
.SteadyStateInterpolate,
|
|
LiveEntityNetworkUpdateController.ApplyRemoteContactRouting(
|
|
fixture.Drive,
|
|
nearRecord,
|
|
nearRemote,
|
|
Classify(hasContact: true, playerDistance: 10f),
|
|
nearBefore + new Vector3(0.5f, 0f, 0f),
|
|
Quaternion.Identity,
|
|
willBeDrTicked: true).Arm);
|
|
|
|
Assert.Equal(
|
|
Destination + RemotePlacementDriveFixture.DestinationWorldOffset,
|
|
farBody.Position);
|
|
Assert.Equal(nearBefore, nearBody.Position);
|
|
|
|
fixture.DrainPlacementFifo();
|
|
Assert.Equal(0, fixture.LiveOperationCount);
|
|
Assert.Equal(0, fixture.RemotePlacementLedger);
|
|
}
|
|
|
|
/// <summary>
|
|
/// R10 review fix: <c>AirborneNoOperation</c> used to fall into
|
|
/// <c>default:</c>, whose comment ASSERTED unreachability that nothing
|
|
/// enforced — so a caller that skipped its own airborne-no-op early
|
|
/// return would have silently enqueued a waypoint on a branch where
|
|
/// retail writes nothing at all (@0x0051636D). The explicit case is what
|
|
/// makes the assertion true.
|
|
/// </summary>
|
|
[Fact]
|
|
public void AirborneNoOperationClassification_IsRejectedByTheRoutingSeam()
|
|
{
|
|
using var fixture = new RemotePlacementDriveFixture();
|
|
(RuntimeEntityRecord record, RemoteMotion remote, PhysicsBody body) =
|
|
fixture.AddRemote(0x7000400Du, Destination);
|
|
Vector3 before = body.Position;
|
|
|
|
RuntimeAuthoritativePositionRoute airborne =
|
|
Classify(hasContact: false, playerDistance: 200f);
|
|
Assert.Equal(
|
|
RuntimeAuthoritativePositionDisposition.NoPositionOperation,
|
|
airborne.Disposition);
|
|
|
|
Assert.Throws<InvalidOperationException>(() =>
|
|
LiveEntityNetworkUpdateController.ApplyRemoteContactRouting(
|
|
fixture.Drive,
|
|
record,
|
|
remote,
|
|
airborne,
|
|
new Vector3(60f, 10f, 7f),
|
|
Quaternion.Identity,
|
|
willBeDrTicked: true));
|
|
|
|
Assert.Equal(before, body.Position);
|
|
Assert.False(remote.Interp.IsActive);
|
|
Assert.Equal(0, fixture.LiveOperationCount);
|
|
}
|
|
|
|
// ── The NPC arm's post-routing wire-cell adoption ──────────────────────
|
|
|
|
/// <summary>
|
|
/// After a far snap the canonical placement owns the cell. The NPC arm's
|
|
/// wire-cell write sits AFTER its routing (the player arm's sits before),
|
|
/// and <c>RemoteMotion.CellId</c> writes through to the canonical
|
|
/// <c>FullCellId</c> — so an unguarded write would discard the resolved
|
|
/// cell the placement just committed.
|
|
/// </summary>
|
|
[Fact]
|
|
public void WireCellAdoption_IsSuppressedAfterAFarSnapAndRunsForEveryOtherArm()
|
|
{
|
|
using var fixture = new RemotePlacementDriveFixture();
|
|
(RuntimeEntityRecord record, RemoteMotion remote, _) =
|
|
fixture.AddRemote(0x7000400Bu, Destination);
|
|
uint resolved = remote.CellId;
|
|
Assert.Equal(RemotePlacementDriveFixture.SourceCell, resolved);
|
|
|
|
Assert.False(
|
|
LiveEntityNetworkUpdateController.TryAdoptWireCellAfterRouting(
|
|
remote,
|
|
LiveEntityNetworkUpdateController.RemoteContactArm
|
|
.FarSnapPlacement,
|
|
RemotePlacementDriveFixture.DestinationCell));
|
|
Assert.Equal(resolved, remote.CellId);
|
|
Assert.Equal(resolved, record.FullCellId);
|
|
|
|
foreach (LiveEntityNetworkUpdateController.RemoteContactArm arm in
|
|
new[]
|
|
{
|
|
LiveEntityNetworkUpdateController.RemoteContactArm.AirborneSnap,
|
|
LiveEntityNetworkUpdateController.RemoteContactArm
|
|
.SteadyStateInterpolate,
|
|
LiveEntityNetworkUpdateController.RemoteContactArm
|
|
.UnroutedCatchUp,
|
|
})
|
|
{
|
|
remote.CellId = RemotePlacementDriveFixture.SourceCell;
|
|
Assert.True(
|
|
LiveEntityNetworkUpdateController.TryAdoptWireCellAfterRouting(
|
|
remote,
|
|
arm,
|
|
RemotePlacementDriveFixture.DestinationCell));
|
|
Assert.Equal(
|
|
RemotePlacementDriveFixture.DestinationCell, remote.CellId);
|
|
}
|
|
}
|
|
|
|
private static RuntimeAuthoritativePositionRoute Classify(
|
|
bool hasContact,
|
|
float playerDistance,
|
|
uint committedCellId = RemotePlacementDriveFixture.SourceCell) =>
|
|
RuntimeAuthoritativePositionRouteClassifier.ClassifyAcceptedPosition(
|
|
new RuntimeAcceptedPositionRouteRequest(
|
|
new RuntimeAuthoritativePositionAuthority(
|
|
new RuntimeGenerationToken(7),
|
|
new RuntimeEntityKey(0x70000001u, 3),
|
|
PositionAuthorityVersion: 11UL,
|
|
AcceptedPositionSequence: 20,
|
|
PreviousTeleportSequence: 10,
|
|
AcceptedTeleportSequence: 10,
|
|
PositionTimestampDisposition.Apply),
|
|
RuntimePositionEntityKind.Remote,
|
|
RuntimeAcceptedPositionSource.PositionEvent,
|
|
new CreateObject.ServerPosition(
|
|
RemotePlacementDriveFixture.DestinationCell,
|
|
Destination.X,
|
|
Destination.Y,
|
|
Destination.Z,
|
|
1f,
|
|
0f,
|
|
0f,
|
|
0f),
|
|
PlacementFrame: 0u,
|
|
PositionPackVelocity: Vector3.Zero,
|
|
committedCellId,
|
|
hasContact,
|
|
playerDistance,
|
|
UsePositionFromServer: false,
|
|
HasAnimations: false,
|
|
default));
|
|
}
|