refactor(world): extract live projection mechanics
Move appearance rebinding, collision construction, default-pose resolution, local shadow ownership, and exact leave-world presentation into focused owners. Preserve retail parent ordering with staged validation, committed recovery, recursive attached-subtree withdrawal, and retryable exact teardown across parent, pickup, position, unwield, and pose-loss edges. Co-Authored-By: OpenAI Codex <codex@openai.com>
This commit is contained in:
Erik
parent
c87bac31a0
commit
69a2ca0c6d
26 changed files with 4172 additions and 430 deletions
|
|
@ -0,0 +1,358 @@
|
|||
using System.Numerics;
|
||||
using AcDream.App.Physics;
|
||||
using AcDream.App.World;
|
||||
using AcDream.Core.Items;
|
||||
using AcDream.Core.Net;
|
||||
using AcDream.Core.Net.Messages;
|
||||
using AcDream.Core.Physics;
|
||||
using AcDream.Core.World;
|
||||
using DatReaderWriter.DBObjs;
|
||||
|
||||
namespace AcDream.App.Tests.Physics;
|
||||
|
||||
public sealed class LiveEntityCollisionBuilderTests
|
||||
{
|
||||
private const uint Guid = 0x70000100u;
|
||||
private const uint Cell = 0x01010001u;
|
||||
|
||||
[Fact]
|
||||
public void EffectivePartResolution_IsSetupAndVisualOptionIndependent()
|
||||
{
|
||||
uint[] resolved = LiveEntityCollisionBuilder.ResolveEffectivePartIdentities(
|
||||
[0x01001000u, 0x01002000u],
|
||||
id => id == 0x01001000u ? 0x01001001u : id);
|
||||
|
||||
Assert.Equal([0x01001001u, 0x01002000u], resolved);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void RadiusFallback_UsesExactStateFlagsScaleAndFullSeedCell()
|
||||
{
|
||||
var setup = new Setup { Radius = 0.75f, Height = 2.5f };
|
||||
WorldSession.EntitySpawn spawn = Spawn(
|
||||
scale: 2f,
|
||||
itemType: (uint)ItemType.Creature,
|
||||
descriptionFlags: 0x28u);
|
||||
var record = new LiveEntityRecord(spawn)
|
||||
{
|
||||
FinalPhysicsState = PhysicsStateFlags.Hidden | PhysicsStateFlags.Static,
|
||||
};
|
||||
WorldEntity entity = Entity();
|
||||
record.WorldEntity = entity;
|
||||
var builder = Builder();
|
||||
|
||||
LiveEntityCollisionRegistration registration = Assert.IsType<LiveEntityCollisionRegistration>(
|
||||
builder.Build(entity, setup, Array.Empty<uint>(), spawn, record, new Vector3(192f, -192f, 0f)));
|
||||
|
||||
ShadowShape shape = Assert.Single(registration.Shapes);
|
||||
Assert.Equal(ShadowCollisionType.Cylinder, shape.CollisionType);
|
||||
Assert.Equal(1.5f, shape.Radius);
|
||||
Assert.Equal(5f, shape.CylHeight);
|
||||
Assert.Equal((uint)record.FinalPhysicsState, registration.State);
|
||||
Assert.True(registration.Flags.HasFlag(EntityCollisionFlags.HasWeenie));
|
||||
Assert.True(registration.Flags.HasFlag(EntityCollisionFlags.IsCreature));
|
||||
Assert.True(registration.Flags.HasFlag(EntityCollisionFlags.IsPlayer));
|
||||
Assert.True(registration.Flags.HasFlag(EntityCollisionFlags.IsPK));
|
||||
Assert.Equal(Cell, registration.LandblockId);
|
||||
Assert.Equal(Cell, registration.SeedCellId);
|
||||
Assert.Equal((192f, -192f), (registration.WorldOffsetX, registration.WorldOffsetY));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void BspOnlyPart_UsesRealScaledPhysicsBoundingRadius()
|
||||
{
|
||||
const uint part = 0x0100ABCDu;
|
||||
var setup = new Setup();
|
||||
setup.Parts.Add(part);
|
||||
WorldSession.EntitySpawn spawn = Spawn(scale: 1.5f);
|
||||
var record = new LiveEntityRecord(spawn);
|
||||
WorldEntity entity = Entity();
|
||||
record.WorldEntity = entity;
|
||||
var builder = new LiveEntityCollisionBuilder(
|
||||
id => id == part,
|
||||
id => id == part ? 3f : null,
|
||||
PoseResolver());
|
||||
|
||||
LiveEntityCollisionRegistration registration = Assert.IsType<LiveEntityCollisionRegistration>(
|
||||
builder.Build(entity, setup, [part], spawn, record, Vector3.Zero));
|
||||
|
||||
ShadowShape shape = Assert.Single(registration.Shapes);
|
||||
Assert.Equal(ShadowCollisionType.BSP, shape.CollisionType);
|
||||
Assert.Equal(4.5f, shape.Radius);
|
||||
Assert.Equal(part, shape.GfxObjId);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EffectiveReplacementWithoutPhysicsBsp_RemovesBasePartCollision()
|
||||
{
|
||||
const uint basePart = 0x0100AB01u;
|
||||
const uint replacement = 0x0100AB02u;
|
||||
var setup = new Setup();
|
||||
setup.Parts.Add(basePart);
|
||||
WorldSession.EntitySpawn spawn = Spawn(scale: 1f);
|
||||
var record = new LiveEntityRecord(spawn);
|
||||
WorldEntity entity = Entity();
|
||||
record.WorldEntity = entity;
|
||||
var builder = new LiveEntityCollisionBuilder(
|
||||
id => id == basePart,
|
||||
_ => 1f,
|
||||
PoseResolver());
|
||||
|
||||
Assert.Null(builder.Build(
|
||||
entity,
|
||||
setup,
|
||||
[replacement],
|
||||
spawn,
|
||||
record,
|
||||
Vector3.Zero));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void EffectiveReplacementWithPhysicsBsp_AddsReplacementCollision()
|
||||
{
|
||||
const uint basePart = 0x0100AB11u;
|
||||
const uint replacement = 0x0100AB12u;
|
||||
var setup = new Setup();
|
||||
setup.Parts.Add(basePart);
|
||||
WorldSession.EntitySpawn spawn = Spawn(scale: 1f);
|
||||
var record = new LiveEntityRecord(spawn);
|
||||
WorldEntity entity = Entity();
|
||||
record.WorldEntity = entity;
|
||||
var builder = new LiveEntityCollisionBuilder(
|
||||
id => id == replacement,
|
||||
id => id == replacement ? 2.25f : null,
|
||||
PoseResolver());
|
||||
|
||||
LiveEntityCollisionRegistration registration =
|
||||
Assert.IsType<LiveEntityCollisionRegistration>(builder.Build(
|
||||
entity,
|
||||
setup,
|
||||
[replacement],
|
||||
spawn,
|
||||
record,
|
||||
Vector3.Zero));
|
||||
|
||||
ShadowShape shape = Assert.Single(registration.Shapes);
|
||||
Assert.Equal(replacement, shape.GfxObjId);
|
||||
Assert.Equal(2.25f, shape.Radius);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ReconcileAppearance_VisibleReplacementWithoutBspRemovesOldPayload()
|
||||
{
|
||||
const uint basePart = 0x0100AC01u;
|
||||
const uint replacement = 0x0100AC02u;
|
||||
var setup = new Setup();
|
||||
setup.Parts.Add(basePart);
|
||||
WorldSession.EntitySpawn spawn = Spawn(scale: 1f);
|
||||
var record = new LiveEntityRecord(spawn);
|
||||
WorldEntity entity = Entity();
|
||||
record.WorldEntity = entity;
|
||||
var builder = new LiveEntityCollisionBuilder(
|
||||
id => id == basePart,
|
||||
_ => 1f,
|
||||
PoseResolver());
|
||||
LiveEntityCollisionRegistration initial =
|
||||
Assert.IsType<LiveEntityCollisionRegistration>(builder.Build(
|
||||
entity, setup, [basePart], spawn, record, Vector3.Zero));
|
||||
var registry = new ShadowObjectRegistry();
|
||||
LiveEntityCollisionBuilder.Register(registry, initial);
|
||||
|
||||
LiveEntityCollisionRegistration? changed = builder.Build(
|
||||
entity, setup, [replacement], spawn, record, Vector3.Zero,
|
||||
retainEmptyPayload: true);
|
||||
LiveEntityCollisionBuilder.ReconcileAppearance(
|
||||
registry, entity.Id, changed, suspendIfNew: false);
|
||||
|
||||
Assert.Equal(1, registry.RetainedRegistrationCount);
|
||||
Assert.DoesNotContain(
|
||||
registry.GetObjectsInCell(Cell),
|
||||
entry => entry.EntityId == entity.Id);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ReconcileAppearance_SuspendedReplacementRetainsNewPayloadUntilRestore()
|
||||
{
|
||||
const uint basePart = 0x0100AC11u;
|
||||
const uint replacement = 0x0100AC12u;
|
||||
var setup = new Setup();
|
||||
setup.Parts.Add(basePart);
|
||||
WorldSession.EntitySpawn spawn = Spawn(scale: 1f);
|
||||
var record = new LiveEntityRecord(spawn);
|
||||
WorldEntity entity = Entity();
|
||||
record.WorldEntity = entity;
|
||||
var builder = new LiveEntityCollisionBuilder(
|
||||
id => id == basePart || id == replacement,
|
||||
_ => 1f,
|
||||
PoseResolver());
|
||||
LiveEntityCollisionRegistration initial =
|
||||
Assert.IsType<LiveEntityCollisionRegistration>(builder.Build(
|
||||
entity, setup, [basePart], spawn, record, Vector3.Zero));
|
||||
var registry = new ShadowObjectRegistry();
|
||||
LiveEntityCollisionBuilder.Register(registry, initial);
|
||||
Assert.True(registry.Suspend(entity.Id));
|
||||
LiveEntityCollisionRegistration changed =
|
||||
Assert.IsType<LiveEntityCollisionRegistration>(builder.Build(
|
||||
entity, setup, [replacement], spawn, record, Vector3.Zero));
|
||||
|
||||
LiveEntityCollisionBuilder.ReconcileAppearance(
|
||||
registry, entity.Id, changed, suspendIfNew: true);
|
||||
|
||||
Assert.Equal(1, registry.RetainedRegistrationCount);
|
||||
Assert.Equal(1, registry.SuspendedRegistrationCount);
|
||||
Assert.DoesNotContain(
|
||||
registry.GetObjectsInCell(Cell),
|
||||
entry => entry.EntityId == entity.Id);
|
||||
|
||||
LiveEntityCollisionRegistration empty =
|
||||
Assert.IsType<LiveEntityCollisionRegistration>(builder.Build(
|
||||
entity,
|
||||
setup,
|
||||
[0x0100AC13u],
|
||||
spawn,
|
||||
record,
|
||||
Vector3.Zero,
|
||||
retainEmptyPayload: true));
|
||||
LiveEntityCollisionBuilder.ReconcileAppearance(
|
||||
registry, entity.Id, empty, suspendIfNew: true);
|
||||
LiveEntityCollisionBuilder.ReconcileAppearance(
|
||||
registry, entity.Id, changed, suspendIfNew: true);
|
||||
Assert.Equal(1, registry.RetainedRegistrationCount);
|
||||
Assert.Equal(1, registry.SuspendedRegistrationCount);
|
||||
|
||||
registry.UpdatePosition(
|
||||
entity.Id,
|
||||
entity.Position,
|
||||
entity.Rotation,
|
||||
worldOffsetX: 0f,
|
||||
worldOffsetY: 0f,
|
||||
landblockId: Cell,
|
||||
seedCellId: Cell);
|
||||
ShadowEntry restored = Assert.Single(
|
||||
registry.GetObjectsInCell(Cell),
|
||||
entry => entry.EntityId == entity.Id);
|
||||
Assert.Equal(replacement, restored.GfxObjId);
|
||||
Assert.Equal(0, registry.SuspendedRegistrationCount);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ReconcileAppearance_ExistingMembershipDoesNotDependOnNewFlood()
|
||||
{
|
||||
const uint basePart = 0x0100AC21u;
|
||||
const uint replacement = 0x0100AC22u;
|
||||
var setup = new Setup();
|
||||
setup.Parts.Add(basePart);
|
||||
WorldSession.EntitySpawn spawn = Spawn(scale: 1f);
|
||||
var record = new LiveEntityRecord(spawn);
|
||||
WorldEntity entity = Entity();
|
||||
record.WorldEntity = entity;
|
||||
var builder = new LiveEntityCollisionBuilder(
|
||||
id => id == basePart || id == replacement,
|
||||
_ => 1f,
|
||||
PoseResolver());
|
||||
LiveEntityCollisionRegistration initial =
|
||||
Assert.IsType<LiveEntityCollisionRegistration>(builder.Build(
|
||||
entity, setup, [basePart], spawn, record, Vector3.Zero));
|
||||
var registry = new ShadowObjectRegistry();
|
||||
LiveEntityCollisionBuilder.Register(registry, initial);
|
||||
LiveEntityCollisionRegistration changed =
|
||||
Assert.IsType<LiveEntityCollisionRegistration>(builder.Build(
|
||||
entity, setup, [replacement], spawn, record, Vector3.Zero))
|
||||
with
|
||||
{
|
||||
LandblockId = 0u,
|
||||
SeedCellId = 0u,
|
||||
};
|
||||
|
||||
LiveEntityCollisionBuilder.ReconcileAppearance(
|
||||
registry, entity.Id, changed, suspendIfNew: false);
|
||||
|
||||
ShadowEntry entry = Assert.Single(
|
||||
registry.GetObjectsInCell(Cell),
|
||||
candidate => candidate.EntityId == entity.Id);
|
||||
Assert.Equal(replacement, entry.GfxObjId);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ShapelessSetup_ProducesNoRegistration()
|
||||
{
|
||||
WorldSession.EntitySpawn spawn = Spawn(scale: 1f);
|
||||
var record = new LiveEntityRecord(spawn);
|
||||
WorldEntity entity = Entity();
|
||||
record.WorldEntity = entity;
|
||||
|
||||
Assert.Null(Builder().Build(
|
||||
entity,
|
||||
new Setup(),
|
||||
Array.Empty<uint>(),
|
||||
spawn,
|
||||
record,
|
||||
Vector3.Zero));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void Build_RejectsDifferentRecordIncarnation()
|
||||
{
|
||||
WorldSession.EntitySpawn spawn = Spawn(scale: 1f);
|
||||
var expected = new LiveEntityRecord(spawn);
|
||||
var other = new LiveEntityRecord(spawn with { InstanceSequence = 2 });
|
||||
WorldEntity entity = Entity();
|
||||
expected.WorldEntity = entity;
|
||||
other.WorldEntity = entity;
|
||||
|
||||
Assert.Throws<InvalidOperationException>(() => Builder().Build(
|
||||
entity,
|
||||
new Setup { Radius = 1f },
|
||||
Array.Empty<uint>(),
|
||||
spawn,
|
||||
other,
|
||||
Vector3.Zero));
|
||||
}
|
||||
|
||||
private static LiveEntityCollisionBuilder Builder() => new(
|
||||
_ => false,
|
||||
_ => null,
|
||||
PoseResolver());
|
||||
|
||||
private static LiveEntityDefaultPoseResolver PoseResolver() => new(
|
||||
_ => null,
|
||||
new NullAnimationLoader(),
|
||||
dumpMotion: false);
|
||||
|
||||
private static WorldEntity Entity() => new()
|
||||
{
|
||||
Id = 101u,
|
||||
ServerGuid = Guid,
|
||||
SourceGfxObjOrSetupId = 0x02000100u,
|
||||
Position = new Vector3(4f, 5f, 6f),
|
||||
Rotation = Quaternion.Identity,
|
||||
MeshRefs = Array.Empty<MeshRef>(),
|
||||
ParentCellId = Cell,
|
||||
};
|
||||
|
||||
private static WorldSession.EntitySpawn Spawn(
|
||||
float scale,
|
||||
uint? itemType = null,
|
||||
uint? descriptionFlags = null) =>
|
||||
new(
|
||||
Guid,
|
||||
new CreateObject.ServerPosition(Cell, 4f, 5f, 6f, 1f, 0f, 0f, 0f),
|
||||
0x02000100u,
|
||||
Array.Empty<CreateObject.AnimPartChange>(),
|
||||
Array.Empty<CreateObject.TextureChange>(),
|
||||
Array.Empty<CreateObject.SubPaletteSwap>(),
|
||||
BasePaletteId: null,
|
||||
ObjScale: scale,
|
||||
Name: "collision fixture",
|
||||
ItemType: itemType,
|
||||
MotionState: null,
|
||||
MotionTableId: null,
|
||||
PhysicsState: 0u,
|
||||
ObjectDescriptionFlags: descriptionFlags,
|
||||
InstanceSequence: 1);
|
||||
|
||||
private sealed class NullAnimationLoader : IAnimationLoader
|
||||
{
|
||||
public Animation? LoadAnimation(uint id) => null;
|
||||
}
|
||||
}
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -1,5 +1,10 @@
|
|||
using System.Numerics;
|
||||
using AcDream.App.Rendering;
|
||||
using AcDream.App.Physics;
|
||||
using AcDream.App.Streaming;
|
||||
using AcDream.App.World;
|
||||
using AcDream.Core.Net;
|
||||
using AcDream.Core.Net.Messages;
|
||||
using AcDream.Core.Physics;
|
||||
using AcDream.Core.World;
|
||||
using DatReaderWriter.DBObjs;
|
||||
|
|
@ -8,6 +13,50 @@ namespace AcDream.App.Tests.Rendering;
|
|||
|
||||
public sealed class LiveAppearanceAnimationTests
|
||||
{
|
||||
[Fact]
|
||||
public void Capture_UsesCanonicalRecordEntityAndAnimationOwner()
|
||||
{
|
||||
const uint guid = 0x70000002u;
|
||||
var runtime = new AcDream.App.World.LiveEntityRuntime(
|
||||
new AcDream.App.Streaming.GpuWorldState(),
|
||||
new AcDream.App.World.DelegateLiveEntityResourceLifecycle(_ => { }, _ => { }));
|
||||
var record = runtime.RegisterLiveEntity(new AcDream.Core.Net.WorldSession.EntitySpawn(
|
||||
guid,
|
||||
Position: null,
|
||||
SetupTableId: null,
|
||||
AnimPartChanges: Array.Empty<AcDream.Core.Net.Messages.CreateObject.AnimPartChange>(),
|
||||
TextureChanges: Array.Empty<AcDream.Core.Net.Messages.CreateObject.TextureChange>(),
|
||||
SubPalettes: Array.Empty<AcDream.Core.Net.Messages.CreateObject.SubPaletteSwap>(),
|
||||
BasePaletteId: null,
|
||||
ObjScale: null,
|
||||
Name: "appearance fixture",
|
||||
ItemType: null,
|
||||
MotionState: null,
|
||||
MotionTableId: null,
|
||||
InstanceSequence: 1)).Record!;
|
||||
WorldEntity entity = Entity(0x70000002u, 0x01000001u);
|
||||
var state = new LiveEntityAnimationState
|
||||
{
|
||||
Entity = entity,
|
||||
Setup = new Setup(),
|
||||
Animation = new Animation(),
|
||||
LowFrame = 0,
|
||||
HighFrame = 0,
|
||||
Framerate = 0f,
|
||||
Scale = 1f,
|
||||
PartTemplate = Array.Empty<LiveAnimationPartTemplate>(),
|
||||
PartAvailability = Array.Empty<bool>(),
|
||||
};
|
||||
record.WorldEntity = entity;
|
||||
record.AnimationRuntime = state;
|
||||
|
||||
LiveEntityAppearanceUpdateState captured = Assert.IsType<LiveEntityAppearanceUpdateState>(
|
||||
LiveEntityAppearanceBinding.Capture(runtime, guid));
|
||||
|
||||
Assert.Same(entity, captured.Entity);
|
||||
Assert.Same(state, captured.Animation);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void RebindAppearance_PreservesEntitySequencerAndPlaybackState()
|
||||
{
|
||||
|
|
@ -36,7 +85,7 @@ public sealed class LiveAppearanceAnimationTests
|
|||
];
|
||||
|
||||
oldEntity.ApplyAppearance(dressedParts, paletteOverride: null, partOverrides: []);
|
||||
GameWindow.RebindAnimatedEntityForAppearance(
|
||||
LiveEntityAppearanceBinding.RebindAnimation(
|
||||
state,
|
||||
oldEntity,
|
||||
setup,
|
||||
|
|
@ -57,6 +106,88 @@ public sealed class LiveAppearanceAnimationTests
|
|||
state.PartTemplate.Select(part => part.GfxObjId));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void CollisionCommit_DelayedOldIncarnationCannotMutateGuidReplacement()
|
||||
{
|
||||
const uint guid = 0x70000010u;
|
||||
const uint cell = 0x01010001u;
|
||||
var spatial = new GpuWorldState();
|
||||
spatial.AddLandblock(new LoadedLandblock(
|
||||
0x0101FFFFu,
|
||||
new LandBlock(),
|
||||
Array.Empty<WorldEntity>()));
|
||||
var runtime = new LiveEntityRuntime(
|
||||
spatial,
|
||||
new DelegateLiveEntityResourceLifecycle(_ => { }, _ => { }));
|
||||
WorldSession.EntitySpawn first = Spawn(guid, cell, instance: 1);
|
||||
runtime.RegisterLiveEntity(first);
|
||||
WorldEntity oldEntity = runtime.MaterializeLiveEntity(
|
||||
guid,
|
||||
cell,
|
||||
id => new WorldEntity
|
||||
{
|
||||
Id = id,
|
||||
ServerGuid = guid,
|
||||
SourceGfxObjOrSetupId = 0x02000010u,
|
||||
Position = Vector3.One,
|
||||
Rotation = Quaternion.Identity,
|
||||
MeshRefs = Array.Empty<MeshRef>(),
|
||||
ParentCellId = cell,
|
||||
})!;
|
||||
var registry = new ShadowObjectRegistry();
|
||||
registry.Register(
|
||||
oldEntity.Id,
|
||||
0x01000010u,
|
||||
oldEntity.Position,
|
||||
oldEntity.Rotation,
|
||||
radius: 0.5f,
|
||||
worldOffsetX: 0f,
|
||||
worldOffsetY: 0f,
|
||||
landblockId: cell,
|
||||
seedCellId: cell,
|
||||
isStatic: false);
|
||||
var builder = new LiveEntityCollisionBuilder(
|
||||
_ => false,
|
||||
_ => null,
|
||||
new LiveEntityDefaultPoseResolver(
|
||||
_ => null,
|
||||
new NullLoader(),
|
||||
dumpMotion: false));
|
||||
LiveEntityAppearanceCollisionUpdate update =
|
||||
Assert.IsType<LiveEntityAppearanceCollisionUpdate>(
|
||||
LiveEntityAppearanceBinding.PrepareCollision(
|
||||
runtime,
|
||||
builder,
|
||||
oldEntity,
|
||||
new Setup(),
|
||||
Array.Empty<uint>(),
|
||||
first,
|
||||
Vector3.Zero));
|
||||
|
||||
runtime.RegisterLiveEntity(Spawn(guid, cell, instance: 2));
|
||||
|
||||
Assert.False(LiveEntityAppearanceBinding.CommitCollision(
|
||||
runtime,
|
||||
registry,
|
||||
update));
|
||||
Assert.Equal(1, registry.RetainedRegistrationCount);
|
||||
}
|
||||
|
||||
private static WorldSession.EntitySpawn Spawn(uint guid, uint cell, ushort instance) => new(
|
||||
guid,
|
||||
new CreateObject.ServerPosition(cell, 1f, 1f, 1f, 1f, 0f, 0f, 0f),
|
||||
0x02000010u,
|
||||
Array.Empty<CreateObject.AnimPartChange>(),
|
||||
Array.Empty<CreateObject.TextureChange>(),
|
||||
Array.Empty<CreateObject.SubPaletteSwap>(),
|
||||
BasePaletteId: null,
|
||||
ObjScale: 1f,
|
||||
Name: "appearance collision fixture",
|
||||
ItemType: null,
|
||||
MotionState: null,
|
||||
MotionTableId: null,
|
||||
InstanceSequence: instance);
|
||||
|
||||
private static WorldEntity Entity(uint id, uint gfxObjId) => new()
|
||||
{
|
||||
Id = id,
|
||||
|
|
|
|||
|
|
@ -134,7 +134,7 @@ public sealed class LiveEntityAnimationPresenterTests
|
|||
replacementSetup.DefaultScale.Add(Vector3.One);
|
||||
fixture.Entity.MeshRefs = [new MeshRef(0x01000009u, Matrix4x4.Identity)];
|
||||
fixture.Entity.SetIndexedPartPoses([Matrix4x4.Identity], [true]);
|
||||
GameWindow.RebindAnimatedEntityForAppearance(
|
||||
LiveEntityAppearanceBinding.RebindAnimation(
|
||||
fixture.State,
|
||||
fixture.Entity,
|
||||
replacementSetup,
|
||||
|
|
@ -169,7 +169,7 @@ public sealed class LiveEntityAnimationPresenterTests
|
|||
var replacement = new Setup();
|
||||
replacement.Parts.Add(0x01000099u);
|
||||
replacement.DefaultScale.Add(Vector3.One);
|
||||
GameWindow.RebindAnimatedEntityForAppearance(
|
||||
LiveEntityAppearanceBinding.RebindAnimation(
|
||||
fixture.State,
|
||||
fixture.Entity,
|
||||
replacement,
|
||||
|
|
|
|||
|
|
@ -453,6 +453,78 @@ public sealed class EntitySpawnAdapterLifetimeTests
|
|||
Assert.Equal(0, meshes.TotalReferenceCount);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AppearanceChange_AfterPublicationRunsBeforeOldRetirement()
|
||||
{
|
||||
const uint guid = 0x7400C100u;
|
||||
const ulong oldMesh = 0x01000A10u;
|
||||
const ulong newMesh = 0x01000A11u;
|
||||
var meshes = new CallbackMeshAdapter();
|
||||
var adapter = new EntitySpawnAdapter(
|
||||
new RecordingTextureLifetime(), _ => MakeSequencer(), meshes);
|
||||
WorldEntity entity = MakeEntity(152u, guid);
|
||||
entity.MeshRefs = [new MeshRef((uint)oldMesh, Matrix4x4.Identity)];
|
||||
adapter.OnCreate(entity);
|
||||
Assert.True(adapter.SetPresentationResident(entity, resident: true));
|
||||
meshes.Operations.Clear();
|
||||
MeshRef[] replacement = [new MeshRef((uint)newMesh, Matrix4x4.Identity)];
|
||||
|
||||
Assert.True(adapter.OnAppearanceChanged(
|
||||
entity,
|
||||
replacement,
|
||||
[],
|
||||
() =>
|
||||
{
|
||||
meshes.Operations.Add("publish");
|
||||
entity.ApplyAppearance(replacement, paletteOverride: null, []);
|
||||
},
|
||||
() =>
|
||||
{
|
||||
Assert.Same(replacement, entity.MeshRefs);
|
||||
Assert.Equal(1, meshes.ReferenceCounts[oldMesh]);
|
||||
Assert.Equal(1, meshes.ReferenceCounts[newMesh]);
|
||||
meshes.Operations.Add("after-publication");
|
||||
}));
|
||||
|
||||
int afterPublication = meshes.Operations.IndexOf("after-publication");
|
||||
Assert.True(meshes.Operations.IndexOf("publish") < afterPublication);
|
||||
Assert.True(meshes.Operations.IndexOf($"decrement:{oldMesh:X8}") > afterPublication);
|
||||
Assert.True(adapter.OnRemove(entity));
|
||||
Assert.Equal(0, meshes.TotalReferenceCount);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AppearanceChange_AfterPublicationFailureKeepsCommittedSetAndRetryRetiresOld()
|
||||
{
|
||||
const uint guid = 0x7400C200u;
|
||||
const ulong oldMesh = 0x01000A20u;
|
||||
const ulong newMesh = 0x01000A21u;
|
||||
var meshes = new RefCountingMeshAdapter();
|
||||
var adapter = new EntitySpawnAdapter(
|
||||
new RecordingTextureLifetime(), _ => MakeSequencer(), meshes);
|
||||
WorldEntity entity = MakeEntity(153u, guid);
|
||||
entity.MeshRefs = [new MeshRef((uint)oldMesh, Matrix4x4.Identity)];
|
||||
adapter.OnCreate(entity);
|
||||
Assert.True(adapter.SetPresentationResident(entity, resident: true));
|
||||
MeshRef[] replacement = [new MeshRef((uint)newMesh, Matrix4x4.Identity)];
|
||||
|
||||
Assert.Throws<InvalidOperationException>(() => adapter.OnAppearanceChanged(
|
||||
entity,
|
||||
replacement,
|
||||
[],
|
||||
() => entity.ApplyAppearance(replacement, paletteOverride: null, []),
|
||||
() => throw new InvalidOperationException("injected dependent publication failure")));
|
||||
|
||||
Assert.Same(replacement, entity.MeshRefs);
|
||||
Assert.Equal(1, meshes.ReferenceCounts[oldMesh]);
|
||||
Assert.Equal(1, meshes.ReferenceCounts[newMesh]);
|
||||
Assert.True(adapter.SetPresentationResident(entity, resident: true));
|
||||
Assert.False(meshes.ReferenceCounts.ContainsKey(oldMesh));
|
||||
Assert.Equal(1, meshes.ReferenceCounts[newMesh]);
|
||||
Assert.True(adapter.OnRemove(entity));
|
||||
Assert.Equal(0, meshes.TotalReferenceCount);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void AppearanceChange_WhileSuspended_OnlyReplacementSetIsAcquiredOnResume()
|
||||
{
|
||||
|
|
|
|||
|
|
@ -0,0 +1,51 @@
|
|||
using System.Collections;
|
||||
using System.Reflection;
|
||||
using AcDream.App.Physics;
|
||||
using AcDream.App.Rendering;
|
||||
using AcDream.App.World;
|
||||
|
||||
namespace AcDream.App.Tests.World;
|
||||
|
||||
public sealed class GameWindowLiveEntityCompositionTests
|
||||
{
|
||||
private const BindingFlags PrivateImplementation =
|
||||
BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic;
|
||||
|
||||
[Theory]
|
||||
[InlineData("RegisterLiveEntityCollision")]
|
||||
[InlineData("MotionTableDefaultPose")]
|
||||
[InlineData("LeaveWorldLiveEntityRuntimeComponents")]
|
||||
[InlineData("WithdrawLiveEntityWorldProjection")]
|
||||
[InlineData("RebindAnimatedEntityForAppearance")]
|
||||
public void GameWindow_DoesNotReacquireExtractedLiveEntityBodies(string methodName)
|
||||
{
|
||||
Assert.Null(typeof(GameWindow).GetMethod(methodName, PrivateImplementation));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void GameWindow_DoesNotOwnAnAppearanceUpdateStateType()
|
||||
{
|
||||
Assert.Null(typeof(GameWindow).GetNestedType(
|
||||
"AppearanceUpdateState",
|
||||
BindingFlags.NonPublic));
|
||||
}
|
||||
|
||||
[Theory]
|
||||
[InlineData(typeof(LiveEntityCollisionBuilder))]
|
||||
[InlineData(typeof(LiveEntityDefaultPoseResolver))]
|
||||
[InlineData(typeof(LiveEntityProjectionWithdrawalController))]
|
||||
[InlineData(typeof(LocalPlayerShadowState))]
|
||||
[InlineData(typeof(LiveEntityAppearanceBinding))]
|
||||
public void ExtractedHelpers_DoNotOwnGuidIndexesOrBackendState(Type helperType)
|
||||
{
|
||||
foreach (FieldInfo field in helperType.GetFields(
|
||||
BindingFlags.Instance | BindingFlags.Static | BindingFlags.NonPublic))
|
||||
{
|
||||
Assert.False(typeof(IDictionary).IsAssignableFrom(field.FieldType),
|
||||
$"{helperType.Name}.{field.Name} must resolve identity through LiveEntityRuntime.");
|
||||
string typeName = field.FieldType.FullName ?? field.FieldType.Name;
|
||||
Assert.DoesNotContain("Silk.NET", typeName, StringComparison.Ordinal);
|
||||
Assert.DoesNotContain("OpenGL", typeName, StringComparison.OrdinalIgnoreCase);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -208,7 +208,7 @@ public sealed class InboundPhysicsStateControllerTests
|
|||
}
|
||||
|
||||
[Fact]
|
||||
public void ParentEventWaitsForParent_ThenConsumesChildPositionOnce()
|
||||
public void ParentEventWaitsForParent_ThenStagesTimestampUntilValidatedCommit()
|
||||
{
|
||||
var controller = new InboundPhysicsStateController();
|
||||
controller.AcceptCreate(Spawn(
|
||||
|
|
@ -219,7 +219,17 @@ public sealed class InboundPhysicsStateControllerTests
|
|||
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 attached));
|
||||
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 _));
|
||||
|
|
|
|||
|
|
@ -0,0 +1,289 @@
|
|||
using System.Numerics;
|
||||
using AcDream.App.Physics;
|
||||
using AcDream.App.Rendering.Vfx;
|
||||
using AcDream.App.Streaming;
|
||||
using AcDream.App.World;
|
||||
using AcDream.Core.Net;
|
||||
using AcDream.Core.Net.Messages;
|
||||
using AcDream.Core.Physics;
|
||||
using AcDream.Core.Plugins;
|
||||
using AcDream.Core.World;
|
||||
using AcDream.Plugin.Abstractions;
|
||||
using DatReaderWriter.DBObjs;
|
||||
|
||||
namespace AcDream.App.Tests.World;
|
||||
|
||||
public sealed class LiveEntityProjectionWithdrawalControllerTests
|
||||
{
|
||||
private const uint Guid = 0x70000200u;
|
||||
private const uint Cell = 0x01010001u;
|
||||
|
||||
[Fact]
|
||||
public void ComponentFailure_StopsBeforeCanonicalWithdrawal_AndRetryConverges()
|
||||
{
|
||||
var fixture = new Fixture();
|
||||
LiveEntityRecord record = fixture.Spawn(instance: 1);
|
||||
fixture.Poses.EffectPoseChanged += ThrowOnPoseChange;
|
||||
|
||||
Assert.Throws<InvalidOperationException>(() =>
|
||||
fixture.Controller.Withdraw(Guid, localPlayerGuid: 0u));
|
||||
|
||||
Assert.True(record.IsSpatiallyProjected);
|
||||
Assert.Empty(fixture.GameState.Entities);
|
||||
Assert.Equal(0, fixture.Poses.Count);
|
||||
Assert.DoesNotContain(
|
||||
fixture.Physics.ShadowObjects.GetObjectsInCell(Cell),
|
||||
entry => entry.EntityId == record.WorldEntity!.Id);
|
||||
Assert.Equal(1, fixture.Physics.ShadowObjects.SuspendedRegistrationCount);
|
||||
|
||||
fixture.Poses.EffectPoseChanged -= ThrowOnPoseChange;
|
||||
Assert.True(fixture.Controller.Withdraw(Guid, localPlayerGuid: 0u));
|
||||
Assert.False(record.IsSpatiallyProjected);
|
||||
|
||||
static void ThrowOnPoseChange(uint _) =>
|
||||
throw new InvalidOperationException("fixture pose observer failure");
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void RuntimeObserverFailure_CommitsCanonicalWithdrawalAfterComponentsRemoved()
|
||||
{
|
||||
var fixture = new Fixture();
|
||||
LiveEntityRecord record = fixture.Spawn(instance: 1);
|
||||
fixture.Live.ProjectionVisibilityChanged += ThrowOnHidden;
|
||||
|
||||
Assert.ThrowsAny<Exception>(() =>
|
||||
fixture.Controller.Withdraw(Guid, localPlayerGuid: 0u));
|
||||
|
||||
Assert.False(record.IsSpatiallyProjected);
|
||||
Assert.False(record.IsSpatiallyVisible);
|
||||
Assert.Empty(fixture.GameState.Entities);
|
||||
Assert.Equal(0, fixture.Poses.Count);
|
||||
|
||||
static void ThrowOnHidden(LiveEntityRecord _, bool visible)
|
||||
{
|
||||
if (!visible)
|
||||
throw new InvalidOperationException("fixture runtime observer failure");
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void OrdinaryLeaveWorld_SuspendsRetainedShadow_AndReentryRestoresIt()
|
||||
{
|
||||
var fixture = new Fixture();
|
||||
LiveEntityRecord record = fixture.Spawn(instance: 1);
|
||||
uint localId = record.WorldEntity!.Id;
|
||||
Assert.Contains(
|
||||
fixture.Physics.ShadowObjects.GetObjectsInCell(Cell),
|
||||
entry => entry.EntityId == localId);
|
||||
|
||||
Assert.True(fixture.Controller.Withdraw(Guid, localPlayerGuid: 0u));
|
||||
Assert.DoesNotContain(
|
||||
fixture.Physics.ShadowObjects.GetObjectsInCell(Cell),
|
||||
entry => entry.EntityId == localId);
|
||||
|
||||
Assert.True(fixture.Live.RebucketLiveEntity(Guid, Cell));
|
||||
Assert.Contains(
|
||||
fixture.Physics.ShadowObjects.GetObjectsInCell(Cell),
|
||||
entry => entry.EntityId == localId);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ComponentCallbackReplacesGuid_DoesNotWithdrawReplacement()
|
||||
{
|
||||
var fixture = new Fixture();
|
||||
LiveEntityRecord old = fixture.Spawn(instance: 1);
|
||||
LiveEntityRecord? replacement = null;
|
||||
bool replacing = false;
|
||||
fixture.LocalShadow.Set(Vector3.One, Quaternion.Identity, Cell);
|
||||
fixture.Poses.EffectPoseChanged += OnPoseChanged;
|
||||
|
||||
Assert.False(fixture.Controller.Withdraw(Guid, localPlayerGuid: Guid));
|
||||
|
||||
Assert.NotNull(replacement);
|
||||
Assert.True(fixture.Live.TryGetRecord(Guid, out LiveEntityRecord current));
|
||||
Assert.Same(replacement, current);
|
||||
Assert.True(current.IsSpatiallyProjected);
|
||||
Assert.Equal(new Vector3(9f, 9f, 9f), current.WorldEntity!.Position);
|
||||
Assert.NotNull(fixture.LocalShadow.Current);
|
||||
Assert.NotSame(old, current);
|
||||
|
||||
void OnPoseChanged(uint localId)
|
||||
{
|
||||
if (replacement is not null || replacing || localId != old.WorldEntity!.Id)
|
||||
return;
|
||||
replacing = true;
|
||||
replacement = fixture.Spawn(instance: 2, position: new Vector3(9f, 9f, 9f));
|
||||
fixture.LocalShadow.Set(new Vector3(9f), Quaternion.Identity, Cell);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ComponentCallbackReprojectsSameIncarnation_DoesNotWithdrawNewPosition()
|
||||
{
|
||||
var fixture = new Fixture();
|
||||
LiveEntityRecord record = fixture.Spawn(instance: 1);
|
||||
bool reentered = false;
|
||||
fixture.Poses.EffectPoseChanged += OnPoseChanged;
|
||||
|
||||
Assert.False(fixture.Controller.Withdraw(Guid, localPlayerGuid: 0u));
|
||||
|
||||
Assert.True(record.IsSpatiallyProjected);
|
||||
Assert.True(record.IsSpatiallyVisible);
|
||||
Assert.Equal(new Vector3(8f, 7f, 6f), record.WorldEntity!.Position);
|
||||
Assert.Contains(fixture.GameState.Entities, entity => entity.Id == record.WorldEntity.Id);
|
||||
Assert.Equal(1, fixture.Poses.Count);
|
||||
|
||||
void OnPoseChanged(uint localId)
|
||||
{
|
||||
if (reentered || localId != record.WorldEntity!.Id)
|
||||
return;
|
||||
reentered = true;
|
||||
var position = new WorldSession.EntityPositionUpdate(
|
||||
Guid,
|
||||
new CreateObject.ServerPosition(
|
||||
Cell, 8f, 7f, 6f, 1f, 0f, 0f, 0f),
|
||||
Velocity: null,
|
||||
PlacementId: null,
|
||||
IsGrounded: true,
|
||||
InstanceSequence: 1,
|
||||
PositionSequence: 2,
|
||||
TeleportSequence: 0,
|
||||
ForcePositionSequence: 0);
|
||||
Assert.True(fixture.Live.TryApplyPosition(
|
||||
position,
|
||||
isLocalPlayer: false,
|
||||
forcePositionRotation: null,
|
||||
currentLocalVelocity: null,
|
||||
out PositionTimestampDisposition disposition,
|
||||
out WorldSession.EntitySpawn accepted,
|
||||
out _));
|
||||
Assert.Equal(PositionTimestampDisposition.Apply, disposition);
|
||||
record.WorldEntity.SetPosition(new Vector3(8f, 7f, 6f));
|
||||
Assert.True(fixture.Live.RebucketLiveEntity(
|
||||
Guid,
|
||||
accepted.Position!.Value.LandblockId));
|
||||
var snapshot = new WorldEntitySnapshot(
|
||||
record.WorldEntity.Id,
|
||||
record.WorldEntity.SourceGfxObjOrSetupId,
|
||||
record.WorldEntity.Position,
|
||||
record.WorldEntity.Rotation);
|
||||
fixture.GameState.Add(snapshot);
|
||||
fixture.Events.UpsertCurrent(snapshot);
|
||||
fixture.Poses.PublishMeshRefs(record.WorldEntity);
|
||||
}
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void LogicalLocalPlayerTeardownWithoutReplacement_ClearsShadowSnapshot()
|
||||
{
|
||||
var fixture = new Fixture();
|
||||
fixture.Spawn(instance: 1);
|
||||
fixture.LocalShadow.Set(Vector3.One, Quaternion.Identity, Cell);
|
||||
|
||||
Assert.True(fixture.Live.UnregisterLiveEntity(
|
||||
new DeleteObject.Parsed(Guid, InstanceSequence: 1),
|
||||
isLocalPlayer: false));
|
||||
|
||||
Assert.Null(fixture.LocalShadow.Current);
|
||||
}
|
||||
|
||||
private sealed class Fixture
|
||||
{
|
||||
internal Fixture()
|
||||
{
|
||||
Spatial.AddLandblock(new LoadedLandblock(
|
||||
(Cell & 0xFFFF0000u) | 0xFFFFu,
|
||||
new LandBlock(),
|
||||
Array.Empty<WorldEntity>()));
|
||||
var lifecycle = new DeferredLiveEntityRuntimeComponentLifecycle();
|
||||
Live = new LiveEntityRuntime(
|
||||
Spatial,
|
||||
new DelegateLiveEntityResourceLifecycle(_ => { }, _ => { }),
|
||||
lifecycle);
|
||||
Projectiles = new ProjectileController(
|
||||
Live,
|
||||
Physics,
|
||||
_ => null,
|
||||
_ => { },
|
||||
() => (0, 0));
|
||||
Controller = new LiveEntityProjectionWithdrawalController(
|
||||
Live,
|
||||
Projectiles,
|
||||
GameState,
|
||||
Events,
|
||||
Physics.ShadowObjects,
|
||||
Poses,
|
||||
LocalShadow);
|
||||
Presentation = new LiveEntityPresentationController(
|
||||
Live,
|
||||
Physics.ShadowObjects,
|
||||
(_, _, _) => false);
|
||||
lifecycle.Bind(new DelegateLiveEntityRuntimeComponentLifecycle(
|
||||
record => Controller.LeaveWorld(record, Guid)));
|
||||
}
|
||||
|
||||
internal GpuWorldState Spatial { get; } = new();
|
||||
internal LiveEntityRuntime Live { get; }
|
||||
internal PhysicsEngine Physics { get; } = new();
|
||||
internal ProjectileController Projectiles { get; }
|
||||
internal WorldGameState GameState { get; } = new();
|
||||
internal WorldEvents Events { get; } = new();
|
||||
internal EntityEffectPoseRegistry Poses { get; } = new();
|
||||
internal LocalPlayerShadowState LocalShadow { get; } = new();
|
||||
internal LiveEntityProjectionWithdrawalController Controller { get; }
|
||||
internal LiveEntityPresentationController Presentation { get; }
|
||||
|
||||
internal LiveEntityRecord Spawn(ushort instance, Vector3? position = null)
|
||||
{
|
||||
WorldSession.EntitySpawn spawn = new(
|
||||
Guid,
|
||||
new CreateObject.ServerPosition(Cell, 1f, 2f, 3f, 1f, 0f, 0f, 0f),
|
||||
0x02000200u,
|
||||
Array.Empty<CreateObject.AnimPartChange>(),
|
||||
Array.Empty<CreateObject.TextureChange>(),
|
||||
Array.Empty<CreateObject.SubPaletteSwap>(),
|
||||
BasePaletteId: null,
|
||||
ObjScale: 1f,
|
||||
Name: "projection fixture",
|
||||
ItemType: null,
|
||||
MotionState: null,
|
||||
MotionTableId: null,
|
||||
InstanceSequence: instance);
|
||||
LiveEntityRecord record = Live.RegisterLiveEntity(spawn).Record!;
|
||||
WorldEntity entity = Live.MaterializeLiveEntity(
|
||||
Guid,
|
||||
Cell,
|
||||
id => new WorldEntity
|
||||
{
|
||||
Id = id,
|
||||
ServerGuid = Guid,
|
||||
SourceGfxObjOrSetupId = 0x02000200u,
|
||||
Position = position ?? new Vector3(1f, 2f, 3f),
|
||||
Rotation = Quaternion.Identity,
|
||||
MeshRefs = Array.Empty<MeshRef>(),
|
||||
ParentCellId = Cell,
|
||||
})!;
|
||||
var snapshot = new WorldEntitySnapshot(
|
||||
entity.Id,
|
||||
entity.SourceGfxObjOrSetupId,
|
||||
entity.Position,
|
||||
entity.Rotation);
|
||||
GameState.Add(snapshot);
|
||||
Events.UpsertCurrent(snapshot);
|
||||
Poses.PublishMeshRefs(entity);
|
||||
Physics.ShadowObjects.Register(
|
||||
entity.Id,
|
||||
entity.SourceGfxObjOrSetupId,
|
||||
entity.Position,
|
||||
entity.Rotation,
|
||||
radius: 0.5f,
|
||||
worldOffsetX: 0f,
|
||||
worldOffsetY: 0f,
|
||||
landblockId: Cell,
|
||||
seedCellId: Cell,
|
||||
isStatic: false);
|
||||
Assert.True(Presentation.OnLiveEntityReady(Guid));
|
||||
return record;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -659,7 +659,7 @@ public sealed class LiveEntityRuntimeTests
|
|||
}
|
||||
|
||||
[Fact]
|
||||
public void InitialChildCreate_PreservesParentEventQueuedForMissingChild()
|
||||
public void InitialChildCreate_PreservesParentEventQueuedForRenderValidation()
|
||||
{
|
||||
const uint parentGuid = 0x70000020u;
|
||||
const uint childGuid = 0x70000021u;
|
||||
|
|
@ -676,7 +676,9 @@ public sealed class LiveEntityRuntimeTests
|
|||
childGuid, out ParentAttachmentRelation relation));
|
||||
Assert.Equal(parentGuid, relation.ParentGuid);
|
||||
Assert.True(runtime.TryGetSnapshot(childGuid, out WorldSession.EntitySpawn child));
|
||||
Assert.Null(child.Position);
|
||||
Assert.NotNull(child.Position);
|
||||
Assert.Null(child.ParentGuid);
|
||||
Assert.Equal((ushort)5, child.PositionSequence);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
|
|||
|
|
@ -27,9 +27,12 @@ public sealed class ParentAttachmentStateTests
|
|||
Assert.True(relations.TryGetProjection(childGuid, out ParentAttachmentRelation projection));
|
||||
Assert.Equal(parentGuid, projection.ParentGuid);
|
||||
Assert.True(inbound.TryGetSnapshot(childGuid, out WorldSession.EntitySpawn child));
|
||||
Assert.NotNull(child.Position);
|
||||
Assert.Null(child.ParentGuid);
|
||||
Assert.Equal((ushort)5, child.PositionSequence);
|
||||
Assert.True(Commit(relations, inbound, projection, out child));
|
||||
Assert.Null(child.Position);
|
||||
Assert.Equal(parentGuid, child.ParentGuid);
|
||||
Assert.Equal((ushort)5, child.PositionSequence);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
|
|
@ -50,9 +53,24 @@ public sealed class ParentAttachmentStateTests
|
|||
update => gate.TryAcceptPositionChannelEvent(3, update.ChildPositionSequence));
|
||||
|
||||
Assert.True(relations.TryGetProjection(childGuid, out ParentAttachmentRelation projection));
|
||||
Assert.Equal((ushort)5, projection.ChildPositionSequence);
|
||||
Assert.Equal((uint)2, projection.PlacementId);
|
||||
Assert.True(relations.CommitProjection(projection));
|
||||
relations.MarkProjected(
|
||||
projection,
|
||||
ParentProjectionCandidateKind.Recovery);
|
||||
relations.Resolve(
|
||||
childGuid,
|
||||
_ => true,
|
||||
guid => guid == parentGuid ? (ushort)9 : null,
|
||||
update => gate.TryAcceptPositionChannelEvent(3, update.ChildPositionSequence));
|
||||
Assert.True(relations.TryGetStagedProjection(childGuid, out projection));
|
||||
Assert.Equal((ushort)6, projection.ChildPositionSequence);
|
||||
Assert.Equal((uint)3, projection.PlacementId);
|
||||
relations.MarkProjected(childGuid);
|
||||
Assert.True(relations.CommitProjection(projection));
|
||||
relations.MarkProjected(
|
||||
projection,
|
||||
ParentProjectionCandidateKind.Recovery);
|
||||
Assert.True(relations.RestoreLastAccepted(childGuid));
|
||||
Assert.True(relations.TryGetProjection(childGuid, out projection));
|
||||
Assert.Equal((ushort)6, projection.ChildPositionSequence);
|
||||
|
|
@ -136,6 +154,7 @@ public sealed class ParentAttachmentStateTests
|
|||
Assert.Equal(parentGuid, projection.ParentGuid);
|
||||
Assert.Equal((ushort)10, projection.ParentInstanceSequence);
|
||||
Assert.Equal((ushort)5, projection.ChildPositionSequence);
|
||||
Assert.True(Commit(relations, inbound, projection, out _));
|
||||
Assert.True(inbound.TryGetSnapshot(childGuid, out WorldSession.EntitySpawn child));
|
||||
Assert.Equal(parentGuid, child.ParentGuid);
|
||||
}
|
||||
|
|
@ -257,6 +276,20 @@ public sealed class ParentAttachmentStateTests
|
|||
: null,
|
||||
update => inbound.TryApplyParent(update, out _));
|
||||
|
||||
private static bool Commit(
|
||||
ParentAttachmentState relations,
|
||||
InboundPhysicsStateController inbound,
|
||||
ParentAttachmentRelation relation,
|
||||
out WorldSession.EntitySpawn accepted) =>
|
||||
inbound.TryCommitParent(
|
||||
relation.ChildGuid,
|
||||
relation.ParentGuid,
|
||||
relation.ParentLocation,
|
||||
relation.PlacementId,
|
||||
relation.ChildPositionSequence,
|
||||
out accepted)
|
||||
&& relations.CommitProjection(relation);
|
||||
|
||||
private static WorldSession.EntitySpawn Spawn(
|
||||
uint guid,
|
||||
ushort instance,
|
||||
|
|
|
|||
|
|
@ -160,6 +160,110 @@ public class ShadowObjectRegistryTests
|
|||
Assert.Equal(0x44u, restored.State);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ReplaceMultiPartPayload_VisibleOwnerKeepsExistingCellMembership()
|
||||
{
|
||||
const uint entityId = 25u;
|
||||
var reg = new ShadowObjectRegistry();
|
||||
Vector3 position = new(12f, 12f, 50f);
|
||||
reg.RegisterMultiPart(
|
||||
entityId,
|
||||
position,
|
||||
Quaternion.Identity,
|
||||
[BspShape(0x01000011u, radius: 0.5f)],
|
||||
state: 0u,
|
||||
flags: EntityCollisionFlags.None,
|
||||
OffX,
|
||||
OffY,
|
||||
LbId,
|
||||
seedCellId: LbId | 1u,
|
||||
isStatic: false);
|
||||
|
||||
reg.ReplaceMultiPartPayload(
|
||||
entityId,
|
||||
position,
|
||||
Quaternion.Identity,
|
||||
[BspShape(0x01000012u, radius: 40f)],
|
||||
state: 0u,
|
||||
flags: EntityCollisionFlags.None,
|
||||
OffX,
|
||||
OffY,
|
||||
landblockId: 0u,
|
||||
seedCellId: 0u,
|
||||
isStatic: false);
|
||||
|
||||
ShadowEntry replaced = Assert.Single(reg.GetObjectsInCell(LbId | 1u));
|
||||
Assert.Equal(0x01000012u, replaced.GfxObjId);
|
||||
Assert.Empty(reg.GetObjectsInCell(LbId | 9u));
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ReplaceMultiPartPayload_SuspendedShapedEmptyShaped_RemainsSuspended()
|
||||
{
|
||||
const uint entityId = 26u;
|
||||
var reg = new ShadowObjectRegistry();
|
||||
Vector3 position = new(12f, 12f, 50f);
|
||||
reg.RegisterMultiPart(
|
||||
entityId,
|
||||
position,
|
||||
Quaternion.Identity,
|
||||
[BspShape(0x01000021u, radius: 0.5f)],
|
||||
state: 0u,
|
||||
flags: EntityCollisionFlags.None,
|
||||
OffX,
|
||||
OffY,
|
||||
LbId,
|
||||
seedCellId: LbId | 1u,
|
||||
isStatic: false);
|
||||
Assert.True(reg.Suspend(entityId));
|
||||
|
||||
reg.ReplaceMultiPartPayload(
|
||||
entityId, position, Quaternion.Identity, [], 0u,
|
||||
EntityCollisionFlags.None, OffX, OffY, LbId, LbId | 1u);
|
||||
reg.ReplaceMultiPartPayload(
|
||||
entityId,
|
||||
position,
|
||||
Quaternion.Identity,
|
||||
[BspShape(0x01000022u, radius: 0.5f)],
|
||||
0u,
|
||||
EntityCollisionFlags.None,
|
||||
OffX,
|
||||
OffY,
|
||||
LbId,
|
||||
LbId | 1u);
|
||||
|
||||
Assert.Equal(1, reg.RetainedRegistrationCount);
|
||||
Assert.Equal(1, reg.SuspendedRegistrationCount);
|
||||
Assert.Empty(reg.GetObjectsInCell(LbId | 1u));
|
||||
reg.UpdatePosition(
|
||||
entityId, position, Quaternion.Identity, OffX, OffY, LbId, LbId | 1u);
|
||||
Assert.Equal(0x01000022u, Assert.Single(reg.GetObjectsInCell(LbId | 1u)).GfxObjId);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void ReplaceMultiPartPayload_NewCelllessOwnerRegistersRetainedButSuspended()
|
||||
{
|
||||
const uint entityId = 27u;
|
||||
var reg = new ShadowObjectRegistry();
|
||||
reg.ReplaceMultiPartPayload(
|
||||
entityId,
|
||||
new Vector3(12f, 12f, 50f),
|
||||
Quaternion.Identity,
|
||||
[BspShape(0x01000031u, radius: 0.5f)],
|
||||
0u,
|
||||
EntityCollisionFlags.None,
|
||||
OffX,
|
||||
OffY,
|
||||
LbId,
|
||||
seedCellId: LbId | 1u,
|
||||
isStatic: false,
|
||||
suspendIfNew: true);
|
||||
|
||||
Assert.Equal(1, reg.RetainedRegistrationCount);
|
||||
Assert.Equal(1, reg.SuspendedRegistrationCount);
|
||||
Assert.Empty(reg.GetObjectsInCell(LbId | 1u));
|
||||
}
|
||||
|
||||
// -----------------------------------------------------------------------
|
||||
// RemoveLandblock
|
||||
// -----------------------------------------------------------------------
|
||||
|
|
@ -652,6 +756,15 @@ public class ShadowObjectRegistryTests
|
|||
};
|
||||
}
|
||||
|
||||
private static ShadowShape BspShape(uint gfxObjId, float radius) => new(
|
||||
gfxObjId,
|
||||
Vector3.Zero,
|
||||
Quaternion.Identity,
|
||||
Scale: 1f,
|
||||
CollisionType: ShadowCollisionType.BSP,
|
||||
Radius: radius,
|
||||
CylHeight: 0f);
|
||||
|
||||
private static CellPhysics BuildShadowCellSetTests_MakeLeafCell(Matrix4x4 worldTransform)
|
||||
{
|
||||
Matrix4x4.Invert(worldTransform, out var inv);
|
||||
|
|
|
|||
|
|
@ -103,6 +103,26 @@ public class ShadowShapeBuilderTests
|
|||
Assert.Equal(1, bspCount);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void FromSetup_EffectivePartIdentitiesControlPhysicsBspSelection()
|
||||
{
|
||||
const uint replacementWithBsp = 0x0100AA01u;
|
||||
const uint replacementWithoutBsp = 0x0100AA02u;
|
||||
var setup = new Setup
|
||||
{
|
||||
Parts = { 0x010044B5u, 0x010044B6u },
|
||||
};
|
||||
|
||||
var shapes = ShadowShapeBuilder.FromSetup(
|
||||
setup,
|
||||
entScale: 1f,
|
||||
hasPhysicsBsp: id => id == replacementWithBsp,
|
||||
effectivePartGfxObjIds: [replacementWithBsp, replacementWithoutBsp]);
|
||||
|
||||
ShadowShape shape = Assert.Single(shapes);
|
||||
Assert.Equal(replacementWithBsp, shape.GfxObjId);
|
||||
}
|
||||
|
||||
[Fact]
|
||||
public void FromSetup_CreatureWithCylSpheres_OnlyEmitsCylinders()
|
||||
{
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue