ff100cf33f
C5b (735f0a72) made the steady-state accepted-Position merge stop writing residency. That is retail-correct — HandleReceivedPosition @0x00453FD0 reads the wire objcell_id into a local and never assigns the object's cell — and it stays. What C5b did not account for is that its replacement writers both live in AcDream.App: the OnPosition prologue rebucket (AD-60's W2) and the post-routing wire-cell adopt (W3, AP-135). The two hosts run parallel, non-shared inbound routes. LiveEntitySessionController -> LiveEntityNetworkUpdateController.OnPosition is graphical-only; RuntimeLiveEntitySessionController.OnPositionUpdated is the no-window route and is constructed only at HeadlessSessionHost.cs:682. So AcDream.Headless had NO post-merge cell writer at all. Every remote's FullCellId was written at create/placement and then frozen for the session — and RuntimeEntityObjectViews .Snapshot projects exactly that field as RuntimeEntitySnapshot.CellId, i.e. every bot's entire world view. The local player lost one of AP-146's three refresh edges, which matters beyond cosmetics: RuntimeSetPositionState .IsAffectedCollisionResident reads FullCellId to pick which bodies a landblock retirement parks, so a bot running A->B without teleporting would have retired A while parking a body physically in B. The fix, in three parts: 1. RuntimeEntityObjectLifetime.CommitWireCellRebucket — a new Runtime owner for the committed VALUE, extracted verbatim from LiveEntityRuntime .RebucketLiveEntity. This is also the root-cause fix for the layering inversion the review found: AD-60 was documenting its own correctness by naming an App class the Runtime assembly cannot reference. Behaviour on the graphical side is unchanged — record.FullCellId is a proxy for record.Canonical.FullCellId, which is the record the callee reads, and the commit is still CommitRebucket. Verified load-bearing for BOTH hosts: sabotaging the preserve branch reddens the graphical LiveEntityRuntimeTests.CanonicalOnlyRebucket_DoesNotOverwriteAuthoritativeFullCell as well as the new headless assertion. 2. RuntimeLiveEntitySessionController.TryCommitAcceptedWireCell — the no-window W2, under the same reachability rules the graphical route applies: Rejected writes nothing (the shape the App authority gate produces by returning false); a bound-projectile packet writes nothing (routed by the graphical host through the canonical projectile placement owner, which returns before W2); an active initial-create residence writes nothing (RebucketLiveEntity's own early return — while the lease is live the SetPosition conductor is the sole cell authority); a local ForcePosition writes only when the accepted-Position drive declined it (NotApplicable), because a handled force is placement-receipt-authoritative. W2/W3 themselves are untouched. 3. On the committed value (the landblock-vs-cell trap). RebucketLiveEntity's preserve branch fires on a LANDBLOCK-shaped id — low 16 bits 0xFFFF — and exists for LocalPlayerProjectionController.Project, the per-frame local movement caller that emits exactly that shape. An inbound wire objcell_id is never landblock-shaped, so on the accepted-Position route the branch is not taken and the exact wire cell is committed. That is what W2 commits today and what this now commits; the no-window host has no per-frame caller at all. Ordering is matched, not improved on: the force drive submits its placement before the commit, so its first submit still reads the pre-commit FullCellId — AP-138's amended route-2 CurrentCellId measurement. Bookkeeping in this commit: - AD-60 corrected. Its surviving-channel enumeration presented "the local force path, the missile arm" as exhaustive; the entire no-window host belonged in it. 23aa62f2's W2/W3-redundancy measurement is preserved verbatim. - AP-146 and #320 amended the same way — their three-edge list was written from the graphical host and silently assumed both hosts shared it. The no-window host had two of three; it now has all three. - AD-64 filed: the reachability decision is now expressed once per host. The value is single-sourced; the gate set is not. - #324 filed: unifying the two session controllers is the genuinely correct fix and is campaign-sized (presentation recovery, hydration, the equipped-child renderer, and the remote/projectile routing arms only one host has). Not attempted here, per the fix brief. Gates. Release build 0 errors. Complete suite 11,141 passed / 4 skipped / 0 failed, against the 11,134 / 4 / 0 baseline at23aa62f2— net +7, exactly the 7 tests added. Eight sabotages verified, each red on at least one discriminating test and green when reverted: remote commit removed (2 Runtime + the end-to-end Headless test); local ordinary commit removed; local NotApplicable-force commit removed; force commit made unconditional; residence gate removed; missile gate removed; Rejected gate removed; preserve branch broken (red on both hosts). Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
1270 lines
47 KiB
C#
1270 lines
47 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>
|
|
/// D1 (C5b architecture review) — THE discriminating test for the
|
|
/// no-window host's missing post-merge cell writer. C5b made the
|
|
/// steady-state merge withhold the wire cell and left the replacement
|
|
/// writers (AD-60's W2/W3) in <c>AcDream.App</c>, which this route does
|
|
/// not have and cannot reach. Before the fix a headless remote's
|
|
/// <c>FullCellId</c> was written at create/placement and then frozen for
|
|
/// the whole session, no matter how far the server said it walked, and
|
|
/// <c>RuntimeEntityObjectViews.Snapshot</c> feeds exactly that field to
|
|
/// every bot's <c>RuntimeEntitySnapshot.CellId</c>.
|
|
/// </summary>
|
|
[Fact]
|
|
public void AcceptedRemotePosition_AdvancesCanonicalResidencyInANoWindowHost()
|
|
{
|
|
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());
|
|
var controller = new RuntimeLiveEntitySessionController(
|
|
runtime,
|
|
session,
|
|
worldProjection: new FixtureWorldProjection());
|
|
LiveEntitySessionSink sink = controller.CreateSink();
|
|
WorldSession.EntitySpawn spawn =
|
|
SpawnAt(0x70000020u, incarnation: 1, 0x01010001u);
|
|
|
|
sink.Spawned(spawn);
|
|
DrainFirstEntry(runtime, drive);
|
|
|
|
Assert.True(runtime.EntityObjects.Entities.TryGetActive(
|
|
spawn.Guid,
|
|
out RuntimeEntityRecord remote));
|
|
uint placedCell = remote.FullCellId;
|
|
Assert.NotEqual(0u, placedCell);
|
|
|
|
// A steady-state Position that crosses into another cell of the SAME
|
|
// landblock — no teleport channel, no force channel, so this is the
|
|
// ordinary accepted-Position merge, the exact packet shape C5b
|
|
// stopped writing residency for.
|
|
const uint movedCell = 0x01010013u;
|
|
Assert.NotEqual(movedCell, placedCell);
|
|
sink.PositionUpdated(PositionUpdate(
|
|
spawn.Guid,
|
|
movedCell,
|
|
positionX: 40f,
|
|
positionSequence: 2));
|
|
|
|
Assert.Equal(movedCell, remote.FullCellId);
|
|
Assert.Equal(0x0101FFFFu, remote.CanonicalLandblockId);
|
|
// The bot-visible projection, which is the observable this defect
|
|
// actually broke.
|
|
Assert.True(runtime.Entities.TryGet(
|
|
spawn.Guid,
|
|
out RuntimeEntitySnapshot view));
|
|
Assert.Equal(movedCell, view.CellId);
|
|
}
|
|
|
|
/// <summary>
|
|
/// D1's local-player half. AP-146 enumerates three edges that refresh
|
|
/// the local player's canonical cell; C5b moved the inbound-Position
|
|
/// one out of the merge and into an App-only writer, so a no-window
|
|
/// host lost it entirely. The consequence is not cosmetic:
|
|
/// <c>RuntimeSetPositionState.IsAffectedCollisionResident</c> reads
|
|
/// <c>FullCellId</c> to decide which bodies a landblock retirement
|
|
/// parks, so a bot that runs A->B without teleporting would have
|
|
/// retired A while parking a body that is physically in B.
|
|
/// </summary>
|
|
[Fact]
|
|
public void AcceptedLocalPlayerPosition_AdvancesCanonicalResidencyInANoWindowHost()
|
|
{
|
|
using StartedRuntime started = StartRuntime();
|
|
GameRuntime runtime = started.Runtime;
|
|
const uint playerGuid = 0x50000020u;
|
|
runtime.PlayerIdentity.ServerGuid = playerGuid;
|
|
CommitLandblockCollision(runtime, 0x01010000u);
|
|
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();
|
|
|
|
sink.Spawned(SpawnAt(playerGuid, incarnation: 1, 0x01010001u));
|
|
DrainFirstEntry(runtime, drive);
|
|
|
|
Assert.True(runtime.EntityObjects.Entities.TryGetActive(
|
|
playerGuid,
|
|
out RuntimeEntityRecord player));
|
|
uint placedCell = player.FullCellId;
|
|
Assert.NotEqual(0u, placedCell);
|
|
|
|
const uint movedCell = 0x01010021u;
|
|
Assert.NotEqual(movedCell, placedCell);
|
|
sink.PositionUpdated(PositionUpdate(
|
|
playerGuid,
|
|
movedCell,
|
|
positionX: 55f,
|
|
positionSequence: 2));
|
|
|
|
Assert.Equal(movedCell, player.FullCellId);
|
|
Assert.Equal(0x0101FFFFu, player.CanonicalLandblockId);
|
|
}
|
|
|
|
/// <summary>
|
|
/// D1's negative half, stated as three separate rules rather than one
|
|
/// aggregate assertion.
|
|
///
|
|
/// <para>
|
|
/// (a) A <c>Rejected</c> disposition writes NOTHING — the shape the
|
|
/// graphical route gets for free by returning false from
|
|
/// <c>LiveEntityInboundAuthorityGate.TryAcceptPosition</c> ahead of
|
|
/// every wire-cell writer. (b) An active initial-create residence
|
|
/// suppresses the commit, mirroring
|
|
/// <c>LiveEntityRuntime.RebucketLiveEntity</c>'s own early return:
|
|
/// while the lease is live, Runtime's SetPosition conductor is the sole
|
|
/// cell authority and a wire cell must not pre-empt it. (c) A
|
|
/// LANDBLOCK-shaped id preserves the exact cell instead of coarsening
|
|
/// it — the rule fact 4 of this fix's brief warned about, asserted
|
|
/// directly against the shared derivation.
|
|
/// </para>
|
|
/// </summary>
|
|
[Fact]
|
|
public void WireCellCommit_HonoursRejection_Residence_AndTheLandblockPreserveRule()
|
|
{
|
|
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());
|
|
var controller = new RuntimeLiveEntitySessionController(
|
|
runtime,
|
|
session,
|
|
worldProjection: new FixtureWorldProjection());
|
|
LiveEntitySessionSink sink = controller.CreateSink();
|
|
WorldSession.EntitySpawn spawn =
|
|
SpawnAt(0x70000021u, incarnation: 1, 0x01010001u);
|
|
|
|
// (b) The residence is open between Spawned and the drive's drain.
|
|
sink.Spawned(spawn);
|
|
Assert.True(runtime.EntityObjects.Entities.TryGetActive(
|
|
spawn.Guid,
|
|
out RuntimeEntityRecord remote));
|
|
Assert.True(runtime.EntityObjects.TryGetInitialCreateResidence(
|
|
remote,
|
|
out _));
|
|
uint duringResidence = remote.FullCellId;
|
|
sink.PositionUpdated(PositionUpdate(
|
|
spawn.Guid,
|
|
0x01010031u,
|
|
positionX: 12f,
|
|
positionSequence: 2));
|
|
Assert.Equal(duringResidence, remote.FullCellId);
|
|
|
|
DrainFirstEntry(runtime, drive);
|
|
uint placedCell = remote.FullCellId;
|
|
Assert.NotEqual(0u, placedCell);
|
|
|
|
// (a) A stale position sequence is Rejected by the timestamp gate.
|
|
sink.PositionUpdated(PositionUpdate(
|
|
spawn.Guid,
|
|
0x01010041u,
|
|
positionX: 13f,
|
|
positionSequence: 1));
|
|
Assert.Equal(placedCell, remote.FullCellId);
|
|
|
|
// (c) The landblock-shaped id preserves the exact cell.
|
|
Assert.True(runtime.EntityObjects.CommitWireCellRebucket(
|
|
remote,
|
|
0x0202FFFFu));
|
|
Assert.Equal(placedCell, remote.FullCellId);
|
|
Assert.Equal(0x0202FFFFu, remote.CanonicalLandblockId);
|
|
}
|
|
|
|
/// <summary>
|
|
/// D1's missile gate. The graphical route sends a BOUND projectile's
|
|
/// accepted Position to the canonical projectile placement owner and
|
|
/// returns before AD-60's W2, so no wire cell is committed for it; the
|
|
/// no-window route must not invent one. An UNBOUND Missile-flagged
|
|
/// record takes the ordinary remote tail in both hosts — the same
|
|
/// distinction <see cref="Entities.RuntimeProjectilePositionKindTests"/>
|
|
/// pins on the classifier, asserted here on the residency write.
|
|
/// </summary>
|
|
[Fact]
|
|
public void BoundProjectilePosition_CommitsNoWireCell_UnboundMissileDoes()
|
|
{
|
|
using StartedRuntime started = StartRuntime();
|
|
GameRuntime runtime = started.Runtime;
|
|
using var session = new WorldSession(
|
|
new IPEndPoint(IPAddress.Loopback, 9000),
|
|
new FixtureTransport());
|
|
// Content-less direct host: legacy registration, no residence lease,
|
|
// so the packet reaches the wire-cell decision with nothing else in
|
|
// the way.
|
|
var controller = new RuntimeLiveEntitySessionController(
|
|
runtime,
|
|
session);
|
|
LiveEntitySessionSink sink = controller.CreateSink();
|
|
|
|
const uint boundGuid = 0x70000041u;
|
|
const uint unboundGuid = 0x70000042u;
|
|
sink.Spawned(SpawnAt(boundGuid, incarnation: 1, 0x01010001u));
|
|
sink.Spawned(SpawnAt(unboundGuid, incarnation: 1, 0x01010001u));
|
|
Assert.True(runtime.EntityObjects.Entities.TryGetActive(
|
|
boundGuid,
|
|
out RuntimeEntityRecord bound));
|
|
Assert.True(runtime.EntityObjects.Entities.TryGetActive(
|
|
unboundGuid,
|
|
out RuntimeEntityRecord unbound));
|
|
|
|
foreach (RuntimeEntityRecord missile in new[] { bound, unbound })
|
|
{
|
|
runtime.EntityObjects.Entities.SetFinalPhysicsState(
|
|
missile,
|
|
missile.FinalPhysicsState | PhysicsStateFlags.Missile);
|
|
}
|
|
|
|
var body = new PhysicsBody
|
|
{
|
|
Position = new System.Numerics.Vector3(10f, 10f, 5f),
|
|
Orientation = System.Numerics.Quaternion.Identity,
|
|
LastUpdateTime = 1d,
|
|
State = bound.FinalPhysicsState,
|
|
TransientState = TransientStateFlags.Active,
|
|
};
|
|
body.SnapToCell(0x01010001u, body.Position, body.Position);
|
|
runtime.EntityObjects.Entities.SetPhysicsBody(bound, body);
|
|
runtime.EntityObjects.Physics.BindProjectile(
|
|
bound,
|
|
body,
|
|
new ProjectileCollisionSphere(
|
|
System.Numerics.Vector3.Zero,
|
|
0.1f,
|
|
1f));
|
|
Assert.NotNull(bound.Projectile);
|
|
Assert.Null(unbound.Projectile);
|
|
|
|
const uint movedCell = 0x01010051u;
|
|
sink.PositionUpdated(PositionUpdate(
|
|
boundGuid,
|
|
movedCell,
|
|
positionX: 30f,
|
|
positionSequence: 2));
|
|
sink.PositionUpdated(PositionUpdate(
|
|
unboundGuid,
|
|
movedCell,
|
|
positionX: 30f,
|
|
positionSequence: 2));
|
|
|
|
Assert.Equal(0x01010001u, bound.FullCellId);
|
|
Assert.Equal(movedCell, unbound.FullCellId);
|
|
}
|
|
|
|
private static WorldSession.EntityPositionUpdate PositionUpdate(
|
|
uint guid,
|
|
uint cellId,
|
|
float positionX,
|
|
ushort positionSequence) =>
|
|
new(
|
|
guid,
|
|
new CreateObject.ServerPosition(
|
|
cellId,
|
|
positionX,
|
|
10f,
|
|
5f,
|
|
1f,
|
|
0f,
|
|
0f,
|
|
0f),
|
|
Velocity: null,
|
|
PlacementId: null,
|
|
IsGrounded: true,
|
|
InstanceSequence: 1,
|
|
PositionSequence: positionSequence,
|
|
TeleportSequence: 0,
|
|
ForcePositionSequence: 0);
|
|
|
|
/// <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()
|
|
{
|
|
}
|
|
}
|
|
}
|