feat(runtime): C3c - production placement cutover: both hosts on the residence conductors (routes 1+8)
Campaign P remaining-physics-divergence, placement cutover slice C3c
(docs/plans/2026-08-02-placement-cutover.md). Both production hosts now
register every initial Create through the residence + continuation-
executor + first-entry-conductor machinery (C0-C3b):
- Graphical (route 1): RegisterEntityWithInitialResidence at Create; the
shared RuntimeFirstEntryDriveController pumps both conductors from the
placement-receipt flow; MaterializeProjection and RebucketLiveEntity
are presentation-only while a residence is ACTIVE (ExecutorCompleted is
the presentation-binding receipt); post-residence entities take the
full legacy path including the prepare_to_enter_world clock edges.
PlayerModeController attaches presentation to the Runtime-published
controller; its legacy resolve/step-heights/host-construction path is
deleted; presentation-only rollback (retail has no entry-flow rollback).
- Headless (route 8): OnSpawned registers with residence when a drive
exists; content-less sessions keep the pre-flip direct registration;
SynchronizeLocalPlayer/CreateController/ApplySetupStepHeights deleted;
prepared-collision read failure is a typed AwaitingCollisionSource
retry; far remotes outside the service window complete celless.
- RuntimeLocalPlayerMovementState.Controller setter sealed internal; all
controller mutation flows through the publication lifecycle.
Fix slices landed within this cutover, each dual-gated:
- F1: live movement-stat/server-physics application routed through the
Runtime ownership seam (post-logout ingest crash on the retired
controller eliminated; RuntimeMovementSkillProjection deleted).
- F2: login activation wedge - collision-admission prefix gate factored
out of the seal (reentrant-commit RejectedAuthority), rearm generation
identity corrected, PlayerModeAutoEntry requires the Runtime-published
controller (world reveal can no longer seal unmaterialized).
- F3: landblock-prefix 0-sentinel replaced by explicit absent-id guards;
map-corner landblocks (grid row/col 0) fully legal through admission,
park/rearm/retire, quiescence, and outdoor shadow seeds.
- F5: local-player first-entry ground contact seeded by the shared
SpawnPlacementSettler (moved App->Core) at FinalizeActivation - the
retail first-gravity-frame touch (enter_world 0x00516170 carries no
seed); the legacy unconditional force-seed is overwritten by a real
floor-found contact; airborne spawns stay airborne; outbound contact
bit verified end-to-end. Fixes the standing-cast 'You can't do that
while in the air!' rejections.
- R1 (dual-review round): login constraint leash armed at the committed
placement (HandleReceivedPosition 0x00453FD0 analog); register rows
AD-61 (settle-timing compression now covering the local player) and
AD-42 (repointed off the deleted resolve split) in this commit;
residence-conversion owner API; wire-landblock guards; drive-pending
ledger in IsConverged; route attach/detach latch; executor-drain drift
model documented + source-pinned.
Gates: Runtime 1,003, App 4,039/3 skips, Headless 79, complete solution
10,816/0 failed/4 skips (Release, -m:1); connected lifecycle/reconnect
gate PASS (logs/connected-world-gate-20260802-175401; graceful exits,
world-visible, zero airborne rejections). The nine-stop soak remains red
for the pre-existing 6b28ff99 whole-world collision-clone throughput
regression (attributed with evidence; scheduled as its own slice before
C5). Dual Opus reviews (retail-conformance + adversarial): delta PASS.
Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
This commit is contained in:
Erik
parent
78f1eb1896
commit
529e0e9d88
68 changed files with 5977 additions and 831 deletions
|
|
@ -104,18 +104,13 @@ public sealed class RuntimeLocalPlayerFirstEntryStateTests
|
|||
Assert.Equal(RuntimeLocalPlayerFirstEntryStatus.AwaitingActivation, second);
|
||||
Assert.Equal(1, fixture.Publication.CaptureOwnership().PendingActivationCount);
|
||||
|
||||
const ulong generation = 1UL;
|
||||
fixture.Lifetime.Physics.SetPosition.BeginCollisionGeneration(
|
||||
Cell & 0xFFFF0000u, generation);
|
||||
fixture.Lifetime.Physics.Engine.AddLandblock(
|
||||
Cell & 0xFFFF0000u,
|
||||
new TerrainSurface(new byte[81], new float[256]),
|
||||
Array.Empty<CellSurface>(),
|
||||
Array.Empty<PortalPlane>(),
|
||||
worldOffsetX: 0f,
|
||||
worldOffsetY: 0f);
|
||||
fixture.Lifetime.Physics.SetPosition.CommitCollisionGeneration(
|
||||
Cell & 0xFFFF0000u, generation, ready: true);
|
||||
// C3c-F2: the wake goes through the SAME owner production uses (the
|
||||
// collision admission ledger). Driving the SetPosition seam directly
|
||||
// leaves that ledger empty — a state production can never be in, and
|
||||
// the reason this very test did not catch the login activation wedge.
|
||||
CommitProductionCollisionGeneration(
|
||||
fixture.Lifetime.Physics,
|
||||
Cell & 0xFFFF0000u);
|
||||
|
||||
Assert.Equal(RuntimeLocalPlayerFirstEntryStatus.Completed,
|
||||
fixture.Advance(out RuntimeInitialCreateExecutionReceipt receipt));
|
||||
|
|
@ -603,18 +598,9 @@ public sealed class RuntimeLocalPlayerFirstEntryStateTests
|
|||
// AwaitingActivation retry test does.
|
||||
Assert.Equal(RuntimeLocalPlayerFirstEntryStatus.AwaitingActivation,
|
||||
fixture.Advance(out _));
|
||||
const ulong generation = 1UL;
|
||||
fixture.Lifetime.Physics.SetPosition.BeginCollisionGeneration(
|
||||
Cell & 0xFFFF0000u, generation);
|
||||
fixture.Lifetime.Physics.Engine.AddLandblock(
|
||||
Cell & 0xFFFF0000u,
|
||||
new TerrainSurface(new byte[81], new float[256]),
|
||||
Array.Empty<CellSurface>(),
|
||||
Array.Empty<PortalPlane>(),
|
||||
worldOffsetX: 0f,
|
||||
worldOffsetY: 0f);
|
||||
fixture.Lifetime.Physics.SetPosition.CommitCollisionGeneration(
|
||||
Cell & 0xFFFF0000u, generation, ready: true);
|
||||
CommitProductionCollisionGeneration(
|
||||
fixture.Lifetime.Physics,
|
||||
Cell & 0xFFFF0000u);
|
||||
|
||||
RuntimeLocalPlayerFirstEntryStatus status = fixture.Advance(
|
||||
out RuntimeInitialCreateExecutionReceipt receipt);
|
||||
|
|
@ -631,6 +617,63 @@ public sealed class RuntimeLocalPlayerFirstEntryStateTests
|
|||
// Helpers
|
||||
// ---------------------------------------------------------------
|
||||
|
||||
/// <summary>
|
||||
/// C3c-F2: publishes one landblock collision generation through the exact
|
||||
/// production owner chain — BeginCollisionAdmission -> prepare -> stage ->
|
||||
/// CommitCollisionGeneration — so a parked local-player activation wakes
|
||||
/// the way it does live, with RuntimePhysicsState's admission ledger
|
||||
/// populated and then retired.
|
||||
/// </summary>
|
||||
private static void CommitProductionCollisionGeneration(
|
||||
RuntimePhysicsState physics,
|
||||
uint landblockId)
|
||||
{
|
||||
RuntimeCollisionAdmission admission =
|
||||
physics.BeginCollisionAdmission(landblockId);
|
||||
using PreparedLandblockCollisionGeneration prepared =
|
||||
physics.PrepareCollisionGeneration(admission);
|
||||
physics.StageCollisionAssets(
|
||||
admission,
|
||||
prepared,
|
||||
new RuntimeLandblockCollisionAssets(
|
||||
landblockId,
|
||||
new TerrainSurface(new byte[81], new float[256]),
|
||||
Array.Empty<CellSurface>(),
|
||||
Array.Empty<PortalPlane>(),
|
||||
0f,
|
||||
0f,
|
||||
0u));
|
||||
for (int poll = 0; poll < 10_000; poll++)
|
||||
{
|
||||
while (physics.SetPosition.TryPeekProjection(
|
||||
out RuntimePlacementProjectionSnapshot projection))
|
||||
{
|
||||
Assert.True(physics.SetPosition.AcknowledgeProjection(
|
||||
projection.Token));
|
||||
}
|
||||
while (!physics.AdvanceCollisionRetainedOwnerCapture(
|
||||
admission,
|
||||
prepared).Completed)
|
||||
{
|
||||
}
|
||||
foreach (uint ownerId in prepared.RetainedOwnerIds)
|
||||
physics.RefreshCollisionRetainedOwner(admission, prepared, ownerId);
|
||||
RuntimeCollisionSealStep seal;
|
||||
do
|
||||
{
|
||||
seal = physics.AdvanceCollisionGenerationSeal(admission, prepared);
|
||||
}
|
||||
while (!seal.Completed && !seal.Restarted);
|
||||
if (!seal.Completed)
|
||||
continue;
|
||||
if (physics.CommitCollisionGeneration(admission, prepared).Completed)
|
||||
return;
|
||||
}
|
||||
|
||||
throw new InvalidOperationException(
|
||||
"Collision generation did not complete its Runtime mutation transaction.");
|
||||
}
|
||||
|
||||
private static (RuntimeEntityRecord Record, RuntimePlacementProjectionToken Token)
|
||||
BeginPendingOrdinaryPlacement(Fixture fixture, uint guid)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -244,4 +244,261 @@ public sealed class RuntimeLocalPlayerMovementStateTests
|
|||
|
||||
Assert.Equal(0L, allocated);
|
||||
}
|
||||
|
||||
// ── C3c-F1 (2026-08-02): movement-stats application seam ──────────────
|
||||
//
|
||||
// The typed seam is the ONLY route by which server stat recomputes
|
||||
// reach the controller; the publication lifecycle decides whether the
|
||||
// write lands (live/dormant) or is a typed displaced drop (terminal).
|
||||
|
||||
private static RuntimeMovementSkillState CompleteSkillState()
|
||||
{
|
||||
var skills = new RuntimeMovementSkillState();
|
||||
skills.Update(runSkill: 240, jumpSkill: 180);
|
||||
skills.UpdateBurden(0.5f);
|
||||
skills.UpdateStamina(37);
|
||||
// BF_PLAYER (0x8) + BF_PLAYER_KILLER (0x20) → ObjectInfoState.IsPK.
|
||||
skills.UpdateOwnPwdBitfield(0x28u);
|
||||
skills.UpdatePlayerKillerStatus(1, 123.5f);
|
||||
return skills;
|
||||
}
|
||||
|
||||
private static PlayerMovementController NewDormantRuntimeController()
|
||||
{
|
||||
PlayerMovementController controller =
|
||||
PlayerMovementController.CreatePublicationCandidate(
|
||||
new PhysicsEngine(),
|
||||
PlayerMovementConstructionOptions.Fallback);
|
||||
controller.SealPublicationCandidate();
|
||||
controller.CommitRuntimeOwnership(new RetailObjectQuantumClock());
|
||||
return controller;
|
||||
}
|
||||
|
||||
private static (float RunRate, float JumpVz, bool CanJump, int JumpCost,
|
||||
ObjectInfoState PvpFlags) CaptureStatObservables(
|
||||
PlayerMovementController controller)
|
||||
{
|
||||
IWeenieObject weenie = controller.Motion.WeenieObj!;
|
||||
Assert.True(weenie.InqRunRate(out float runRate));
|
||||
Assert.True(weenie.InqJumpVelocity(1.0f, out float jumpVz));
|
||||
bool canJump = weenie.CanJump(1.0f);
|
||||
Assert.True(((PlayerWeenie)weenie).JumpStaminaCost(1.0f, out int cost));
|
||||
return (runRate, jumpVz, canJump, cost, controller.OwnPvpFlags);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ApplyCharacterMovementStats_LiveApplicationIsByteIdenticalToTheRetiredDirectPath()
|
||||
{
|
||||
RuntimeMovementSkillState skills = CompleteSkillState();
|
||||
RuntimeMovementSkillSnapshot snapshot = skills.Snapshot;
|
||||
|
||||
// Old direct path (the deleted RuntimeMovementSkillProjection.ApplyTo
|
||||
// body), applied through the public gated setters.
|
||||
var direct = new PlayerMovementController(new PhysicsEngine());
|
||||
direct.SetCharacterSkills(snapshot.RunSkill, snapshot.JumpSkill);
|
||||
direct.SetCharacterBurden(snapshot.Burden);
|
||||
direct.SetCharacterStamina(snapshot.CurrentStamina);
|
||||
direct.OwnPvpFlags = EntityCollisionFlagsExt
|
||||
.FromPwdBitfield(snapshot.OwnPwdBitfield)
|
||||
.ToMoverState();
|
||||
direct.SetCharacterPkStatus(
|
||||
snapshot.PlayerKillerStatus,
|
||||
snapshot.LastPkAttackTimestamp);
|
||||
|
||||
var routed = new PlayerMovementController(new PhysicsEngine());
|
||||
using var movement = new RuntimeLocalPlayerMovementState
|
||||
{
|
||||
Controller = routed,
|
||||
};
|
||||
|
||||
Assert.Equal(
|
||||
RuntimeMovementStatsApplication.AppliedLive,
|
||||
movement.ApplyCharacterMovementStats(skills));
|
||||
Assert.Equal(
|
||||
CaptureStatObservables(direct),
|
||||
CaptureStatObservables(routed));
|
||||
Assert.Equal(ObjectInfoState.IsPK, routed.OwnPvpFlags);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ApplyCharacterMovementStats_DormantWindowWriteLandsOnTheControllerThatGoesLive()
|
||||
{
|
||||
RuntimeMovementSkillState skills = CompleteSkillState();
|
||||
PlayerMovementController controller = NewDormantRuntimeController();
|
||||
using var movement = new RuntimeLocalPlayerMovementState
|
||||
{
|
||||
Controller = controller,
|
||||
};
|
||||
|
||||
// The committed-but-unactivated first-entry window: the dormant
|
||||
// controller is installed in the movement owner while activation
|
||||
// waits on cell streaming, and inbound recomputes keep pumping.
|
||||
Assert.True(controller.IsRuntimeOwnedDormant);
|
||||
Assert.Throws<InvalidOperationException>(
|
||||
() => controller.SetCharacterSkills(1, 1));
|
||||
Assert.Equal(
|
||||
RuntimeMovementStatsApplication.AppliedDormant,
|
||||
movement.ApplyCharacterMovementStats(skills));
|
||||
|
||||
// Activation flips the SAME instance live — the applied values are
|
||||
// already current when movement starts.
|
||||
controller.ActivateRuntimePublication();
|
||||
Assert.True(controller.IsRuntimePublished);
|
||||
(float runRate, _, _, _, ObjectInfoState pvp) =
|
||||
CaptureStatObservables(controller);
|
||||
Assert.Equal(
|
||||
PlayerWeenie.GetRunRate(0.5f, 240),
|
||||
runRate,
|
||||
precision: 5);
|
||||
Assert.Equal(ObjectInfoState.IsPK, pvp);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ApplyCharacterMovementStats_TerminalControllerReportsTypedDisplacedDrop()
|
||||
{
|
||||
RuntimeMovementSkillState skills = CompleteSkillState();
|
||||
PlayerMovementController controller = NewDormantRuntimeController();
|
||||
using var movement = new RuntimeLocalPlayerMovementState
|
||||
{
|
||||
Controller = controller,
|
||||
};
|
||||
controller.ActivateRuntimePublication();
|
||||
var before = CaptureStatObservables(controller);
|
||||
// The Motion surface is gated once terminal; capture the weenie
|
||||
// reference while the controller is still published.
|
||||
IWeenieObject weenie = controller.Motion.WeenieObj!;
|
||||
|
||||
// Post-teardown transient truth: the controller retired while still
|
||||
// reachable through a displaced recompute callback. The public
|
||||
// setter still throws (the seal working); the seam reports the
|
||||
// typed drop instead and mutates nothing.
|
||||
controller.RetireRuntimePublication();
|
||||
Assert.Throws<InvalidOperationException>(
|
||||
() => controller.SetCharacterSkills(1, 1));
|
||||
Assert.Equal(
|
||||
RuntimeMovementStatsApplication.DroppedDisplacedController,
|
||||
movement.ApplyCharacterMovementStats(skills));
|
||||
|
||||
Assert.True(weenie.InqRunRate(out float runRate));
|
||||
Assert.Equal(before.RunRate, runRate);
|
||||
Assert.Equal(before.PvpFlags, controller.OwnPvpFlags);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ApplyCharacterMovementStats_SealedCandidateIsATypedDisplacedDrop()
|
||||
{
|
||||
// Defensive lifecycle-matrix row: a sealed candidate is frozen for
|
||||
// the Prepare→Commit validation handshake and never installed into
|
||||
// the movement owner in production (Prepare requires the owner
|
||||
// empty; Commit installs it already-dormant within the same
|
||||
// synchronous conductor step), so only a direct controller-level
|
||||
// call can observe this row.
|
||||
PlayerMovementController controller =
|
||||
PlayerMovementController.CreatePublicationCandidate(
|
||||
new PhysicsEngine(),
|
||||
PlayerMovementConstructionOptions.Fallback);
|
||||
controller.SealPublicationCandidate();
|
||||
|
||||
Assert.Equal(
|
||||
RuntimeMovementStatsApplication.DroppedDisplacedController,
|
||||
controller.ApplyCharacterMovementStats(
|
||||
CompleteSkillState().Snapshot));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ApplyCharacterMovementStats_AbsentControllerAndIncompleteSnapshotDropSilently()
|
||||
{
|
||||
var skills = new RuntimeMovementSkillState();
|
||||
using var movement = new RuntimeLocalPlayerMovementState();
|
||||
|
||||
Assert.Equal(
|
||||
RuntimeMovementStatsApplication.DroppedNoController,
|
||||
movement.ApplyCharacterMovementStats(skills));
|
||||
|
||||
movement.Controller = new PlayerMovementController(new PhysicsEngine());
|
||||
Assert.Equal(
|
||||
RuntimeMovementStatsApplication.DroppedIncompleteSnapshot,
|
||||
movement.ApplyCharacterMovementStats(skills));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ApplyCharacterMovementStats_DisposedOwnerToleratesTheDisplacedCallback()
|
||||
{
|
||||
var movement = new RuntimeLocalPlayerMovementState
|
||||
{
|
||||
Controller = new PlayerMovementController(new PhysicsEngine()),
|
||||
};
|
||||
movement.Dispose();
|
||||
|
||||
// The displaced-callback-rejection pattern: a recompute landing
|
||||
// after terminal disposal observes a typed drop, never a fault.
|
||||
Assert.Equal(
|
||||
RuntimeMovementStatsApplication.DroppedNoController,
|
||||
movement.ApplyCharacterMovementStats(CompleteSkillState()));
|
||||
Assert.False(movement.ReportExhaustion());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ReportExhaustion_DispatchesOnlyThroughALiveController()
|
||||
{
|
||||
using var movement = new RuntimeLocalPlayerMovementState();
|
||||
Assert.False(movement.ReportExhaustion());
|
||||
|
||||
PlayerMovementController controller = NewDormantRuntimeController();
|
||||
movement.Controller = controller;
|
||||
Assert.False(movement.ReportExhaustion());
|
||||
|
||||
controller.ActivateRuntimePublication();
|
||||
Assert.True(movement.ReportExhaustion());
|
||||
|
||||
controller.RetireRuntimePublication();
|
||||
Assert.False(movement.ReportExhaustion());
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ApplyServerPhysicsState_DormantDropsForActivationAndLiveAppliesExactly()
|
||||
{
|
||||
// The second connected-gate crash chain
|
||||
// (logs/connected-world-gate-20260802-125907): an inbound local-
|
||||
// player SetState pushed ApplyPhysicsState at the dormant
|
||||
// first-entry controller. The typed entry decides by lifecycle.
|
||||
PlayerMovementController controller =
|
||||
PlayerMovementController.CreatePublicationCandidate(
|
||||
new PhysicsEngine(),
|
||||
PlayerMovementConstructionOptions.Fallback);
|
||||
PhysicsBody body = controller.PhysicsBody;
|
||||
PhysicsStateFlags initial = body.State;
|
||||
PhysicsStateFlags pushed =
|
||||
PhysicsStateFlags.Gravity
|
||||
| PhysicsStateFlags.ReportCollisions
|
||||
| PhysicsStateFlags.Ethereal;
|
||||
Assert.NotEqual(initial, pushed);
|
||||
|
||||
controller.SealPublicationCandidate();
|
||||
controller.CommitRuntimeOwnership(new RetailObjectQuantumClock());
|
||||
|
||||
// Dormant: the activation transaction owns the dormant body's
|
||||
// physics state; the push is dropped and the body is untouched.
|
||||
Assert.Equal(
|
||||
RuntimeServerPhysicsStateApplication.DroppedDormantActivationOwned,
|
||||
controller.ApplyServerPhysicsState(pushed));
|
||||
Assert.Equal(initial, body.State);
|
||||
|
||||
// Published: byte-identical to the direct ApplyPhysicsState body.
|
||||
controller.ActivateRuntimePublication();
|
||||
Assert.Equal(
|
||||
RuntimeServerPhysicsStateApplication.AppliedLive,
|
||||
controller.ApplyServerPhysicsState(pushed));
|
||||
Assert.Equal(pushed, body.State);
|
||||
|
||||
// Terminal: a displaced push, typed instead of a fault, mutating
|
||||
// nothing.
|
||||
controller.RetireRuntimePublication();
|
||||
Assert.Throws<InvalidOperationException>(
|
||||
() => controller.ApplyPhysicsState(initial));
|
||||
Assert.Equal(
|
||||
RuntimeServerPhysicsStateApplication.DroppedDisplacedController,
|
||||
controller.ApplyServerPhysicsState(initial));
|
||||
Assert.Equal(pushed, body.State);
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -198,6 +198,175 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
|
|||
Assert.True(body.InWorld);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// C3c-F5: retail seeds the local player's ground contact from the first
|
||||
/// gravity frame after <c>enter_world</c> (SmartBox::HandleCreateObject
|
||||
/// 0x00454C80 → init_player 0x00455010 → CPhysicsObj::enter_world
|
||||
/// 0x00516170; SetPosition records no touch), which the activation
|
||||
/// compresses through the shared #270 settle sweep. Spawn (1,2,3) with a
|
||||
/// flat floor at 2.7 — feet 0.3 m above it, inside the 0.5 m settle
|
||||
/// reach — and the production human bottom-sphere origin (0.475) so the
|
||||
/// authored placement itself stands clear of the floor.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void CommitActivationOnFlatGroundSeedsRetailFirstGravityFrameContact()
|
||||
{
|
||||
using var fixture = new Fixture(
|
||||
residentWorld: true,
|
||||
terrainHeight: 2.7f,
|
||||
moverSphereOriginZ: 0.475f);
|
||||
Assert.Equal(RuntimeLocalPlayerPhysicsPublicationStatus.Committed,
|
||||
fixture.Owner.Commit(
|
||||
fixture.Prepare(),
|
||||
out RuntimeLocalPlayerPhysicsActivationToken token));
|
||||
Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.Evaluated,
|
||||
fixture.Owner.EvaluateActivation(token, out var evaluation));
|
||||
|
||||
Assert.Equal(RuntimeDormantSetPositionCommitStatus.Committed,
|
||||
fixture.Owner.CommitActivation(evaluation, out _));
|
||||
|
||||
PhysicsBody body = Assert.IsType<PhysicsBody>(fixture.Record.PhysicsBody);
|
||||
Assert.True(body.InWorld);
|
||||
Assert.True(body.InContact);
|
||||
Assert.True(body.OnWalkable);
|
||||
Assert.True(body.ContactPlaneValid);
|
||||
Assert.True(body.ContactPlane.Normal.Z > 0.9f);
|
||||
// The settle snapped the feet onto the floor, exactly like retail's
|
||||
// first gravity frame.
|
||||
Assert.InRange(body.Position.Z, 2.65f, 2.76f);
|
||||
PlayerMovementController controller =
|
||||
Assert.IsType<PlayerMovementController>(
|
||||
fixture.Movement.Controller);
|
||||
// The exact outbound predicate LocalPlayerOutboundController
|
||||
// serializes as the wire contact bit (InContact && OnWalkable).
|
||||
Assert.True(controller.CanSendPositionEvent);
|
||||
Assert.True(controller.CaptureMovementResult(
|
||||
mouseLookEvent: false).IsOnGround);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// C3c-F5 counterpart: a spawn with no floor within the settle's reach
|
||||
/// (flat terrain at 0, feet at 3) must stay genuinely airborne — the
|
||||
/// seed only ever commits contact the sweep actually found, exactly
|
||||
/// like retail's fall after enter_world.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void CommitActivationOverVoidLeavesFirstEntryGenuinelyAirborne()
|
||||
{
|
||||
using var fixture = new Fixture(
|
||||
residentWorld: true,
|
||||
moverSphereOriginZ: 0.475f);
|
||||
Assert.Equal(RuntimeLocalPlayerPhysicsPublicationStatus.Committed,
|
||||
fixture.Owner.Commit(
|
||||
fixture.Prepare(),
|
||||
out RuntimeLocalPlayerPhysicsActivationToken token));
|
||||
Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.Evaluated,
|
||||
fixture.Owner.EvaluateActivation(token, out var evaluation));
|
||||
|
||||
Assert.Equal(RuntimeDormantSetPositionCommitStatus.Committed,
|
||||
fixture.Owner.CommitActivation(evaluation, out _));
|
||||
|
||||
PhysicsBody body = Assert.IsType<PhysicsBody>(fixture.Record.PhysicsBody);
|
||||
Assert.True(body.InWorld);
|
||||
Assert.False(body.InContact);
|
||||
Assert.False(body.OnWalkable);
|
||||
Assert.False(body.ContactPlaneValid);
|
||||
Assert.Equal(3f, body.Position.Z);
|
||||
PlayerMovementController controller =
|
||||
Assert.IsType<PlayerMovementController>(
|
||||
fixture.Movement.Controller);
|
||||
Assert.False(controller.CanSendPositionEvent);
|
||||
Assert.False(controller.CaptureMovementResult(
|
||||
mouseLookEvent: false).IsOnGround);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// C3c-R1 review R1: the login constraint leash. Retail arms the leash
|
||||
/// at every accepted-position event (SmartBox::HandleReceivedPosition
|
||||
/// 0x00453FD0); the flip deleted the App-side login arm
|
||||
/// (CommitPreparedPosition), so the dormant activation's final commit
|
||||
/// must arm it — anchored at the committed placement (already
|
||||
/// floor-snapped by the faithful placement transaction), before the
|
||||
/// compressed first-gravity-frame settle runs, exactly like retail arms
|
||||
/// at the received position and only then simulates the first frame.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void CommitActivationArmsTheLoginConstraintLeashAtTheCommittedPlacement()
|
||||
{
|
||||
using var fixture = new Fixture(
|
||||
residentWorld: true,
|
||||
terrainHeight: 2.7f,
|
||||
moverSphereOriginZ: 0.475f);
|
||||
Assert.Equal(RuntimeLocalPlayerPhysicsPublicationStatus.Committed,
|
||||
fixture.Owner.Commit(
|
||||
fixture.Prepare(),
|
||||
out RuntimeLocalPlayerPhysicsActivationToken token));
|
||||
Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.Evaluated,
|
||||
fixture.Owner.EvaluateActivation(token, out var evaluation));
|
||||
|
||||
Assert.Equal(RuntimeDormantSetPositionCommitStatus.Committed,
|
||||
fixture.Owner.CommitActivation(evaluation, out _));
|
||||
|
||||
PlayerMovementController controller =
|
||||
Assert.IsType<PlayerMovementController>(
|
||||
fixture.Movement.Controller);
|
||||
ConstraintManager? constraint =
|
||||
controller.PositionManager?.Constraint;
|
||||
Assert.NotNull(constraint);
|
||||
Assert.True(constraint!.IsConstrained);
|
||||
// The anchor cell is the placement's committed containing cell.
|
||||
Assert.Equal(
|
||||
controller.PhysicsBody.CellPosition.ObjCellId,
|
||||
constraint.ConstraintPos.ObjCellId);
|
||||
// Anchored at the committed (floor-snapped) placement pose.
|
||||
Assert.InRange(
|
||||
constraint.ConstraintPos.Frame.Origin.Z, 2.65f, 2.76f);
|
||||
Assert.InRange(
|
||||
controller.PhysicsBody.Position.Z, 2.65f, 2.76f);
|
||||
Assert.Equal(
|
||||
ConstraintDistance.GetStartConstraintDistance(
|
||||
constraint.ConstraintPos.ObjCellId),
|
||||
constraint.ConstraintDistanceStart);
|
||||
Assert.Equal(
|
||||
ConstraintDistance.GetMaxConstraintDistance(
|
||||
constraint.ConstraintPos.ObjCellId),
|
||||
constraint.ConstraintDistanceMax);
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// C3c-R1 review R1: the arm is exactly-once — the successful final
|
||||
/// commit nulls the activation envelope, so a stale CommitActivation
|
||||
/// retry is RejectedAuthority and can never re-arm the leash.
|
||||
/// </summary>
|
||||
[Fact]
|
||||
public void CommitActivationNeverRearmsTheLeashOnAStaleRetry()
|
||||
{
|
||||
using var fixture = new Fixture(
|
||||
residentWorld: true,
|
||||
terrainHeight: 2.7f,
|
||||
moverSphereOriginZ: 0.475f);
|
||||
Assert.Equal(RuntimeLocalPlayerPhysicsPublicationStatus.Committed,
|
||||
fixture.Owner.Commit(
|
||||
fixture.Prepare(),
|
||||
out RuntimeLocalPlayerPhysicsActivationToken token));
|
||||
Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.Evaluated,
|
||||
fixture.Owner.EvaluateActivation(token, out var evaluation));
|
||||
Assert.Equal(RuntimeDormantSetPositionCommitStatus.Committed,
|
||||
fixture.Owner.CommitActivation(evaluation, out _));
|
||||
PlayerMovementController controller =
|
||||
Assert.IsType<PlayerMovementController>(
|
||||
fixture.Movement.Controller);
|
||||
Assert.True(
|
||||
controller.PositionManager!.Constraint!.IsConstrained);
|
||||
|
||||
controller.PositionManager.UnConstrain();
|
||||
Assert.Equal(RuntimeDormantSetPositionCommitStatus.RejectedAuthority,
|
||||
fixture.Owner.CommitActivation(evaluation, out _));
|
||||
|
||||
Assert.False(
|
||||
controller.PositionManager.Constraint.IsConstrained);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void DeferredActivationEvaluationLeavesExactOwnedGraphDormantAndRetryable()
|
||||
{
|
||||
|
|
@ -356,10 +525,117 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
|
|||
Assert.Equal(1, fixture.Owner.CaptureOwnership()
|
||||
.PendingActivationCount);
|
||||
|
||||
const ulong generation = 1UL;
|
||||
fixture.Lifetime.Physics.SetPosition.BeginCollisionGeneration(
|
||||
Cell & 0xFFFF0000u,
|
||||
generation);
|
||||
// C3c-F2: the wake is driven through the SAME owner production uses
|
||||
// (RuntimePhysicsState's collision admission), not through the raw
|
||||
// SetPosition seam. Driving SetPosition directly leaves the admission
|
||||
// ledger empty, which is a state production can never be in and which
|
||||
// hid the login rearm wedge this test is supposed to cover.
|
||||
CommitProductionCollisionGeneration(fixture, Cell & 0xFFFF0000u);
|
||||
|
||||
Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.Evaluated,
|
||||
fixture.Owner.EvaluateActivation(token, out var ready));
|
||||
Assert.Equal(RuntimeDormantSetPositionCommitStatus.Committed,
|
||||
fixture.Owner.CommitActivation(ready, out var projection));
|
||||
Assert.True(projection.IsValid);
|
||||
Assert.True(fixture.Record.PhysicsBody!.InWorld);
|
||||
Assert.Equal(0, fixture.Owner.CaptureOwnership()
|
||||
.PendingActivationCount);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void DeferredCommitRearmsAfterProductionAdmissionCommitsItsGeneration()
|
||||
{
|
||||
// C3c-F2 regression (the connected-gate login wedge). The sibling
|
||||
// test above wakes the parked lease by calling BeginCollisionGeneration
|
||||
// / CommitCollisionGeneration DIRECTLY on the SetPosition state, which
|
||||
// leaves RuntimePhysicsState's admission ledger empty. PRODUCTION
|
||||
// always wakes through BeginCollisionAdmission -> stage ->
|
||||
// CommitCollisionGeneration, and that path retires the admission the
|
||||
// instant the generation commits — after which
|
||||
// ExpectedCollisionGeneration names the NEXT, never-begun generation.
|
||||
// The rearm must key off the generation the collision world now HOLDS.
|
||||
using var fixture = new Fixture();
|
||||
Assert.Equal(RuntimeLocalPlayerPhysicsPublicationStatus.Committed,
|
||||
fixture.Owner.Commit(
|
||||
fixture.Prepare(),
|
||||
out RuntimeLocalPlayerPhysicsActivationToken token));
|
||||
Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.DeferredCell,
|
||||
fixture.Owner.EvaluateActivation(token, out var deferred));
|
||||
Assert.Equal(RuntimeDormantSetPositionCommitStatus.DeferredCell,
|
||||
fixture.Owner.CommitActivation(deferred, out var noProjection));
|
||||
Assert.False(noProjection.IsValid);
|
||||
Assert.False(fixture.Record.PhysicsBody!.InWorld);
|
||||
Assert.False(fixture.Movement.Controller!.IsRuntimePublished);
|
||||
Assert.Equal(1, fixture.Owner.CaptureOwnership()
|
||||
.PendingActivationCount);
|
||||
|
||||
RuntimeCollisionAdmission admission = fixture.Lifetime.Physics
|
||||
.BeginCollisionAdmission(Cell & 0xFFFF0000u);
|
||||
// While the destination admission is in flight the lease must simply
|
||||
// keep waiting — never a rejection, never an early rearm.
|
||||
Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.DeferredCell,
|
||||
fixture.Owner.EvaluateActivation(token, out var waiting));
|
||||
Assert.False(waiting.IsValid);
|
||||
using PreparedLandblockCollisionGeneration prepared = fixture
|
||||
.Lifetime.Physics.PrepareCollisionGeneration(admission);
|
||||
fixture.Lifetime.Physics.StageCollisionAssets(
|
||||
admission,
|
||||
prepared,
|
||||
CollisionAssets(Cell & 0xFFFF0000u));
|
||||
Assert.True(CommitPrepared(
|
||||
fixture.Lifetime.Physics,
|
||||
admission,
|
||||
prepared).Committed);
|
||||
|
||||
// The exact divergence this test pins: the committed authority is the
|
||||
// generation the lease parked on; "expected" has already moved past it.
|
||||
Assert.Equal(
|
||||
admission.Generation,
|
||||
fixture.Lifetime.Physics.CollisionGenerationAuthority(Cell));
|
||||
Assert.NotEqual(
|
||||
admission.Generation,
|
||||
fixture.Lifetime.Physics.ExpectedCollisionGeneration(Cell));
|
||||
|
||||
Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.Evaluated,
|
||||
fixture.Owner.EvaluateActivation(token, out var ready));
|
||||
Assert.Equal(RuntimeDormantSetPositionCommitStatus.Committed,
|
||||
fixture.Owner.CommitActivation(ready, out var projection));
|
||||
Assert.True(projection.IsValid);
|
||||
Assert.True(fixture.Record.PhysicsBody!.InWorld);
|
||||
Assert.NotNull(fixture.Record.PhysicsHost);
|
||||
Assert.True(fixture.Movement.Controller!.IsRuntimePublished);
|
||||
Assert.Equal(0, fixture.Owner.CaptureOwnership()
|
||||
.PendingActivationCount);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void DeferredCommitStaysParkedWhileTheCommittingAdmissionIsStillRegistered()
|
||||
{
|
||||
// C3c-F2, the link the live probe caught: the collision-generation
|
||||
// commit marks the parked lease ready and only THEN retires its
|
||||
// admission (RuntimePhysicsState.cs:2503 vs :2552-2558). Production
|
||||
// reenters the first-entry pump inside that window. Rearming there
|
||||
// moves the lease out of AwaitingCell and its very next evaluation
|
||||
// fails the seal on the still-registered admission — after which
|
||||
// EvaluateActivation can no longer answer DeferredCell and reports
|
||||
// RejectedAuthority, which is TERMINAL for the conductor. The lease
|
||||
// must stay parked and retryable instead.
|
||||
using var fixture = new Fixture();
|
||||
Assert.Equal(RuntimeLocalPlayerPhysicsPublicationStatus.Committed,
|
||||
fixture.Owner.Commit(
|
||||
fixture.Prepare(),
|
||||
out RuntimeLocalPlayerPhysicsActivationToken token));
|
||||
Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.DeferredCell,
|
||||
fixture.Owner.EvaluateActivation(token, out var deferred));
|
||||
Assert.Equal(RuntimeDormantSetPositionCommitStatus.DeferredCell,
|
||||
fixture.Owner.CommitActivation(deferred, out _));
|
||||
|
||||
RuntimeCollisionAdmission admission = fixture.Lifetime.Physics
|
||||
.BeginCollisionAdmission(Cell & 0xFFFF0000u);
|
||||
// Reconstruct the exact production instant: the landblock is in the
|
||||
// engine and the parked lease has been marked ready by the SAME call
|
||||
// RuntimePhysicsState.cs:2503 makes, while the admission that is
|
||||
// committing has not yet been retired (:2552-2558).
|
||||
fixture.Lifetime.Physics.Engine.AddLandblock(
|
||||
Cell & 0xFFFF0000u,
|
||||
new TerrainSurface(new byte[81], new float[256]),
|
||||
|
|
@ -369,8 +645,39 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
|
|||
worldOffsetY: 0f);
|
||||
fixture.Lifetime.Physics.SetPosition.CommitCollisionGeneration(
|
||||
Cell & 0xFFFF0000u,
|
||||
generation,
|
||||
admission.Generation,
|
||||
ready: true);
|
||||
Assert.Equal(
|
||||
admission.Generation,
|
||||
fixture.Lifetime.Physics.CollisionGenerationAuthority(Cell));
|
||||
Assert.Equal(
|
||||
admission.Generation,
|
||||
fixture.Lifetime.Physics.ExpectedCollisionGeneration(Cell));
|
||||
Assert.False(fixture.Lifetime.Physics
|
||||
.IsCollisionEvaluationPrefixAdmissible(Cell));
|
||||
|
||||
Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.DeferredCell,
|
||||
fixture.Owner.EvaluateActivation(token, out var stillWaiting));
|
||||
Assert.False(stillWaiting.IsValid);
|
||||
Assert.Equal(1, fixture.Owner.CaptureOwnership()
|
||||
.PendingActivationCount);
|
||||
Assert.False(fixture.Record.PhysicsBody!.InWorld);
|
||||
Assert.False(fixture.Movement.Controller!.IsRuntimePublished);
|
||||
|
||||
using (PreparedLandblockCollisionGeneration prepared = fixture
|
||||
.Lifetime.Physics.PrepareCollisionGeneration(admission))
|
||||
{
|
||||
fixture.Lifetime.Physics.StageCollisionAssets(
|
||||
admission,
|
||||
prepared,
|
||||
CollisionAssets(Cell & 0xFFFF0000u));
|
||||
Assert.True(CommitPrepared(
|
||||
fixture.Lifetime.Physics,
|
||||
admission,
|
||||
prepared).Committed);
|
||||
}
|
||||
Assert.True(fixture.Lifetime.Physics
|
||||
.IsCollisionEvaluationPrefixAdmissible(Cell));
|
||||
|
||||
Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.Evaluated,
|
||||
fixture.Owner.EvaluateActivation(token, out var ready));
|
||||
|
|
@ -378,6 +685,7 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
|
|||
fixture.Owner.CommitActivation(ready, out var projection));
|
||||
Assert.True(projection.IsValid);
|
||||
Assert.True(fixture.Record.PhysicsBody!.InWorld);
|
||||
Assert.True(fixture.Movement.Controller!.IsRuntimePublished);
|
||||
Assert.Equal(0, fixture.Owner.CaptureOwnership()
|
||||
.PendingActivationCount);
|
||||
}
|
||||
|
|
@ -562,15 +870,9 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
|
|||
Assert.Equal(0, fixture.Lifetime.Physics.Engine.ShadowObjects
|
||||
.PendingSetPositionDispatchCount);
|
||||
|
||||
const ulong generation = 1UL;
|
||||
fixture.Lifetime.Physics.SetPosition.BeginCollisionGeneration(
|
||||
Cell & 0xFFFF0000u, generation);
|
||||
fixture.Lifetime.Physics.Engine.AddLandblock(
|
||||
Cell & 0xFFFF0000u,
|
||||
new TerrainSurface(new byte[81], new float[256]),
|
||||
Array.Empty<CellSurface>(), Array.Empty<PortalPlane>(), 0f, 0f);
|
||||
fixture.Lifetime.Physics.SetPosition.CommitCollisionGeneration(
|
||||
Cell & 0xFFFF0000u, generation, ready: true);
|
||||
// C3c-F2: production wake path (collision admission), see
|
||||
// CommitProductionCollisionGeneration.
|
||||
CommitProductionCollisionGeneration(fixture, Cell & 0xFFFF0000u);
|
||||
Assert.Equal(RuntimeLocalPlayerPhysicsActivationStatus.Evaluated,
|
||||
fixture.Owner.EvaluateActivation(token, out var ready));
|
||||
Assert.Equal(RuntimeDormantSetPositionCommitStatus.Committed,
|
||||
|
|
@ -2192,6 +2494,11 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
|
|||
private sealed class Fixture : IDisposable
|
||||
{
|
||||
private bool _lifetimeDisposed;
|
||||
// C3c-F5: default 0 keeps every pre-existing test's mover shape
|
||||
// byte-identical; the first-entry settle tests pass the production
|
||||
// human Setup's bottom-sphere origin (0.475) so an authored
|
||||
// placement can stand clear of a floor the settle then reaches.
|
||||
private readonly float _moverSphereOriginZ;
|
||||
|
||||
internal Fixture(
|
||||
bool preparePlacement = true,
|
||||
|
|
@ -2199,11 +2506,13 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
|
|||
RuntimeLocalPlayerShadowDisposition shadowDisposition =
|
||||
RuntimeLocalPlayerShadowDisposition.ProvenShapeless,
|
||||
float terrainHeight = 0f,
|
||||
float moverSphereOriginZ = 0f,
|
||||
Vector3? initialVelocity = null,
|
||||
Vector3? initialOmega = null,
|
||||
float? initialFriction = null,
|
||||
float? initialElasticity = null)
|
||||
{
|
||||
_moverSphereOriginZ = moverSphereOriginZ;
|
||||
if (residentWorld)
|
||||
{
|
||||
var engine = new PhysicsEngine
|
||||
|
|
@ -2269,7 +2578,9 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
|
|||
Assert.True(Placement.IsValid);
|
||||
var setup = new FlatSetupCollision(
|
||||
ImmutableArray<FlatCollisionCylinder>.Empty,
|
||||
[new FlatCollisionSphere(Vector3.Zero, 0.48f)],
|
||||
[new FlatCollisionSphere(
|
||||
new Vector3(0f, 0f, _moverSphereOriginZ),
|
||||
0.48f)],
|
||||
height: 0f,
|
||||
radius: 0f,
|
||||
stepUpHeight: 0.4f,
|
||||
|
|
@ -2537,6 +2848,31 @@ public sealed class RuntimeLocalPlayerPhysicsPublicationStateTests
|
|||
"Collision generation did not complete its Runtime mutation transaction.");
|
||||
}
|
||||
|
||||
/// <summary>
|
||||
/// C3c-F2: publishes one landblock collision generation through the exact
|
||||
/// production owner chain — BeginCollisionAdmission -> prepare -> stage ->
|
||||
/// CommitCollisionGeneration. Waking a parked activation any other way
|
||||
/// (calling the SetPosition seam directly) leaves RuntimePhysicsState's
|
||||
/// admission ledger empty, a state production can never reach.
|
||||
/// </summary>
|
||||
private static void CommitProductionCollisionGeneration(
|
||||
Fixture fixture,
|
||||
uint landblockId)
|
||||
{
|
||||
RuntimeCollisionAdmission admission = fixture.Lifetime.Physics
|
||||
.BeginCollisionAdmission(landblockId);
|
||||
using PreparedLandblockCollisionGeneration prepared = fixture
|
||||
.Lifetime.Physics.PrepareCollisionGeneration(admission);
|
||||
fixture.Lifetime.Physics.StageCollisionAssets(
|
||||
admission,
|
||||
prepared,
|
||||
CollisionAssets(landblockId));
|
||||
Assert.True(CommitPrepared(
|
||||
fixture.Lifetime.Physics,
|
||||
admission,
|
||||
prepared).Committed);
|
||||
}
|
||||
|
||||
private static RuntimeLandblockCollisionAssets CollisionAssets(
|
||||
uint landblockId) => new(
|
||||
landblockId,
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue