7e6033d0ad
Move the sole PhysicsEngine, production cache, collision admissions, canonical bodies and hosts, remote components, ordinary/remote worksets, simulation, cell commits, and shadow synchronization under RuntimeEntityObjectLifetime. Keep App as the prepared-asset, animation-input, and render-projection adapter while preserving the named-retail update and collision order. Add exact-incarnation, object-clock, callback-reentrancy, GUID-reuse, two-runtime isolation, source ownership, collision publication, and graphical projection coverage. Release build and the complete 8,588-test solution pass. Co-authored-by: Codex <noreply@openai.com>
415 lines
15 KiB
C#
415 lines
15 KiB
C#
using AcDream.Core.Net;
|
|
using AcDream.Core.Net.Messages;
|
|
using AcDream.Core.Physics;
|
|
using AcDream.Runtime.Entities;
|
|
using AcDream.Runtime.Physics;
|
|
using AcDream.Core.Physics.Motion;
|
|
using System.Numerics;
|
|
|
|
namespace AcDream.Runtime.Tests.Physics;
|
|
|
|
public sealed class RuntimePhysicsStateTests
|
|
{
|
|
[Fact]
|
|
public void EntityLifetimeConstructsOneCanonicalProductionPhysicsWorld()
|
|
{
|
|
using var lifetime = new RuntimeEntityObjectLifetime();
|
|
|
|
Assert.Same(
|
|
lifetime.Physics.DataCache,
|
|
lifetime.Physics.Engine.DataCache);
|
|
Assert.True(lifetime.Physics.CaptureOwnership().OwnsProductionDataCache);
|
|
Assert.Equal(0, lifetime.Physics.CaptureOwnership().LandblockCount);
|
|
Assert.False(lifetime.Physics.CaptureOwnership().IsDisposed);
|
|
}
|
|
|
|
[Fact]
|
|
public void ConcurrentRuntimeLifetimesDoNotShareMutablePhysicsState()
|
|
{
|
|
using var first = new RuntimeEntityObjectLifetime();
|
|
using var second = new RuntimeEntityObjectLifetime();
|
|
|
|
Assert.NotSame(first.Physics, second.Physics);
|
|
Assert.NotSame(first.Physics.Engine, second.Physics.Engine);
|
|
Assert.NotSame(first.Physics.DataCache, second.Physics.DataCache);
|
|
Assert.NotSame(
|
|
first.Physics.Engine.ShadowObjects,
|
|
second.Physics.Engine.ShadowObjects);
|
|
Assert.NotSame(
|
|
first.Physics.DataCache.CellGraph,
|
|
second.Physics.DataCache.CellGraph);
|
|
}
|
|
|
|
[Fact]
|
|
public void PhysicsOwnerDisposesWithItsEntityLifetime()
|
|
{
|
|
var lifetime = new RuntimeEntityObjectLifetime();
|
|
var physics = lifetime.Physics;
|
|
|
|
lifetime.Dispose();
|
|
|
|
Assert.True(physics.CaptureOwnership().IsDisposed);
|
|
}
|
|
|
|
[Fact]
|
|
public void CanonicalRecordAndPhysicsOwnerOwnRemoteComponentAndWorksets()
|
|
{
|
|
using var lifetime = new RuntimeEntityObjectLifetime();
|
|
RuntimeEntityRecord record =
|
|
lifetime.Entities.AddActive(Spawn(0x70000001u, 1));
|
|
var remote = new TestRemoteMotion();
|
|
lifetime.Entities.SetPhysicsBody(record, remote.Body);
|
|
lifetime.Entities.SetRemoteMotion(record, remote);
|
|
|
|
lifetime.Physics.AcknowledgeSpatialProjection(record, spatial: true);
|
|
|
|
Assert.Same(remote, record.RemoteMotion);
|
|
Assert.Same(remote.Body, record.PhysicsBody);
|
|
Assert.True(lifetime.Physics.IsSpatialRoot(record));
|
|
Assert.True(lifetime.Physics.IsSpatialRemote(record, remote));
|
|
Assert.Equal(1, lifetime.Physics.SpatialRootCount);
|
|
Assert.Equal(1, lifetime.Physics.SpatialRemoteCount);
|
|
|
|
var roots = new List<RuntimeEntityRecord>();
|
|
var remotes = new List<RuntimeEntityRecord>();
|
|
lifetime.Physics.CopySpatialRootsTo(roots);
|
|
lifetime.Physics.CopySpatialRemotesTo(remotes);
|
|
Assert.Same(record, Assert.Single(roots));
|
|
Assert.Same(record, Assert.Single(remotes));
|
|
|
|
lifetime.Entities.SetRemoteMotion(record, null);
|
|
lifetime.Physics.RefreshRemoteComponent(record);
|
|
Assert.True(lifetime.Physics.IsSpatialRoot(record));
|
|
Assert.Equal(0, lifetime.Physics.SpatialRemoteCount);
|
|
|
|
lifetime.Physics.RemoveSpatialProjection(record);
|
|
Assert.Equal(0, lifetime.Physics.SpatialRootCount);
|
|
}
|
|
|
|
[Fact]
|
|
public void EqualLocalKeysInConcurrentRuntimesDoNotShareWorksets()
|
|
{
|
|
using var first = new RuntimeEntityObjectLifetime();
|
|
using var second = new RuntimeEntityObjectLifetime();
|
|
RuntimeEntityRecord firstRecord =
|
|
first.Entities.AddActive(Spawn(0x70000002u, 1));
|
|
RuntimeEntityRecord secondRecord =
|
|
second.Entities.AddActive(Spawn(0x70000003u, 1));
|
|
Assert.Equal(firstRecord.Key, secondRecord.Key);
|
|
|
|
first.Physics.AcknowledgeSpatialProjection(firstRecord, spatial: true);
|
|
|
|
Assert.True(first.Physics.IsSpatialRoot(firstRecord));
|
|
Assert.False(second.Physics.IsSpatialRoot(secondRecord));
|
|
Assert.Equal(1, first.Physics.SpatialRootCount);
|
|
Assert.Equal(0, second.Physics.SpatialRootCount);
|
|
}
|
|
|
|
[Fact]
|
|
public void CollisionAdmissionIsExactRuntimeScopedAndWithdrawalIsTyped()
|
|
{
|
|
using var first = new RuntimeEntityObjectLifetime();
|
|
using var second = new RuntimeEntityObjectLifetime();
|
|
RuntimeCollisionAdmission admission =
|
|
first.Physics.BeginCollisionAdmission(0xA9B4FFFFu);
|
|
RuntimeCollisionAdmission newer =
|
|
first.Physics.BeginCollisionAdmission(0xA9B4FFFFu);
|
|
|
|
Assert.Throws<InvalidOperationException>(() =>
|
|
first.Physics.AdmitCollisionAssets(
|
|
admission,
|
|
CollisionAssets(0xA9B4FFFFu)));
|
|
Assert.Throws<InvalidOperationException>(() =>
|
|
second.Physics.AdmitCollisionAssets(
|
|
newer,
|
|
CollisionAssets(0xA9B4FFFFu)));
|
|
|
|
first.Physics.AdmitCollisionAssets(
|
|
newer,
|
|
CollisionAssets(0xA9B4FFFFu));
|
|
RuntimeCollisionAcknowledgement completed =
|
|
first.Physics.CompleteCollisionAdmission(newer);
|
|
|
|
Assert.True(completed.WasResident);
|
|
Assert.Equal(1, first.Physics.Engine.LandblockCount);
|
|
Assert.Equal(
|
|
0,
|
|
first.Physics.CaptureOwnership().CollisionAdmissionCount);
|
|
Assert.Throws<InvalidOperationException>(() =>
|
|
first.Physics.CompleteCollisionAdmission(newer));
|
|
|
|
RuntimeCollisionAcknowledgement withdrawn =
|
|
first.Physics.WithdrawCollision(0xA9B4FFFFu);
|
|
Assert.True(withdrawn.WasResident);
|
|
Assert.True(withdrawn.Generation > completed.Generation);
|
|
Assert.Equal(0, first.Physics.Engine.LandblockCount);
|
|
}
|
|
|
|
[Fact]
|
|
public void RemoteBindingOwnsCanonicalBodyCellAndTypedCellPublication()
|
|
{
|
|
using var lifetime = new RuntimeEntityObjectLifetime();
|
|
RuntimeEntityRecord record =
|
|
lifetime.Entities.AddActive(Spawn(0x70000021u, 1));
|
|
var remote = new RemoteMotion();
|
|
var commits = new List<RuntimePhysicsCellCommit>();
|
|
lifetime.Physics.CellCommitted += commits.Add;
|
|
lifetime.Physics.SetRemoteMotion(record, remote);
|
|
lifetime.Physics.AcknowledgeSpatialProjection(record, spatial: true);
|
|
|
|
remote.CellId = 0x02020001u;
|
|
|
|
Assert.Same(remote, record.RemoteMotion);
|
|
Assert.Same(remote.Body, record.PhysicsBody);
|
|
Assert.Equal(0x02020001u, record.FullCellId);
|
|
RuntimePhysicsCellCommit commit = Assert.Single(commits);
|
|
Assert.Same(record, commit.Record);
|
|
Assert.Equal(0x0101FFFFu, commit.PreviousFullCellId);
|
|
Assert.Equal(0x02020001u, commit.FullCellId);
|
|
Assert.True(lifetime.Physics.IsSpatialRemote(record, remote));
|
|
|
|
Assert.True(lifetime.Physics.ClearRemoteMotion(record));
|
|
Assert.Null(record.RemoteMotion);
|
|
Assert.Equal(0, lifetime.Physics.SpatialRemoteCount);
|
|
}
|
|
|
|
[Fact]
|
|
public void RemotePhysicsTickUsesCanonicalRuntimeAndPublishesPoseSnapshot()
|
|
{
|
|
using var lifetime = new RuntimeEntityObjectLifetime();
|
|
RuntimeEntityRecord record =
|
|
lifetime.Entities.AddActive(Spawn(0x70000022u, 1));
|
|
var remote = new RemoteMotion();
|
|
remote.Body.Position = new Vector3(10f, 20f, 5f);
|
|
remote.Body.Orientation = Quaternion.Identity;
|
|
remote.Body.TransientState = TransientStateFlags.Active
|
|
| TransientStateFlags.Contact
|
|
| TransientStateFlags.OnWalkable;
|
|
lifetime.Physics.SetRemoteMotion(record, remote);
|
|
lifetime.Physics.AcknowledgeSpatialProjection(record, spatial: true);
|
|
var updater = new RuntimeRemotePhysicsUpdater(lifetime.Physics);
|
|
RuntimeRemotePhysicsSnapshot snapshot = default;
|
|
int publishes = 0;
|
|
|
|
Assert.True(updater.Tick(
|
|
record,
|
|
remote,
|
|
objectScale: 1f,
|
|
sequencer: null,
|
|
dt: 0.1f,
|
|
objectClockEpoch: record.ObjectClockEpoch,
|
|
new MotionDeltaFrame
|
|
{
|
|
Origin = Vector3.UnitX,
|
|
Orientation = Quaternion.Identity,
|
|
},
|
|
radius: 0.48f,
|
|
height: 1.835f,
|
|
liveCenterX: 1,
|
|
liveCenterY: 1,
|
|
acknowledgeProjection: value =>
|
|
{
|
|
snapshot = value;
|
|
publishes++;
|
|
return true;
|
|
}));
|
|
|
|
Assert.Equal(1, publishes);
|
|
Assert.True(snapshot.Position.X > 10f);
|
|
Assert.Equal(remote.Body.Position, snapshot.Position);
|
|
Assert.Equal(record.FullCellId, snapshot.FullCellId);
|
|
}
|
|
|
|
[Fact]
|
|
public void PhysicsBodyAcquisitionIsCanonicalAndRejectsGuidReuse()
|
|
{
|
|
using var lifetime = new RuntimeEntityObjectLifetime();
|
|
RuntimeEntityRecord first =
|
|
lifetime.Entities.AddActive(Spawn(0x70000023u, 1));
|
|
var body = new PhysicsBody();
|
|
|
|
Assert.Same(
|
|
body,
|
|
lifetime.Physics.GetOrCreatePhysicsBody(first, _ => body));
|
|
Assert.Same(
|
|
body,
|
|
lifetime.Physics.GetOrCreatePhysicsBody(
|
|
first,
|
|
_ => throw new InvalidOperationException(
|
|
"The factory must not replay.")));
|
|
|
|
RuntimeEntityRecord stale =
|
|
lifetime.Entities.AddActive(Spawn(0x70000024u, 1));
|
|
Assert.Throws<InvalidOperationException>(() =>
|
|
lifetime.Physics.GetOrCreatePhysicsBody(
|
|
stale,
|
|
_ =>
|
|
{
|
|
Assert.True(lifetime.Entities.RemoveActive(stale));
|
|
lifetime.Entities.AddActive(Spawn(0x70000024u, 2));
|
|
return new PhysicsBody();
|
|
}));
|
|
Assert.Null(stale.PhysicsBody);
|
|
Assert.False(stale.PhysicsBodyAcquisitionInProgress);
|
|
}
|
|
|
|
[Fact]
|
|
public void PhysicsHostIdentityAndLookupBelongToExactRuntimeIncarnation()
|
|
{
|
|
using var lifetime = new RuntimeEntityObjectLifetime();
|
|
RuntimeEntityRecord record =
|
|
lifetime.Entities.AddActive(Spawn(0x70000025u, 1));
|
|
EntityPhysicsHost initial = Host(record.ServerGuid, 1f);
|
|
EntityPhysicsHost replacement = Host(record.ServerGuid, 2f);
|
|
|
|
Assert.Same(
|
|
initial,
|
|
lifetime.Physics.InstallOrRebindPhysicsHost(record, initial));
|
|
Assert.True(
|
|
lifetime.Physics.TryGetPhysicsHost(
|
|
record.ServerGuid,
|
|
out IPhysicsObjHost resolved));
|
|
Assert.Same(initial, resolved);
|
|
Assert.Same(
|
|
initial,
|
|
lifetime.Physics.InstallOrRebindPhysicsHost(record, replacement));
|
|
Assert.Equal(2f, initial.Position.Frame.Origin.X);
|
|
|
|
Assert.True(lifetime.Entities.RemoveActive(record));
|
|
RuntimeEntityRecord next =
|
|
lifetime.Entities.AddActive(Spawn(record.ServerGuid, 2));
|
|
Assert.False(
|
|
lifetime.Physics.TryGetPhysicsHost(
|
|
record.ServerGuid,
|
|
out _));
|
|
Assert.Null(next.PhysicsHost);
|
|
}
|
|
|
|
[Fact]
|
|
public void OrdinaryCellCommitIsCanonicalBeforePublication()
|
|
{
|
|
using var lifetime = new RuntimeEntityObjectLifetime();
|
|
RuntimeEntityRecord record =
|
|
lifetime.Entities.AddActive(Spawn(0x70000026u, 1));
|
|
var body = new PhysicsBody();
|
|
lifetime.Entities.SetPhysicsBody(record, body);
|
|
lifetime.Physics.AcknowledgeSpatialProjection(record, spatial: true);
|
|
RuntimePhysicsCellCommit observed = default;
|
|
lifetime.Physics.CellCommitted += value =>
|
|
{
|
|
Assert.Equal(value.FullCellId, value.Record.FullCellId);
|
|
observed = value;
|
|
};
|
|
|
|
Assert.True(lifetime.Physics.CommitOrdinaryCell(
|
|
record,
|
|
body,
|
|
record.ObjectClockEpoch,
|
|
0x02020001u,
|
|
externalOwnerValid: null));
|
|
|
|
Assert.Equal(0x02020001u, record.FullCellId);
|
|
Assert.Same(record, observed.Record);
|
|
Assert.Equal(record.SpatialAuthorityVersion, observed.SpatialAuthorityVersion);
|
|
}
|
|
|
|
private static RuntimeLandblockCollisionAssets CollisionAssets(
|
|
uint landblockId)
|
|
{
|
|
var heights = new byte[81];
|
|
var table = new float[256];
|
|
return new RuntimeLandblockCollisionAssets(
|
|
landblockId,
|
|
new TerrainSurface(heights, table),
|
|
Array.Empty<CellSurface>(),
|
|
Array.Empty<PortalPlane>(),
|
|
0f,
|
|
0f,
|
|
0u);
|
|
}
|
|
|
|
private static WorldSession.EntitySpawn Spawn(uint guid, ushort instance)
|
|
{
|
|
var position = new CreateObject.ServerPosition(
|
|
0x0101FFFFu,
|
|
10f,
|
|
20f,
|
|
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: instance);
|
|
var physics = new PhysicsSpawnData(
|
|
RawState: 0x408u,
|
|
Position: position,
|
|
Movement: null,
|
|
AnimationFrame: null,
|
|
SetupTableId: 0x02000001u,
|
|
MotionTableId: 0x09000001u,
|
|
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,
|
|
0x09000001u,
|
|
PhysicsState: 0x408u,
|
|
InstanceSequence: instance,
|
|
MovementSequence: 1,
|
|
ServerControlSequence: 1,
|
|
PositionSequence: 1,
|
|
Physics: physics);
|
|
}
|
|
|
|
private static EntityPhysicsHost Host(uint guid, float x) =>
|
|
new(
|
|
guid,
|
|
getPosition: () => new Position(
|
|
0x0101FFFFu,
|
|
new Vector3(x, 0f, 0f),
|
|
Quaternion.Identity),
|
|
getVelocity: () => Vector3.Zero,
|
|
getRadius: () => 0.48f,
|
|
inContact: () => true,
|
|
minterpMaxSpeed: () => null,
|
|
curTime: () => 0d,
|
|
physicsTimerTime: () => 0d,
|
|
getObjectA: _ => null,
|
|
handleUpdateTarget: _ => { },
|
|
interruptCurrentMovement: () => { });
|
|
|
|
private sealed class TestRemoteMotion : IRuntimeRemoteMotion
|
|
{
|
|
public PhysicsBody Body { get; } = new();
|
|
}
|
|
}
|