e0f96a55bf
Removes a duplicate placement authority for local-player portal arrival. Portalling worked before this change and works after it — this is not a bug fix, EXCEPT that it found and fixed one dead-code production bug. THE PRODUCTION BUG: TryExecuteCanonicalPortalPlacement re-read the accepted destination at Place time, but TryBeginPortalReveal already consumes that slot at Aim time — so the arm was 100% dead code and every real portal Place refused with host-token-unavailable. Found only because we refused to accept 7 skipped tests instead of chasing the count to zero. RETAIL IS THE GENERIC PATH FOR THE THIRD ROUTE RUNNING: SmartBox::TeleportPlayer @0x00453910 = SetPositionSimple(dest, 1) with flags 0x1012, followed by PlayerPositionUpdated. BOTH INVERSIONS, WITH THEIR ANCHORS: unlike route 2, the leash IS armed here (ConstrainTo @0x0045418A) and velocity is zeroed (set_velocity @0x004541B4); unlike route 4b-3, the local teleport_hook runs AFTER placement (@0x004538AE). THE THREE-ROUND DEFECT CHAIN, HONESTLY: - Round 1 released the player at the pre-teleport position while the anim stream marched on — the contract wrongly assumed Place re-fires (process rule 1's third occurrence this campaign). - Round 2's fix inferred commit from a global PendingCount, which three non-committing paths also clear — making the SAME bug complete cleanly and silently. Strictly worse than round 1: round 1 at least tripped portal-complete-before-materialized. - Round 3 latches the commit where it actually happens (ReconcileAndAcknowledgePortal), keyed on reveal generation and teleport sequence, via TryConsumePortalCommit. Two of the three required regression tests landed and are sabotage-verified on both hosts (ParkedPlace_ForgottenByOrdinaryMergeDoesNotLatchAsCommitted / HeadlessPortalPrepareDestinationForgottenByOrdinaryMergeDoesNotLatchAsCommitted). The third (force-arm-takes-the-slot) was judged unnecessary on review: with the inference gone, PendingCount is only a "don't ask yet" guard at both gates, so a force operation occupying or vacating the slot no longer changes an input the commit decision reads — the case collapses into what the landed test already discriminates. THE B2/P3 RESOLUTION: both round-2 reviews were right about different branches of the same synchronous call. RuntimePlacementProjectionSubscription .OnPlacement acknowledges the FIFO head only when TryApply returns true; a Place whose portal authority went stale (transit ended/superseded while parked) used to return false, wedging every later entity's placement receipt behind it forever. Both sinks (RuntimePlacementPresentationSink, HeadlessRuntimePlacementProjectionSink) now acknowledge-and-ignore a stale-authority Place instead of refusing it. The regression test (RuntimePlacementPresentationSinkTests .PortalPlace_StaleTransitHostOrSequenceIsAcknowledgedAndIgnored) had been asserting the old, wrong `false` behaviour; it now asserts and sabotage-verifies the fix. Also lands: AP-144 (register discipline — the portal movement-event send reuses the stricter UsePositionFromServer gate where retail's SendMovementEvent is the looser autonomy_level != 0 test, diverging only at level 1, currently unreachable), AP-145 + issue #318 (the local-player collision-shadow presentation write bypasses its own publisher's ShadowObjects write via a direct cache .Set(), self-healing only once dedup diverges — filed, not fixed, pending a composition test), AD-42 deleted (its last citation retired by the canonical portal arm), AD-2 updated (the wait-cue's trigger predicate now covers a second cause), and two documentation corrections: the enter_world misattribution (both call sites are in SmartBox::HandleCreateObject, only one in the player branch — portal arrival is TeleportPlayer, not enter_world) and the stale "local player never reaches this path" comment on the generic-remote-render-pose write. Suite: 11,090 passed / 4 skipped / 0 failed. No new skips, nothing weakened. STILL OWED: the connected two-client gate, with ACDREAM_PROBE_LOCAL_TELEPORT=1, scored only if [local-tp] lines actually appear in the capture — and explicitly NOT scored as covering issue #318 (no composition test yet asserts PhysicsEngine.ShadowObjects directly). Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
986 lines
35 KiB
C#
986 lines
35 KiB
C#
using System.Net;
|
|
using AcDream.Core.Combat;
|
|
using AcDream.Core.Items;
|
|
using AcDream.Core.Net;
|
|
using AcDream.Core.Net.Messages;
|
|
using AcDream.Core.Physics;
|
|
using AcDream.Core.Spells;
|
|
using AcDream.Runtime.Entities;
|
|
using AcDream.Runtime.Gameplay;
|
|
using AcDream.Runtime.Session;
|
|
using AcDream.Runtime.World;
|
|
|
|
namespace AcDream.Runtime.Tests.Session;
|
|
|
|
public sealed class RuntimeLiveEntitySessionControllerTests
|
|
{
|
|
[Fact]
|
|
public void DirectSinkOwnsCanonicalCreateUpdateDeleteWithoutProjection()
|
|
{
|
|
// C3c: the direct sink's Create now enters the canonical initial
|
|
// residence; this test drives the remote first-entry conductor to
|
|
// completion (the direct-host pump's job) before the follow-up
|
|
// Position flows the ordinary post-residence path.
|
|
using StartedRuntime started = StartRuntime();
|
|
GameRuntime runtime = started.Runtime;
|
|
CommitLandblockCollision(runtime, 0x01010000u);
|
|
RuntimeFirstEntryDriveController drive = CreateDrive(runtime);
|
|
using var session = new WorldSession(
|
|
new IPEndPoint(IPAddress.Loopback, 9000),
|
|
new FixtureTransport());
|
|
// C3c-R1 review R3: the residence route requires a drive-backed
|
|
// world projection — a content-less (projection-less) controller
|
|
// keeps the pre-flip legacy registration instead (see
|
|
// ContentLessDirectSink_KeepsPreFlipLegacyRegistration).
|
|
var controller = new RuntimeLiveEntitySessionController(
|
|
runtime,
|
|
session,
|
|
worldProjection: new FixtureWorldProjection());
|
|
LiveEntitySessionSink sink = controller.CreateSink();
|
|
WorldSession.EntitySpawn spawn =
|
|
Spawn(0x70000001u, incarnation: 1);
|
|
|
|
sink.Spawned(spawn);
|
|
drive.DriveAll();
|
|
Assert.Equal(0, drive.PendingCount);
|
|
DrainPlacementFifo(runtime);
|
|
sink.PositionUpdated(new WorldSession.EntityPositionUpdate(
|
|
spawn.Guid,
|
|
spawn.Position!.Value with
|
|
{
|
|
PositionX = 20f,
|
|
},
|
|
Velocity: null,
|
|
PlacementId: null,
|
|
IsGrounded: true,
|
|
InstanceSequence: 1,
|
|
PositionSequence: 2,
|
|
TeleportSequence: 0,
|
|
ForcePositionSequence: 0));
|
|
|
|
Assert.Equal(1, runtime.Entities.Count);
|
|
Assert.Equal(1, runtime.Inventory.ObjectCount);
|
|
Assert.True(
|
|
runtime.EntityObjects.Entities.TryGetActive(
|
|
spawn.Guid,
|
|
out RuntimeEntityRecord canonical));
|
|
Assert.Equal(
|
|
20f,
|
|
canonical.Snapshot.Position!.Value.PositionX);
|
|
|
|
sink.Deleted(new DeleteObject.Parsed(spawn.Guid, 1));
|
|
|
|
Assert.Equal(0, runtime.Entities.Count);
|
|
Assert.Equal(0, runtime.Inventory.ObjectCount);
|
|
Assert.Equal(
|
|
0,
|
|
runtime.EntityObjects.Entities.PendingTeardownCount);
|
|
}
|
|
|
|
/// <summary>
|
|
/// C3c-R1 review R3: a CONTENT-LESS headless host (validated-legal
|
|
/// configuration: HeadlessConfigurationLoader accepts a null
|
|
/// process.content) builds no world projection and no first-entry
|
|
/// drive. Its Creates must keep the exact pre-flip legacy registration
|
|
/// — the accepted frame commits directly (FullCellId derives from the
|
|
/// wire cell at registration), no residence lease ever opens, and the
|
|
/// entity/residence/drive ledgers stay at zero — because a residence
|
|
/// with no drive to pump it would park every Create (and every packet
|
|
/// FIFO'd behind its pending residence) forever.
|
|
/// </summary>
|
|
[Fact]
|
|
public void ContentLessDirectSink_KeepsPreFlipLegacyRegistration()
|
|
{
|
|
using StartedRuntime started = StartRuntime();
|
|
GameRuntime runtime = started.Runtime;
|
|
using var session = new WorldSession(
|
|
new IPEndPoint(IPAddress.Loopback, 9000),
|
|
new FixtureTransport());
|
|
var controller = new RuntimeLiveEntitySessionController(
|
|
runtime,
|
|
session);
|
|
LiveEntitySessionSink sink = controller.CreateSink();
|
|
WorldSession.EntitySpawn spawn =
|
|
Spawn(0x70000003u, incarnation: 1);
|
|
|
|
sink.Spawned(spawn);
|
|
|
|
Assert.True(
|
|
runtime.EntityObjects.Entities.TryGetActive(
|
|
spawn.Guid,
|
|
out RuntimeEntityRecord canonical));
|
|
Assert.Equal(
|
|
spawn.Position!.Value.LandblockId,
|
|
canonical.FullCellId);
|
|
RuntimeEntityObjectOwnershipSnapshot ownership =
|
|
runtime.EntityObjects.CaptureOwnership();
|
|
Assert.Equal(0, ownership.InitialCreateResidenceLeaseCount);
|
|
Assert.Equal(0, ownership.FirstEntryDrivePendingCount);
|
|
Assert.Equal(1, runtime.Entities.Count);
|
|
Assert.Equal(1, runtime.Inventory.ObjectCount);
|
|
|
|
// Position packets flow the ordinary immediate path — nothing is
|
|
// FIFO'd behind a pending residence.
|
|
sink.PositionUpdated(new WorldSession.EntityPositionUpdate(
|
|
spawn.Guid,
|
|
spawn.Position!.Value with
|
|
{
|
|
PositionX = 20f,
|
|
},
|
|
Velocity: null,
|
|
PlacementId: null,
|
|
IsGrounded: true,
|
|
InstanceSequence: 1,
|
|
PositionSequence: 2,
|
|
TeleportSequence: 0,
|
|
ForcePositionSequence: 0));
|
|
Assert.Equal(
|
|
20f,
|
|
canonical.Snapshot.Position!.Value.PositionX);
|
|
|
|
sink.Deleted(new DeleteObject.Parsed(spawn.Guid, 1));
|
|
Assert.Equal(0, runtime.Entities.Count);
|
|
Assert.Equal(
|
|
0,
|
|
runtime.EntityObjects.Entities.PendingTeardownCount);
|
|
}
|
|
|
|
[Fact]
|
|
public void DirectSinkCompletesExactPortalAndSendsLoginComplete()
|
|
{
|
|
using StartedRuntime started = StartRuntime();
|
|
GameRuntime runtime = started.Runtime;
|
|
const uint playerGuid = 0x50000001u;
|
|
runtime.PlayerIdentity.ServerGuid = playerGuid;
|
|
using var session = new WorldSession(
|
|
new IPEndPoint(IPAddress.Loopback, 9000),
|
|
new FixtureTransport());
|
|
var gameActions = new List<byte[]>();
|
|
session.GameActionCapture = body => gameActions.Add(body);
|
|
var controller = new RuntimeLiveEntitySessionController(
|
|
runtime,
|
|
session);
|
|
LiveEntitySessionSink sink = controller.CreateSink();
|
|
WorldSession.EntitySpawn spawn =
|
|
Spawn(playerGuid, incarnation: 1);
|
|
sink.Spawned(spawn);
|
|
|
|
Assert.Single(gameActions);
|
|
Assert.Equal(GameActionLoginComplete.Build(), gameActions[0]);
|
|
sink.Spawned(spawn);
|
|
Assert.Single(gameActions);
|
|
gameActions.Clear();
|
|
|
|
sink.TeleportStarted(1u);
|
|
sink.PositionUpdated(new WorldSession.EntityPositionUpdate(
|
|
playerGuid,
|
|
spawn.Position!.Value with
|
|
{
|
|
LandblockId = 0x01020001u,
|
|
PositionX = 30f,
|
|
},
|
|
Velocity: null,
|
|
PlacementId: null,
|
|
IsGrounded: true,
|
|
InstanceSequence: 1,
|
|
PositionSequence: 2,
|
|
TeleportSequence: 1,
|
|
ForcePositionSequence: 0));
|
|
|
|
Assert.Single(gameActions);
|
|
Assert.Equal(GameActionLoginComplete.Build(), gameActions[0]);
|
|
Assert.True(runtime.TransitOwner.CaptureOwnership().IsSessionIdle);
|
|
Assert.True(runtime.Portal.Snapshot.Completed);
|
|
Assert.Equal(0x01020001u, runtime.Portal.Snapshot.DestinationCell);
|
|
}
|
|
|
|
[Fact]
|
|
public void DirectSinkProjectsAcceptedLocalWorldStateThroughOneHostSeam()
|
|
{
|
|
using StartedRuntime started = StartRuntime();
|
|
GameRuntime runtime = started.Runtime;
|
|
const uint playerGuid = 0x50000002u;
|
|
runtime.PlayerIdentity.ServerGuid = playerGuid;
|
|
using var session = new WorldSession(
|
|
new IPEndPoint(IPAddress.Loopback, 9000),
|
|
new FixtureTransport());
|
|
session.GameActionCapture = _ => { };
|
|
var projection = new FixtureWorldProjection();
|
|
var controller = new RuntimeLiveEntitySessionController(
|
|
runtime,
|
|
session,
|
|
worldProjection: projection);
|
|
LiveEntitySessionSink sink = controller.CreateSink();
|
|
WorldSession.EntitySpawn spawn =
|
|
Spawn(playerGuid, incarnation: 1);
|
|
|
|
sink.Spawned(spawn);
|
|
sink.TeleportStarted(1u);
|
|
sink.PositionUpdated(new WorldSession.EntityPositionUpdate(
|
|
playerGuid,
|
|
spawn.Position!.Value with
|
|
{
|
|
LandblockId = 0x01020001u,
|
|
PositionX = 30f,
|
|
},
|
|
Velocity: null,
|
|
PlacementId: null,
|
|
IsGrounded: true,
|
|
InstanceSequence: 1,
|
|
PositionSequence: 2,
|
|
TeleportSequence: 1,
|
|
ForcePositionSequence: 0));
|
|
|
|
Assert.Equal(1, projection.SpawnCount);
|
|
Assert.Equal(1, projection.PositionCount);
|
|
Assert.Equal(1, projection.TeleportStartCount);
|
|
Assert.Equal(1, projection.PrepareCount);
|
|
Assert.True(projection.LastSpawnWasLocal);
|
|
Assert.True(projection.LastPositionWasLocal);
|
|
Assert.Equal(
|
|
PositionTimestampDisposition.Apply,
|
|
projection.LastPositionDisposition);
|
|
Assert.Equal(playerGuid, projection.LastRecord?.ServerGuid);
|
|
Assert.Equal(0x01020001u, projection.LastDestination.CellId);
|
|
Assert.True(runtime.TransitOwner.CaptureOwnership().IsSessionIdle);
|
|
Assert.True(runtime.Portal.Snapshot.Completed);
|
|
}
|
|
|
|
/// <summary>
|
|
/// R2/R3 review fix (2026-08-03). No accepted-position drive is supplied
|
|
/// (mirrors <see cref="ContentLessDirectSink_KeepsPreFlipLegacyRegistration"/>'s
|
|
/// "content-less" shape, applied to route 2 specifically), so
|
|
/// <c>TryExecuteAcceptedLocalPosition</c> can never run and every
|
|
/// ForcePosition resolves <c>NotApplicable</c> at the call site. Proves
|
|
/// two things the first implementation pass got wrong: (R2)
|
|
/// <see cref="IRuntimeDirectWorldProjection.CenterOnAcceptedForcePosition"/>
|
|
/// still fires — a host is not left holding a stale collision/streaming
|
|
/// window just because the drive is momentarily absent or NotApplicable
|
|
/// — and (R3) the pre-existing <c>ProjectPosition</c> fallback still runs
|
|
/// for a NotApplicable result, exactly like it did before route 2 existed
|
|
/// (the "no legacy fallback to run instead" comment the review found at
|
|
/// this exact call site was false).
|
|
/// </summary>
|
|
[Fact]
|
|
public void ForcePositionWithoutAnAcceptedPositionDrive_StillCentersAndFallsBackToProjectPosition()
|
|
{
|
|
using StartedRuntime started = StartRuntime();
|
|
GameRuntime runtime = started.Runtime;
|
|
const uint playerGuid = 0x50000005u;
|
|
runtime.PlayerIdentity.ServerGuid = playerGuid;
|
|
using var session = new WorldSession(
|
|
new IPEndPoint(IPAddress.Loopback, 9000),
|
|
new FixtureTransport());
|
|
session.GameActionCapture = _ => { };
|
|
var projection = new FixtureWorldProjection();
|
|
// Deliberately no acceptedPositionDrive argument — mirrors a
|
|
// content-less headless host, where the accepted-position drive is
|
|
// null and route 2 can never apply.
|
|
var controller = new RuntimeLiveEntitySessionController(
|
|
runtime,
|
|
session,
|
|
worldProjection: projection);
|
|
LiveEntitySessionSink sink = controller.CreateSink();
|
|
WorldSession.EntitySpawn spawn =
|
|
Spawn(playerGuid, incarnation: 1);
|
|
|
|
sink.Spawned(spawn);
|
|
Assert.Equal(1, projection.SpawnCount);
|
|
Assert.Equal(0, projection.CenterOnForceCount);
|
|
|
|
sink.PositionUpdated(new WorldSession.EntityPositionUpdate(
|
|
playerGuid,
|
|
spawn.Position!.Value with
|
|
{
|
|
PositionX = 30f,
|
|
},
|
|
Velocity: null,
|
|
PlacementId: null,
|
|
IsGrounded: true,
|
|
InstanceSequence: 1,
|
|
PositionSequence: 2,
|
|
TeleportSequence: 0,
|
|
ForcePositionSequence: 1));
|
|
|
|
Assert.Equal(1, projection.CenterOnForceCount);
|
|
Assert.Equal(playerGuid, projection.LastCenteredRecord?.ServerGuid);
|
|
// The fallback ran: ProjectPosition observed this exact
|
|
// ForcePosition disposition, not just the earlier Apply-shaped spawn
|
|
// follow-up.
|
|
Assert.Equal(1, projection.PositionCount);
|
|
Assert.Equal(
|
|
PositionTimestampDisposition.ForcePosition,
|
|
projection.LastPositionDisposition);
|
|
}
|
|
|
|
/// <summary>
|
|
/// C4 route 7 headless gate (D5) — the direct regression test for the
|
|
/// route-6 scoping's stranded-equipped-child defect: a committed
|
|
/// child's canonical FullCellId must equal its parent's, driven purely
|
|
/// through <see cref="RuntimeLiveEntitySessionController.OnParentUpdated"/>
|
|
/// with no App/graphical layer involved. Fails without D1/D2/D5.
|
|
/// </summary>
|
|
[Fact]
|
|
public void DirectSink_D5_StandaloneParentEventCommitsChildToParentsExactCell()
|
|
{
|
|
using StartedRuntime started = StartRuntime();
|
|
GameRuntime runtime = started.Runtime;
|
|
CommitLandblockCollision(runtime, 0x01010000u);
|
|
CommitLandblockCollision(runtime, 0x01020000u);
|
|
RuntimeFirstEntryDriveController drive = CreateDrive(runtime);
|
|
using var session = new WorldSession(
|
|
new IPEndPoint(IPAddress.Loopback, 9000),
|
|
new FixtureTransport());
|
|
var controller = new RuntimeLiveEntitySessionController(
|
|
runtime,
|
|
session,
|
|
worldProjection: new FixtureWorldProjection());
|
|
LiveEntitySessionSink sink = controller.CreateSink();
|
|
|
|
const uint parentGuid = 0x70000020u;
|
|
const uint childGuid = 0x70000021u;
|
|
sink.Spawned(SpawnAt(parentGuid, incarnation: 1, 0x01010001u));
|
|
drive.DriveAll();
|
|
DrainPlacementFifo(runtime);
|
|
sink.Spawned(SpawnAt(childGuid, incarnation: 1, 0x01020001u));
|
|
drive.DriveAll();
|
|
DrainPlacementFifo(runtime);
|
|
|
|
Assert.True(runtime.EntityObjects.Entities.TryGetActive(
|
|
parentGuid, out RuntimeEntityRecord parent));
|
|
Assert.True(runtime.EntityObjects.Entities.TryGetActive(
|
|
childGuid, out RuntimeEntityRecord child));
|
|
Assert.NotEqual(0u, parent.FullCellId);
|
|
// Distinct starting cells — equality below can only come from D5's
|
|
// commit, never from coincidence.
|
|
Assert.NotEqual(parent.FullCellId, child.FullCellId);
|
|
|
|
sink.ParentUpdated(new ParentEvent.Parsed(
|
|
parentGuid,
|
|
childGuid,
|
|
ParentLocation: 0u,
|
|
PlacementId: 0u,
|
|
ParentInstanceSequence: 1,
|
|
ChildPositionSequence: 2));
|
|
|
|
Assert.Equal(parent.FullCellId, child.FullCellId);
|
|
Assert.NotEqual(0u, child.FullCellId);
|
|
}
|
|
|
|
/// <summary>
|
|
/// D5 companion: the deferred flavor — a standalone ParentEvent naming a
|
|
/// parent whose own CreateObject has not arrived yet must commit once
|
|
/// that guid becomes addressable (<c>OnSpawned</c>'s
|
|
/// <c>RetryChildrenWaitingForParent</c>).
|
|
/// </summary>
|
|
[Fact]
|
|
public void DirectSink_D5_DeferredParentEventCommitsOnceTheParentBecomesAddressable()
|
|
{
|
|
using StartedRuntime started = StartRuntime();
|
|
GameRuntime runtime = started.Runtime;
|
|
CommitLandblockCollision(runtime, 0x01010000u);
|
|
CommitLandblockCollision(runtime, 0x01020000u);
|
|
RuntimeFirstEntryDriveController drive = CreateDrive(runtime);
|
|
using var session = new WorldSession(
|
|
new IPEndPoint(IPAddress.Loopback, 9000),
|
|
new FixtureTransport());
|
|
var controller = new RuntimeLiveEntitySessionController(
|
|
runtime,
|
|
session,
|
|
worldProjection: new FixtureWorldProjection());
|
|
LiveEntitySessionSink sink = controller.CreateSink();
|
|
|
|
const uint parentGuid = 0x70000022u;
|
|
const uint childGuid = 0x70000023u;
|
|
sink.Spawned(SpawnAt(childGuid, incarnation: 1, 0x01020001u));
|
|
drive.DriveAll();
|
|
DrainPlacementFifo(runtime);
|
|
Assert.True(runtime.EntityObjects.Entities.TryGetActive(
|
|
childGuid, out RuntimeEntityRecord child));
|
|
uint childOriginalCell = child.FullCellId;
|
|
|
|
// The ParentEvent arrives BEFORE the parent's own CreateObject.
|
|
sink.ParentUpdated(new ParentEvent.Parsed(
|
|
parentGuid,
|
|
childGuid,
|
|
ParentLocation: 0u,
|
|
PlacementId: 0u,
|
|
ParentInstanceSequence: 1,
|
|
ChildPositionSequence: 2));
|
|
Assert.Equal(childOriginalCell, child.FullCellId);
|
|
|
|
sink.Spawned(SpawnAt(parentGuid, incarnation: 1, 0x01010001u));
|
|
drive.DriveAll();
|
|
DrainPlacementFifo(runtime);
|
|
|
|
Assert.True(runtime.EntityObjects.Entities.TryGetActive(
|
|
parentGuid, out RuntimeEntityRecord parent));
|
|
Assert.Equal(parent.FullCellId, child.FullCellId);
|
|
Assert.NotEqual(0u, child.FullCellId);
|
|
}
|
|
|
|
/// <summary>
|
|
/// C3c-R1 review F6: the drive controller outlives its session routes,
|
|
/// so "session reset precedes a new route" is an asserted latch, not a
|
|
/// silent assumption — a second route cannot attach before the prior
|
|
/// route detached, and a route that never owned the drive cannot clear
|
|
/// the live route's tracked entries.
|
|
/// </summary>
|
|
[Fact]
|
|
public void FirstEntryDriveServesOneRouteAtATimeAndScopesClearToTheOwner()
|
|
{
|
|
using StartedRuntime started = StartRuntime();
|
|
GameRuntime runtime = started.Runtime;
|
|
RuntimeFirstEntryDriveController drive = CreateDrive(runtime);
|
|
var routeA = new object();
|
|
var routeB = new object();
|
|
|
|
drive.AttachRoute(routeA);
|
|
// Re-attaching the same owner is a no-op; a SECOND route asserts.
|
|
drive.AttachRoute(routeA);
|
|
Assert.Throws<InvalidOperationException>(
|
|
() => drive.AttachRoute(routeB));
|
|
|
|
_ = runtime.EntityObjects.RegisterEntityWithInitialResidence(
|
|
Spawn(0x70000004u, incarnation: 1),
|
|
isLocalPlayer: false);
|
|
Assert.Equal(1, drive.PendingCount);
|
|
|
|
// A non-owner detach (never-attached / displaced route rollback)
|
|
// must not clear the live route's entries.
|
|
drive.DetachRoute(routeB);
|
|
Assert.Equal(1, drive.PendingCount);
|
|
|
|
drive.DetachRoute(routeA);
|
|
Assert.Equal(0, drive.PendingCount);
|
|
// After the owner detached, a replacement route may attach.
|
|
drive.AttachRoute(routeB);
|
|
drive.DetachRoute(routeB);
|
|
}
|
|
|
|
[Fact]
|
|
public void FirstEntryDriveSignalsLocalCompletionOnceAfterCanonicalPlacement()
|
|
{
|
|
using StartedRuntime started = StartRuntime();
|
|
GameRuntime runtime = started.Runtime;
|
|
const uint playerGuid = 0x50000003u;
|
|
runtime.PlayerIdentity.ServerGuid = playerGuid;
|
|
CommitLandblockCollision(runtime, 0x01010000u);
|
|
RuntimeFirstEntryDriveController drive = CreateDrive(runtime);
|
|
var route = new object();
|
|
int completed = 0;
|
|
drive.AttachRoute(route, record =>
|
|
{
|
|
Assert.Equal(playerGuid, record.ServerGuid);
|
|
completed++;
|
|
});
|
|
using var session = new WorldSession(
|
|
new IPEndPoint(IPAddress.Loopback, 9000),
|
|
new FixtureTransport());
|
|
var controller = new RuntimeLiveEntitySessionController(
|
|
runtime,
|
|
session,
|
|
worldProjection: new FixtureWorldProjection());
|
|
LiveEntitySessionSink sink = controller.CreateSink();
|
|
|
|
sink.Spawned(Spawn(playerGuid, incarnation: 1));
|
|
Assert.Equal(0, completed);
|
|
|
|
DrainFirstEntry(runtime, drive);
|
|
|
|
Assert.Equal(1, completed);
|
|
Assert.Equal(0, drive.PendingCount);
|
|
drive.DetachRoute(route);
|
|
}
|
|
|
|
/// <summary>
|
|
/// C3c: initial-residence admission requires a live session generation
|
|
/// (RuntimeInitialCreateResidenceState.CanAcceptCreate), so these direct
|
|
/// sink tests start one through the same fixture-session shape
|
|
/// DirectGameRuntimeCommandAdapterTests uses.
|
|
/// </summary>
|
|
private sealed class StartedRuntime : IDisposable
|
|
{
|
|
internal required GameRuntime Runtime { get; init; }
|
|
internal required LiveSessionHost Live { get; init; }
|
|
|
|
public void Dispose()
|
|
{
|
|
_ = Live.Stop(Runtime.Generation);
|
|
Runtime.Dispose();
|
|
}
|
|
}
|
|
|
|
private static StartedRuntime StartRuntime()
|
|
{
|
|
var operations = new FixtureGameplayOperations();
|
|
var sessionOperations = new FixtureSessionOperations();
|
|
var runtime = new GameRuntime(new GameRuntimeDependencies(
|
|
operations,
|
|
operations,
|
|
operations,
|
|
operations,
|
|
SessionOperations: sessionOperations));
|
|
operations.Bind(runtime);
|
|
var resetHost = new FixtureResetHost();
|
|
var options = new LiveSessionConnectOptions(
|
|
true,
|
|
"127.0.0.1",
|
|
9000,
|
|
"account",
|
|
"password");
|
|
var live = new LiveSessionHost(
|
|
runtime.Session,
|
|
new LiveSessionHostBindings(
|
|
new LiveSessionRoutingFactories(
|
|
_ => new FixtureEventRoute(),
|
|
_ => new FixtureCommandRoute()),
|
|
generation => runtime.ResetGeneration(generation, resetHost),
|
|
new LiveSessionSelectionBindings(
|
|
id => runtime.PlayerIdentity.ServerGuid = id,
|
|
_ => { },
|
|
runtime.CommunicationOwner.Chat.SetLocalPlayerGuid,
|
|
_ => { },
|
|
_ => { },
|
|
runtime.ActionOwner.Combat.Clear),
|
|
new LiveSessionEnteredWorldBindings(
|
|
_ => { },
|
|
() => { },
|
|
() => { },
|
|
_ => { },
|
|
() => { }),
|
|
(_, _, _) => { },
|
|
() => { }),
|
|
options);
|
|
LiveSessionStartResult startResult = live.Start(options);
|
|
Assert.Equal(LiveSessionStartStatus.Connected, startResult.Status);
|
|
Assert.NotEqual(0UL, runtime.Generation.Value);
|
|
return new StartedRuntime { Runtime = runtime, Live = live };
|
|
}
|
|
|
|
private static void CommitLandblockCollision(
|
|
GameRuntime runtime,
|
|
uint landblockId)
|
|
{
|
|
runtime.EntityObjects.Physics.SetPosition.BeginCollisionGeneration(
|
|
landblockId, 1UL);
|
|
runtime.EntityObjects.Physics.Engine.AddLandblock(
|
|
landblockId,
|
|
new TerrainSurface(new byte[81], new float[256]),
|
|
Array.Empty<CellSurface>(),
|
|
Array.Empty<PortalPlane>(),
|
|
worldOffsetX: 0f,
|
|
worldOffsetY: 0f);
|
|
runtime.EntityObjects.Physics.SetPosition.CommitCollisionGeneration(
|
|
landblockId, 1UL, ready: true);
|
|
|
|
// 670f307c: a remote conductor resolves its landblock-local Create
|
|
// origin through Runtime's world frame
|
|
// (RuntimeSetPositionState.PrepareMover:1526-1544) and parks on
|
|
// RetrySetupUnavailable until that frame exists. Production publishes
|
|
// it from the accepted local-player Create
|
|
// (RuntimeEntityObjectLifetime.RegisterEntityCore:558-570), which
|
|
// always precedes broadcast Creates. Model it with the resident
|
|
// landblock it belongs to, so these direct-sink tests keep asserting
|
|
// exact single-entity ledgers.
|
|
runtime.EntityObjects.Physics.ObserveLocalWorldFrame(
|
|
landblockId | 0x0001u,
|
|
teleportAdvanced: false);
|
|
}
|
|
|
|
private static RuntimeFirstEntryDriveController CreateDrive(
|
|
GameRuntime runtime) =>
|
|
new(
|
|
runtime.EntityObjects,
|
|
runtime.Clock,
|
|
new UnusedCollisionSource(),
|
|
() => PlayerMovementConstructionOptions.Fallback,
|
|
static _ => new RuntimeLocalPlayerPhysicsActivationPreparation(
|
|
Radius: 0.48f,
|
|
Height: 1.835f,
|
|
RuntimeLocalPlayerShadowDisposition.ProvenShapeless));
|
|
|
|
private static void DrainFirstEntry(
|
|
GameRuntime runtime,
|
|
RuntimeFirstEntryDriveController drive)
|
|
{
|
|
for (int attempt = 0; attempt < 8 && drive.PendingCount != 0; attempt++)
|
|
{
|
|
drive.DriveAll();
|
|
DrainPlacementFifo(runtime);
|
|
}
|
|
Assert.Equal(0, drive.PendingCount);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Drains/acknowledges every still-pending placement receipt (the
|
|
/// ExecutorCompleted correlation is reaped by its acknowledgement) the
|
|
/// way a host subscription would.
|
|
/// </summary>
|
|
private static void DrainPlacementFifo(GameRuntime runtime)
|
|
{
|
|
while (runtime.EntityObjects.Physics.SetPosition.TryPeekProjection(
|
|
out AcDream.Runtime.Physics.RuntimePlacementProjectionSnapshot head))
|
|
{
|
|
if (!runtime.EntityObjects.Physics.SetPosition
|
|
.AcknowledgeProjection(head.Token))
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
private sealed class UnusedCollisionSource
|
|
: AcDream.Content.IPreparedCollisionSource
|
|
{
|
|
public AcDream.Content.PreparedAssetPresence ProbeCollision(
|
|
AcDream.Content.Pak.PakAssetType type,
|
|
uint sourceFileId) =>
|
|
AcDream.Content.PreparedAssetPresence.Available;
|
|
|
|
public AcDream.Content.PreparedCollisionReadResult<
|
|
AcDream.Core.Physics.FlatSetupCollision> ReadSetupCollision(
|
|
uint sourceFileId,
|
|
CancellationToken cancellationToken = default) =>
|
|
AcDream.Content.PreparedCollisionReadResult<
|
|
AcDream.Core.Physics.FlatSetupCollision>.Missing;
|
|
|
|
public AcDream.Content.PreparedCollisionReadResult<
|
|
AcDream.Core.Physics.FlatGfxObjCollisionAsset> ReadGfxObjCollision(
|
|
uint sourceFileId,
|
|
CancellationToken cancellationToken = default) =>
|
|
throw new NotSupportedException();
|
|
|
|
public AcDream.Content.PreparedCollisionReadResult<
|
|
AcDream.Core.Physics.FlatCellStructureCollisionAsset>
|
|
ReadCellStructureCollision(
|
|
uint sourceFileId,
|
|
CancellationToken cancellationToken = default) =>
|
|
throw new NotSupportedException();
|
|
|
|
public AcDream.Content.PreparedCollisionReadResult<
|
|
AcDream.Core.Physics.FlatEnvCellTopology> ReadEnvCellTopology(
|
|
uint sourceFileId,
|
|
CancellationToken cancellationToken = default) =>
|
|
throw new NotSupportedException();
|
|
|
|
public AcDream.Content.PreparedCollisionSourceStats CollisionStats =>
|
|
default;
|
|
|
|
public void Dispose()
|
|
{
|
|
}
|
|
}
|
|
|
|
private sealed class FixtureSessionOperations : ILiveSessionOperations
|
|
{
|
|
public IPEndPoint ResolveEndpoint(string host, int port) =>
|
|
new(IPAddress.Loopback, port);
|
|
|
|
public WorldSession CreateSession(IPEndPoint endpoint) =>
|
|
new(endpoint, new FixtureTransport());
|
|
|
|
public void Connect(WorldSession session, string user, string password)
|
|
{
|
|
}
|
|
|
|
public CharacterList.Parsed GetCharacters(WorldSession session) =>
|
|
new(
|
|
0u,
|
|
[new CharacterList.Character(0x50000001u, "Direct", 0u)],
|
|
[],
|
|
11,
|
|
"account",
|
|
true,
|
|
true);
|
|
|
|
public void EnterWorld(WorldSession session, int activeCharacterIndex)
|
|
{
|
|
}
|
|
|
|
public void Tick(WorldSession session)
|
|
{
|
|
}
|
|
|
|
public void DisposeSession(WorldSession session) =>
|
|
session.Dispose();
|
|
}
|
|
|
|
private sealed class FixtureEventRoute : ILiveSessionEventRouting
|
|
{
|
|
public void Attach()
|
|
{
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
}
|
|
}
|
|
|
|
private sealed class FixtureCommandRoute : ILiveSessionCommandRouting
|
|
{
|
|
public void Activate()
|
|
{
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
}
|
|
}
|
|
|
|
private sealed class FixtureResetHost : IRuntimeGenerationResetHost
|
|
{
|
|
public void RetireEntityProjection(RuntimeEntityRecord entity)
|
|
{
|
|
}
|
|
|
|
public void DrainEntityProjectionBoundary()
|
|
{
|
|
}
|
|
|
|
public void CompleteEntityProjectionRetirement()
|
|
{
|
|
}
|
|
}
|
|
|
|
private static WorldSession.EntitySpawn Spawn(
|
|
uint guid,
|
|
ushort incarnation) =>
|
|
SpawnAt(guid, incarnation, 0x01010001u);
|
|
|
|
/// <summary>
|
|
/// C4 route 7 D5 gate: <see cref="Spawn"/> parametrized over the wire
|
|
/// landblock, so a parent and a child can be seeded at DISTINCT cells —
|
|
/// equality after the D5 commit can then only come from the
|
|
/// propagation write, never from a coincidental shared default.
|
|
/// </summary>
|
|
private static WorldSession.EntitySpawn SpawnAt(
|
|
uint guid,
|
|
ushort incarnation,
|
|
uint landblockId)
|
|
{
|
|
var position = new CreateObject.ServerPosition(
|
|
landblockId,
|
|
10f,
|
|
10f,
|
|
5f,
|
|
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: incarnation);
|
|
var physics = new PhysicsSpawnData(
|
|
RawState: (uint)PhysicsStateFlags.ReportCollisions,
|
|
Position: position,
|
|
Movement: null,
|
|
AnimationFrame: null,
|
|
SetupTableId: null,
|
|
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,
|
|
null,
|
|
[],
|
|
[],
|
|
[],
|
|
null,
|
|
null,
|
|
"direct entity",
|
|
null,
|
|
null,
|
|
null,
|
|
PhysicsState: physics.RawState,
|
|
InstanceSequence: incarnation,
|
|
MovementSequence: 1,
|
|
ServerControlSequence: 1,
|
|
PositionSequence: 1,
|
|
Physics: physics);
|
|
}
|
|
|
|
private sealed class FixtureTransport : IWorldSessionTransport
|
|
{
|
|
public void Send(ReadOnlySpan<byte> datagram)
|
|
{
|
|
}
|
|
|
|
public void Send(
|
|
IPEndPoint remote,
|
|
ReadOnlySpan<byte> datagram)
|
|
{
|
|
}
|
|
|
|
public int Receive(
|
|
Span<byte> destination,
|
|
TimeSpan timeout,
|
|
out IPEndPoint? from)
|
|
{
|
|
from = null;
|
|
return -1;
|
|
}
|
|
|
|
public ValueTask<NetReceiveResult> ReceiveAsync(
|
|
Memory<byte> destination,
|
|
CancellationToken cancellationToken) =>
|
|
ValueTask.FromException<NetReceiveResult>(
|
|
new OperationCanceledException(cancellationToken));
|
|
|
|
public void Dispose()
|
|
{
|
|
}
|
|
}
|
|
|
|
private sealed class FixtureWorldProjection
|
|
: IRuntimeDirectWorldProjection
|
|
{
|
|
public int SpawnCount { get; private set; }
|
|
public int PositionCount { get; private set; }
|
|
public int TeleportStartCount { get; private set; }
|
|
public int PrepareCount { get; private set; }
|
|
public int CenterOnForceCount { get; private set; }
|
|
public RuntimeEntityRecord? LastCenteredRecord { get; private set; }
|
|
public bool LastSpawnWasLocal { get; private set; }
|
|
public bool LastPositionWasLocal { get; private set; }
|
|
public PositionTimestampDisposition LastPositionDisposition
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
public RuntimeEntityRecord? LastRecord { get; private set; }
|
|
public RuntimeTeleportDestination LastDestination { get; private set; }
|
|
|
|
public void ProjectSpawn(
|
|
RuntimeEntityRecord record,
|
|
bool isLocalPlayer)
|
|
{
|
|
SpawnCount++;
|
|
LastRecord = record;
|
|
LastSpawnWasLocal = isLocalPlayer;
|
|
}
|
|
|
|
public void ProjectPosition(
|
|
RuntimeEntityRecord record,
|
|
bool isLocalPlayer,
|
|
PositionTimestampDisposition disposition)
|
|
{
|
|
PositionCount++;
|
|
LastRecord = record;
|
|
LastPositionWasLocal = isLocalPlayer;
|
|
LastPositionDisposition = disposition;
|
|
}
|
|
|
|
public void CenterOnAcceptedForcePosition(RuntimeEntityRecord record)
|
|
{
|
|
CenterOnForceCount++;
|
|
LastCenteredRecord = record;
|
|
}
|
|
|
|
public void BeginTeleport() => TeleportStartCount++;
|
|
|
|
public RuntimeDestinationReadiness PrepareDestination(
|
|
long revealGeneration,
|
|
RuntimeTeleportDestination destination,
|
|
RuntimeWorldHostProjectionToken portal)
|
|
{
|
|
PrepareCount++;
|
|
LastDestination = destination;
|
|
bool indoor = (destination.CellId & 0xFFFFu) >= 0x0100u;
|
|
return new RuntimeDestinationReadiness(
|
|
revealGeneration,
|
|
destination.CellId,
|
|
indoor,
|
|
IsUnhydratable: false,
|
|
RequiredRenderRadius: indoor ? 0 : 1,
|
|
IsRenderNeighborhoodReady: true,
|
|
AreCompositeTexturesReady: true,
|
|
IsCollisionReady: true);
|
|
}
|
|
}
|
|
|
|
private sealed class FixtureGameplayOperations
|
|
: IRuntimeCombatAttackOperations,
|
|
IRuntimeCombatTargetOperations,
|
|
IRuntimeCombatModeOperations,
|
|
IRuntimeSpellCastOperations
|
|
{
|
|
private GameRuntime? _runtime;
|
|
|
|
public void Bind(GameRuntime runtime) => _runtime = runtime;
|
|
public bool CanStartAttack() => false;
|
|
public void PrepareAttackRequest()
|
|
{
|
|
}
|
|
|
|
public bool SendAttack(AttackHeight height, float power) => false;
|
|
public void SendCancelAttack()
|
|
{
|
|
}
|
|
|
|
public bool IsDualWield => false;
|
|
public bool PlayerReadyForAttack => false;
|
|
public bool AutoRepeatAttack => false;
|
|
public bool AutoTarget => false;
|
|
public uint? SelectClosestTarget() => null;
|
|
public bool IsInWorld => _runtime?.Session.IsInWorld == true;
|
|
public IReadOnlyList<ClientObject> GetOrderedEquipment() => [];
|
|
public void NotifyExplicitCombatModeRequest()
|
|
{
|
|
}
|
|
|
|
public void SendChangeCombatMode(CombatMode mode)
|
|
{
|
|
}
|
|
|
|
public uint LocalPlayerId =>
|
|
_runtime?.PlayerIdentity.ServerGuid ?? 0u;
|
|
public bool CanSend => false;
|
|
public bool HasRequiredComponents(uint spellId) => false;
|
|
|
|
public bool IsTargetCompatible(
|
|
uint targetId,
|
|
SpellMetadata spell,
|
|
bool showMessage) => false;
|
|
|
|
public void StopCompletely()
|
|
{
|
|
}
|
|
|
|
public void SendUntargeted(uint spellId)
|
|
{
|
|
}
|
|
|
|
public void SendTargeted(uint targetId, uint spellId)
|
|
{
|
|
}
|
|
|
|
public void DisplayMessage(string message)
|
|
{
|
|
}
|
|
|
|
public void IncrementBusy()
|
|
{
|
|
}
|
|
}
|
|
}
|