735f0a72af
The steady-state accepted-Position merge did two things retail never does,
on every single Position packet: it installed the wire placement frame and
unparented unconditionally, and it derived the record's FullCellId from
bare wire acceptance. Both are now correct, and they land together - a
half-flipped intermediate (classified flags with the wire stamp, or vice
versa) is exactly the mixed-residency state this campaign keeps paying for.
WHY the flags need no route. SmartBox::HandleReceivedPosition @0x00453FD0
decides both pre-placement writes BEFORE MoveOrTeleport is consulted: Gate A
@0x0045400C returns @0x0045409D ahead of unset_parent @0x00454129 and ahead
of the HasAnims SetPlacementFrame gate @0x00454137. Neither gate reads the
near/far/teleport classification. So the two flags are a pure function of
(disposition, hasAnimations) and are computable inside the merge, pre-merge,
with no signature change, no route construction and no playerDistance - the
scoping's ~150-400-line route-plumbing estimate over-counted because it did
not see this. That truth table IS
RuntimeAuthoritativePositionRouteClassifier.ClassifyAcceptedPosition's own
ApplyPlacementFrameBeforeRouting/UnparentBeforeRouting rows; the classifier
stays the oracle and the equality is pinned by test, not by a shared path,
so each computation remains separately sabotage-verifiable.
WHY the cell is withheld. HandleReceivedPosition reads the wire objcell_id
into a LOCAL @0x00453FE3 and hands it only to BlipPlayer / TeleportPlayer /
MoveOrTeleport / ConstrainTo; it never assigns the object's cell. The
object's cell moves inside the placement family (SetPositionInternal
@0x00515BD0 to set_cell, enter_world) or per-frame transit, and nowhere
else. The continuation executor has encoded that rule since the executor
slice; this caller now matches it verbatim.
WHAT DELIBERATELY SURVIVES. Two steady-state wire-cell writers stay,
downstream of the merge and outside the classification window: the
OnPosition prologue rebucket (W2, into CommitRebucket), which is also the
local player's own cell-freshness path, and the post-routing wire-cell adopt
for non-placing arms (W3, AP-135). Gating W2 "for symmetry" would freeze the
player's canonical cell between teleports and #319's child-cell equality
would inherit the freeze. AD-60's rewrite names both so the retirement
cannot be misread as "wire acceptance never changes residency anywhere".
REGISTER. AP-131 RETIRED - the unconditional literals no longer exist; the
caller was corrected, not deleted, so the row's own "deleted at the
production cutover" framing is overtaken. AD-60's legacy half RETIRED and
the row REWRITTEN rather than deleted, naming W2/W3 (route 4b-3's D8
precedent: a silent whole-row deletion would hide surviving channels).
AP-130 amended - the merge consumes the same static HasAnimations proxy,
deliberately not escalated to a live animation-queue read. AP-146 and #320
amended - their "accepted inbound Position (RefreshSnapshot into
RuntimeEntityRecord.cs:234)" local-player cell writer is now the generic
tail's CommitRebucket, and a ForcePosition (which returns before that tail)
is placement-receipt-authoritative. #275 closed.
HEADLINE BEHAVIOURAL DELTA, stated once: a refused or contended local
ForcePosition now leaves FullCellId at the last committed cell where the
merge used to stamp the refused packet's wire cell. Retail cannot refuse
(AD-62) and its body keeps its last placed cell, so the new shape is the
retail-reachable one.
THREE CONSUMER SITES THE CONTRACT'S BLAST-RADIUS SURVEY MISSED, all
D2-caused, all found by the suite rather than by reading, all intended
semantics rather than regressions (recorded in the contract's new section
14):
(1) DatLiveEntityProjectionMaterializer's self-projection branch reads
FullCellId inside OnPosition's prologue recovery, ahead of W2. It now
correctly declines to project from an unplaced wire claim; production
installs the bucket at W2 in the same call (verified: no return between
the recovery call and W2 is conditioned on IsSpatiallyProjected or
FullCellId). Two hydration tests asserted the bucket at the recovery
boundary and now drive the production W2 step - the same shape as trap
T2, one layer up.
(2) ProjectileController.SyncPresentationFromResolvedBody writes
ParentCellId = record.FullCellId. On a refused missile placement that is
now the committed source cell. The MAJOR-1 invariant is unchanged and is
now asserted as the identity it always meant rather than as a wire-cell
constant.
(3) The merge's Rebucketed ternary does NOT become always-Updated as the
contract predicted, and is deliberately kept: the
Forget(restoreCancelledPark: true) above it can roll a wakeable
lost-cell park back, and RestoreParkWithdrawal restores canonical
residency. That is a real cell edge produced inside this method by a
placement owner.
TEST-COUNT RECONCILIATION. Baseline measured at this HEAD by stashing the
change: Runtime.Tests 1176, App.Tests 4135 (4132 passed / 3 skipped),
solution 11,106 passed / 4 skipped - matching the recorded figure at
6921a027 exactly. Post-change: Runtime.Tests 1195, App.Tests 4135 unchanged,
solution 11,125 passed / 4 skipped / 0 failed. Net +19, entirely new Runtime
tests: 3 facts plus a 12-row matrix theory in
InboundPhysicsStateControllerTests, 1 fact plus a 2-row theory in the new
RuntimeSteadyStatePositionMergeTests, and 1 fact in
RuntimeAcceptedPositionDriveControllerTests. No test was deleted; five
existing tests were rewritten in place, never delete-only. No new skip; none
of #302/#308/#321 appeared.
SABOTAGE VERIFICATIONS (each new discriminating test, both directions;
production line broken, suite run, line restored):
installPlacementFrame (!force && !hasAnimations) to (!force)
5 fail: ApplyOnAnimatedEntity_NeverInstallsTheWirePlacementFrame plus
the 4 animated non-force matrix rows.
installPlacementFrame to false
6 fail: ApplyOnNonAnimatedEntity_InstallsTheWirePlacementFrame,
PositionPlacementAbsentAndPresentZeroBothApplyRetailZero plus the 4
non-animated non-force matrix rows.
clearParent (!force) to true
3 fail: ForcePositionOnParentedLocalPlayer_RetainsTheParentAttachment
plus the 2 force+parented matrix rows.
clearParent (!force) to false
4 fail: the 4 Apply+parented matrix rows.
refreshPosition false to acceptedPosition
4 fail: AcceptedPosition_WithholdsTheWireCellAtTheMergeBoundary,
ContendedForcePosition_WritesNoResidencyAnywhere,
ReentrantNewerPositionDuringPickupDiscardSuppressesStalePickupDelta,
MissileFarRefused_...ParentCellIdAgreesWithCommittedCell. Confirmed a
second time by the baseline measurement above, where the withhold test
was the sole red.
CommitRebucket publishes Updated instead of Rebucketed
2 fail: both parent classes of
CellChangingAcceptedPosition_ConservesOneRebucketAndOneChildPropagation.
RuntimeEntityDirectory.SetFullCell drops PropagateFullCellToChildren
2 fail: the same two rows.
T4 respected: the ForcePosition placement-frame half is inert
(appliedPlacement keeps old.PlacementId under either flag value), so the
force row's discriminating assertion is parent retention, never the frame.
NOT DONE, deliberately: the executor is still not wired into the
steady-state path (#275's alternative branch); W2/W3 are untouched; no probe
added or stripped; AP-130's proxy not escalated; no while-here unification
of the two merge callsites. No automated OnPosition-level test drives the
full pickup / drop / reproject sequence (no fixture covers pickup at that
layer); the contract's connected gate recipe item 1 is the positive evidence
for it and has NOT been run - this commit is not connected-gated.
Contract: docs/research/2026-08-05-c5b-contract.md (committed here, with its
section 14 implementation outcome appended).
Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
1035 lines
40 KiB
C#
1035 lines
40 KiB
C#
using System.Numerics;
|
|
using AcDream.Core.Net;
|
|
using AcDream.Core.Net.Messages;
|
|
using AcDream.Core.Physics;
|
|
using AcDream.Runtime;
|
|
using AcDream.Runtime.Entities;
|
|
using AcDream.Runtime.Physics;
|
|
|
|
namespace AcDream.Runtime.Tests.Entities;
|
|
|
|
public sealed class InboundPhysicsStateControllerTests
|
|
{
|
|
[Fact]
|
|
public void SameGenerationCreate_RoutesChannelsIndependently()
|
|
{
|
|
var controller = new InboundPhysicsStateController();
|
|
CreateObject.ServerPosition original = Position(0x0101FFFFu, 10f);
|
|
CreateObject.ServerPosition incoming = Position(0x0101FFFFu, 20f);
|
|
controller.AcceptCreate(Spawn(0x70000001u, 1, 10, 10, original, 0x408u));
|
|
|
|
InboundCreateResult refresh = controller.AcceptCreate(
|
|
Spawn(0x70000001u, 1, 9, 11, incoming, 0x448u));
|
|
|
|
Assert.Equal(CreateObjectTimestampDisposition.ExistingGeneration, refresh.Disposition);
|
|
Assert.NotNull(refresh.SameGenerationEvents);
|
|
SameGenerationCreateObjectEvents events = refresh.SameGenerationEvents.Value;
|
|
Assert.True(controller.TryApplyPosition(
|
|
events.Position!.Value,
|
|
isLocalPlayer: false,
|
|
forcePositionRotation: null,
|
|
currentLocalVelocity: null,
|
|
out PositionTimestampDisposition positionResult,
|
|
out _,
|
|
out _));
|
|
Assert.Equal(PositionTimestampDisposition.Rejected, positionResult);
|
|
Assert.True(controller.TryApplyState(events.State, out _));
|
|
Assert.True(controller.TryGetSnapshot(0x70000001u, out WorldSession.EntitySpawn accepted));
|
|
Assert.Equal(original, accepted.Position);
|
|
Assert.Equal(0x448u, accepted.PhysicsState);
|
|
}
|
|
|
|
[Fact]
|
|
public void PickupRetainsGeneration_AndFreshPositionReturnsToWorld()
|
|
{
|
|
var controller = new InboundPhysicsStateController();
|
|
controller.AcceptCreate(Spawn(
|
|
0x70000002u, 7, 20, 1, Position(0x0101FFFFu, 10f), 0x408u));
|
|
|
|
Assert.True(controller.TryApplyPickup(
|
|
new PickupEvent.Parsed(0x70000002u, 7, 21), out WorldSession.EntitySpawn pickedUp));
|
|
Assert.Null(pickedUp.Position);
|
|
|
|
var update = new WorldSession.EntityPositionUpdate(
|
|
0x70000002u,
|
|
Position(0x0101FFFFu, 30f),
|
|
null,
|
|
null,
|
|
true,
|
|
7,
|
|
22,
|
|
0,
|
|
0);
|
|
Assert.True(controller.TryApplyPosition(
|
|
update, false, null, null, out var disposition, out WorldSession.EntitySpawn returned, out _));
|
|
Assert.Equal(PositionTimestampDisposition.Apply, disposition);
|
|
Assert.Equal(30f, returned.Position!.Value.PositionX);
|
|
}
|
|
|
|
/// <summary>
|
|
/// C5b (#275) rewrite of the pre-classification test: the retail-zero
|
|
/// rule (<c>PositionPack::UnPack</c> @0x00516740 initializes an absent
|
|
/// placement id to zero and <c>HandleReceivedPosition</c> forwards that
|
|
/// exact value to <c>SetPlacementFrame</c>) is only reachable when the
|
|
/// gate ABOVE it passes — <c>CPhysicsObj::HasAnims(arg2) == 0</c>
|
|
/// @0x00454137. The seed is therefore explicitly NON-animated; the
|
|
/// animated counterpart is
|
|
/// <see cref="ApplyOnAnimatedEntity_NeverInstallsTheWirePlacementFrame"/>.
|
|
/// </summary>
|
|
[Fact]
|
|
public void PositionPlacementAbsentAndPresentZeroBothApplyRetailZero()
|
|
{
|
|
var controller = new InboundPhysicsStateController();
|
|
WorldSession.EntitySpawn seed = Spawn(
|
|
0x70000009u,
|
|
7,
|
|
20,
|
|
1,
|
|
Position(0x0101FFFFu, 10f),
|
|
0x408u,
|
|
motionTableId: null);
|
|
seed = seed with
|
|
{
|
|
PlacementId = 7,
|
|
Physics = seed.Physics!.Value with { AnimationFrame = 7 },
|
|
};
|
|
controller.AcceptCreate(seed);
|
|
|
|
Assert.True(controller.TryApplyPosition(
|
|
new WorldSession.EntityPositionUpdate(
|
|
seed.Guid,
|
|
Position(0x0101FFFFu, 20f),
|
|
null,
|
|
null,
|
|
true,
|
|
7,
|
|
21,
|
|
0,
|
|
0),
|
|
false,
|
|
null,
|
|
null,
|
|
out PositionTimestampDisposition firstDisposition,
|
|
out WorldSession.EntitySpawn first,
|
|
out _));
|
|
Assert.Equal(PositionTimestampDisposition.Apply, firstDisposition);
|
|
Assert.Equal((uint)0, first.PlacementId);
|
|
Assert.Equal((uint)0, first.Physics!.Value.AnimationFrame);
|
|
|
|
Assert.True(controller.TryApplyPosition(
|
|
new WorldSession.EntityPositionUpdate(
|
|
seed.Guid,
|
|
Position(0x0101FFFFu, 30f),
|
|
null,
|
|
0,
|
|
true,
|
|
7,
|
|
22,
|
|
0,
|
|
0),
|
|
false,
|
|
null,
|
|
null,
|
|
out PositionTimestampDisposition secondDisposition,
|
|
out WorldSession.EntitySpawn second,
|
|
out _));
|
|
Assert.Equal(PositionTimestampDisposition.Apply, secondDisposition);
|
|
Assert.Equal((uint)0, second.PlacementId);
|
|
Assert.Equal((uint)0, second.Physics!.Value.AnimationFrame);
|
|
}
|
|
|
|
/// <summary>
|
|
/// C5b (#275) / AP-131 retirement, half 1. Retail gates
|
|
/// <c>CPhysicsObj::SetPlacementFrame</c> @0x00454142 on
|
|
/// <c>CPhysicsObj::HasAnims(arg2) == 0</c> @0x00454137: an ANIMATED body
|
|
/// never takes the wire placement frame, because its animation sequencer
|
|
/// owns the pose. Before C5b the steady-state merge stamped it anyway,
|
|
/// which is the animation snap/reset half of AP-131.
|
|
/// </summary>
|
|
[Fact]
|
|
public void ApplyOnAnimatedEntity_NeverInstallsTheWirePlacementFrame()
|
|
{
|
|
var controller = new InboundPhysicsStateController();
|
|
WorldSession.EntitySpawn seed = Spawn(
|
|
0x8000C001u,
|
|
7,
|
|
20,
|
|
1,
|
|
Position(0x0101FFFFu, 10f),
|
|
0x408u,
|
|
motionTableId: 0x09000001u);
|
|
seed = seed with
|
|
{
|
|
PlacementId = 7,
|
|
Physics = seed.Physics!.Value with { AnimationFrame = 7 },
|
|
};
|
|
controller.AcceptCreate(seed);
|
|
|
|
Assert.True(controller.TryApplyPosition(
|
|
new WorldSession.EntityPositionUpdate(
|
|
seed.Guid,
|
|
Position(0x0101FFFFu, 20f),
|
|
Velocity: null,
|
|
PlacementId: 5,
|
|
IsGrounded: true,
|
|
InstanceSequence: 7,
|
|
PositionSequence: 21,
|
|
TeleportSequence: 0,
|
|
ForcePositionSequence: 0),
|
|
isLocalPlayer: false,
|
|
forcePositionRotation: null,
|
|
currentLocalVelocity: null,
|
|
out PositionTimestampDisposition disposition,
|
|
out WorldSession.EntitySpawn accepted,
|
|
out _));
|
|
|
|
Assert.Equal(PositionTimestampDisposition.Apply, disposition);
|
|
// The gate above SetPlacementFrame never opened.
|
|
Assert.Equal((uint)7, accepted.PlacementId);
|
|
Assert.Equal((uint)7, accepted.Physics!.Value.AnimationFrame);
|
|
// The rest of the merge is unaffected: pose and POSITION_TS still land.
|
|
Assert.Equal(20f, accepted.Position!.Value.PositionX);
|
|
Assert.Equal((ushort)21, accepted.PositionSequence);
|
|
// unset_parent @0x00454129 is unconditional on this path.
|
|
Assert.Null(accepted.ParentGuid);
|
|
}
|
|
|
|
/// <summary>
|
|
/// C5b (#275) / AP-131 retirement, half 1 (the other direction). A
|
|
/// NON-animated body reaches <c>SetPlacementFrame</c> @0x00454142 and
|
|
/// takes the wire frame verbatim.
|
|
/// </summary>
|
|
[Fact]
|
|
public void ApplyOnNonAnimatedEntity_InstallsTheWirePlacementFrame()
|
|
{
|
|
var controller = new InboundPhysicsStateController();
|
|
WorldSession.EntitySpawn seed = Spawn(
|
|
0x8000C002u,
|
|
7,
|
|
20,
|
|
1,
|
|
Position(0x0101FFFFu, 10f),
|
|
0x408u,
|
|
motionTableId: null);
|
|
seed = seed with
|
|
{
|
|
PlacementId = 7,
|
|
Physics = seed.Physics!.Value with { AnimationFrame = 7 },
|
|
};
|
|
controller.AcceptCreate(seed);
|
|
|
|
Assert.True(controller.TryApplyPosition(
|
|
new WorldSession.EntityPositionUpdate(
|
|
seed.Guid,
|
|
Position(0x0101FFFFu, 20f),
|
|
Velocity: null,
|
|
PlacementId: 5,
|
|
IsGrounded: true,
|
|
InstanceSequence: 7,
|
|
PositionSequence: 21,
|
|
TeleportSequence: 0,
|
|
ForcePositionSequence: 0),
|
|
isLocalPlayer: false,
|
|
forcePositionRotation: null,
|
|
currentLocalVelocity: null,
|
|
out PositionTimestampDisposition disposition,
|
|
out WorldSession.EntitySpawn accepted,
|
|
out _));
|
|
|
|
Assert.Equal(PositionTimestampDisposition.Apply, disposition);
|
|
Assert.Equal((uint)5, accepted.PlacementId);
|
|
Assert.Equal((uint)5, accepted.Physics!.Value.AnimationFrame);
|
|
}
|
|
|
|
/// <summary>
|
|
/// C5b (#275) / AP-131 retirement, half 2. Retail's Gate A
|
|
/// (@0x0045400C, the local-player FORCE_POSITION self-echo shortcut)
|
|
/// returns @0x0045409D BEFORE <c>CPhysicsObj::unset_parent</c>
|
|
/// @0x00454129, so a ForcePosition never unparents. Parent RETENTION is
|
|
/// the discriminating observable for the force row: the placement-frame
|
|
/// half is inert there (<c>appliedPlacement</c> keeps
|
|
/// <c>old.PlacementId</c> under either flag value), so sabotaging it on a
|
|
/// ForcePosition proves nothing.
|
|
/// </summary>
|
|
[Fact]
|
|
public void ForcePositionOnParentedLocalPlayer_RetainsTheParentAttachment()
|
|
{
|
|
var controller = new InboundPhysicsStateController();
|
|
WorldSession.EntitySpawn seed = WithTimestamps(
|
|
Spawn(0x50000021u, 3, 10, 1, Position(0x0101FFFFu, 10f), 0x408u),
|
|
teleport: 10,
|
|
forcePosition: 0);
|
|
seed = seed with
|
|
{
|
|
ParentGuid = 0x70004444u,
|
|
ParentLocation = 9u,
|
|
Physics = seed.Physics!.Value with
|
|
{
|
|
Parent = new PhysicsAttachment(0x70004444u, 9u),
|
|
},
|
|
};
|
|
controller.AcceptCreate(seed);
|
|
var preserved = new Quaternion(0.1f, 0.2f, 0.3f, 0.9f);
|
|
|
|
Assert.True(controller.TryApplyPosition(
|
|
PositionUpdate(
|
|
seed.Guid,
|
|
instance: 3,
|
|
position: 9,
|
|
teleport: 10,
|
|
forcePosition: 1),
|
|
isLocalPlayer: true,
|
|
forcePositionRotation: preserved,
|
|
currentLocalVelocity: Vector3.Zero,
|
|
out PositionTimestampDisposition disposition,
|
|
out WorldSession.EntitySpawn accepted,
|
|
out _));
|
|
|
|
Assert.Equal(PositionTimestampDisposition.ForcePosition, disposition);
|
|
Assert.Equal(0x70004444u, accepted.ParentGuid);
|
|
Assert.Equal(9u, accepted.ParentLocation);
|
|
Assert.Equal(
|
|
new PhysicsAttachment(0x70004444u, 9u),
|
|
accepted.Physics!.Value.Parent);
|
|
// Heading preservation (BlipPlayer's get_heading/set_heading pair
|
|
// @0x00454056-68) is unchanged by C5b.
|
|
Assert.Equal(preserved.W, accepted.Position!.Value.RotationW);
|
|
Assert.Equal(preserved.X, accepted.Position!.Value.RotationX);
|
|
}
|
|
|
|
/// <summary>
|
|
/// C5b (#275) proof obligation 1: the merge's two pre-placement flags ARE
|
|
/// <see cref="RuntimeAuthoritativePositionRouteClassifier"/>'s
|
|
/// <c>ApplyPlacementFrameBeforeRouting</c>/<c>UnparentBeforeRouting</c>
|
|
/// rows. The production classifier is the oracle — this test does not
|
|
/// re-encode the truth table, it drives both computations over the packet
|
|
/// matrix and asserts the merged snapshot equals what the route's own
|
|
/// flags would have produced. Dual parent classes (player <c>0x5…</c> and
|
|
/// creature <c>0x8…</c>) per the #319 discipline.
|
|
/// </summary>
|
|
[Theory]
|
|
// guid, isLocalPlayer, animated, parented, force
|
|
[InlineData(0x50000031u, true, true, true, false)]
|
|
[InlineData(0x50000032u, true, true, false, false)]
|
|
[InlineData(0x50000033u, true, false, true, false)]
|
|
[InlineData(0x50000034u, true, false, false, false)]
|
|
[InlineData(0x50000035u, true, true, true, true)]
|
|
[InlineData(0x50000036u, true, true, false, true)]
|
|
[InlineData(0x50000037u, true, false, true, true)]
|
|
[InlineData(0x50000038u, true, false, false, true)]
|
|
[InlineData(0x80000031u, false, true, true, false)]
|
|
[InlineData(0x80000032u, false, true, false, false)]
|
|
[InlineData(0x80000033u, false, false, true, false)]
|
|
[InlineData(0x80000034u, false, false, false, false)]
|
|
public void MergedPrePlacementFieldsMatchTheClassifiedRouteFlags(
|
|
uint guid,
|
|
bool isLocalPlayer,
|
|
bool animated,
|
|
bool parented,
|
|
bool force)
|
|
{
|
|
WorldSession.EntitySpawn seed = WithTimestamps(
|
|
Spawn(
|
|
guid,
|
|
3,
|
|
10,
|
|
1,
|
|
Position(0x0101FFFFu, 10f),
|
|
0x408u,
|
|
motionTableId: animated ? 0x09000001u : null),
|
|
teleport: 10,
|
|
forcePosition: 0);
|
|
seed = seed with
|
|
{
|
|
PlacementId = 7,
|
|
Physics = seed.Physics!.Value with { AnimationFrame = 7 },
|
|
};
|
|
if (parented)
|
|
{
|
|
seed = seed with
|
|
{
|
|
ParentGuid = 0x70004444u,
|
|
ParentLocation = 9u,
|
|
Physics = seed.Physics!.Value with
|
|
{
|
|
Parent = new PhysicsAttachment(0x70004444u, 9u),
|
|
},
|
|
};
|
|
}
|
|
|
|
WorldSession.EntityPositionUpdate update = new(
|
|
guid,
|
|
Position(0x0101FFFFu, 20f),
|
|
Velocity: null,
|
|
PlacementId: 5,
|
|
IsGrounded: true,
|
|
InstanceSequence: 3,
|
|
PositionSequence: force ? (ushort)9 : (ushort)11,
|
|
TeleportSequence: 10,
|
|
ForcePositionSequence: force ? (ushort)1 : (ushort)0);
|
|
|
|
var merging = new InboundPhysicsStateController();
|
|
merging.AcceptCreate(seed);
|
|
Assert.True(merging.TryApplyPosition(
|
|
update,
|
|
isLocalPlayer,
|
|
forcePositionRotation: isLocalPlayer ? Quaternion.Identity : null,
|
|
currentLocalVelocity: isLocalPlayer ? Vector3.Zero : null,
|
|
out PositionTimestampDisposition disposition,
|
|
out WorldSession.EntitySpawn merged,
|
|
out AcceptedPhysicsTimestamps timestamps));
|
|
Assert.Equal(
|
|
force
|
|
? PositionTimestampDisposition.ForcePosition
|
|
: PositionTimestampDisposition.Apply,
|
|
disposition);
|
|
|
|
// The oracle: the production classifier, fed the same wire packet and
|
|
// the same static HasAnimations proxy.
|
|
RuntimeAuthoritativePositionRoute route =
|
|
RuntimeAuthoritativePositionRouteClassifier.ClassifyAcceptedPosition(
|
|
new RuntimeAcceptedPositionRouteRequest(
|
|
new RuntimeAuthoritativePositionAuthority(
|
|
new RuntimeGenerationToken(7),
|
|
new RuntimeEntityKey(guid, 1),
|
|
PositionAuthorityVersion: 4UL,
|
|
AcceptedPositionSequence: update.PositionSequence,
|
|
timestamps.PreviousTeleport,
|
|
timestamps.Teleport,
|
|
disposition),
|
|
isLocalPlayer
|
|
? RuntimePositionEntityKind.LocalPlayer
|
|
: RuntimePositionEntityKind.Remote,
|
|
RuntimeAcceptedPositionSource.PositionEvent,
|
|
update.Position,
|
|
PlacementFrame: update.PlacementId,
|
|
PositionPackVelocity: null,
|
|
CommittedCellId: 0x0101FFFFu,
|
|
HasContact: true,
|
|
PlayerDistance: 0f,
|
|
UsePositionFromServer: true,
|
|
HasAnimations: animated,
|
|
default));
|
|
|
|
// Rebuild what the classified route would have installed, through the
|
|
// SAME production merge, and require field equality.
|
|
var classified = new InboundPhysicsStateController();
|
|
classified.AcceptCreate(seed);
|
|
Assert.True(classified.ApplyAcceptedPositionSnapshot(
|
|
guid,
|
|
update,
|
|
disposition,
|
|
timestamps,
|
|
isLocalPlayer,
|
|
isLocalPlayer ? Quaternion.Identity : null,
|
|
isLocalPlayer ? Vector3.Zero : null,
|
|
installPlacementFrame: route.ApplyPlacementFrameBeforeRouting,
|
|
clearParent: route.UnparentBeforeRouting,
|
|
out WorldSession.EntitySpawn expected));
|
|
|
|
Assert.Equal(expected.PlacementId, merged.PlacementId);
|
|
Assert.Equal(
|
|
expected.Physics!.Value.AnimationFrame,
|
|
merged.Physics!.Value.AnimationFrame);
|
|
Assert.Equal(expected.ParentGuid, merged.ParentGuid);
|
|
Assert.Equal(expected.ParentLocation, merged.ParentLocation);
|
|
Assert.Equal(
|
|
expected.Physics!.Value.Parent,
|
|
merged.Physics!.Value.Parent);
|
|
}
|
|
|
|
[Fact]
|
|
public void RemotePositionWithoutVelocityAppliesUnpackedZeroVector()
|
|
{
|
|
var controller = new InboundPhysicsStateController();
|
|
WorldSession.EntitySpawn seed = Spawn(
|
|
0x7000000Au, 7, 20, 1, Position(0x0101FFFFu, 10f), 0x408u);
|
|
seed = seed with
|
|
{
|
|
Physics = seed.Physics!.Value with { Velocity = new Vector3(4f, 5f, 6f) },
|
|
};
|
|
controller.AcceptCreate(seed);
|
|
|
|
Assert.True(controller.TryApplyPosition(
|
|
new WorldSession.EntityPositionUpdate(
|
|
seed.Guid,
|
|
Position(0x0101FFFFu, 20f),
|
|
null,
|
|
null,
|
|
true,
|
|
7,
|
|
21,
|
|
0,
|
|
0),
|
|
false,
|
|
null,
|
|
null,
|
|
out PositionTimestampDisposition disposition,
|
|
out WorldSession.EntitySpawn accepted,
|
|
out _));
|
|
|
|
Assert.Equal(PositionTimestampDisposition.Apply, disposition);
|
|
Assert.Equal(Vector3.Zero, accepted.Physics!.Value.Velocity);
|
|
}
|
|
|
|
[Fact]
|
|
public void LocalNormalCorrectionRetainsLiveVelocity_ButFreshTeleportZerosIt()
|
|
{
|
|
var controller = new InboundPhysicsStateController();
|
|
WorldSession.EntitySpawn seed = WithTimestamps(
|
|
Spawn(0x5000000Au, 7, 20, 1, Position(0x0101FFFFu, 10f), 0x408u),
|
|
teleport: 10);
|
|
controller.AcceptCreate(seed);
|
|
Vector3 liveVelocity = new(4f, 5f, 6f);
|
|
|
|
Assert.True(controller.TryApplyPosition(
|
|
new WorldSession.EntityPositionUpdate(
|
|
seed.Guid,
|
|
Position(0x0101FFFFu, 20f),
|
|
new Vector3(90f, 80f, 70f),
|
|
null,
|
|
true,
|
|
7,
|
|
21,
|
|
10,
|
|
0),
|
|
true,
|
|
null,
|
|
liveVelocity,
|
|
out PositionTimestampDisposition normalDisposition,
|
|
out WorldSession.EntitySpawn normal,
|
|
out AcceptedPhysicsTimestamps normalTimestamps));
|
|
Assert.Equal(PositionTimestampDisposition.Apply, normalDisposition);
|
|
Assert.Equal(liveVelocity, normal.Physics!.Value.Velocity);
|
|
Assert.False(normalTimestamps.TeleportAdvanced);
|
|
|
|
Assert.True(controller.TryApplyPosition(
|
|
new WorldSession.EntityPositionUpdate(
|
|
seed.Guid,
|
|
Position(0x0101FFFFu, 30f),
|
|
new Vector3(9f, 8f, 7f),
|
|
null,
|
|
true,
|
|
7,
|
|
22,
|
|
11,
|
|
0),
|
|
true,
|
|
null,
|
|
liveVelocity,
|
|
out PositionTimestampDisposition teleportDisposition,
|
|
out WorldSession.EntitySpawn teleported,
|
|
out AcceptedPhysicsTimestamps teleportTimestamps));
|
|
Assert.Equal(PositionTimestampDisposition.Apply, teleportDisposition);
|
|
Assert.Equal(Vector3.Zero, teleported.Physics!.Value.Velocity);
|
|
Assert.True(teleportTimestamps.TeleportAdvanced);
|
|
}
|
|
|
|
[Fact]
|
|
public void ParentEventWaitsForParent_ThenStagesTimestampUntilValidatedCommit()
|
|
{
|
|
var controller = new InboundPhysicsStateController();
|
|
controller.AcceptCreate(Spawn(
|
|
0x70000003u, 3, 4, 1, Position(0x0101FFFFu, 10f), 0x408u));
|
|
var update = new ParentEvent.Parsed(
|
|
0x70000004u, 0x70000003u, 1, 2, 9, 5);
|
|
|
|
Assert.False(controller.TryApplyParent(update, out _));
|
|
controller.AcceptCreate(Spawn(
|
|
0x70000004u, 9, 1, 1, Position(0x0101FFFFu, 15f), 0x408u));
|
|
Assert.True(controller.TryApplyParent(update, out WorldSession.EntitySpawn staged));
|
|
Assert.Null(staged.ParentGuid);
|
|
Assert.NotNull(staged.Position);
|
|
Assert.Equal((ushort)5, staged.PositionSequence);
|
|
Assert.True(controller.TryCommitParent(
|
|
update.ChildGuid,
|
|
update.ParentGuid,
|
|
update.ParentLocation,
|
|
update.PlacementId,
|
|
update.ChildPositionSequence,
|
|
out WorldSession.EntitySpawn attached));
|
|
Assert.Equal(0x70000004u, attached.ParentGuid);
|
|
Assert.Null(attached.Position);
|
|
Assert.False(controller.TryApplyParent(update, out _));
|
|
}
|
|
|
|
[Fact]
|
|
public void LocalDeleteIsRejected_AndClearDropsSessionState()
|
|
{
|
|
var controller = new InboundPhysicsStateController();
|
|
controller.AcceptCreate(Spawn(
|
|
0x50000001u, 4, 1, 1, Position(0x0101FFFFu, 10f), 0x408u));
|
|
|
|
Assert.False(controller.TryDelete(new DeleteObject.Parsed(0x50000001u, 4), true));
|
|
Assert.True(controller.TryGetSnapshot(0x50000001u, out _));
|
|
|
|
controller.Clear();
|
|
Assert.Empty(controller.Snapshots);
|
|
Assert.False(controller.IsFreshTeleportStart(0x50000001u, 1));
|
|
}
|
|
|
|
[Fact]
|
|
public void DeleteForUnknownGenerationIsRejected()
|
|
{
|
|
var controller = new InboundPhysicsStateController();
|
|
|
|
Assert.False(controller.TryDelete(
|
|
new DeleteObject.Parsed(0x5000FFFFu, 9), isLocalPlayer: false));
|
|
}
|
|
|
|
[Fact]
|
|
public void TeleportStartIsComparedWithoutAdvancingTeleportTimestamp()
|
|
{
|
|
var controller = new InboundPhysicsStateController();
|
|
WorldSession.EntitySpawn spawn = Spawn(
|
|
0x50000002u, 2, 1, 1, Position(0x0101FFFFu, 10f), 0x408u);
|
|
PhysicsSpawnData physics = spawn.Physics!.Value with
|
|
{
|
|
Timestamps = spawn.Physics.Value.Timestamps with { Teleport = 10 },
|
|
};
|
|
controller.AcceptCreate(spawn with { Physics = physics });
|
|
|
|
Assert.True(controller.IsFreshTeleportStart(0x50000002u, 10));
|
|
Assert.False(controller.IsFreshTeleportStart(0x50000002u, 9));
|
|
Assert.True(controller.IsFreshTeleportStart(0x50000002u, 11));
|
|
Assert.True(controller.IsFreshTeleportStart(0x50000002u, 11));
|
|
}
|
|
|
|
[Fact]
|
|
public void RejectedServerControlStillMirrorsConsumedMovementTimestamp()
|
|
{
|
|
var controller = new InboundPhysicsStateController();
|
|
WorldSession.EntitySpawn spawn = WithTimestamps(
|
|
Spawn(0x70000005u, 3, 1, 1, Position(0x0101FFFFu, 10f), 0x408u),
|
|
movement: 1,
|
|
serverControl: 5);
|
|
controller.AcceptCreate(spawn);
|
|
|
|
bool applied = controller.TryApplyMotion(
|
|
new WorldSession.EntityMotionUpdate(
|
|
spawn.Guid,
|
|
new CreateObject.ServerMotionState(0x3d, 0x11),
|
|
3,
|
|
2,
|
|
4,
|
|
false),
|
|
retainPayload: true,
|
|
out _,
|
|
out _);
|
|
|
|
Assert.False(applied);
|
|
Assert.True(controller.TryGetSnapshot(spawn.Guid, out WorldSession.EntitySpawn retained));
|
|
Assert.Equal((ushort)2, retained.MovementSequence);
|
|
Assert.Equal((ushort)5, retained.ServerControlSequence);
|
|
Assert.Equal((ushort)2, retained.Physics!.Value.Timestamps.Movement);
|
|
Assert.Equal((ushort)5, retained.Physics.Value.Timestamps.ServerControlledMove);
|
|
Assert.Equal(spawn.MotionState, retained.MotionState);
|
|
}
|
|
|
|
[Fact]
|
|
public void AutonomousLocalEchoRetainsPayloadButMirrorsAcceptedTimestamps()
|
|
{
|
|
var controller = new InboundPhysicsStateController();
|
|
WorldSession.EntitySpawn spawn = WithTimestamps(
|
|
Spawn(0x50000006u, 3, 1, 1, Position(0x0101FFFFu, 10f), 0x408u),
|
|
movement: 1,
|
|
serverControl: 5) with
|
|
{
|
|
MotionState = new CreateObject.ServerMotionState(0x3d, 0x10),
|
|
};
|
|
controller.AcceptCreate(spawn);
|
|
|
|
Assert.True(controller.TryApplyMotion(
|
|
new WorldSession.EntityMotionUpdate(
|
|
spawn.Guid,
|
|
new CreateObject.ServerMotionState(0x3d, 0x12),
|
|
3,
|
|
2,
|
|
5,
|
|
true),
|
|
retainPayload: false,
|
|
out WorldSession.EntitySpawn retained,
|
|
out _));
|
|
|
|
Assert.Equal(spawn.MotionState, retained.MotionState);
|
|
Assert.Equal((ushort)2, retained.MovementSequence);
|
|
Assert.Equal((ushort)5, retained.ServerControlSequence);
|
|
Assert.Equal((ushort)2, retained.Physics!.Value.Timestamps.Movement);
|
|
}
|
|
|
|
[Fact]
|
|
public void StaleMovementTimestampLeavesLegacySnapshotByteIdentical()
|
|
{
|
|
var controller = new InboundPhysicsStateController();
|
|
WorldSession.EntitySpawn spawn = WithTimestamps(
|
|
Spawn(0x70000008u, 3, 1, 1, Position(0x0101FFFFu, 10f), 0x408u),
|
|
movement: 5,
|
|
serverControl: 5);
|
|
controller.AcceptCreate(spawn);
|
|
Assert.True(controller.TryGetSnapshot(spawn.Guid, out WorldSession.EntitySpawn before));
|
|
|
|
// MOVEMENT_TS 3 is OLDER than the stored 5:
|
|
// PhysicsTimestampGate.TryAcceptMovementEvent's
|
|
// AdvanceStrict(Movement, ...) fails before ever consulting
|
|
// SERVER_CONTROLLED_MOVE_TS - the gate is entirely untouched, and
|
|
// the canonical snapshot must not move either (the regression this
|
|
// guards: ApplyAcceptedMotion stamping the WIRE's own stale
|
|
// MovementSequence instead of the gate's unchanged post-call value).
|
|
bool applied = controller.TryApplyMotion(
|
|
new WorldSession.EntityMotionUpdate(
|
|
spawn.Guid,
|
|
new CreateObject.ServerMotionState(0x3d, 0x99),
|
|
InstanceSequence: 3,
|
|
MovementSequence: 3,
|
|
ServerControlSequence: 9,
|
|
IsAutonomous: false),
|
|
retainPayload: true,
|
|
out WorldSession.EntitySpawn accepted,
|
|
out _);
|
|
|
|
Assert.False(applied);
|
|
Assert.Equal(default, accepted);
|
|
Assert.True(controller.TryGetSnapshot(spawn.Guid, out WorldSession.EntitySpawn after));
|
|
Assert.Equal(before, after);
|
|
}
|
|
|
|
[Fact]
|
|
public void InstanceMismatchedMovementLeavesLegacySnapshotByteIdentical()
|
|
{
|
|
var controller = new InboundPhysicsStateController();
|
|
WorldSession.EntitySpawn spawn = WithTimestamps(
|
|
Spawn(0x70000009u, 3, 1, 1, Position(0x0101FFFFu, 10f), 0x408u),
|
|
movement: 1,
|
|
serverControl: 1);
|
|
controller.AcceptCreate(spawn);
|
|
Assert.True(controller.TryGetSnapshot(spawn.Guid, out WorldSession.EntitySpawn before));
|
|
|
|
// A different INSTANCE_TS: TryAcceptInstance fails immediately,
|
|
// before MOVEMENT_TS or SERVER_CONTROLLED_MOVE_TS are ever
|
|
// consulted. Nothing in the gate or the canonical snapshot may move
|
|
// - a stale duplicate or foreign-incarnation packet must not
|
|
// silently drag a live entity's movement timestamps forward.
|
|
bool applied = controller.TryApplyMotion(
|
|
new WorldSession.EntityMotionUpdate(
|
|
spawn.Guid,
|
|
new CreateObject.ServerMotionState(0x3d, 0x99),
|
|
InstanceSequence: 4,
|
|
MovementSequence: 9,
|
|
ServerControlSequence: 9,
|
|
IsAutonomous: false),
|
|
retainPayload: true,
|
|
out WorldSession.EntitySpawn accepted,
|
|
out _);
|
|
|
|
Assert.False(applied);
|
|
Assert.Equal(default, accepted);
|
|
Assert.True(controller.TryGetSnapshot(spawn.Guid, out WorldSession.EntitySpawn after));
|
|
Assert.Equal(before, after);
|
|
}
|
|
|
|
[Fact]
|
|
public void FreshForceWithOlderTeleportMirrorsForceButRejectsPose()
|
|
{
|
|
var controller = new InboundPhysicsStateController();
|
|
WorldSession.EntitySpawn spawn = WithTimestamps(
|
|
Spawn(0x50000007u, 3, 10, 1, Position(0x0101FFFFu, 10f), 0x408u),
|
|
teleport: 10,
|
|
forcePosition: 0);
|
|
controller.AcceptCreate(spawn);
|
|
|
|
Assert.True(controller.TryApplyPosition(
|
|
new WorldSession.EntityPositionUpdate(
|
|
spawn.Guid,
|
|
Position(0x0101FFFFu, 99f),
|
|
null,
|
|
null,
|
|
true,
|
|
3,
|
|
11,
|
|
9,
|
|
1),
|
|
isLocalPlayer: true,
|
|
forcePositionRotation: Quaternion.Identity,
|
|
currentLocalVelocity: Vector3.Zero,
|
|
out PositionTimestampDisposition disposition,
|
|
out WorldSession.EntitySpawn retained,
|
|
out _));
|
|
|
|
Assert.Equal(PositionTimestampDisposition.Rejected, disposition);
|
|
Assert.Equal(10f, retained.Position!.Value.PositionX);
|
|
Assert.Equal((ushort)10, retained.PositionSequence);
|
|
Assert.Equal((ushort)1, retained.Physics!.Value.Timestamps.ForcePosition);
|
|
Assert.Equal((ushort)10, retained.Physics.Value.Timestamps.Position);
|
|
}
|
|
|
|
[Fact]
|
|
public void ForcePositionStoresPreservedLocalHeadingForLaterHydration()
|
|
{
|
|
var controller = new InboundPhysicsStateController();
|
|
WorldSession.EntitySpawn spawn = WithTimestamps(
|
|
Spawn(0x50000008u, 3, 10, 1, Position(0x0101FFFFu, 10f), 0x408u),
|
|
teleport: 10,
|
|
forcePosition: 0);
|
|
controller.AcceptCreate(spawn);
|
|
Quaternion heading = Quaternion.CreateFromAxisAngle(Vector3.UnitZ, 0.75f);
|
|
Vector3 liveVelocity = new(1f, 2f, 3f);
|
|
|
|
Assert.True(controller.TryApplyPosition(
|
|
new WorldSession.EntityPositionUpdate(
|
|
spawn.Guid,
|
|
Position(0x0101FFFFu, 99f),
|
|
new Vector3(90f, 80f, 70f),
|
|
null,
|
|
true,
|
|
3,
|
|
9,
|
|
10,
|
|
1),
|
|
isLocalPlayer: true,
|
|
forcePositionRotation: heading,
|
|
currentLocalVelocity: liveVelocity,
|
|
out PositionTimestampDisposition disposition,
|
|
out WorldSession.EntitySpawn retained,
|
|
out _));
|
|
|
|
Assert.Equal(PositionTimestampDisposition.ForcePosition, disposition);
|
|
Assert.Equal(99f, retained.Position!.Value.PositionX);
|
|
Assert.Equal(heading.W, retained.Position.Value.RotationW, precision: 6);
|
|
Assert.Equal(heading.X, retained.Position.Value.RotationX, precision: 6);
|
|
Assert.Equal(heading.Y, retained.Position.Value.RotationY, precision: 6);
|
|
Assert.Equal(heading.Z, retained.Position.Value.RotationZ, precision: 6);
|
|
Assert.Equal(retained.Position, retained.Physics!.Value.Position);
|
|
Assert.Equal(liveVelocity, retained.Physics.Value.Velocity);
|
|
}
|
|
|
|
/// <summary>
|
|
/// #307: the live Position path must report the TELEPORT_TS value the gate
|
|
/// held BEFORE the event, not 0. Every consumer of
|
|
/// <c>AcceptedPhysicsTimestamps.PreviousTeleport</c> compares it against
|
|
/// the accepted stamp; a hard 0 makes "this packet did not advance
|
|
/// TELEPORT_TS" indistinguishable from "this packet regressed it" for any
|
|
/// entity that has ever teleported.
|
|
/// </summary>
|
|
[Fact]
|
|
public void TryApplyPosition_ReportsThePreEventTeleportStamp()
|
|
{
|
|
var controller = new InboundPhysicsStateController();
|
|
WorldSession.EntitySpawn spawn = WithTimestamps(
|
|
Spawn(0x50000010u, 3, 10, 1, Position(0x0101FFFFu, 10f), 0x408u),
|
|
teleport: 10,
|
|
forcePosition: 0);
|
|
controller.AcceptCreate(spawn);
|
|
|
|
// An ordinary Position carrying the SAME TELEPORT_TS: previous and
|
|
// accepted must both be the live stamp, and nothing advanced.
|
|
Assert.True(controller.TryApplyPosition(
|
|
PositionUpdate(spawn.Guid, instance: 3, position: 11, teleport: 10),
|
|
isLocalPlayer: false,
|
|
forcePositionRotation: null,
|
|
currentLocalVelocity: null,
|
|
out PositionTimestampDisposition steady,
|
|
out _,
|
|
out AcceptedPhysicsTimestamps steadyStamps));
|
|
Assert.Equal(PositionTimestampDisposition.Apply, steady);
|
|
Assert.Equal((ushort)10, steadyStamps.PreviousTeleport);
|
|
Assert.Equal((ushort)10, steadyStamps.Teleport);
|
|
Assert.False(steadyStamps.TeleportAdvanced);
|
|
|
|
// A fresh TELEPORT_TS: previous is the PRE-event stamp, accepted is
|
|
// the new one. Capturing after the gate mutated would collapse both
|
|
// onto 11 and silently lose the advance.
|
|
Assert.True(controller.TryApplyPosition(
|
|
PositionUpdate(spawn.Guid, instance: 3, position: 12, teleport: 11),
|
|
isLocalPlayer: false,
|
|
forcePositionRotation: null,
|
|
currentLocalVelocity: null,
|
|
out PositionTimestampDisposition advanced,
|
|
out _,
|
|
out AcceptedPhysicsTimestamps advancedStamps));
|
|
Assert.Equal(PositionTimestampDisposition.Apply, advanced);
|
|
Assert.Equal((ushort)10, advancedStamps.PreviousTeleport);
|
|
Assert.Equal((ushort)11, advancedStamps.Teleport);
|
|
Assert.True(advancedStamps.TeleportAdvanced);
|
|
}
|
|
|
|
/// <summary>
|
|
/// #307, the shipped consequence: a local player who has portalled or
|
|
/// recalled this session holds a nonzero TELEPORT_TS. Retail's
|
|
/// FORCE_POSITION branch (<c>SmartBox::HandleReceivedPosition</c>
|
|
/// 0x00453FD0) fires only when the packet's teleport stamp EQUALS the live
|
|
/// one and never advances it, so the authority C4 route 2 builds from
|
|
/// these timestamps must satisfy
|
|
/// <c>PreviousTeleportSequence == AcceptedTeleportSequence</c>. With
|
|
/// PreviousTeleport pinned to 0 the classifier rejected the authority and
|
|
/// the force correction was silently dropped.
|
|
/// </summary>
|
|
[Fact]
|
|
public void LocalPlayerForcePositionAfterATeleport_ClassifiesAsAnAcceptedForceCorrection()
|
|
{
|
|
var controller = new InboundPhysicsStateController();
|
|
WorldSession.EntitySpawn spawn = WithTimestamps(
|
|
Spawn(0x50000011u, 3, 10, 1, Position(0x0101FFFFu, 10f), 0x408u),
|
|
teleport: 10,
|
|
forcePosition: 0);
|
|
controller.AcceptCreate(spawn);
|
|
|
|
Assert.True(controller.TryApplyPosition(
|
|
PositionUpdate(
|
|
spawn.Guid,
|
|
instance: 3,
|
|
position: 9,
|
|
teleport: 10,
|
|
forcePosition: 1),
|
|
isLocalPlayer: true,
|
|
forcePositionRotation: Quaternion.Identity,
|
|
currentLocalVelocity: Vector3.Zero,
|
|
out PositionTimestampDisposition disposition,
|
|
out WorldSession.EntitySpawn accepted,
|
|
out AcceptedPhysicsTimestamps timestamps));
|
|
Assert.Equal(PositionTimestampDisposition.ForcePosition, disposition);
|
|
|
|
// Built exactly as the route-2 drive builds it from these outputs.
|
|
var authority = new RuntimeAuthoritativePositionAuthority(
|
|
new RuntimeGenerationToken(7),
|
|
new RuntimeEntityKey(spawn.Guid, 1),
|
|
PositionAuthorityVersion: 4UL,
|
|
AcceptedPositionSequence: 9,
|
|
timestamps.PreviousTeleport,
|
|
timestamps.Teleport,
|
|
disposition);
|
|
RuntimeAuthoritativePositionRoute route =
|
|
RuntimeAuthoritativePositionRouteClassifier.ClassifyAcceptedPosition(
|
|
new RuntimeAcceptedPositionRouteRequest(
|
|
authority,
|
|
RuntimePositionEntityKind.LocalPlayer,
|
|
RuntimeAcceptedPositionSource.PositionEvent,
|
|
accepted.Position!.Value,
|
|
PlacementFrame: 0u,
|
|
PositionPackVelocity: Vector3.Zero,
|
|
CommittedCellId: 0x0101FFFFu,
|
|
HasContact: true,
|
|
PlayerDistance: 0f,
|
|
UsePositionFromServer: true,
|
|
HasAnimations: false,
|
|
default));
|
|
|
|
Assert.Equal(
|
|
RuntimeAuthoritativePositionDisposition.SetPositionSimple,
|
|
route.Disposition);
|
|
Assert.True(route.SendPositionImmediately);
|
|
Assert.Equal((ushort)10, timestamps.PreviousTeleport);
|
|
Assert.Equal((ushort)10, timestamps.Teleport);
|
|
}
|
|
|
|
private static WorldSession.EntityPositionUpdate PositionUpdate(
|
|
uint guid,
|
|
ushort instance,
|
|
ushort position,
|
|
ushort teleport,
|
|
ushort forcePosition = 0) =>
|
|
new(
|
|
guid,
|
|
Position(0x0101FFFFu, 20f),
|
|
null,
|
|
null,
|
|
true,
|
|
instance,
|
|
position,
|
|
teleport,
|
|
forcePosition);
|
|
|
|
private static WorldSession.EntitySpawn WithTimestamps(
|
|
WorldSession.EntitySpawn spawn,
|
|
ushort? movement = null,
|
|
ushort? serverControl = null,
|
|
ushort? teleport = null,
|
|
ushort? forcePosition = null)
|
|
{
|
|
PhysicsSpawnData physics = spawn.Physics!.Value;
|
|
PhysicsTimestamps timestamps = physics.Timestamps with
|
|
{
|
|
Movement = movement ?? physics.Timestamps.Movement,
|
|
ServerControlledMove = serverControl ?? physics.Timestamps.ServerControlledMove,
|
|
Teleport = teleport ?? physics.Timestamps.Teleport,
|
|
ForcePosition = forcePosition ?? physics.Timestamps.ForcePosition,
|
|
};
|
|
return spawn with
|
|
{
|
|
MovementSequence = timestamps.Movement,
|
|
ServerControlSequence = timestamps.ServerControlledMove,
|
|
Physics = physics with { Timestamps = timestamps },
|
|
};
|
|
}
|
|
|
|
/// <summary>
|
|
/// C5b (#275): <paramref name="motionTableId"/> drives AP-130's static
|
|
/// HasAnimations proxy, which now gates the steady-state merge's
|
|
/// placement-frame install exactly as retail's
|
|
/// <c>CPhysicsObj::HasAnims</c> check @0x00454137 gates
|
|
/// <c>SetPlacementFrame</c>. The default keeps every pre-existing fixture
|
|
/// animated, which is what the retail population overwhelmingly is.
|
|
/// </summary>
|
|
private static WorldSession.EntitySpawn Spawn(
|
|
uint guid,
|
|
ushort instance,
|
|
ushort positionSequence,
|
|
ushort stateSequence,
|
|
CreateObject.ServerPosition? position,
|
|
uint state,
|
|
uint? motionTableId = 0x09000001u)
|
|
{
|
|
var timestamps = new PhysicsTimestamps(
|
|
positionSequence,
|
|
1,
|
|
stateSequence,
|
|
1,
|
|
0,
|
|
1,
|
|
0,
|
|
1,
|
|
instance);
|
|
var physics = new PhysicsSpawnData(
|
|
RawState: state,
|
|
Position: position,
|
|
Movement: null,
|
|
AnimationFrame: null,
|
|
SetupTableId: 0x02000001u,
|
|
MotionTableId: motionTableId,
|
|
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,
|
|
Array.Empty<CreateObject.AnimPartChange>(),
|
|
Array.Empty<CreateObject.TextureChange>(),
|
|
Array.Empty<CreateObject.SubPaletteSwap>(),
|
|
null,
|
|
null,
|
|
"fixture",
|
|
null,
|
|
null,
|
|
motionTableId,
|
|
PhysicsState: state,
|
|
InstanceSequence: instance,
|
|
MovementSequence: 1,
|
|
ServerControlSequence: 1,
|
|
PositionSequence: positionSequence,
|
|
Physics: physics);
|
|
}
|
|
|
|
private static CreateObject.ServerPosition Position(uint cell, float x) =>
|
|
new(cell, x, 10f, 5f, 1f, 0f, 0f, 0f);
|
|
}
|