890 lines
31 KiB
C#
890 lines
31 KiB
C#
using System.Numerics;
|
|
using AcDream.Core.Physics;
|
|
using AcDream.Runtime.World;
|
|
|
|
namespace AcDream.Runtime.Tests.World;
|
|
|
|
public sealed class RuntimeWorldTransitStateTests
|
|
{
|
|
private const uint OutdoorCell = 0x11340021u;
|
|
private const uint OtherCell = 0x3032001Cu;
|
|
|
|
[Fact]
|
|
public void BeginReveal_OwnsGenerationDestinationAndSimulationGate()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
|
|
long generation =
|
|
state.BeginLoginReveal(OutdoorCell);
|
|
|
|
Assert.Equal(1, generation);
|
|
Assert.Equal(generation, state.Snapshot.Generation);
|
|
Assert.Equal(RuntimePortalKind.Login, state.Snapshot.Kind);
|
|
Assert.Equal(OutdoorCell, state.Snapshot.DestinationCell);
|
|
Assert.False(state.IsWorldSimulationAvailable);
|
|
Assert.False(state.Snapshot.IsReady);
|
|
}
|
|
|
|
[Fact]
|
|
public void TypedReadiness_RejectsWrongGenerationAndDestination()
|
|
{
|
|
List<string> log = [];
|
|
var state = new RuntimeWorldTransitState(log.Add);
|
|
long generation =
|
|
BeginPortal(state, OutdoorCell);
|
|
|
|
Assert.False(state.AcknowledgeDestinationReadiness(
|
|
Ready(generation + 1, OutdoorCell)));
|
|
Assert.False(state.AcknowledgeDestinationReadiness(
|
|
Ready(generation, OtherCell)));
|
|
|
|
Assert.Equal(OutdoorCell, state.Snapshot.DestinationCell);
|
|
Assert.False(state.Snapshot.IsReady);
|
|
Assert.Equal(1, state.Snapshot.InvariantFailureCount);
|
|
Assert.Equal(
|
|
1,
|
|
log.Count(value => value.Contains(
|
|
"event=invariant-failure",
|
|
StringComparison.Ordinal)));
|
|
Assert.Single(
|
|
log,
|
|
value => value.Contains(
|
|
"event=rejected",
|
|
StringComparison.Ordinal));
|
|
}
|
|
|
|
[Fact]
|
|
public void Materialization_ReleasesSimulationBeforeViewportAndCompletion()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
long generation =
|
|
BeginPortal(state, OutdoorCell);
|
|
Assert.True(state.AcknowledgeDestinationReadiness(
|
|
Ready(generation, OutdoorCell)));
|
|
|
|
Assert.True(state.AcknowledgePortalMaterialized(
|
|
generation,
|
|
1,
|
|
OutdoorCell));
|
|
|
|
Assert.True(state.IsWorldSimulationAvailable);
|
|
Assert.True(state.Snapshot.Materialized);
|
|
Assert.False(state.Snapshot.WorldViewportObserved);
|
|
Assert.False(state.Snapshot.Completed);
|
|
Assert.Equal(1, state.Snapshot.PortalMaterializationCount);
|
|
Assert.False(state.AcknowledgePortalMaterialized(
|
|
generation,
|
|
1,
|
|
OutdoorCell));
|
|
|
|
Assert.True(state.AcknowledgeWorldViewportVisible(generation));
|
|
Assert.True(state.Complete(generation));
|
|
Assert.True(state.Snapshot.WorldViewportObserved);
|
|
Assert.True(state.Snapshot.Completed);
|
|
Assert.Equal(1, state.Snapshot.PortalMaterializationCount);
|
|
}
|
|
|
|
[Fact]
|
|
public void MaterializationBeforeReadiness_IsRejectedWithoutOpeningWorld()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
long generation =
|
|
BeginPortal(state, OutdoorCell);
|
|
|
|
Assert.False(state.AcknowledgePortalMaterialized(
|
|
generation,
|
|
1,
|
|
OutdoorCell));
|
|
|
|
Assert.False(state.IsWorldSimulationAvailable);
|
|
Assert.False(state.Snapshot.Materialized);
|
|
Assert.Equal(1, state.Snapshot.InvariantFailureCount);
|
|
Assert.Equal(0, state.Snapshot.PortalMaterializationCount);
|
|
}
|
|
|
|
[Fact]
|
|
public void LoginCompletion_ReleasesSimulationBeforeFirstVisibleFrame()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
long generation =
|
|
state.BeginLoginReveal(OutdoorCell);
|
|
state.AcknowledgeDestinationReadiness(
|
|
Ready(generation, OutdoorCell));
|
|
|
|
Assert.True(state.Complete(generation));
|
|
Assert.True(state.IsWorldSimulationAvailable);
|
|
Assert.False(state.Snapshot.WorldViewportObserved);
|
|
|
|
Assert.True(state.AcknowledgeWorldViewportVisible(generation));
|
|
Assert.True(state.Snapshot.WorldViewportObserved);
|
|
Assert.Equal(0, state.Snapshot.InvariantFailureCount);
|
|
}
|
|
|
|
[Fact]
|
|
public void EarlyViewport_IsRejectedWithoutFabricatingVisibility()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
long generation =
|
|
state.BeginLoginReveal(OutdoorCell);
|
|
|
|
Assert.False(state.AcknowledgeWorldViewportVisible(generation));
|
|
|
|
Assert.False(state.Snapshot.IsReady);
|
|
Assert.False(state.Snapshot.WorldViewportObserved);
|
|
Assert.Equal(1, state.Snapshot.InvariantFailureCount);
|
|
}
|
|
|
|
[Fact]
|
|
public void ReadinessShape_MustMatchDestinationCell()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
long generation =
|
|
state.BeginLoginReveal(OutdoorCell);
|
|
RuntimeDestinationReadiness invalid =
|
|
Ready(generation, OutdoorCell) with
|
|
{
|
|
IsIndoor = true,
|
|
RequiredRenderRadius = 0,
|
|
};
|
|
|
|
Assert.False(state.AcknowledgeDestinationReadiness(invalid));
|
|
|
|
Assert.False(state.Snapshot.IsReady);
|
|
Assert.Equal(1, state.Snapshot.InvariantFailureCount);
|
|
}
|
|
|
|
[Fact]
|
|
public void AcceptedReadiness_IsGenerationSticky()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
long generation =
|
|
BeginPortal(state, OutdoorCell);
|
|
RuntimeDestinationReadiness accepted =
|
|
Ready(generation, OutdoorCell);
|
|
Assert.True(state.AcknowledgeDestinationReadiness(accepted));
|
|
|
|
RuntimeDestinationReadiness regressed = accepted with
|
|
{
|
|
IsCollisionReady = false,
|
|
};
|
|
Assert.False(state.AcknowledgeDestinationReadiness(regressed));
|
|
|
|
Assert.Equal(accepted, state.Snapshot.Readiness);
|
|
Assert.True(state.Snapshot.IsReady);
|
|
Assert.Equal(0, state.Snapshot.InvariantFailureCount);
|
|
}
|
|
|
|
[Fact]
|
|
public void Completion_RejectsReorderedLoginAndPortalEdges()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
long login =
|
|
state.BeginLoginReveal(OutdoorCell);
|
|
|
|
Assert.False(state.Complete(login));
|
|
Assert.False(state.Snapshot.Completed);
|
|
|
|
long portal =
|
|
BeginPortal(state, OtherCell, sequence: 2);
|
|
Assert.True(state.AcknowledgeDestinationReadiness(
|
|
Ready(portal, OtherCell)));
|
|
Assert.False(state.Complete(portal));
|
|
Assert.False(state.Snapshot.Completed);
|
|
Assert.Equal(2, state.Snapshot.InvariantFailureCount);
|
|
}
|
|
|
|
[Fact]
|
|
public void Supersession_RejectsOldAcknowledgementsAndKeepsLatestDestination()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
long first =
|
|
state.BeginLoginReveal(OutdoorCell);
|
|
long second =
|
|
BeginPortal(state, OtherCell);
|
|
|
|
Assert.True(second > first);
|
|
Assert.False(state.AcknowledgeDestinationReadiness(
|
|
Ready(first, OutdoorCell)));
|
|
Assert.False(state.AcknowledgePortalMaterialized(
|
|
first,
|
|
1,
|
|
OutdoorCell));
|
|
|
|
Assert.Equal(second, state.Snapshot.Generation);
|
|
Assert.Equal(OtherCell, state.Snapshot.DestinationCell);
|
|
Assert.False(state.Snapshot.IsReady);
|
|
Assert.False(state.IsWorldSimulationAvailable);
|
|
Assert.Equal(0, state.Snapshot.InvariantFailureCount);
|
|
}
|
|
|
|
[Fact]
|
|
public void Cancel_ReleasesSimulationAndRejectsLateHostWork()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
long generation =
|
|
BeginPortal(state, OutdoorCell);
|
|
|
|
Assert.True(state.Cancel(generation));
|
|
Assert.True(state.IsWorldSimulationAvailable);
|
|
Assert.True(state.Snapshot.Cancelled);
|
|
|
|
Assert.False(state.AcknowledgeDestinationReadiness(
|
|
Ready(generation, OutdoorCell)));
|
|
Assert.False(state.AcknowledgePortalMaterialized(
|
|
generation,
|
|
1,
|
|
OutdoorCell));
|
|
Assert.False(state.Complete(generation));
|
|
Assert.False(state.Snapshot.Materialized);
|
|
Assert.False(state.Snapshot.Completed);
|
|
}
|
|
|
|
[Fact]
|
|
public void MaterializedThenCancelled_RemainsAvailableAndCannotComplete()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
long generation =
|
|
BeginPortal(state, OutdoorCell);
|
|
state.AcknowledgeDestinationReadiness(
|
|
Ready(generation, OutdoorCell));
|
|
state.AcknowledgePortalMaterialized(
|
|
generation,
|
|
1,
|
|
OutdoorCell);
|
|
|
|
Assert.True(state.Cancel(generation));
|
|
Assert.True(state.IsWorldSimulationAvailable);
|
|
Assert.True(state.Snapshot.Materialized);
|
|
Assert.True(state.Snapshot.Cancelled);
|
|
Assert.False(state.Complete(generation));
|
|
Assert.False(state.Snapshot.Completed);
|
|
Assert.Equal(1, state.Snapshot.PortalMaterializationCount);
|
|
}
|
|
|
|
[Fact]
|
|
public void WaitCue_UsesRetailFiveSecondEdgeWithoutCompletingReveal()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
long generation =
|
|
BeginPortal(state, OutdoorCell);
|
|
|
|
Assert.False(state.ObserveWait(
|
|
generation,
|
|
RuntimeWorldTransitState.RetailWaitCueDelay
|
|
- TimeSpan.FromMilliseconds(1)));
|
|
Assert.True(state.ObserveWait(
|
|
generation,
|
|
RuntimeWorldTransitState.RetailWaitCueDelay));
|
|
Assert.True(state.ObserveWait(
|
|
generation,
|
|
RuntimeWorldTransitState.RetailWaitCueDelay
|
|
+ TimeSpan.FromSeconds(20)));
|
|
|
|
Assert.True(state.Snapshot.WaitCueShown);
|
|
Assert.False(state.Snapshot.Completed);
|
|
Assert.False(state.IsWorldSimulationAvailable);
|
|
}
|
|
|
|
[Fact]
|
|
public void UnhydratableDestination_IsAnExplicitReadyAcknowledgement()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
long generation =
|
|
BeginPortal(state, OutdoorCell);
|
|
var acknowledgement = new RuntimeDestinationReadiness(
|
|
generation,
|
|
OutdoorCell,
|
|
IsIndoor: false,
|
|
IsUnhydratable: true,
|
|
RequiredRenderRadius: 1,
|
|
IsRenderNeighborhoodReady: false,
|
|
AreCompositeTexturesReady: false,
|
|
IsCollisionReady: false);
|
|
|
|
Assert.True(state.AcknowledgeDestinationReadiness(acknowledgement));
|
|
Assert.True(state.Snapshot.IsReady);
|
|
Assert.True(state.AcknowledgePortalMaterialized(
|
|
generation,
|
|
1,
|
|
OutdoorCell));
|
|
}
|
|
|
|
[Fact]
|
|
public void ResetSession_ClearsVisibleStateButNeverReusesGeneration()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
long first =
|
|
BeginPortal(state, OutdoorCell);
|
|
state.ResetSession();
|
|
|
|
Assert.Equal(RuntimePortalSnapshot.Idle, state.Snapshot);
|
|
Assert.True(state.IsWorldSimulationAvailable);
|
|
|
|
long second =
|
|
state.BeginLoginReveal(OtherCell);
|
|
Assert.True(second > first);
|
|
Assert.False(state.AcknowledgeDestinationReadiness(
|
|
Ready(first, OutdoorCell)));
|
|
Assert.Equal(second, state.Snapshot.Generation);
|
|
Assert.Equal(OtherCell, state.Snapshot.DestinationCell);
|
|
}
|
|
|
|
[Fact]
|
|
public void Instances_IsolateGenerationReadinessAndMaterializationCounts()
|
|
{
|
|
var first = new RuntimeWorldTransitState();
|
|
var second = new RuntimeWorldTransitState();
|
|
long firstGeneration =
|
|
BeginPortal(first, OutdoorCell);
|
|
long secondGeneration =
|
|
second.BeginLoginReveal(OtherCell);
|
|
RuntimeWorldHostProjectionToken firstHost =
|
|
RegisterHost(first, firstGeneration, OutdoorCell);
|
|
RuntimeWorldHostProjectionToken secondHost =
|
|
RegisterHost(second, secondGeneration, OtherCell);
|
|
Assert.True(Acknowledge(
|
|
first,
|
|
firstHost,
|
|
RuntimeWorldHostAcknowledgementStage.ProjectionRegistered));
|
|
Assert.True(Acknowledge(
|
|
second,
|
|
secondHost,
|
|
RuntimeWorldHostAcknowledgementStage.ProjectionRegistered));
|
|
first.AcknowledgeDestinationReadiness(
|
|
Ready(firstGeneration, OutdoorCell));
|
|
first.AcknowledgePortalMaterialized(
|
|
firstGeneration,
|
|
1,
|
|
OutdoorCell);
|
|
|
|
Assert.Equal(1, first.Snapshot.PortalMaterializationCount);
|
|
Assert.Equal(0, second.Snapshot.PortalMaterializationCount);
|
|
Assert.True(first.IsWorldSimulationAvailable);
|
|
Assert.False(second.IsWorldSimulationAvailable);
|
|
Assert.Equal(OtherCell, second.Snapshot.DestinationCell);
|
|
Assert.Equal(1, secondGeneration);
|
|
Assert.False(Acknowledge(
|
|
second,
|
|
firstHost,
|
|
RuntimeWorldHostAcknowledgementStage
|
|
.SimulationReleaseProjected));
|
|
Assert.Equal(1, first.Ownership.PendingHostAcknowledgementCount);
|
|
Assert.Equal(0, second.Ownership.PendingHostAcknowledgementCount);
|
|
}
|
|
|
|
[Fact]
|
|
public void DiagnosticCallbackFailure_CannotInterruptCanonicalTransition()
|
|
{
|
|
var state = new RuntimeWorldTransitState(
|
|
_ => throw new InvalidOperationException("diagnostic failed"));
|
|
|
|
long generation =
|
|
BeginPortal(state, OutdoorCell);
|
|
Assert.True(state.AcknowledgeDestinationReadiness(
|
|
Ready(generation, OutdoorCell)));
|
|
Assert.True(state.AcknowledgePortalMaterialized(
|
|
generation,
|
|
1,
|
|
OutdoorCell));
|
|
Assert.True(state.Complete(generation));
|
|
|
|
Assert.True(state.Snapshot.Completed);
|
|
Assert.True(state.IsWorldSimulationAvailable);
|
|
Assert.True(state.DiagnosticFailureCount >= 4);
|
|
Assert.IsType<InvalidOperationException>(
|
|
state.LastDiagnosticFailure);
|
|
}
|
|
|
|
[Fact]
|
|
public void ReplacementRejectsDelayedPriorDestinationAndAcceptsCurrentAdvance()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
Assert.True(state.TryQueueTeleportStart(10));
|
|
Assert.True(state.ActivateQueuedTeleport());
|
|
state.EndTeleport();
|
|
Assert.True(state.TryQueueTeleportStart(11));
|
|
Assert.True(state.ActivateQueuedTeleport());
|
|
|
|
Assert.False(state.OfferTeleportDestination(
|
|
Destination(OutdoorCell, 10, x: 10f),
|
|
teleportTimestampAdvanced: true));
|
|
Assert.True(state.OfferTeleportDestination(
|
|
Destination(OtherCell, 11, x: 11f),
|
|
teleportTimestampAdvanced: true));
|
|
Assert.True(state.TryGetAcceptedTeleportDestination(
|
|
out RuntimeTeleportDestination accepted));
|
|
Assert.Equal(11f, accepted.Position.Frame.Origin.X);
|
|
Assert.Equal(OtherCell, accepted.CellId);
|
|
}
|
|
|
|
[Fact]
|
|
public void PositionBeforeF751IsBufferedAndEqualFollowupCannotReplaceIt()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
|
|
Assert.False(state.OfferTeleportDestination(
|
|
Destination(OutdoorCell, 11, x: 110f),
|
|
teleportTimestampAdvanced: true));
|
|
Assert.Equal(1, state.BufferedTeleportDestinationCount);
|
|
Assert.True(state.TryQueueTeleportStart(11));
|
|
Assert.True(state.ActivateQueuedTeleport());
|
|
Assert.True(state.TryGetAcceptedTeleportDestination(
|
|
out RuntimeTeleportDestination buffered));
|
|
Assert.Equal(110f, buffered.Position.Frame.Origin.X);
|
|
|
|
Assert.False(state.OfferTeleportDestination(
|
|
Destination(OtherCell, 11, x: 111f),
|
|
teleportTimestampAdvanced: false));
|
|
Assert.True(state.TryGetAcceptedTeleportDestination(out buffered));
|
|
Assert.Equal(OutdoorCell, buffered.CellId);
|
|
}
|
|
|
|
[Fact]
|
|
public void InactiveOrdinaryPositionIsNeverBuffered()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
|
|
Assert.False(state.OfferTeleportDestination(
|
|
Destination(OutdoorCell, 11),
|
|
teleportTimestampAdvanced: false));
|
|
Assert.Equal(0, state.BufferedTeleportDestinationCount);
|
|
Assert.True(state.TryQueueTeleportStart(11));
|
|
Assert.True(state.ActivateQueuedTeleport());
|
|
Assert.False(state.HasAcceptedTeleportDestination);
|
|
}
|
|
|
|
[Fact]
|
|
public void DuplicateStartIsRejectedButSequenceWrapIsFresh()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
Assert.True(state.TryQueueTeleportStart(ushort.MaxValue));
|
|
Assert.True(state.ActivateQueuedTeleport());
|
|
state.EndTeleport();
|
|
|
|
Assert.False(state.CanQueueTeleportStart(ushort.MaxValue));
|
|
Assert.False(state.TryQueueTeleportStart(ushort.MaxValue));
|
|
Assert.True(state.CanQueueTeleportStart(0));
|
|
Assert.True(state.TryQueueTeleportStart(0));
|
|
Assert.True(state.HasPendingTeleportStart);
|
|
}
|
|
|
|
[Fact]
|
|
public void ExactHalfRangeUsesRetailLowerStampTieBreak()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
Assert.True(state.TryQueueTeleportStart(0x8000));
|
|
Assert.True(state.ActivateQueuedTeleport());
|
|
state.EndTeleport();
|
|
|
|
Assert.True(state.CanQueueTeleportStart(0x0000));
|
|
Assert.True(state.TryQueueTeleportStart(0x0000));
|
|
}
|
|
|
|
[Fact]
|
|
public void PendingStartAcceptsEqualPositionUntilHostCanActivate()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
Assert.True(state.TryQueueTeleportStart(11));
|
|
|
|
Assert.False(state.OfferTeleportDestination(
|
|
Destination(OutdoorCell, 11, x: 110f),
|
|
teleportTimestampAdvanced: false));
|
|
Assert.True(state.ActivateQueuedTeleport());
|
|
Assert.True(state.TryGetAcceptedTeleportDestination(
|
|
out RuntimeTeleportDestination buffered));
|
|
|
|
Assert.Equal(110f, buffered.Position.Frame.Origin.X);
|
|
Assert.True(state.IsTeleportActive);
|
|
}
|
|
|
|
[Fact]
|
|
public void AdvancingPositionPrunesSkippedDestination()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
|
|
Assert.False(state.OfferTeleportDestination(
|
|
Destination(OutdoorCell, 11),
|
|
teleportTimestampAdvanced: true));
|
|
Assert.False(state.OfferTeleportDestination(
|
|
Destination(OtherCell, 12),
|
|
teleportTimestampAdvanced: true));
|
|
Assert.Equal(1, state.BufferedTeleportDestinationCount);
|
|
Assert.True(state.TryQueueTeleportStart(12));
|
|
Assert.True(state.ActivateQueuedTeleport());
|
|
Assert.True(state.TryGetAcceptedTeleportDestination(
|
|
out RuntimeTeleportDestination buffered));
|
|
|
|
Assert.Equal(OtherCell, buffered.CellId);
|
|
}
|
|
|
|
[Fact]
|
|
public void ObsoleteDestinationCannotSurviveSequenceWrap()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
|
|
Assert.False(state.OfferTeleportDestination(
|
|
Destination(OutdoorCell, ushort.MaxValue),
|
|
teleportTimestampAdvanced: true));
|
|
Assert.False(state.OfferTeleportDestination(
|
|
Destination(OtherCell, 0),
|
|
teleportTimestampAdvanced: true));
|
|
Assert.True(state.TryQueueTeleportStart(0));
|
|
Assert.True(state.ActivateQueuedTeleport());
|
|
Assert.True(state.TryGetAcceptedTeleportDestination(
|
|
out RuntimeTeleportDestination wrapped));
|
|
Assert.Equal(OtherCell, wrapped.CellId);
|
|
state.EndTeleport();
|
|
|
|
Assert.True(state.TryQueueTeleportStart(0x7FFF));
|
|
Assert.True(state.ActivateQueuedTeleport());
|
|
state.EndTeleport();
|
|
Assert.True(state.TryQueueTeleportStart(0xFFFE));
|
|
Assert.True(state.ActivateQueuedTeleport());
|
|
state.EndTeleport();
|
|
Assert.True(state.TryQueueTeleportStart(ushort.MaxValue));
|
|
Assert.True(state.ActivateQueuedTeleport());
|
|
|
|
Assert.False(state.HasAcceptedTeleportDestination);
|
|
}
|
|
|
|
[Fact]
|
|
public void PortalRevealClaimsOnlyExactAcceptedSequenceAndCell()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
Assert.True(state.TryQueueTeleportStart(7));
|
|
Assert.True(state.ActivateQueuedTeleport());
|
|
Assert.True(state.OfferTeleportDestination(
|
|
Destination(OutdoorCell, 7),
|
|
teleportTimestampAdvanced: true));
|
|
|
|
Assert.False(state.TryBeginPortalReveal(
|
|
8,
|
|
OutdoorCell,
|
|
out _));
|
|
Assert.False(state.TryBeginPortalReveal(
|
|
7,
|
|
OtherCell,
|
|
out _));
|
|
Assert.Equal(RuntimePortalSnapshot.Idle.Generation, state.Snapshot.Generation);
|
|
Assert.True(state.HasAcceptedTeleportDestination);
|
|
|
|
Assert.True(state.TryBeginPortalReveal(
|
|
7,
|
|
OutdoorCell,
|
|
out long generation));
|
|
Assert.True(generation > 0);
|
|
Assert.False(state.HasAcceptedTeleportDestination);
|
|
Assert.True(state.CanPlacePortalDestination(
|
|
generation,
|
|
7,
|
|
OutdoorCell));
|
|
Assert.False(state.CanPlacePortalDestination(
|
|
generation,
|
|
8,
|
|
OutdoorCell));
|
|
Assert.False(state.CanPlacePortalDestination(
|
|
generation,
|
|
7,
|
|
OtherCell));
|
|
}
|
|
|
|
[Fact]
|
|
public void MaterializationRequiresExactGenerationSequenceAndCell()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
long generation = BeginPortal(state, OutdoorCell, sequence: 17);
|
|
Assert.True(state.AcknowledgeDestinationReadiness(
|
|
Ready(generation, OutdoorCell)));
|
|
|
|
Assert.False(state.AcknowledgePortalMaterialized(
|
|
generation + 1,
|
|
17,
|
|
OutdoorCell));
|
|
Assert.False(state.AcknowledgePortalMaterialized(
|
|
generation,
|
|
18,
|
|
OutdoorCell));
|
|
Assert.False(state.AcknowledgePortalMaterialized(
|
|
generation,
|
|
17,
|
|
OtherCell));
|
|
Assert.False(state.Snapshot.Materialized);
|
|
|
|
Assert.True(state.AcknowledgePortalMaterialized(
|
|
generation,
|
|
17,
|
|
OutdoorCell));
|
|
Assert.True(state.Snapshot.Materialized);
|
|
}
|
|
|
|
[Fact]
|
|
public void ResetSessionClearsCorrelationHistoryAndBufferedDestinations()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
Assert.False(state.OfferTeleportDestination(
|
|
Destination(OutdoorCell, 7),
|
|
teleportTimestampAdvanced: true));
|
|
Assert.True(state.TryQueueTeleportStart(8));
|
|
|
|
state.ResetSession();
|
|
|
|
Assert.False(state.IsTeleportActive);
|
|
Assert.False(state.HasPendingTeleportStart);
|
|
Assert.False(state.HasAcceptedTeleportDestination);
|
|
Assert.Equal(0, state.BufferedTeleportDestinationCount);
|
|
Assert.True(state.TryQueueTeleportStart(8));
|
|
}
|
|
|
|
[Fact]
|
|
public void HostProjection_TracksExactGenerationScopedAcknowledgementSuffix()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
long generation = BeginPortal(state, OutdoorCell);
|
|
RuntimeWorldHostProjectionToken host =
|
|
RegisterHost(state, generation, OutdoorCell);
|
|
|
|
Assert.Equal(
|
|
new RuntimeWorldTransitOwnershipSnapshot(
|
|
BufferedTeleportDestinationCount: 0,
|
|
PendingTeleportStartCount: 0,
|
|
ActiveTeleportCount: 1,
|
|
AcceptedTeleportDestinationCount: 0,
|
|
ActiveRevealCount: 1,
|
|
PendingDestinationReadinessCount: 1,
|
|
HostProjectionCount: 1,
|
|
PendingHostAcknowledgementCount: 1),
|
|
state.Ownership);
|
|
Assert.False(Acknowledge(
|
|
state,
|
|
host with { Generation = generation + 1 },
|
|
RuntimeWorldHostAcknowledgementStage.ProjectionRegistered));
|
|
Assert.False(Acknowledge(
|
|
state,
|
|
host with { DestinationCell = OtherCell },
|
|
RuntimeWorldHostAcknowledgementStage.ProjectionRegistered));
|
|
Assert.False(Acknowledge(
|
|
state,
|
|
host,
|
|
RuntimeWorldHostAcknowledgementStage.None));
|
|
Assert.False(Acknowledge(
|
|
state,
|
|
host,
|
|
RuntimeWorldHostAcknowledgementStage.ProjectionRegistered
|
|
| RuntimeWorldHostAcknowledgementStage
|
|
.DestinationReservationReleased));
|
|
Assert.True(Acknowledge(
|
|
state,
|
|
host,
|
|
RuntimeWorldHostAcknowledgementStage.ProjectionRegistered));
|
|
|
|
Assert.True(state.AcknowledgeDestinationReadiness(
|
|
Ready(generation, OutdoorCell)));
|
|
Assert.True(state.AcknowledgePortalMaterialized(
|
|
generation,
|
|
1,
|
|
OutdoorCell));
|
|
Assert.Equal(1, state.Ownership.PendingHostAcknowledgementCount);
|
|
Assert.True(Acknowledge(
|
|
state,
|
|
host,
|
|
RuntimeWorldHostAcknowledgementStage
|
|
.SimulationReleaseProjected));
|
|
|
|
Assert.True(state.RequireDestinationReservationRelease(host));
|
|
Assert.True(Acknowledge(
|
|
state,
|
|
host,
|
|
RuntimeWorldHostAcknowledgementStage
|
|
.DestinationReservationReleased));
|
|
Assert.True(state.AcknowledgeWorldViewportVisible(generation));
|
|
Assert.True(state.Complete(generation));
|
|
Assert.Equal(1, state.Ownership.PendingHostAcknowledgementCount);
|
|
Assert.True(Acknowledge(
|
|
state,
|
|
host,
|
|
RuntimeWorldHostAcknowledgementStage.TerminalProjected));
|
|
Assert.Equal(0, state.Ownership.HostProjectionCount);
|
|
Assert.Equal(0, state.Ownership.PendingHostAcknowledgementCount);
|
|
|
|
state.EndTeleport();
|
|
state.ResetSession();
|
|
Assert.True(state.Ownership.IsSessionIdle);
|
|
}
|
|
|
|
[Fact]
|
|
public void Cancel_ReplacesIncompleteRegistrationWithRetryableWithdrawal()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
long generation = state.BeginLoginReveal(OutdoorCell);
|
|
RuntimeWorldHostProjectionToken host =
|
|
RegisterHost(state, generation, OutdoorCell);
|
|
|
|
Assert.True(state.Cancel(generation));
|
|
Assert.True(state.TryGetHostProjection(
|
|
host,
|
|
out RuntimeWorldHostProjectionSnapshot projection));
|
|
Assert.Equal(
|
|
RuntimeWorldHostAcknowledgementStage
|
|
.SimulationReleaseProjected
|
|
| RuntimeWorldHostAcknowledgementStage
|
|
.DestinationReservationReleased
|
|
| RuntimeWorldHostAcknowledgementStage.TerminalProjected,
|
|
projection.PendingAcknowledgements);
|
|
Assert.False(Acknowledge(
|
|
state,
|
|
host,
|
|
RuntimeWorldHostAcknowledgementStage.TerminalProjected));
|
|
Assert.True(Acknowledge(
|
|
state,
|
|
host,
|
|
RuntimeWorldHostAcknowledgementStage
|
|
.SimulationReleaseProjected));
|
|
Assert.True(Acknowledge(
|
|
state,
|
|
host,
|
|
RuntimeWorldHostAcknowledgementStage
|
|
.DestinationReservationReleased));
|
|
Assert.True(Acknowledge(
|
|
state,
|
|
host,
|
|
RuntimeWorldHostAcknowledgementStage.TerminalProjected));
|
|
|
|
state.ResetSession();
|
|
Assert.True(state.Ownership.IsSessionIdle);
|
|
}
|
|
|
|
[Fact]
|
|
public void Supersession_PreservesOldHostWithdrawalByExactGeneration()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
long first = state.BeginLoginReveal(OutdoorCell);
|
|
RuntimeWorldHostProjectionToken firstHost =
|
|
RegisterHost(state, first, OutdoorCell);
|
|
Assert.True(Acknowledge(
|
|
state,
|
|
firstHost,
|
|
RuntimeWorldHostAcknowledgementStage.ProjectionRegistered));
|
|
|
|
long second = BeginPortal(state, OtherCell, sequence: 2);
|
|
|
|
Assert.True(state.TryGetHostProjection(
|
|
firstHost,
|
|
out RuntimeWorldHostProjectionSnapshot superseded));
|
|
Assert.True(superseded.IsSuperseding);
|
|
Assert.Equal(
|
|
RuntimeWorldHostAcknowledgementStage
|
|
.DestinationReservationReleased
|
|
| RuntimeWorldHostAcknowledgementStage.TerminalProjected,
|
|
superseded.PendingAcknowledgements);
|
|
Assert.False(Acknowledge(
|
|
state,
|
|
firstHost,
|
|
RuntimeWorldHostAcknowledgementStage.TerminalProjected));
|
|
Assert.True(Acknowledge(
|
|
state,
|
|
firstHost,
|
|
RuntimeWorldHostAcknowledgementStage
|
|
.DestinationReservationReleased));
|
|
Assert.True(Acknowledge(
|
|
state,
|
|
firstHost,
|
|
RuntimeWorldHostAcknowledgementStage.TerminalProjected));
|
|
Assert.Equal(second, state.Snapshot.Generation);
|
|
Assert.Equal(0, state.Ownership.HostProjectionCount);
|
|
}
|
|
|
|
[Fact]
|
|
public void ResetSession_RejectsUnacknowledgedHostProjection()
|
|
{
|
|
var state = new RuntimeWorldTransitState();
|
|
long generation = state.BeginLoginReveal(OutdoorCell);
|
|
RuntimeWorldHostProjectionToken host =
|
|
RegisterHost(state, generation, OutdoorCell);
|
|
|
|
InvalidOperationException error =
|
|
Assert.Throws<InvalidOperationException>(state.ResetSession);
|
|
Assert.Contains("hosts=1", error.Message);
|
|
Assert.Equal(generation, state.Snapshot.Generation);
|
|
|
|
Assert.True(state.Cancel(generation));
|
|
Assert.True(Acknowledge(
|
|
state,
|
|
host,
|
|
RuntimeWorldHostAcknowledgementStage
|
|
.SimulationReleaseProjected));
|
|
Assert.True(Acknowledge(
|
|
state,
|
|
host,
|
|
RuntimeWorldHostAcknowledgementStage
|
|
.DestinationReservationReleased));
|
|
Assert.True(Acknowledge(
|
|
state,
|
|
host,
|
|
RuntimeWorldHostAcknowledgementStage.TerminalProjected));
|
|
state.ResetSession();
|
|
}
|
|
|
|
private static long BeginPortal(
|
|
RuntimeWorldTransitState state,
|
|
uint cell,
|
|
ushort sequence = 1)
|
|
{
|
|
Assert.True(state.TryQueueTeleportStart(sequence));
|
|
Assert.True(state.ActivateQueuedTeleport());
|
|
Assert.True(state.OfferTeleportDestination(
|
|
Destination(cell, sequence),
|
|
teleportTimestampAdvanced: true));
|
|
Assert.True(state.TryBeginPortalReveal(
|
|
sequence,
|
|
cell,
|
|
out long generation));
|
|
return generation;
|
|
}
|
|
|
|
private static RuntimeWorldHostProjectionToken RegisterHost(
|
|
RuntimeWorldTransitState state,
|
|
long generation,
|
|
uint cell)
|
|
{
|
|
Assert.True(state.TryRegisterHostProjection(
|
|
generation,
|
|
cell,
|
|
out RuntimeWorldHostProjectionToken host));
|
|
return host;
|
|
}
|
|
|
|
private static bool Acknowledge(
|
|
RuntimeWorldTransitState state,
|
|
RuntimeWorldHostProjectionToken host,
|
|
RuntimeWorldHostAcknowledgementStage stage) =>
|
|
state.AcknowledgeHostProjection(
|
|
new RuntimeWorldHostAcknowledgement(host, stage));
|
|
|
|
private static RuntimeTeleportDestination Destination(
|
|
uint cell,
|
|
ushort sequence,
|
|
float x = 1f) =>
|
|
new(
|
|
EntityGuid: 0x50000001u,
|
|
InstanceSequence: 1,
|
|
PositionSequence: 1,
|
|
TeleportSequence: sequence,
|
|
ForcePositionSequence: 1,
|
|
Position: new Position(
|
|
cell,
|
|
new Vector3(x, 2f, 3f),
|
|
Quaternion.Identity));
|
|
|
|
private static RuntimeDestinationReadiness Ready(
|
|
long generation,
|
|
uint cell) =>
|
|
new(
|
|
generation,
|
|
cell,
|
|
IsIndoor: (cell & 0xFFFFu) >= 0x0100u,
|
|
IsUnhydratable: false,
|
|
RequiredRenderRadius: (cell & 0xFFFFu) >= 0x0100u ? 0 : 1,
|
|
IsRenderNeighborhoodReady: true,
|
|
AreCompositeTexturesReady: true,
|
|
IsCollisionReady: true);
|
|
}
|