2e8e09acd0
Builds the machinery route 4b-2 and 4b-3 will flip on, and changes no remote behaviour: it has no production caller, so RemotePlacementDrivePendingCount is provably 0 and IsConverged is unchanged. Five pieces: a per-entity remote placement owner (RuntimeRemotePlacementDriveController), a Position-time service-window guard with a Runtime interface plus BOTH host implementations, N3's headless RetryPending pump, parked-count observability in the ownership ledger, and the service-window optimisation that avoids parks we can cheaply predict. Landed alone because it is where the park-withdraws-the-entity failure was decided; that decision is fixed at the source in the preceding commit and must not share a review signal with a behaviour flip. Two parts of route 2's controller are deliberately NOT ported, both verified against retail rather than assumed. There is no ack: SendPositionEvent is called only inside HandleReceivedPosition's local-player FORCE_POSITION gate @0x0045400C-@0x00454091, and the remote arm @0x0045414D has no equivalent. There is no re-issue funnel: retail never re-attempts a position it could not apply — stale timestamps merely bump error_count @0x004542AC — and re-issuing packet N after N+1 has merged would apply a pose the newer packet already superseded, which is correct for a one-shot ForcePosition and wrong for a 5-10 Hz stream. The service-window guard is an OPTIMISATION, not the correctness mechanism. The original contract had it the other way round, justified by a claim that retail cannot represent "arrived but not placeable" — false, and corrected in the review findings: retail's GotoLostCell/reenter_visibility path represents it exactly. A pre-flight guard also cannot be complete, because Core defers on the entity's CURRENT cell, on the swept QueriedCellIds footprint spanning neighbouring landblocks, and on residency evaluated after AdjustToOutside — conditions only Core can see. Review found and this commit fixes: DetachRoute cleared two maps of LIVE Core operations without cancelling them (route 2's AbandonPending is the correct mirror, not the first-entry controller) and its test asserted that blindness as convergence; the headless predicate answered "can ever publish" rather than "is published", and after the first fix still matched only 1 of the 9 landblocks this host publishes; OwnsPlacement admitted remote top-level Creates until gated on the Teleport flag as well as the disposition; Advance re-submitted without re-checking the window; and four comments cited a report that did not exist. Contract item 6 is met by the structural proof, not the earlier test: HasOldPrefixPlacementDebt refuses collision-prefix mutation permission before ParkCollisionResidents is ever entered, so its overlap throw is unreachable. That same mechanism is the unbounded stall filed as #310, which 4b-1 does not bound — it only avoids widening it. #311 files the remaining per-tick allocation in RetryPendingProjections; the early-out for the empty-FIFO case landed via a new HasPendingReceipts accessor so hosts still never touch .Placements. directly. Gates: complete Release solution 10,973 passed / 4 skipped / 0 failed (baseline 10,938). Four review rounds; every fix discrimination-verified by revert. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
1789 lines
68 KiB
C#
1789 lines
68 KiB
C#
using System.Buffers.Binary;
|
||
using System.Collections.Immutable;
|
||
using System.Net;
|
||
using System.Numerics;
|
||
using System.Reflection;
|
||
using AcDream.Core.Net;
|
||
using AcDream.Core.Net.Messages;
|
||
using AcDream.Core.Physics;
|
||
using AcDream.Headless.Configuration;
|
||
using AcDream.Headless.Credentials;
|
||
using AcDream.Headless.Diagnostics;
|
||
using AcDream.Headless.Hosting;
|
||
using AcDream.Headless.Platform;
|
||
using AcDream.Runtime;
|
||
using AcDream.Runtime.Entities;
|
||
using AcDream.Runtime.Gameplay;
|
||
using AcDream.Runtime.Physics;
|
||
using AcDream.Runtime.Session;
|
||
using AcDream.Runtime.World;
|
||
|
||
namespace AcDream.Headless.Tests;
|
||
|
||
public sealed class HeadlessSessionHostTests
|
||
{
|
||
[Fact]
|
||
public void SingleSessionStartsReconnectsAndConvergesWithoutPresentation()
|
||
{
|
||
var operations = new FixtureSessionOperations();
|
||
using var diagnosticsOutput = new StringWriter();
|
||
using var credential = new HeadlessCredentialSecret(
|
||
"fixture",
|
||
"password");
|
||
var host = new HeadlessSessionHost(
|
||
Descriptor(),
|
||
credential,
|
||
new HeadlessDiagnosticWriter(diagnosticsOutput),
|
||
operations);
|
||
|
||
RuntimeSessionStartResult first = host.Start();
|
||
ulong firstGeneration = host.Runtime.Generation.Value;
|
||
host.Tick(0.015d);
|
||
RuntimeSessionStartResult second = host.Reconnect();
|
||
|
||
Assert.Equal(RuntimeSessionStartStatus.Connected, first.Status);
|
||
Assert.Equal(RuntimeSessionStartStatus.Connected, second.Status);
|
||
Assert.Equal(0x50000002u, first.CharacterId);
|
||
Assert.Equal("Headless", host.ActiveCharacterName);
|
||
Assert.True(host.Runtime.Session.IsInWorld);
|
||
Assert.True(host.Runtime.Generation.Value > firstGeneration);
|
||
Assert.Equal(2, operations.CreatedSessionCount);
|
||
Assert.Equal(1, operations.DisposedSessionCount);
|
||
|
||
host.Dispose();
|
||
|
||
Assert.Equal(2, operations.DisposedSessionCount);
|
||
Assert.True(host.Runtime.CaptureOwnership().IsConverged);
|
||
Assert.True(credential.IsDisposed);
|
||
string diagnostics = diagnosticsOutput.ToString();
|
||
Assert.Contains("\"state\":\"start-result\"", diagnostics);
|
||
Assert.DoesNotContain("password", diagnostics);
|
||
Assert.DoesNotContain("AcDream.App", diagnostics);
|
||
}
|
||
|
||
[Fact]
|
||
public async Task ProcessHostRunsUntilCancellationAndReturnsStableExitCode()
|
||
{
|
||
var configuration = new HeadlessConfiguration
|
||
{
|
||
Version = 1,
|
||
Sessions =
|
||
[
|
||
Descriptor(
|
||
HeadlessCredentialProviderKind.StandardInput,
|
||
"stdin-bot"),
|
||
],
|
||
};
|
||
HeadlessPathSet paths = HeadlessPathSet.Resolve(
|
||
new HeadlessPathOverrides());
|
||
using var diagnostics = new StringWriter();
|
||
var operations = new FixtureSessionOperations();
|
||
using var host = new HeadlessProcessHost(
|
||
configuration,
|
||
paths,
|
||
new System.IO.StringReader(
|
||
"process-password" + Environment.NewLine),
|
||
diagnostics,
|
||
operations);
|
||
using var cancellation = new CancellationTokenSource();
|
||
cancellation.Cancel();
|
||
|
||
HeadlessExitCode result =
|
||
await host.RunAsync(cancellation.Token);
|
||
|
||
Assert.Equal(HeadlessExitCode.Success, result);
|
||
Assert.True(host.Session.Runtime.Session.IsInWorld);
|
||
Assert.DoesNotContain(
|
||
"process-password",
|
||
diagnostics.ToString());
|
||
}
|
||
|
||
[Fact]
|
||
public async Task DirectCredentialsOverrideSingleConfiguredSession()
|
||
{
|
||
var configuration = new HeadlessConfiguration
|
||
{
|
||
Version = 1,
|
||
Sessions = [Descriptor()],
|
||
};
|
||
HeadlessPathSet paths = HeadlessPathSet.Resolve(
|
||
new HeadlessPathOverrides());
|
||
using var diagnostics = new StringWriter();
|
||
var operations = new FixtureSessionOperations();
|
||
using var host = new HeadlessProcessHost(
|
||
configuration,
|
||
paths,
|
||
TextReader.Null,
|
||
diagnostics,
|
||
operations,
|
||
directCredentials: new HeadlessDirectCredentials(
|
||
"direct-account",
|
||
"direct-secret"));
|
||
using var cancellation = new CancellationTokenSource();
|
||
cancellation.Cancel();
|
||
|
||
HeadlessExitCode result =
|
||
await host.RunAsync(cancellation.Token);
|
||
|
||
Assert.Equal(HeadlessExitCode.Success, result);
|
||
Assert.Equal("direct-account", operations.LastUser);
|
||
Assert.Equal("direct-secret", operations.LastPassword);
|
||
Assert.DoesNotContain(
|
||
"direct-secret",
|
||
diagnostics.ToString());
|
||
}
|
||
|
||
[Fact]
|
||
public void DirectFrameUsesSharedRetailOrderAndMovementCadence()
|
||
{
|
||
var operations = new FixtureSessionOperations();
|
||
using var credential = new HeadlessCredentialSecret(
|
||
"fixture",
|
||
"password");
|
||
using var host = new HeadlessSessionHost(
|
||
Descriptor(),
|
||
credential,
|
||
new HeadlessDiagnosticWriter(TextWriter.Null),
|
||
operations);
|
||
Assert.Equal(
|
||
RuntimeSessionStartStatus.Connected,
|
||
host.Start().Status);
|
||
HydrateGroundedPlayer(host.Runtime);
|
||
var sent = new List<(byte[] Body, double Time)>();
|
||
var trace = new RuntimeTraceRecorder();
|
||
using IDisposable subscription =
|
||
host.Runtime.Subscribe(trace);
|
||
operations.Sessions[^1].GameActionCapture =
|
||
body => sent.Add((
|
||
body,
|
||
host.Runtime.Clock.SimulationTimeSeconds));
|
||
|
||
RuntimeCommandResult intent = host.Commands.Movement.SetIntent(
|
||
host.Runtime.Generation,
|
||
new MovementInput(Forward: true, Run: true));
|
||
host.Tick(0.015d);
|
||
|
||
Assert.True(intent.Accepted);
|
||
Assert.Contains(
|
||
trace.Entries,
|
||
static entry =>
|
||
entry.Kind == RuntimeTraceKind.Movement);
|
||
Assert.Equal(
|
||
[
|
||
MoveToState.MoveToStateAction,
|
||
AutonomousPosition.AutonomousPositionAction,
|
||
],
|
||
sent.Select(static entry =>
|
||
ActionOpcode(entry.Body)).ToArray());
|
||
|
||
sent.Clear();
|
||
for (int index = 0; index < 70; index++)
|
||
host.Tick(0.015d);
|
||
|
||
(byte[] Body, double Time)[] positions = sent
|
||
.Where(static entry =>
|
||
ActionOpcode(entry.Body)
|
||
== AutonomousPosition.AutonomousPositionAction)
|
||
.ToArray();
|
||
Assert.InRange(positions.Length, 1, 2);
|
||
Assert.True(positions[^1].Time >= 1d);
|
||
if (positions.Length == 2)
|
||
{
|
||
Assert.True(
|
||
positions[1].Time - positions[0].Time >= 0.99d);
|
||
}
|
||
Assert.DoesNotContain(
|
||
sent,
|
||
entry => ActionOpcode(entry.Body)
|
||
== MoveToState.MoveToStateAction);
|
||
}
|
||
|
||
[Fact]
|
||
public void TeardownRetriesOnlyTheUnfinishedSuffix()
|
||
{
|
||
var operations = new FixtureSessionOperations();
|
||
var writer = new FailOnceTextWriter();
|
||
using var credential = new HeadlessCredentialSecret(
|
||
"fixture",
|
||
"password");
|
||
var host = new HeadlessSessionHost(
|
||
Descriptor(),
|
||
credential,
|
||
new HeadlessDiagnosticWriter(writer),
|
||
operations);
|
||
Assert.Equal(
|
||
RuntimeSessionStartStatus.Connected,
|
||
host.Start().Status);
|
||
writer.FailNextWrite = true;
|
||
|
||
Assert.Throws<IOException>(host.Dispose);
|
||
Assert.Equal(1, operations.DisposedSessionCount);
|
||
|
||
host.Dispose();
|
||
|
||
Assert.Equal(1, operations.DisposedSessionCount);
|
||
Assert.True(host.Runtime.CaptureOwnership().IsConverged);
|
||
}
|
||
|
||
/// <summary>
|
||
/// B5(a) review fix: <see cref="HeadlessSessionEventRouteRetryPendingTests"/>
|
||
/// proved the underlying re-offer MECHANISM works, but hand-constructed
|
||
/// <see cref="HeadlessSessionEventRoute"/> directly and called
|
||
/// <c>route.RetryPending()</c> itself — it never touches
|
||
/// <see cref="HeadlessSessionHost.Tick"/>'s own
|
||
/// <c>_eventRoute?.RetryPending()</c> call. This test drives <c>Tick</c>
|
||
/// itself (via the <c>placementSinkOverride</c> test seam added for this
|
||
/// fix, mirroring the existing <c>policyOverride</c> parameter) so a
|
||
/// regression that deletes or reorders that exact line would fail HERE,
|
||
/// not just in the lower-level subscription test.
|
||
/// </summary>
|
||
[Fact]
|
||
public void TickRetriesAPreviouslyDeclinedPlacementThroughTheRealEventRoute()
|
||
{
|
||
const uint remote = 0x70004301u;
|
||
const uint landblock = 0xA9B40000u;
|
||
const uint cell = landblock | 0x0001u;
|
||
const float height = 6f;
|
||
|
||
var operations = new FixtureSessionOperations();
|
||
using var credential = new HeadlessCredentialSecret(
|
||
"fixture",
|
||
"password");
|
||
var sink = new DecliningThenAcceptingPlacementSink();
|
||
using var host = new HeadlessSessionHost(
|
||
Descriptor(),
|
||
credential,
|
||
new HeadlessDiagnosticWriter(TextWriter.Null),
|
||
operations,
|
||
placementSinkOverride: sink);
|
||
GameRuntime runtime = host.Runtime;
|
||
Assert.Equal(
|
||
RuntimeSessionStartStatus.Connected,
|
||
host.Start().Status);
|
||
|
||
runtime.EntityObjects.Physics.ObserveLocalWorldFrame(
|
||
cell, teleportAdvanced: false);
|
||
runtime.EntityObjects.Physics.SetPosition.BeginCollisionGeneration(
|
||
landblock, 1UL);
|
||
AddFlatLandblock(runtime.EntityObjects.Physics.Engine);
|
||
runtime.EntityObjects.Physics.SetPosition.CommitCollisionGeneration(
|
||
landblock, 1UL, ready: true);
|
||
|
||
RuntimeEntityRecord record = runtime.EntityObjects
|
||
.RegisterEntity(Spawn(remote, cell))
|
||
.Canonical!;
|
||
runtime.EntityObjects.Entities.SetFinalPhysicsState(
|
||
record, PhysicsStateFlags.Gravity);
|
||
runtime.EntityObjects.Entities.SetFullCell(
|
||
record, cell, landblock);
|
||
var body = new PhysicsBody
|
||
{
|
||
Position = new Vector3(10f, 10f, height),
|
||
Orientation = Quaternion.Identity,
|
||
LastUpdateTime = 1d,
|
||
State = PhysicsStateFlags.Gravity,
|
||
TransientState = TransientStateFlags.Active,
|
||
};
|
||
body.SnapToCell(cell, body.Position, body.Position);
|
||
runtime.EntityObjects.Entities.SetPhysicsBody(record, body);
|
||
record.ObjectClock.Activate();
|
||
runtime.EntityObjects.Physics.AcknowledgeSpatialProjection(
|
||
record, spatial: true);
|
||
|
||
RuntimeEntityPlacementToken token = runtime.EntityObjects.Physics
|
||
.SetPosition.TryBeginExclusiveAuthoredPlacement(
|
||
record,
|
||
record.PositionAuthorityVersion,
|
||
RuntimeSetPositionOperationKind.RemoteAuthoritative);
|
||
Assert.True(token.IsValid);
|
||
RuntimeSetPositionMoverPreparationStatus status = runtime.EntityObjects
|
||
.Physics.SetPosition.TryPrepareAndSubmitAuthoredPlacement(
|
||
record,
|
||
token,
|
||
RuntimeSetPositionOperationKind.RemoteAuthoritative,
|
||
PhysicsSetPositionFlags.Teleport | PhysicsSetPositionFlags.Slide,
|
||
new LoadedSetupCollisionSource(),
|
||
gameTime: runtime.Clock.SimulationTimeSeconds,
|
||
out RuntimeSetPositionOutcome outcome,
|
||
resolveWorldOffsetFromRuntimeFrame: true);
|
||
Assert.Equal(RuntimeSetPositionMoverPreparationStatus.Prepared, status);
|
||
Assert.Equal(
|
||
RuntimeSetPositionStatus.CommittedHostAcknowledgementPending,
|
||
outcome.Status);
|
||
|
||
// The production HeadlessSessionEventRoute's subscription attached
|
||
// during host.Start() already observed this Place synchronously —
|
||
// the fake sink is still declining, so it must remain unacknowledged.
|
||
Assert.Equal(1, sink.CallCount);
|
||
Assert.True(
|
||
runtime.EntityObjects.Physics.SetPosition.TryPeekProjection(
|
||
out _));
|
||
|
||
// The sink starts accepting (mirrors a landblock finishing streaming
|
||
// in) — driving ONE real host tick is what must re-offer the head,
|
||
// through Tick's own wiring, not a hand-built route.
|
||
sink.Accept = true;
|
||
host.Tick(0.015d);
|
||
|
||
Assert.Equal(2, sink.CallCount);
|
||
Assert.False(
|
||
runtime.EntityObjects.Physics.SetPosition.TryPeekProjection(
|
||
out _));
|
||
}
|
||
|
||
private sealed class DecliningThenAcceptingPlacementSink
|
||
: IRuntimePlacementProjectionSink
|
||
{
|
||
internal int CallCount { get; private set; }
|
||
internal bool Accept { get; set; }
|
||
|
||
public bool TryApply(in RuntimePlacementProjectionSnapshot projection)
|
||
{
|
||
CallCount++;
|
||
return Accept;
|
||
}
|
||
}
|
||
|
||
[Fact]
|
||
public void WorldProjectionHydratesCanonicalMovementAndTeleportState()
|
||
{
|
||
var operations = new FixtureSessionOperations();
|
||
using var credential = new HeadlessCredentialSecret(
|
||
"fixture",
|
||
"password");
|
||
using var host = new HeadlessSessionHost(
|
||
Descriptor(),
|
||
credential,
|
||
new HeadlessDiagnosticWriter(TextWriter.Null),
|
||
operations);
|
||
GameRuntime runtime = host.Runtime;
|
||
// C3c: conductor-driven flow — a live generation admits the initial
|
||
// residence, the flat landblock's collision generation commits, and
|
||
// the world projection's pump drives the local first-entry conductor
|
||
// to completion (the deleted SynchronizeLocalPlayer hand-copy's
|
||
// replacement).
|
||
Assert.Equal(
|
||
RuntimeSessionStartStatus.Connected,
|
||
host.Start().Status);
|
||
const uint player = 0x50000002u;
|
||
runtime.PlayerIdentity.ServerGuid = player;
|
||
runtime.EntityObjects.Physics.SetPosition.BeginCollisionGeneration(
|
||
0xA9B40000u, 1UL);
|
||
AddFlatLandblock(runtime.EntityObjects.Physics.Engine);
|
||
runtime.EntityObjects.Physics.SetPosition.CommitCollisionGeneration(
|
||
0xA9B40000u, 1UL, ready: true);
|
||
AcDream.Runtime.Session.RuntimeFirstEntryDriveController firstEntry =
|
||
CreateFirstEntryDrive(runtime);
|
||
RuntimeEntityRecord record = runtime.EntityObjects
|
||
.RegisterEntityWithInitialResidence(Spawn(player), isLocalPlayer: true)
|
||
.Canonical!;
|
||
Assert.True(runtime.EntityObjects.ApplyAcceptedSpawn(
|
||
record,
|
||
record.CreateIntegrationVersion,
|
||
record.Snapshot,
|
||
replaceGeneration: false));
|
||
var collision = new FixtureCollisionNeighborhood();
|
||
var projection = new HeadlessSessionWorldProjection(
|
||
runtime,
|
||
collision,
|
||
firstEntry);
|
||
|
||
projection.ProjectSpawn(record, isLocalPlayer: true);
|
||
PlayerMovementController controller =
|
||
Assert.IsType<PlayerMovementController>(
|
||
runtime.MovementOwner.Controller);
|
||
controller.SetPosition(
|
||
new Vector3(48f, 49f, 50f),
|
||
0xA9B40001u);
|
||
projection.ProjectPosition(
|
||
record,
|
||
isLocalPlayer: true,
|
||
PositionTimestampDisposition.Apply);
|
||
|
||
Assert.Same(controller, runtime.MovementOwner.Controller);
|
||
Assert.Equal(record.LocalEntityId, controller.LocalEntityId);
|
||
Assert.Equal(new Vector3(48f, 49f, 50f), controller.Position);
|
||
Assert.Equal(
|
||
0xA9B40000u,
|
||
controller.CellId & 0xFFFF0000u);
|
||
Assert.True((controller.CellId & 0xFFFFu) < 0x0100u);
|
||
projection.BeginTeleport();
|
||
Assert.Equal(PlayerState.PortalSpace, controller.State);
|
||
|
||
RuntimeDestinationReadiness readiness =
|
||
projection.PrepareDestination(
|
||
revealGeneration: 7,
|
||
new RuntimeTeleportDestination(
|
||
player,
|
||
InstanceSequence: 1,
|
||
PositionSequence: 2,
|
||
TeleportSequence: 1,
|
||
ForcePositionSequence: 0,
|
||
new Position(
|
||
0xA9B40001u,
|
||
new Vector3(96f, 97f, 50f),
|
||
Quaternion.Identity)));
|
||
|
||
Assert.True(readiness.IsCollisionReady);
|
||
Assert.False(readiness.IsUnhydratable);
|
||
Assert.Equal(PlayerState.InWorld, controller.State);
|
||
Assert.Equal(3, collision.CenterCount);
|
||
Assert.Equal(0xA9B40001u, collision.LastCell);
|
||
}
|
||
|
||
[Fact]
|
||
public void WorldProjectionIgnoresNormalEchoButBlipsForcePosition()
|
||
{
|
||
var operations = new FixtureSessionOperations();
|
||
using var credential = new HeadlessCredentialSecret(
|
||
"fixture",
|
||
"password");
|
||
using var host = new HeadlessSessionHost(
|
||
Descriptor(),
|
||
credential,
|
||
new HeadlessDiagnosticWriter(TextWriter.Null),
|
||
operations);
|
||
GameRuntime runtime = host.Runtime;
|
||
// C3c: conductor-driven flow — a live generation admits the initial
|
||
// residence, the flat landblock's collision generation commits, and
|
||
// the world projection's pump drives the local first-entry conductor
|
||
// to completion (the deleted SynchronizeLocalPlayer hand-copy's
|
||
// replacement).
|
||
Assert.Equal(
|
||
RuntimeSessionStartStatus.Connected,
|
||
host.Start().Status);
|
||
const uint player = 0x50000003u;
|
||
runtime.PlayerIdentity.ServerGuid = player;
|
||
runtime.EntityObjects.Physics.SetPosition.BeginCollisionGeneration(
|
||
0xA9B40000u, 1UL);
|
||
AddFlatLandblock(runtime.EntityObjects.Physics.Engine);
|
||
runtime.EntityObjects.Physics.SetPosition.CommitCollisionGeneration(
|
||
0xA9B40000u, 1UL, ready: true);
|
||
AcDream.Runtime.Session.RuntimeFirstEntryDriveController firstEntry =
|
||
CreateFirstEntryDrive(runtime);
|
||
RuntimeEntityRecord record = runtime.EntityObjects
|
||
.RegisterEntityWithInitialResidence(Spawn(player), isLocalPlayer: true)
|
||
.Canonical!;
|
||
Assert.True(runtime.EntityObjects.ApplyAcceptedSpawn(
|
||
record,
|
||
record.CreateIntegrationVersion,
|
||
record.Snapshot,
|
||
replaceGeneration: false));
|
||
var collision = new FixtureCollisionNeighborhood();
|
||
var projection = new HeadlessSessionWorldProjection(
|
||
runtime,
|
||
collision,
|
||
firstEntry);
|
||
projection.ProjectSpawn(record, isLocalPlayer: true);
|
||
PlayerMovementController controller =
|
||
Assert.IsType<PlayerMovementController>(
|
||
runtime.MovementOwner.Controller);
|
||
|
||
controller.SetPosition(
|
||
new Vector3(48f, 49f, 50f),
|
||
0xA9B40001u);
|
||
projection.ProjectPosition(
|
||
record,
|
||
isLocalPlayer: true,
|
||
PositionTimestampDisposition.Apply);
|
||
|
||
Assert.Equal(new Vector3(48f, 49f, 50f), controller.Position);
|
||
|
||
var force = new WorldSession.EntityPositionUpdate(
|
||
player,
|
||
record.Snapshot.Position!.Value with
|
||
{
|
||
PositionX = 72f,
|
||
PositionY = 73f,
|
||
},
|
||
Velocity: null,
|
||
PlacementId: null,
|
||
IsGrounded: true,
|
||
InstanceSequence: 1,
|
||
PositionSequence: 2,
|
||
TeleportSequence: 0,
|
||
ForcePositionSequence: 1);
|
||
Assert.True(runtime.EntityObjects.TryApplyPosition(
|
||
force,
|
||
isLocalPlayer: true,
|
||
forcePositionRotation: Quaternion.Identity,
|
||
currentLocalVelocity: controller.BodyVelocity,
|
||
projectionRequiresTeleportHook: false,
|
||
acknowledgeProjection: null,
|
||
out PositionTimestampDisposition disposition,
|
||
out _,
|
||
out AcceptedPhysicsTimestamps timestamps));
|
||
Assert.Equal(
|
||
PositionTimestampDisposition.ForcePosition,
|
||
disposition);
|
||
|
||
// C4 route 2 (2026-08-03): a ForcePosition on the local player no
|
||
// longer routes through HeadlessSessionWorldProjection.ProjectPosition
|
||
// at all — RuntimeLiveEntitySessionController.OnPositionUpdated
|
||
// dispatches it directly to RuntimeAcceptedPositionDriveController
|
||
// instead (the deleted BlipLocalPlayer's replacement), but R2 review
|
||
// fix (2026-08-03): it re-centers the collision neighborhood on the
|
||
// destination FIRST — the deleted BlipLocalPlayer's own CenterOn
|
||
// side effect, restored via CenterOnAcceptedForcePosition, because a
|
||
// DeferredCell park this neighborhood's window can never publish is
|
||
// a dead end, not a real park
|
||
// (RuntimeAcceptedPositionDriveController.Advance's R1 doc comment).
|
||
projection.CenterOnAcceptedForcePosition(record);
|
||
RuntimeAcceptedPositionDriveController acceptedPositionDrive =
|
||
CreateAcceptedPositionDrive(runtime);
|
||
RuntimeAcceptedPositionExecutionStatus forceStatus =
|
||
acceptedPositionDrive.TryExecuteAcceptedLocalPosition(
|
||
record,
|
||
force,
|
||
disposition,
|
||
timestamps,
|
||
timestamps.PreviousTeleport);
|
||
|
||
Assert.Equal(
|
||
RuntimeAcceptedPositionExecutionStatus.Committed,
|
||
forceStatus);
|
||
// R7 review fix (2026-08-03): Z is 50.005f — within 5 mm of the
|
||
// wire's bare 50f — NOT 50.48f. The dat-exact human Setup's foot
|
||
// sphere is (0,0,0.475) r=.48 (LoadedSetupCollisionSource above);
|
||
// its bottom sits at origin + 0.475 − 0.48 = origin − 0.005, so a
|
||
// settled origin lands 0.005 m ABOVE the floor it rests on (measured
|
||
// empirically against this exact fixture), not a full sphere RADIUS
|
||
// above it. Retail's BlipPlayer (CPhysicsObj::SetPositionSimple
|
||
// @0x005162B0, called from SmartBox::BlipPlayer @0x00453940) has
|
||
// never lifted the origin by a sphere radius — the C4-route-2 FIRST
|
||
// implementation pass (uncommitted; this file asserts a bare 50f at
|
||
// HEAD, never 50.48f) had fitted a 50.48f assertion to a dummy
|
||
// fixture sphere whose offset happened to equal its own radius, not
|
||
// to retail behavior. The comment it carried described the sphere's
|
||
// CENTRE, then wrongly asserted that description about
|
||
// controller.Position, which is the body's ORIGIN
|
||
// (PlayerMovementController.cs -> PhysicsBody.cs Position), not the
|
||
// sphere centre.
|
||
Assert.Equal(new Vector3(72f, 73f, 50.005f), controller.Position);
|
||
// CenterCount is 2: ProjectSpawn's initial centering plus the
|
||
// ForcePosition's own re-centering above (R2's restored mechanism).
|
||
Assert.Equal(2, collision.CenterCount);
|
||
}
|
||
|
||
/// <summary>
|
||
/// C3c-R1 review F7: a remote Create whose landblock lies outside the
|
||
/// bounded collision neighborhood's service window can never see its
|
||
/// deferred placement's collision-generation wake — left alone it would
|
||
/// pin its residence (and the drive's pending entry) for the whole
|
||
/// session. The host converts it to the celless completion route before
|
||
/// the pump: the residence completes with FullCell 0, the accepted wire
|
||
/// frame stays on the canonical snapshot (the exact pre-flip
|
||
/// accepted-frame behavior for far remotes), and every ledger converges.
|
||
/// </summary>
|
||
[Fact]
|
||
public void FarRemoteCreateCompletesCelllessWithoutPinningItsResidence()
|
||
{
|
||
var operations = new FixtureSessionOperations();
|
||
using var credential = new HeadlessCredentialSecret(
|
||
"fixture",
|
||
"password");
|
||
using var host = new HeadlessSessionHost(
|
||
Descriptor(),
|
||
credential,
|
||
new HeadlessDiagnosticWriter(TextWriter.Null),
|
||
operations);
|
||
GameRuntime runtime = host.Runtime;
|
||
Assert.Equal(
|
||
RuntimeSessionStartStatus.Connected,
|
||
host.Start().Status);
|
||
const uint player = 0x5000000Bu;
|
||
runtime.PlayerIdentity.ServerGuid = player;
|
||
runtime.EntityObjects.Physics.SetPosition.BeginCollisionGeneration(
|
||
0xA9B40000u, 1UL);
|
||
AddFlatLandblock(runtime.EntityObjects.Physics.Engine);
|
||
runtime.EntityObjects.Physics.SetPosition.CommitCollisionGeneration(
|
||
0xA9B40000u, 1UL, ready: true);
|
||
AcDream.Runtime.Session.RuntimeFirstEntryDriveController firstEntry =
|
||
CreateFirstEntryDrive(runtime);
|
||
var collision = new FixtureCollisionNeighborhood();
|
||
var projection = new HeadlessSessionWorldProjection(
|
||
runtime,
|
||
collision,
|
||
firstEntry);
|
||
RuntimeEntityRecord playerRecord = runtime.EntityObjects
|
||
.RegisterEntityWithInitialResidence(Spawn(player), isLocalPlayer: true)
|
||
.Canonical!;
|
||
Assert.True(runtime.EntityObjects.ApplyAcceptedSpawn(
|
||
playerRecord,
|
||
playerRecord.CreateIntegrationVersion,
|
||
playerRecord.Snapshot,
|
||
replaceGeneration: false));
|
||
projection.ProjectSpawn(playerRecord, isLocalPlayer: true);
|
||
|
||
const uint farRemote = 0x70000010u;
|
||
const uint farCell = 0x00010001u;
|
||
Assert.False(collision.IsWithinServiceWindow(farCell));
|
||
RuntimeEntityRecord remote = runtime.EntityObjects
|
||
.RegisterEntityWithInitialResidence(
|
||
Spawn(farRemote, farCell),
|
||
isLocalPlayer: false)
|
||
.Canonical!;
|
||
Assert.True(runtime.EntityObjects.ApplyAcceptedSpawn(
|
||
remote,
|
||
remote.CreateIntegrationVersion,
|
||
remote.Snapshot,
|
||
replaceGeneration: false));
|
||
|
||
projection.ProjectSpawn(remote, isLocalPlayer: false);
|
||
|
||
// Celless completion: no pinned residence, FullCell stays 0, the
|
||
// accepted wire frame survives on the canonical snapshot.
|
||
Assert.False(runtime.EntityObjects.TryGetInitialCreateResidence(
|
||
remote,
|
||
out _));
|
||
Assert.Equal(0u, remote.FullCellId);
|
||
Assert.Equal(
|
||
farCell,
|
||
remote.Snapshot.Position!.Value.LandblockId);
|
||
RuntimeEntityObjectOwnershipSnapshot ownership =
|
||
runtime.EntityObjects.CaptureOwnership();
|
||
Assert.Equal(0, ownership.InitialCreateResidenceLeaseCount);
|
||
Assert.Equal(0, ownership.FirstEntryDrivePendingCount);
|
||
Assert.Equal(0, firstEntry.PendingCount);
|
||
|
||
// Draining the placement FIFO the way the host subscription would
|
||
// converges the completion-receipt ledger too.
|
||
while (runtime.EntityObjects.Physics.SetPosition.TryPeekProjection(
|
||
out RuntimePlacementProjectionSnapshot head))
|
||
{
|
||
if (!runtime.EntityObjects.Physics.SetPosition
|
||
.AcknowledgeProjection(head.Token))
|
||
{
|
||
break;
|
||
}
|
||
}
|
||
Assert.Equal(
|
||
0,
|
||
runtime.EntityObjects.CaptureOwnership()
|
||
.PendingCompletionReceiptCount);
|
||
}
|
||
|
||
[Fact]
|
||
public void PlacementReceiptValidationDoesNotRegainMovementOrPhysicsAuthority()
|
||
{
|
||
var operations = new FixtureSessionOperations();
|
||
using var credential = new HeadlessCredentialSecret(
|
||
"fixture",
|
||
"password");
|
||
using var host = new HeadlessSessionHost(
|
||
Descriptor(),
|
||
credential,
|
||
new HeadlessDiagnosticWriter(TextWriter.Null),
|
||
operations);
|
||
GameRuntime runtime = host.Runtime;
|
||
// C3c: conductor-driven flow — a live generation admits the initial
|
||
// residence, the flat landblock's collision generation commits, and
|
||
// the world projection's pump drives the local first-entry conductor
|
||
// to completion (the deleted SynchronizeLocalPlayer hand-copy's
|
||
// replacement).
|
||
Assert.Equal(
|
||
RuntimeSessionStartStatus.Connected,
|
||
host.Start().Status);
|
||
const uint player = 0x50000004u;
|
||
runtime.PlayerIdentity.ServerGuid = player;
|
||
runtime.EntityObjects.Physics.SetPosition.BeginCollisionGeneration(
|
||
0xA9B40000u, 1UL);
|
||
AddFlatLandblock(runtime.EntityObjects.Physics.Engine);
|
||
runtime.EntityObjects.Physics.SetPosition.CommitCollisionGeneration(
|
||
0xA9B40000u, 1UL, ready: true);
|
||
AcDream.Runtime.Session.RuntimeFirstEntryDriveController firstEntry =
|
||
CreateFirstEntryDrive(runtime);
|
||
RuntimeEntityRecord record = runtime.EntityObjects
|
||
.RegisterEntityWithInitialResidence(Spawn(player), isLocalPlayer: true)
|
||
.Canonical!;
|
||
Assert.True(runtime.EntityObjects.ApplyAcceptedSpawn(
|
||
record,
|
||
record.CreateIntegrationVersion,
|
||
record.Snapshot,
|
||
replaceGeneration: false));
|
||
var directProjection = new HeadlessSessionWorldProjection(
|
||
runtime,
|
||
new FixtureCollisionNeighborhood(),
|
||
firstEntry);
|
||
directProjection.ProjectSpawn(record, isLocalPlayer: true);
|
||
PlayerMovementController controller = Assert.IsType<
|
||
PlayerMovementController>(runtime.MovementOwner.Controller);
|
||
Vector3 positionBefore = controller.Position;
|
||
Quaternion orientationBefore = controller.BodyOrientation;
|
||
RuntimePhysicsOwnershipSnapshot physicsBefore =
|
||
runtime.EntityObjects.Physics.CaptureOwnership();
|
||
RuntimePlacementProjectionSnapshot receipt = Placement(
|
||
runtime,
|
||
record,
|
||
RuntimePlacementProjectionKind.Place,
|
||
new Vector3(600f, 601f, 602f),
|
||
Quaternion.CreateFromAxisAngle(Vector3.UnitY, 1.2f));
|
||
|
||
var receiptSink = new HeadlessRuntimePlacementProjectionSink(runtime);
|
||
Assert.True(receiptSink.TryApply(in receipt));
|
||
|
||
Assert.Equal(positionBefore, controller.Position);
|
||
Assert.Equal(orientationBefore, controller.BodyOrientation);
|
||
Assert.Equal(
|
||
physicsBefore,
|
||
runtime.EntityObjects.Physics.CaptureOwnership());
|
||
}
|
||
|
||
[Fact]
|
||
public void PlacementReceiptUsesExactIncarnationAndDiscardIsAckOnly()
|
||
{
|
||
var operations = new FixtureSessionOperations();
|
||
using var credential = new HeadlessCredentialSecret(
|
||
"fixture",
|
||
"password");
|
||
using var host = new HeadlessSessionHost(
|
||
Descriptor(),
|
||
credential,
|
||
new HeadlessDiagnosticWriter(TextWriter.Null),
|
||
operations);
|
||
GameRuntime runtime = host.Runtime;
|
||
RuntimeEntityRecord record = runtime.EntityObjects
|
||
.RegisterEntity(Spawn(0x50000005u))
|
||
.Canonical!;
|
||
Assert.True(runtime.EntityObjects.ApplyAcceptedSpawn(
|
||
record,
|
||
record.CreateIntegrationVersion,
|
||
record.Snapshot,
|
||
replaceGeneration: false));
|
||
var projection = new HeadlessRuntimePlacementProjectionSink(runtime);
|
||
RuntimePlacementProjectionSnapshot place = Placement(
|
||
runtime,
|
||
record,
|
||
RuntimePlacementProjectionKind.Place,
|
||
Vector3.One,
|
||
Quaternion.Identity);
|
||
RuntimePlacementProjectionSnapshot stale = place with
|
||
{
|
||
Token = place.Token with
|
||
{
|
||
Entity = place.Token.Entity with
|
||
{
|
||
Incarnation = unchecked((ushort)(
|
||
place.Token.Entity.Incarnation + 1)),
|
||
},
|
||
},
|
||
};
|
||
RuntimePlacementProjectionSnapshot discard = stale with
|
||
{
|
||
Kind = RuntimePlacementProjectionKind.Discard,
|
||
Token = stale.Token with
|
||
{
|
||
SessionLifetimeVersion = ulong.MaxValue,
|
||
},
|
||
};
|
||
|
||
Assert.False(projection.TryApply(in stale));
|
||
Assert.True(projection.TryApply(in discard));
|
||
}
|
||
|
||
[Fact]
|
||
public void ExecutorCompletedReceiptIsAcknowledgeOnlyRegardlessOfRecordValidity()
|
||
{
|
||
// F1: mirrors PlacementReceiptUsesExactIncarnationAndDiscardIsAckOnly's
|
||
// stale-token half - proves ExecutorCompleted is acknowledged
|
||
// unconditionally (never gated by the record-lookup/portal-shape
|
||
// checks Place/Withdraw depend on), so a genuinely stale/mismatched
|
||
// token can never wedge the FIFO behind it.
|
||
var operations = new FixtureSessionOperations();
|
||
using var credential = new HeadlessCredentialSecret(
|
||
"fixture",
|
||
"password");
|
||
using var host = new HeadlessSessionHost(
|
||
Descriptor(),
|
||
credential,
|
||
new HeadlessDiagnosticWriter(TextWriter.Null),
|
||
operations);
|
||
GameRuntime runtime = host.Runtime;
|
||
RuntimeEntityRecord record = runtime.EntityObjects
|
||
.RegisterEntity(Spawn(0x50000006u))
|
||
.Canonical!;
|
||
Assert.True(runtime.EntityObjects.ApplyAcceptedSpawn(
|
||
record,
|
||
record.CreateIntegrationVersion,
|
||
record.Snapshot,
|
||
replaceGeneration: false));
|
||
var sink = new HeadlessRuntimePlacementProjectionSink(runtime);
|
||
RuntimePlacementProjectionSnapshot completion = Placement(
|
||
runtime,
|
||
record,
|
||
RuntimePlacementProjectionKind.ExecutorCompleted,
|
||
Vector3.One,
|
||
Quaternion.Identity);
|
||
RuntimePlacementProjectionSnapshot stale = completion with
|
||
{
|
||
Token = completion.Token with
|
||
{
|
||
Entity = completion.Token.Entity with
|
||
{
|
||
Incarnation = unchecked((ushort)(
|
||
completion.Token.Entity.Incarnation + 1)),
|
||
},
|
||
SessionLifetimeVersion = ulong.MaxValue,
|
||
},
|
||
};
|
||
|
||
Assert.True(sink.TryApply(in completion));
|
||
Assert.True(sink.TryApply(in stale));
|
||
}
|
||
|
||
[Fact]
|
||
public void SessionEventRouteOwnsOneObserverAndUnsubscribesBeforeNetworkDetach()
|
||
{
|
||
var operations = new FixtureSessionOperations();
|
||
using var credential = new HeadlessCredentialSecret(
|
||
"fixture",
|
||
"password");
|
||
using var host = new HeadlessSessionHost(
|
||
Descriptor(),
|
||
credential,
|
||
new HeadlessDiagnosticWriter(TextWriter.Null),
|
||
operations);
|
||
GameRuntime runtime = host.Runtime;
|
||
int subscriberCountDuringDetach = -1;
|
||
var inner = new FixtureEventRoute(
|
||
onDispose: () => subscriberCountDuringDetach =
|
||
runtime.EntityObjects.Events.PlacementSubscriberCount);
|
||
var placements = new HeadlessRuntimePlacementProjectionSink(runtime);
|
||
var route = new HeadlessSessionEventRoute(
|
||
inner,
|
||
runtime,
|
||
placements);
|
||
|
||
Assert.Equal(
|
||
0,
|
||
runtime.EntityObjects.Events.PlacementSubscriberCount);
|
||
route.Attach();
|
||
route.Attach();
|
||
Assert.Equal(
|
||
1,
|
||
runtime.EntityObjects.Events.PlacementSubscriberCount);
|
||
Assert.Equal(1, inner.AttachCount);
|
||
|
||
route.Dispose();
|
||
route.Dispose();
|
||
|
||
Assert.Equal(0, subscriberCountDuringDetach);
|
||
Assert.Equal(
|
||
0,
|
||
runtime.EntityObjects.Events.PlacementSubscriberCount);
|
||
Assert.Equal(1, inner.DisposeCount);
|
||
}
|
||
|
||
[Fact]
|
||
public void ReplacementSessionEventRouteGetsOneFreshObserver()
|
||
{
|
||
var operations = new FixtureSessionOperations();
|
||
using var credential = new HeadlessCredentialSecret(
|
||
"fixture",
|
||
"password");
|
||
using var host = new HeadlessSessionHost(
|
||
Descriptor(),
|
||
credential,
|
||
new HeadlessDiagnosticWriter(TextWriter.Null),
|
||
operations);
|
||
GameRuntime runtime = host.Runtime;
|
||
var placements = new HeadlessRuntimePlacementProjectionSink(runtime);
|
||
|
||
var first = new HeadlessSessionEventRoute(
|
||
new FixtureEventRoute(),
|
||
runtime,
|
||
placements);
|
||
first.Attach();
|
||
Assert.Equal(
|
||
1,
|
||
runtime.EntityObjects.Events.PlacementSubscriberCount);
|
||
first.Dispose();
|
||
Assert.Equal(
|
||
0,
|
||
runtime.EntityObjects.Events.PlacementSubscriberCount);
|
||
|
||
var replacement = new HeadlessSessionEventRoute(
|
||
new FixtureEventRoute(),
|
||
runtime,
|
||
placements);
|
||
replacement.Attach();
|
||
Assert.Equal(
|
||
1,
|
||
runtime.EntityObjects.Events.PlacementSubscriberCount);
|
||
replacement.Dispose();
|
||
Assert.Equal(
|
||
0,
|
||
runtime.EntityObjects.Events.PlacementSubscriberCount);
|
||
}
|
||
|
||
[Fact]
|
||
public void SessionEventRouteRetryDoesNotRestorePlacementObserver()
|
||
{
|
||
var operations = new FixtureSessionOperations();
|
||
using var credential = new HeadlessCredentialSecret(
|
||
"fixture",
|
||
"password");
|
||
using var host = new HeadlessSessionHost(
|
||
Descriptor(),
|
||
credential,
|
||
new HeadlessDiagnosticWriter(TextWriter.Null),
|
||
operations);
|
||
GameRuntime runtime = host.Runtime;
|
||
var inner = new FixtureEventRoute
|
||
{
|
||
DisposeFailuresRemaining = 1,
|
||
};
|
||
var route = new HeadlessSessionEventRoute(
|
||
inner,
|
||
runtime,
|
||
new HeadlessRuntimePlacementProjectionSink(runtime));
|
||
route.Attach();
|
||
|
||
Assert.Throws<IOException>(route.Dispose);
|
||
Assert.Equal(
|
||
0,
|
||
runtime.EntityObjects.Events.PlacementSubscriberCount);
|
||
Assert.Equal(1, inner.DisposeCount);
|
||
|
||
route.Dispose();
|
||
|
||
Assert.Equal(2, inner.DisposeCount);
|
||
Assert.Equal(
|
||
0,
|
||
runtime.EntityObjects.Events.PlacementSubscriberCount);
|
||
}
|
||
|
||
[Fact]
|
||
public void CollisionTransactionCancelsPostAdmissionFaultWithoutWithdrawingActiveWorld()
|
||
{
|
||
using var lifetime = new RuntimeEntityObjectLifetime();
|
||
RuntimePhysicsState physics = lifetime.Physics;
|
||
const uint landblockId = 0xA9B4FFFFu;
|
||
CompleteCollisionGeneration(
|
||
physics,
|
||
landblockId,
|
||
afterAdmission: null,
|
||
(admission, prepared) =>
|
||
physics.StageCollisionAssets(
|
||
admission,
|
||
prepared,
|
||
CollisionAssets(landblockId, 10f)));
|
||
|
||
Assert.Throws<FixtureCollisionPublicationException>(() =>
|
||
CompleteCollisionGeneration(
|
||
physics,
|
||
landblockId,
|
||
_ => throw new FixtureCollisionPublicationException(),
|
||
(_, _) => throw new InvalidOperationException(
|
||
"Staging must not run after the injected admission fault.")));
|
||
|
||
Assert.Equal(10f, physics.Engine.SampleTerrainZ(1f, 1f));
|
||
RuntimePhysicsOwnershipSnapshot ownership = physics.CaptureOwnership();
|
||
Assert.Equal(1, ownership.LandblockCount);
|
||
Assert.Equal(0, ownership.CollisionAdmissionCount);
|
||
}
|
||
|
||
[Fact]
|
||
public void CollisionTransactionYieldsTheFirstNonterminalRuntimePoll()
|
||
{
|
||
using var lifetime = new RuntimeEntityObjectLifetime();
|
||
RuntimePhysicsState physics = lifetime.Physics;
|
||
const uint landblockId = 0xA9B4FFFFu;
|
||
HeadlessCollisionGenerationTransaction transaction =
|
||
HeadlessCollisionGenerationTransaction.Begin(
|
||
physics,
|
||
landblockId,
|
||
afterAdmission: null,
|
||
(admission, prepared) =>
|
||
physics.StageCollisionAssets(
|
||
admission,
|
||
prepared,
|
||
CollisionAssets(landblockId, 10f)));
|
||
|
||
HeadlessCollisionGenerationAdvance advance;
|
||
do
|
||
{
|
||
advance = transaction.Advance();
|
||
Assert.True(advance.Progressed);
|
||
}
|
||
while (!advance.YieldToCaller);
|
||
|
||
Assert.False(advance.Completed);
|
||
Assert.False(advance.WaitingForProjectionAcknowledgement);
|
||
Assert.False(transaction.CompletionCommitted);
|
||
|
||
do
|
||
{
|
||
advance = transaction.Advance();
|
||
Assert.True(advance.Progressed);
|
||
}
|
||
while (!advance.Completed && !advance.YieldToCaller);
|
||
if (!advance.Completed)
|
||
advance = transaction.Advance();
|
||
|
||
Assert.True(advance.Completed);
|
||
Assert.True(transaction.EngineMutationCommitted);
|
||
Assert.True(transaction.CompletionCommitted);
|
||
Assert.Equal(0, physics.CaptureOwnership().CollisionAdmissionCount);
|
||
}
|
||
|
||
[Fact]
|
||
public void CollisionTransactionRetainsPostEngineCancellationUntilPlaceAck()
|
||
{
|
||
using var lifetime = new RuntimeEntityObjectLifetime();
|
||
RuntimePhysicsState physics = lifetime.Physics;
|
||
const uint landblockId = 0xA9B4FFFFu;
|
||
CompleteCollisionGeneration(
|
||
physics,
|
||
landblockId,
|
||
afterAdmission: null,
|
||
(admission, prepared) =>
|
||
physics.StageCollisionAssets(
|
||
admission,
|
||
prepared,
|
||
CollisionAssets(landblockId, 10f)));
|
||
|
||
const uint guid = 0x70004201u;
|
||
const uint cell = 0xA9B40001u;
|
||
Vector3 position = new(10f, 10f, 0f);
|
||
RuntimeEntityRecord record = lifetime.RegisterEntity(
|
||
Spawn(guid)).Canonical!;
|
||
lifetime.Entities.SetFinalPhysicsState(record, PhysicsStateFlags.Gravity);
|
||
lifetime.Entities.SetFullCell(record, cell, landblockId);
|
||
var body = new PhysicsBody
|
||
{
|
||
Position = position,
|
||
Orientation = Quaternion.Identity,
|
||
LastUpdateTime = 1d,
|
||
State = PhysicsStateFlags.Gravity,
|
||
TransientState = TransientStateFlags.Active,
|
||
};
|
||
body.SnapToCell(cell, position, position);
|
||
lifetime.Entities.SetPhysicsBody(record, body);
|
||
record.ObjectClock.Activate();
|
||
physics.AcknowledgeSpatialProjection(record, spatial: true);
|
||
RuntimePlacementProjectionToken seeded = SeedRuntimePlacement(
|
||
physics,
|
||
record,
|
||
cell,
|
||
position);
|
||
Assert.True(physics.SetPosition.AcknowledgeProjection(seeded));
|
||
|
||
HeadlessCollisionGenerationTransaction transaction =
|
||
HeadlessCollisionGenerationTransaction.Begin(
|
||
physics,
|
||
landblockId,
|
||
afterAdmission: null,
|
||
(admission, prepared) =>
|
||
physics.StageCollisionAssets(
|
||
admission,
|
||
prepared,
|
||
CollisionAssets(landblockId, 20f)));
|
||
HeadlessCollisionGenerationAdvance advance;
|
||
do
|
||
{
|
||
advance = transaction.Advance();
|
||
}
|
||
while (!advance.WaitingForProjectionAcknowledgement);
|
||
Assert.False(transaction.EngineMutationCommitted);
|
||
Assert.True(physics.SetPosition.TryPeekProjection(
|
||
out RuntimePlacementProjectionSnapshot withdrawal));
|
||
Assert.True(physics.SetPosition.AcknowledgeProjection(withdrawal.Token));
|
||
|
||
do
|
||
{
|
||
advance = transaction.Advance();
|
||
}
|
||
while (!advance.WaitingForProjectionAcknowledgement);
|
||
Assert.True(transaction.EngineMutationCommitted);
|
||
Assert.True(physics.SetPosition.TryPeekProjection(
|
||
out RuntimePlacementProjectionSnapshot placement));
|
||
|
||
Assert.False(transaction.TryCancel());
|
||
Assert.True(physics.SetPosition.AcknowledgeProjection(placement.Token));
|
||
Assert.True(transaction.TryCancel());
|
||
RuntimePhysicsOwnershipSnapshot ownership = physics.CaptureOwnership();
|
||
Assert.Equal(0, ownership.CollisionPrefixMutationCount);
|
||
Assert.Equal(0, ownership.CollisionAdmissionCount);
|
||
}
|
||
|
||
[Fact]
|
||
public void CollisionTransactionCancelsStagingFaultWithoutWithdrawingActiveWorld()
|
||
{
|
||
using var lifetime = new RuntimeEntityObjectLifetime();
|
||
RuntimePhysicsState physics = lifetime.Physics;
|
||
const uint landblockId = 0xA9B4FFFFu;
|
||
CompleteCollisionGeneration(
|
||
physics,
|
||
landblockId,
|
||
afterAdmission: null,
|
||
(admission, prepared) =>
|
||
physics.StageCollisionAssets(
|
||
admission,
|
||
prepared,
|
||
CollisionAssets(landblockId, 10f)));
|
||
|
||
Assert.Throws<FixtureCollisionPublicationException>(() =>
|
||
CompleteCollisionGeneration(
|
||
physics,
|
||
landblockId,
|
||
afterAdmission: null,
|
||
(admission, prepared) =>
|
||
{
|
||
physics.StageCollisionAssets(
|
||
admission,
|
||
prepared,
|
||
CollisionAssets(landblockId, 25f));
|
||
throw new FixtureCollisionPublicationException();
|
||
}));
|
||
|
||
Assert.Equal(10f, physics.Engine.SampleTerrainZ(1f, 1f));
|
||
RuntimePhysicsOwnershipSnapshot ownership = physics.CaptureOwnership();
|
||
Assert.Equal(1, ownership.LandblockCount);
|
||
Assert.Equal(0, ownership.CollisionAdmissionCount);
|
||
}
|
||
|
||
private static HeadlessSessionDescriptor Descriptor(
|
||
HeadlessCredentialProviderKind provider =
|
||
HeadlessCredentialProviderKind.Environment,
|
||
string credentialReference = "BOT_PASSWORD") => new()
|
||
{
|
||
Id = "bot",
|
||
Endpoint = new HeadlessEndpointDescriptor
|
||
{
|
||
Host = "127.0.0.1",
|
||
Port = 9000,
|
||
},
|
||
Account = "account",
|
||
Character = new HeadlessCharacterSelector
|
||
{
|
||
Name = "headless",
|
||
},
|
||
Policy = new HeadlessBotPolicyDescriptor
|
||
{
|
||
Id = "idle",
|
||
},
|
||
Credential = new HeadlessCredentialReference
|
||
{
|
||
Provider = provider,
|
||
Reference = credentialReference,
|
||
},
|
||
};
|
||
|
||
private static void HydrateGroundedPlayer(GameRuntime runtime)
|
||
{
|
||
const uint player = 0x50000002u;
|
||
PhysicsEngine engine = runtime.EntityObjects.Physics.Engine;
|
||
AddFlatLandblock(engine);
|
||
|
||
RuntimeEntityRecord record = runtime.EntityObjects
|
||
.RegisterEntity(Spawn(player))
|
||
.Canonical!;
|
||
Assert.True(runtime.EntityObjects.ApplyAcceptedSpawn(
|
||
record,
|
||
record.CreateIntegrationVersion,
|
||
record.Snapshot,
|
||
replaceGeneration: false));
|
||
var controller = new PlayerMovementController(engine);
|
||
controller.SetPosition(
|
||
new Vector3(96f, 97f, 50f),
|
||
0xA9B40001u,
|
||
new Vector3(96f, 97f, 50f));
|
||
runtime.MovementOwner.Controller = controller;
|
||
}
|
||
|
||
private static void CompleteCollisionGeneration(
|
||
RuntimePhysicsState physics,
|
||
uint landblockId,
|
||
Action<RuntimeCollisionAdmission>? afterAdmission,
|
||
Action<RuntimeCollisionAdmission,
|
||
PreparedLandblockCollisionGeneration> stage)
|
||
{
|
||
HeadlessCollisionGenerationTransaction transaction =
|
||
HeadlessCollisionGenerationTransaction.Begin(
|
||
physics,
|
||
landblockId,
|
||
afterAdmission,
|
||
stage);
|
||
while (true)
|
||
{
|
||
HeadlessCollisionGenerationAdvance advance = transaction.Advance();
|
||
if (advance.Completed)
|
||
return;
|
||
Assert.True(advance.Progressed);
|
||
Assert.False(advance.WaitingForProjectionAcknowledgement);
|
||
}
|
||
}
|
||
|
||
private static RuntimePlacementProjectionToken SeedRuntimePlacement(
|
||
RuntimePhysicsState physics,
|
||
RuntimeEntityRecord record,
|
||
uint cell,
|
||
Vector3 position)
|
||
{
|
||
Type coreMarker = typeof(PhysicsEngine);
|
||
Type requestType = coreMarker.Assembly.GetType(
|
||
"AcDream.Core.Physics.PhysicsSetPositionRequest",
|
||
throwOnError: true)!;
|
||
Type flagsType = coreMarker.Assembly.GetType(
|
||
"AcDream.Core.Physics.PhysicsSetPositionFlags",
|
||
throwOnError: true)!;
|
||
Type placementClassType = coreMarker.Assembly.GetType(
|
||
"AcDream.Core.Physics.PhysicsPlacementClass",
|
||
throwOnError: true)!;
|
||
object request = Activator.CreateInstance(
|
||
requestType,
|
||
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
|
||
binder: null,
|
||
args:
|
||
[
|
||
position,
|
||
Quaternion.Identity,
|
||
cell,
|
||
position,
|
||
ImmutableArray<FlatCollisionSphere>.Empty,
|
||
1f,
|
||
0.4f,
|
||
0.4f,
|
||
PhysicsStateFlags.None,
|
||
ObjectInfoState.None,
|
||
0u,
|
||
Enum.ToObject(placementClassType, 0),
|
||
Enum.ToObject(flagsType, 0x011u),
|
||
Vector3.Zero,
|
||
0f,
|
||
0f,
|
||
0u,
|
||
cell,
|
||
],
|
||
culture: null)!;
|
||
Type runtimeMarker = typeof(RuntimePhysicsState);
|
||
Type commandType = runtimeMarker.Assembly.GetType(
|
||
"AcDream.Runtime.Physics.RuntimeSetPositionCommand",
|
||
throwOnError: true)!;
|
||
Type kindType = runtimeMarker.Assembly.GetType(
|
||
"AcDream.Runtime.Physics.RuntimeSetPositionOperationKind",
|
||
throwOnError: true)!;
|
||
object command = Activator.CreateInstance(
|
||
commandType,
|
||
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic,
|
||
binder: null,
|
||
args:
|
||
[
|
||
request,
|
||
Enum.ToObject(kindType, 2),
|
||
10d,
|
||
0UL,
|
||
0f,
|
||
0f,
|
||
default(RuntimePortalPlacementAuthority),
|
||
],
|
||
culture: null)!;
|
||
MethodInfo apply = physics.SetPosition.GetType().GetMethod(
|
||
"Apply",
|
||
BindingFlags.Instance | BindingFlags.NonPublic)
|
||
?? throw new MissingMethodException("Runtime SetPosition.Apply");
|
||
object outcome = apply.Invoke(
|
||
physics.SetPosition,
|
||
[record, record.PositionAuthorityVersion, command])!;
|
||
return (RuntimePlacementProjectionToken)(outcome.GetType().GetProperty(
|
||
"Projection",
|
||
BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic)
|
||
?.GetValue(outcome)
|
||
?? throw new MissingMemberException("Runtime placement projection"));
|
||
}
|
||
|
||
private static RuntimeLandblockCollisionAssets CollisionAssets(
|
||
uint landblockId,
|
||
float terrainHeight)
|
||
{
|
||
var heights = new byte[81];
|
||
var table = new float[256];
|
||
table[0] = terrainHeight;
|
||
return new RuntimeLandblockCollisionAssets(
|
||
landblockId,
|
||
new TerrainSurface(heights, table),
|
||
Array.Empty<CellSurface>(),
|
||
Array.Empty<PortalPlane>(),
|
||
0f,
|
||
0f,
|
||
0u);
|
||
}
|
||
|
||
private sealed class FixtureCollisionPublicationException : Exception;
|
||
|
||
[Fact]
|
||
public void MissingPreparedCollisionYieldsTypedRetryAndCompletesWhenAvailable()
|
||
{
|
||
// C3c contract: the prepared-collision read failure is the
|
||
// conductor's typed AwaitingCollisionSource retry — no
|
||
// InvalidDataException (or any exception) escapes the host wiring,
|
||
// the entity stays a tracked, re-drivable first entry, and the same
|
||
// sequence completes once the source can serve the Setup.
|
||
var operations = new FixtureSessionOperations();
|
||
using var credential = new HeadlessCredentialSecret(
|
||
"fixture",
|
||
"password");
|
||
using var host = new HeadlessSessionHost(
|
||
Descriptor(),
|
||
credential,
|
||
new HeadlessDiagnosticWriter(TextWriter.Null),
|
||
operations);
|
||
GameRuntime runtime = host.Runtime;
|
||
Assert.Equal(
|
||
RuntimeSessionStartStatus.Connected,
|
||
host.Start().Status);
|
||
const uint player = 0x50000021u;
|
||
runtime.PlayerIdentity.ServerGuid = player;
|
||
runtime.EntityObjects.Physics.SetPosition.BeginCollisionGeneration(
|
||
0xA9B40000u, 1UL);
|
||
AddFlatLandblock(runtime.EntityObjects.Physics.Engine);
|
||
runtime.EntityObjects.Physics.SetPosition.CommitCollisionGeneration(
|
||
0xA9B40000u, 1UL, ready: true);
|
||
var source = new FlakySetupCollisionSource();
|
||
var firstEntry = new AcDream.Runtime.Session
|
||
.RuntimeFirstEntryDriveController(
|
||
runtime.EntityObjects,
|
||
runtime.Clock,
|
||
source,
|
||
() => PlayerMovementConstructionOptions.From(
|
||
runtime.CharacterOwner.MovementSkills.Snapshot),
|
||
static _ => new RuntimeLocalPlayerPhysicsActivationPreparation(
|
||
Radius: 0.48f,
|
||
Height: 1.835f,
|
||
RuntimeLocalPlayerShadowDisposition.ProvenShapeless));
|
||
RuntimeEntityRecord record = runtime.EntityObjects
|
||
.RegisterEntityWithInitialResidence(Spawn(player), isLocalPlayer: true)
|
||
.Canonical!;
|
||
Assert.True(runtime.EntityObjects.ApplyAcceptedSpawn(
|
||
record,
|
||
record.CreateIntegrationVersion,
|
||
record.Snapshot,
|
||
replaceGeneration: false));
|
||
var collision = new FixtureCollisionNeighborhood();
|
||
var projection = new HeadlessSessionWorldProjection(
|
||
runtime,
|
||
collision,
|
||
firstEntry);
|
||
|
||
projection.ProjectSpawn(record, isLocalPlayer: true);
|
||
|
||
Assert.True(source.SetupReadAttempts >= 1);
|
||
Assert.Null(runtime.MovementOwner.Controller);
|
||
Assert.Equal(1, firstEntry.PendingCount);
|
||
Assert.Equal(0u, record.FullCellId);
|
||
|
||
source.Available = true;
|
||
// The session tick's retry pump.
|
||
firstEntry.DriveAll();
|
||
|
||
Assert.IsType<PlayerMovementController>(
|
||
runtime.MovementOwner.Controller);
|
||
Assert.Equal(0, firstEntry.PendingCount);
|
||
Assert.Equal(0xA9B40000u, record.FullCellId & 0xFFFF0000u);
|
||
Assert.NotEqual(0u, record.FullCellId);
|
||
}
|
||
|
||
private sealed class FlakySetupCollisionSource
|
||
: AcDream.Content.IPreparedCollisionSource
|
||
{
|
||
internal bool Available { get; set; }
|
||
internal int SetupReadAttempts { get; private set; }
|
||
|
||
public AcDream.Content.PreparedAssetPresence ProbeCollision(
|
||
AcDream.Content.Pak.PakAssetType type,
|
||
uint sourceFileId) =>
|
||
AcDream.Content.PreparedAssetPresence.Available;
|
||
|
||
public AcDream.Content.PreparedCollisionReadResult<FlatSetupCollision>
|
||
ReadSetupCollision(
|
||
uint sourceFileId,
|
||
CancellationToken cancellationToken = default)
|
||
{
|
||
SetupReadAttempts++;
|
||
if (!Available)
|
||
{
|
||
return AcDream.Content.PreparedCollisionReadResult<
|
||
FlatSetupCollision>.Missing;
|
||
}
|
||
return AcDream.Content.PreparedCollisionReadResult<
|
||
FlatSetupCollision>.Loaded(new FlatSetupCollision(
|
||
System.Collections.Immutable.ImmutableArray<
|
||
FlatCollisionCylinder>.Empty,
|
||
[new FlatCollisionSphere(Vector3.Zero, 0.48f)],
|
||
height: 0f,
|
||
radius: 0f,
|
||
stepUpHeight: 0.4f,
|
||
stepDownHeight: 0.4f));
|
||
}
|
||
|
||
public AcDream.Content.PreparedCollisionReadResult<
|
||
FlatGfxObjCollisionAsset> ReadGfxObjCollision(
|
||
uint sourceFileId,
|
||
CancellationToken cancellationToken = default) =>
|
||
throw new NotSupportedException();
|
||
|
||
public AcDream.Content.PreparedCollisionReadResult<
|
||
FlatCellStructureCollisionAsset> ReadCellStructureCollision(
|
||
uint sourceFileId,
|
||
CancellationToken cancellationToken = default) =>
|
||
throw new NotSupportedException();
|
||
|
||
public AcDream.Content.PreparedCollisionReadResult<FlatEnvCellTopology>
|
||
ReadEnvCellTopology(
|
||
uint sourceFileId,
|
||
CancellationToken cancellationToken = default) =>
|
||
throw new NotSupportedException();
|
||
|
||
public AcDream.Content.PreparedCollisionSourceStats CollisionStats =>
|
||
default;
|
||
|
||
public void Dispose()
|
||
{
|
||
}
|
||
}
|
||
|
||
private static AcDream.Runtime.Session.RuntimeFirstEntryDriveController
|
||
CreateFirstEntryDrive(GameRuntime runtime) => new(
|
||
runtime.EntityObjects,
|
||
runtime.Clock,
|
||
new LoadedSetupCollisionSource(),
|
||
() => PlayerMovementConstructionOptions.From(
|
||
runtime.CharacterOwner.MovementSkills.Snapshot),
|
||
static _ => new RuntimeLocalPlayerPhysicsActivationPreparation(
|
||
Radius: 0.48f,
|
||
Height: 1.835f,
|
||
RuntimeLocalPlayerShadowDisposition.ProvenShapeless));
|
||
|
||
/// <summary>
|
||
/// C4 route 2 (2026-08-03): mirrors <see cref="CreateFirstEntryDrive"/>'s
|
||
/// construction pattern for the accepted-Position drive controller. No
|
||
/// real WorldSession is needed for these fixture tests —
|
||
/// LocalPlayerOutboundController.SendImmediatePosition no-ops on a null
|
||
/// session.
|
||
/// </summary>
|
||
private static RuntimeAcceptedPositionDriveController
|
||
CreateAcceptedPositionDrive(GameRuntime runtime) => new(
|
||
runtime.EntityObjects,
|
||
runtime.Clock,
|
||
new LoadedSetupCollisionSource(),
|
||
new LocalPlayerOutboundController((_, _, _, _, _, _) => { }),
|
||
() => runtime.Generation,
|
||
() => runtime.PlayerIdentity.ServerGuid,
|
||
() => runtime.MovementOwner.Controller,
|
||
() => runtime.CharacterOwner.UsePositionFromServer,
|
||
() => null);
|
||
|
||
private sealed class LoadedSetupCollisionSource
|
||
: AcDream.Content.IPreparedCollisionSource
|
||
{
|
||
public AcDream.Content.PreparedAssetPresence ProbeCollision(
|
||
AcDream.Content.Pak.PakAssetType type,
|
||
uint sourceFileId) =>
|
||
AcDream.Content.PreparedAssetPresence.Available;
|
||
|
||
public AcDream.Content.PreparedCollisionReadResult<FlatSetupCollision>
|
||
ReadSetupCollision(
|
||
uint sourceFileId,
|
||
CancellationToken cancellationToken = default) =>
|
||
AcDream.Content.PreparedCollisionReadResult<FlatSetupCollision>
|
||
.Loaded(new FlatSetupCollision(
|
||
System.Collections.Immutable.ImmutableArray<
|
||
FlatCollisionCylinder>.Empty,
|
||
// R7 review fix (2026-08-03): the dat-exact human Setup
|
||
// 0x02000001 spheres (Ts46SphereListConformanceTests.cs
|
||
// :35-39) — foot (0,0,0.475) r=.48, head/torso
|
||
// (0,0,1.350) r=.48. The PREVIOUS single dummy sphere at
|
||
// (0,0,0) r=.48 (offset == radius) made a settled origin
|
||
// rest a FULL radius above the floor; the real foot
|
||
// sphere's bottom is origin + 0.475 − 0.48 = origin −
|
||
// 0.005, so a settled origin lands ON the floor within
|
||
// 5 mm. Retail's BlipPlayer has never lifted the origin
|
||
// by a sphere radius — that was a fixture artifact, not
|
||
// a retail-fidelity gain (docs/ISSUES.md #285 correction).
|
||
[
|
||
new FlatCollisionSphere(
|
||
new Vector3(0f, 0f, 0.475f), 0.48f),
|
||
new FlatCollisionSphere(
|
||
new Vector3(0f, 0f, 1.350f), 0.48f),
|
||
],
|
||
height: 0f,
|
||
radius: 0f,
|
||
stepUpHeight: 0.4f,
|
||
stepDownHeight: 0.4f));
|
||
|
||
public AcDream.Content.PreparedCollisionReadResult<
|
||
FlatGfxObjCollisionAsset> ReadGfxObjCollision(
|
||
uint sourceFileId,
|
||
CancellationToken cancellationToken = default) =>
|
||
throw new NotSupportedException();
|
||
|
||
public AcDream.Content.PreparedCollisionReadResult<
|
||
FlatCellStructureCollisionAsset> ReadCellStructureCollision(
|
||
uint sourceFileId,
|
||
CancellationToken cancellationToken = default) =>
|
||
throw new NotSupportedException();
|
||
|
||
public AcDream.Content.PreparedCollisionReadResult<FlatEnvCellTopology>
|
||
ReadEnvCellTopology(
|
||
uint sourceFileId,
|
||
CancellationToken cancellationToken = default) =>
|
||
throw new NotSupportedException();
|
||
|
||
public AcDream.Content.PreparedCollisionSourceStats CollisionStats =>
|
||
default;
|
||
|
||
public void Dispose()
|
||
{
|
||
}
|
||
}
|
||
|
||
private static void AddFlatLandblock(PhysicsEngine engine)
|
||
{
|
||
var heights = new byte[81];
|
||
Array.Fill(heights, (byte)50);
|
||
var heightTable = new float[256];
|
||
for (int index = 0; index < heightTable.Length; index++)
|
||
heightTable[index] = index;
|
||
engine.AddLandblock(
|
||
0xA9B4FFFFu,
|
||
new TerrainSurface(heights, heightTable),
|
||
[],
|
||
[],
|
||
worldOffsetX: 0f,
|
||
worldOffsetY: 0f);
|
||
}
|
||
|
||
private static WorldSession.EntitySpawn Spawn(
|
||
uint guid,
|
||
uint cellId = 0xA9B40001u)
|
||
{
|
||
var position = new CreateObject.ServerPosition(
|
||
cellId,
|
||
96f,
|
||
97f,
|
||
50f,
|
||
1f,
|
||
0f,
|
||
0f,
|
||
0f);
|
||
var timestamps = new PhysicsTimestamps(
|
||
Position: 1,
|
||
Movement: 1,
|
||
State: 1,
|
||
Vector: 1,
|
||
Teleport: 0,
|
||
ServerControlledMove: 1,
|
||
ForcePosition: 0,
|
||
ObjDesc: 1,
|
||
Instance: 1);
|
||
var physics = new PhysicsSpawnData(
|
||
RawState: (uint)PhysicsStateFlags.ReportCollisions,
|
||
Position: position,
|
||
Movement: null,
|
||
AnimationFrame: null,
|
||
SetupTableId: 0x02000001u,
|
||
MotionTableId: null,
|
||
SoundTableId: null,
|
||
PhysicsScriptTableId: null,
|
||
Parent: null,
|
||
Children: null,
|
||
Scale: null,
|
||
Friction: null,
|
||
Elasticity: null,
|
||
Translucency: null,
|
||
Velocity: null,
|
||
Acceleration: null,
|
||
AngularVelocity: null,
|
||
DefaultScriptType: null,
|
||
DefaultScriptIntensity: null,
|
||
Timestamps: timestamps);
|
||
return new WorldSession.EntitySpawn(
|
||
guid,
|
||
position,
|
||
0x02000001u,
|
||
[],
|
||
[],
|
||
[],
|
||
null,
|
||
null,
|
||
"Headless",
|
||
null,
|
||
null,
|
||
null,
|
||
PhysicsState: physics.RawState,
|
||
InstanceSequence: 1,
|
||
MovementSequence: 1,
|
||
ServerControlSequence: 1,
|
||
PositionSequence: 1,
|
||
Physics: physics);
|
||
}
|
||
|
||
private static RuntimePlacementProjectionSnapshot Placement(
|
||
GameRuntime runtime,
|
||
RuntimeEntityRecord record,
|
||
RuntimePlacementProjectionKind kind,
|
||
Vector3 position,
|
||
Quaternion orientation)
|
||
{
|
||
RuntimeEntityKey key = Assert.IsType<RuntimeEntityKey>(record.Key);
|
||
var token = new RuntimePlacementProjectionToken(
|
||
Sequence: 1,
|
||
Revision: 1,
|
||
Entity: key,
|
||
PositionAuthorityVersion: record.PositionAuthorityVersion,
|
||
SpatialAuthorityVersion: record.SpatialAuthorityVersion,
|
||
PlacementCommitVersion: record.PlacementCommitVersion,
|
||
SessionLifetimeVersion:
|
||
runtime.EntityObjects.Entities.SessionLifetimeVersion,
|
||
ExactCellId: record.FullCellId,
|
||
CollisionGeneration: 1,
|
||
Portal: default);
|
||
return new RuntimePlacementProjectionSnapshot(
|
||
token,
|
||
kind,
|
||
position,
|
||
orientation,
|
||
CellLocalPosition: position,
|
||
InContact: false,
|
||
OnWalkable: false);
|
||
}
|
||
|
||
private static uint ActionOpcode(byte[] body) =>
|
||
BinaryPrimitives.ReadUInt32LittleEndian(
|
||
body.AsSpan(8, sizeof(uint)));
|
||
|
||
private sealed class FixtureSessionOperations : ILiveSessionOperations
|
||
{
|
||
public List<WorldSession> Sessions { get; } = [];
|
||
public int CreatedSessionCount { get; private set; }
|
||
public int DisposedSessionCount { get; private set; }
|
||
public string? LastUser { get; private set; }
|
||
public string? LastPassword { get; private set; }
|
||
|
||
public IPEndPoint ResolveEndpoint(string host, int port) =>
|
||
new(IPAddress.Loopback, port);
|
||
|
||
public WorldSession CreateSession(IPEndPoint endpoint)
|
||
{
|
||
CreatedSessionCount++;
|
||
var session = new WorldSession(endpoint);
|
||
Sessions.Add(session);
|
||
return session;
|
||
}
|
||
|
||
public void Connect(
|
||
WorldSession session,
|
||
string user,
|
||
string password)
|
||
{
|
||
LastUser = user;
|
||
LastPassword = password;
|
||
}
|
||
|
||
public CharacterList.Parsed GetCharacters(
|
||
WorldSession session) =>
|
||
new(
|
||
0u,
|
||
[
|
||
new CharacterList.Character(
|
||
0x50000001u,
|
||
"Other",
|
||
0u),
|
||
new CharacterList.Character(
|
||
0x50000002u,
|
||
"Headless",
|
||
0u),
|
||
],
|
||
[],
|
||
11,
|
||
"account",
|
||
true,
|
||
true);
|
||
|
||
public void EnterWorld(
|
||
WorldSession session,
|
||
int activeCharacterIndex)
|
||
{
|
||
}
|
||
|
||
public void Tick(WorldSession session)
|
||
{
|
||
}
|
||
|
||
public void DisposeSession(WorldSession session)
|
||
{
|
||
DisposedSessionCount++;
|
||
session.Dispose();
|
||
}
|
||
}
|
||
|
||
private sealed class FailOnceTextWriter : StringWriter
|
||
{
|
||
public bool FailNextWrite { get; set; }
|
||
|
||
public override void WriteLine(string? value)
|
||
{
|
||
if (FailNextWrite)
|
||
{
|
||
FailNextWrite = false;
|
||
throw new IOException("fixture write failure");
|
||
}
|
||
base.WriteLine(value);
|
||
}
|
||
}
|
||
|
||
private sealed class FixtureCollisionNeighborhood
|
||
: IHeadlessCollisionNeighborhood
|
||
{
|
||
public int CenterCount { get; private set; }
|
||
public uint LastCell { get; private set; }
|
||
|
||
public void CenterOn(uint fullCellId)
|
||
{
|
||
CenterCount++;
|
||
LastCell = fullCellId;
|
||
}
|
||
|
||
public bool IsReady(uint fullCellId) =>
|
||
fullCellId == LastCell;
|
||
|
||
// C3c-R1 review F7: the fixture window mirrors production's 3x3
|
||
// membership around the last requested center; no center yet means
|
||
// "within" (never convert before the first CenterOn).
|
||
public bool IsWithinServiceWindow(uint fullCellId)
|
||
{
|
||
if (LastCell == 0u)
|
||
return true;
|
||
int dx = Math.Abs(
|
||
(int)((fullCellId >> 24) & 0xFFu)
|
||
- (int)((LastCell >> 24) & 0xFFu));
|
||
int dy = Math.Abs(
|
||
(int)((fullCellId >> 16) & 0xFFu)
|
||
- (int)((LastCell >> 16) & 0xFFu));
|
||
return dx <= 1 && dy <= 1;
|
||
}
|
||
}
|
||
|
||
private sealed class FixtureEventRoute(
|
||
Action? onDispose = null) : ILiveSessionEventRouting
|
||
{
|
||
public int AttachCount { get; private set; }
|
||
public int DisposeCount { get; private set; }
|
||
public int DisposeFailuresRemaining { get; set; }
|
||
|
||
public void Attach() => AttachCount++;
|
||
|
||
public void Dispose()
|
||
{
|
||
DisposeCount++;
|
||
onDispose?.Invoke();
|
||
if (DisposeFailuresRemaining > 0)
|
||
{
|
||
DisposeFailuresRemaining--;
|
||
throw new IOException("fixture route detach failure");
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|