7f1c1f5aa6
Flips the SetPositionSimple classification (contact, PlayerDistance >= 96 m) for remotes onto 4b-1's drive controller and deletes both legacy far blocks, both duplicated 96f/4f constant pairs, and both `?? Vector3.Zero` fabrications. The 4 m constant now exists exactly once. Teleport and cell-less stay legacy for 4b-3. Retail: MoveOrTeleport @0x00516330's far branch runs StopInterpolating @0x005163CB before SetPositionSimple @0x005163D9 and returns 1 @0x005163E8 regardless — the SetPositionError is discarded — so HandleReceivedPosition arms ConstrainTo @0x00454272 post-move on commit AND on failure. The x87 parity decode at @0x00516393-@0x0051639E puts exactly 96.0 on the far branch. SetPositionSimple @0x005162B0 builds flags 0x1012 at @0x005162C4. Non-commit outcomes still advance the body, because retail's SetPositionInternal @0x00515BD0 commits the destination via store_position @0x00515CE2 when no cell resolves. The partition is by STAGE, not heuristic, enforced by an exhaustive switch: Refused/Contention/NotApplicable/RejectedPreparation store (the placement never executed); Committed/Deferred/RejectedByPlacement do not (the engine ran and refused, matching retail's non-storing returns @0x00515CB2 and @0x00515CD5). Without this a refused far snap froze the remote with an emptied queue. Also fixes a shipped defect this route made live: ParkDeferred's quiescence parks withdrew the entity (InWorld=false, clock suspended, residency removed) and were never restorable, while Forget(restoreCancelledPark: true) runs for every accepted Position on every entity. The restorable decision now lives inside ParkDeferred AFTER SnapToCell, reading body.CellPosition.ObjCellId — the value RestoreParkWithdrawal actually restores at — against every live quiescence rather than one minimum-OperationId token. The three pre-snap fields are hoisted into locals because SnapToCell ends with InWorld = true. ParkCollisionResidents passes restorableOnCancel: false explicitly; the plain unplaceable park is provably unchanged. RestoreParkWithdrawal re-tests the prefix at restore time so a retained route-2 park cannot re-admit into a prefix that began quiescing during the park. CanAttemptDestination is retained as an OPTIMISATION only, with the two Core predicates it cannot reproduce written down at the pre-flight, plus the two properties that depend on it staying there. Four fix rounds and eight Opus reviews. The slice was fully green at 10,990, 10,997 and 11,004 while containing real defects — a frozen remote pinned as correct by its own test, a fallback that over-wrote on the exact retail paths that decline to store, and a park guard incomplete on two independent axes. Register: AP-137 (leftover classifications take AP-87's catch-up; states the cell-less enqueue-vs-place delta deferred to 4b-3, that RejectedData is applied anyway, and the headless divergence), AP-138 (the refusable far placement), AP-136 narrowed to match the relocation. #309's acceptance steps rewritten — step 5 previously asserted a recovery the code does not perform — and gated on a new ACDREAM_PROBE_PARK=1 signal so the check cannot pass while broken. Suite 11,009 passed / 4 skipped / 0 failed against a measured 10,968 baseline. The 10,973 figure recorded earlier was wrong and is corrected here. Connected gate outstanding: the two-client far-snap walk and #309. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
582 lines
24 KiB
C#
582 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);
|
|
remote.Airborne = true;
|
|
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));
|
|
}
|