455 lines
17 KiB
C#
455 lines
17 KiB
C#
using AcDream.Core.World;
|
|
using Xunit;
|
|
|
|
namespace AcDream.Core.Tests.World;
|
|
|
|
public sealed class TeleportAnimSequencerTests
|
|
{
|
|
// --- Task 1.1: type presence ---
|
|
|
|
[Fact]
|
|
public void Enums_HaveExpectedValues()
|
|
{
|
|
Assert.Equal(0, (int)TeleportAnimState.Off);
|
|
Assert.Equal(1, (int)TeleportAnimState.WorldFadeOut);
|
|
Assert.Equal(2, (int)TeleportAnimState.TunnelFadeIn);
|
|
Assert.Equal(3, (int)TeleportAnimState.Tunnel);
|
|
Assert.Equal(4, (int)TeleportAnimState.TunnelContinue);
|
|
Assert.Equal(5, (int)TeleportAnimState.TunnelFadeOut);
|
|
Assert.Equal(6, (int)TeleportAnimState.WorldFadeIn);
|
|
|
|
_ = TeleportEntryKind.Portal;
|
|
_ = TeleportEntryKind.Login;
|
|
_ = TeleportEntryKind.Death;
|
|
_ = TeleportEntryKind.Logout;
|
|
|
|
_ = TeleportAnimEvent.PlayEnterSound;
|
|
_ = TeleportAnimEvent.PlayExitSound;
|
|
_ = TeleportAnimEvent.Place;
|
|
_ = TeleportAnimEvent.FireLoginComplete;
|
|
_ = TeleportAnimEvent.EnterTunnel;
|
|
}
|
|
|
|
[Fact]
|
|
public void Snapshot_DefaultsAreOff_ClearAlpha()
|
|
{
|
|
var snap = new TeleportAnimSnapshot(
|
|
TeleportAnimState.Off, FadeAlpha: 0f, ShowTunnel: false, ShowPleaseWait: false);
|
|
Assert.Equal(TeleportAnimState.Off, snap.State);
|
|
Assert.Equal(0f, snap.FadeAlpha);
|
|
Assert.False(snap.ShowTunnel);
|
|
Assert.False(snap.ShowPleaseWait);
|
|
}
|
|
|
|
// --- Task 1.2: Begin(), IsActive, initial state ---
|
|
|
|
[Theory]
|
|
[InlineData(TeleportEntryKind.Portal, TeleportAnimState.Tunnel)]
|
|
[InlineData(TeleportEntryKind.Login, TeleportAnimState.Tunnel)]
|
|
[InlineData(TeleportEntryKind.Death, TeleportAnimState.Tunnel)]
|
|
[InlineData(TeleportEntryKind.Logout, TeleportAnimState.WorldFadeOut)]
|
|
public void Begin_SetsCorrectStartState(TeleportEntryKind kind, TeleportAnimState expectedStart)
|
|
{
|
|
var seq = new TeleportAnimSequencer();
|
|
Assert.False(seq.IsActive);
|
|
|
|
seq.Begin(kind);
|
|
|
|
Assert.True(seq.IsActive);
|
|
Assert.Equal(expectedStart, seq.State);
|
|
}
|
|
|
|
[Fact]
|
|
public void Begin_EmitsPlayEnterSoundOnFirstTick()
|
|
{
|
|
// PlayEnterSound is edge-triggered on the first Tick after Begin.
|
|
var seq = new TeleportAnimSequencer();
|
|
seq.Begin(TeleportEntryKind.Portal);
|
|
var (_, events) = seq.Tick(dt: 0f, worldReady: false);
|
|
Assert.Contains(TeleportAnimEvent.PlayEnterSound, events);
|
|
}
|
|
|
|
// --- Task 1.3: State transitions — timing-correct Tick() ---
|
|
|
|
// Helper: drive the sequencer forward by total elapsed time using small fixed steps.
|
|
private static (TeleportAnimSnapshot snap, List<TeleportAnimEvent> allEvents)
|
|
DriveSeconds(TeleportAnimSequencer seq, float seconds, bool worldReady, float step = 0.016f)
|
|
{
|
|
var allEvts = new List<TeleportAnimEvent>();
|
|
float remaining = seconds;
|
|
TeleportAnimSnapshot last = default;
|
|
while (remaining > 0f)
|
|
{
|
|
float dt = Math.Min(step, remaining);
|
|
var (snap, evts) = seq.Tick(dt, worldReady);
|
|
last = snap;
|
|
allEvts.AddRange(evts);
|
|
remaining -= dt;
|
|
}
|
|
return (last, allEvts);
|
|
}
|
|
|
|
// --- Logout path: WorldFadeOut -> TunnelFadeIn -> Tunnel ---
|
|
|
|
[Fact]
|
|
public void Logout_AfterFadeTime_TransitionsToTunnelFadeIn()
|
|
{
|
|
var seq = new TeleportAnimSequencer();
|
|
seq.Begin(TeleportEntryKind.Logout);
|
|
|
|
// Consume the enter-sound tick at dt=0
|
|
seq.Tick(0f, worldReady: false);
|
|
|
|
// Drive just past FadeTime (1.0s)
|
|
DriveSeconds(seq, TeleportAnimSequencer.FadeTime + 0.02f, worldReady: false);
|
|
|
|
Assert.Equal(TeleportAnimState.TunnelFadeIn, seq.State);
|
|
}
|
|
|
|
[Fact]
|
|
public void Logout_After2xFadeTime_TransitionsToTunnel()
|
|
{
|
|
var seq = new TeleportAnimSequencer();
|
|
seq.Begin(TeleportEntryKind.Logout);
|
|
seq.Tick(0f, worldReady: false); // consume enter-sound
|
|
|
|
DriveSeconds(seq, 2f * TeleportAnimSequencer.FadeTime + 0.02f, worldReady: false);
|
|
|
|
Assert.Equal(TeleportAnimState.Tunnel, seq.State);
|
|
}
|
|
|
|
// --- Portal/Login/Death path: enters at Tunnel ---
|
|
|
|
[Fact]
|
|
public void Portal_StartsInTunnel_HoldsWhileNotReady()
|
|
{
|
|
var seq = new TeleportAnimSequencer();
|
|
seq.Begin(TeleportEntryKind.Portal);
|
|
seq.Tick(0f, worldReady: false); // consume enter-sound
|
|
|
|
// Drive 10s — should not advance past Tunnel while !worldReady
|
|
DriveSeconds(seq, 10f, worldReady: false);
|
|
|
|
Assert.Equal(TeleportAnimState.Tunnel, seq.State);
|
|
}
|
|
|
|
[Fact]
|
|
public void Portal_WhenWorldReady_TransitionsToTunnelContinue_EmitsEnterTunnelAndPlace()
|
|
{
|
|
var seq = new TeleportAnimSequencer();
|
|
seq.Begin(TeleportEntryKind.Portal);
|
|
seq.Tick(0f, worldReady: false); // consume enter-sound
|
|
|
|
// The very first tick with worldReady=true should advance Tunnel→TunnelContinue and emit Place.
|
|
var (_, evts) = seq.Tick(0.016f, worldReady: true);
|
|
|
|
Assert.Equal(TeleportAnimState.TunnelContinue, seq.State);
|
|
Assert.Contains(TeleportAnimEvent.Place, evts);
|
|
}
|
|
|
|
// --- TunnelContinue: MIN_CONTINUE hold then TunnelFadeOut ---
|
|
|
|
[Fact]
|
|
public void TunnelContinue_DoesNotAdvance_BeforeMinContinue()
|
|
{
|
|
var seq = new TeleportAnimSequencer();
|
|
seq.Begin(TeleportEntryKind.Portal);
|
|
seq.Tick(0f, worldReady: false);
|
|
// Enter TunnelContinue
|
|
seq.Tick(0.016f, worldReady: true);
|
|
Assert.Equal(TeleportAnimState.TunnelContinue, seq.State);
|
|
|
|
// Drive MinContinue - ε — should still be TunnelContinue
|
|
DriveSeconds(seq, TeleportAnimSequencer.MinContinue - 0.1f, worldReady: true);
|
|
|
|
Assert.Equal(TeleportAnimState.TunnelContinue, seq.State);
|
|
}
|
|
|
|
[Fact]
|
|
public void TunnelContinue_AdvancesToTunnelFadeOut_AfterMinContinue()
|
|
{
|
|
var seq = new TeleportAnimSequencer();
|
|
seq.Begin(TeleportEntryKind.Portal);
|
|
seq.Tick(0f, worldReady: false);
|
|
seq.Tick(0.016f, worldReady: true); // -> TunnelContinue
|
|
|
|
DriveSeconds(seq, TeleportAnimSequencer.MinContinue + 0.05f, worldReady: true);
|
|
|
|
Assert.Equal(TeleportAnimState.TunnelFadeOut, seq.State);
|
|
}
|
|
|
|
// --- MAX_CONTINUE forces progress even when !worldReady ---
|
|
|
|
[Fact]
|
|
public void TunnelContinue_ForcesAdvance_AtMaxContinue_EvenIfNotReady()
|
|
{
|
|
// Simulate: world never becomes fully ready but MAX_CONTINUE forces fade-out
|
|
// This path exercises the safety-net from spec §3.4.
|
|
var seq = new TeleportAnimSequencer();
|
|
seq.Begin(TeleportEntryKind.Portal);
|
|
seq.Tick(0f, worldReady: false);
|
|
// Manually push the state to TunnelContinue by passing worldReady=true for one tick,
|
|
// then simulate worldReady toggling back to false.
|
|
seq.Tick(0.016f, worldReady: true); // -> TunnelContinue
|
|
|
|
// Drive MaxContinue + ε with worldReady=false (simulating "world never loaded")
|
|
DriveSeconds(seq, TeleportAnimSequencer.MaxContinue + 0.05f, worldReady: false);
|
|
|
|
Assert.Equal(TeleportAnimState.TunnelFadeOut, seq.State);
|
|
}
|
|
|
|
// --- TunnelFadeOut -> WorldFadeIn: PlayExitSound edge event ---
|
|
|
|
[Fact]
|
|
public void TunnelFadeOut_EmitsPlayExitSound_OnTransitionToWorldFadeIn()
|
|
{
|
|
var seq = new TeleportAnimSequencer();
|
|
seq.Begin(TeleportEntryKind.Portal);
|
|
seq.Tick(0f, worldReady: false);
|
|
seq.Tick(0.016f, worldReady: true); // -> TunnelContinue
|
|
|
|
// Drive through MinContinue -> TunnelFadeOut
|
|
DriveSeconds(seq, TeleportAnimSequencer.MinContinue + 0.05f, worldReady: true);
|
|
Assert.Equal(TeleportAnimState.TunnelFadeOut, seq.State);
|
|
|
|
// Drive through FadeTime -> WorldFadeIn; PlayExitSound should fire on that edge
|
|
var (_, evts) = DriveSeconds(seq, TeleportAnimSequencer.FadeTime + 0.05f, worldReady: true);
|
|
Assert.Equal(TeleportAnimState.WorldFadeIn, seq.State);
|
|
Assert.Contains(TeleportAnimEvent.PlayExitSound, evts);
|
|
}
|
|
|
|
// --- WorldFadeIn -> Off: FireLoginComplete edge event ---
|
|
|
|
[Fact]
|
|
public void WorldFadeIn_EmitsFireLoginComplete_OnTransitionToOff()
|
|
{
|
|
var seq = new TeleportAnimSequencer();
|
|
seq.Begin(TeleportEntryKind.Portal);
|
|
seq.Tick(0f, worldReady: false);
|
|
seq.Tick(0.016f, worldReady: true); // -> TunnelContinue
|
|
DriveSeconds(seq, TeleportAnimSequencer.MinContinue + 0.05f, worldReady: true);
|
|
DriveSeconds(seq, TeleportAnimSequencer.FadeTime + 0.05f, worldReady: true); // -> WorldFadeIn
|
|
|
|
var (_, evts) = DriveSeconds(seq, TeleportAnimSequencer.FadeTime + 0.05f, worldReady: true);
|
|
|
|
Assert.Equal(TeleportAnimState.Off, seq.State);
|
|
Assert.False(seq.IsActive);
|
|
Assert.Contains(TeleportAnimEvent.FireLoginComplete, evts);
|
|
}
|
|
|
|
// --- Task 1.4: FadeAlpha endpoints and monotonicity ---
|
|
|
|
[Fact]
|
|
public void FadeAlpha_IsZeroAtStart_OfWorldFadeOut()
|
|
{
|
|
var seq = new TeleportAnimSequencer();
|
|
seq.Begin(TeleportEntryKind.Logout);
|
|
var (snap, _) = seq.Tick(dt: 0f, worldReady: false);
|
|
// At elapsed=0 in WorldFadeOut: smoothstep(0)=0 => alpha=0 (world fully visible).
|
|
Assert.Equal(0f, snap.FadeAlpha, precision: 4);
|
|
}
|
|
|
|
[Fact]
|
|
public void FadeAlpha_IsOneAtEnd_OfWorldFadeOut()
|
|
{
|
|
var seq = new TeleportAnimSequencer();
|
|
seq.Begin(TeleportEntryKind.Logout);
|
|
seq.Tick(0f, worldReady: false); // consume enter-sound tick, elapsed≈0
|
|
|
|
// Drive to just BEFORE the transition (so we're still in WorldFadeOut)
|
|
DriveSeconds(seq, TeleportAnimSequencer.FadeTime - 0.02f, worldReady: false);
|
|
Assert.Equal(TeleportAnimState.WorldFadeOut, seq.State);
|
|
|
|
var (snap, _) = seq.Tick(0f, worldReady: false);
|
|
// smoothstep(clamp((1.0-0.02)/1.0,0,1)) should be close to 1
|
|
Assert.True(snap.FadeAlpha > 0.95f, $"Expected FadeAlpha near 1, got {snap.FadeAlpha}");
|
|
}
|
|
|
|
[Fact]
|
|
public void FadeAlpha_IsMonotonicallyIncreasing_DuringWorldFadeOut()
|
|
{
|
|
var seq = new TeleportAnimSequencer();
|
|
seq.Begin(TeleportEntryKind.Logout);
|
|
seq.Tick(0f, worldReady: false);
|
|
|
|
float prev = -1f;
|
|
// Sample 50 steps within FadeTime
|
|
float step = TeleportAnimSequencer.FadeTime / 50f;
|
|
for (int i = 0; i < 48; i++) // stop before transition
|
|
{
|
|
var (snap, _) = seq.Tick(step, worldReady: false);
|
|
if (seq.State != TeleportAnimState.WorldFadeOut) break;
|
|
Assert.True(snap.FadeAlpha >= prev - 0.001f,
|
|
$"Alpha decreased: {prev} -> {snap.FadeAlpha} at step {i}");
|
|
prev = snap.FadeAlpha;
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void FadeAlpha_IsZero_DuringTunnelStates()
|
|
{
|
|
var seq = new TeleportAnimSequencer();
|
|
seq.Begin(TeleportEntryKind.Portal);
|
|
seq.Tick(0f, worldReady: false);
|
|
|
|
// In Tunnel state, overlay alpha should be 0 (the tunnel viewport is shown; no alpha quad needed)
|
|
var (snap, _) = seq.Tick(0.016f, worldReady: false);
|
|
Assert.Equal(TeleportAnimState.Tunnel, seq.State);
|
|
Assert.Equal(0f, snap.FadeAlpha);
|
|
}
|
|
|
|
[Fact]
|
|
public void ShowTunnel_TrueInTunnelFamilyStates_FalseOtherwise()
|
|
{
|
|
// Logout path: WorldFadeOut -> TunnelFadeIn -> Tunnel -> TunnelContinue -> TunnelFadeOut -> WorldFadeIn -> Off
|
|
var seq = new TeleportAnimSequencer();
|
|
seq.Begin(TeleportEntryKind.Logout);
|
|
seq.Tick(0f, worldReady: false);
|
|
|
|
// WorldFadeOut: ShowTunnel = false
|
|
var (snap, _) = seq.Tick(0.016f, worldReady: false);
|
|
Assert.Equal(TeleportAnimState.WorldFadeOut, seq.State);
|
|
Assert.False(snap.ShowTunnel);
|
|
|
|
// Advance to TunnelFadeIn
|
|
DriveSeconds(seq, TeleportAnimSequencer.FadeTime, worldReady: false);
|
|
Assert.Equal(TeleportAnimState.TunnelFadeIn, seq.State);
|
|
var (snap2, _) = seq.Tick(0f, worldReady: false);
|
|
Assert.True(snap2.ShowTunnel);
|
|
|
|
// Advance to Tunnel
|
|
DriveSeconds(seq, TeleportAnimSequencer.FadeTime, worldReady: false);
|
|
Assert.Equal(TeleportAnimState.Tunnel, seq.State);
|
|
var (snap3, _) = seq.Tick(0f, worldReady: false);
|
|
Assert.True(snap3.ShowTunnel);
|
|
}
|
|
|
|
[Fact]
|
|
public void ShowPleaseWait_TrueOnlyInTunnelContinue()
|
|
{
|
|
var seq = new TeleportAnimSequencer();
|
|
seq.Begin(TeleportEntryKind.Portal);
|
|
seq.Tick(0f, worldReady: false);
|
|
|
|
// Tunnel: ShowPleaseWait false
|
|
var (snap1, _) = seq.Tick(0.016f, worldReady: false);
|
|
Assert.Equal(TeleportAnimState.Tunnel, seq.State);
|
|
Assert.False(snap1.ShowPleaseWait);
|
|
|
|
// Advance to TunnelContinue
|
|
var (snap2, _) = seq.Tick(0.016f, worldReady: true);
|
|
Assert.Equal(TeleportAnimState.TunnelContinue, seq.State);
|
|
Assert.True(snap2.ShowPleaseWait);
|
|
}
|
|
|
|
// --- Task 1.5: Full portal event sequence and logout event sequence ---
|
|
|
|
// Helper: run the sequencer to completion collecting ordered events.
|
|
private static List<TeleportAnimEvent> RunToOff(
|
|
TeleportEntryKind kind, bool worldReadyAfterFirstTunnel = true, float step = 0.05f)
|
|
{
|
|
var seq = new TeleportAnimSequencer();
|
|
var allEvts = new List<TeleportAnimEvent>();
|
|
seq.Begin(kind);
|
|
|
|
int safetyNet = 5000;
|
|
while (seq.IsActive && --safetyNet > 0)
|
|
{
|
|
// Simulate world becoming ready on first Tick inside Tunnel
|
|
bool ready = worldReadyAfterFirstTunnel && seq.State == TeleportAnimState.Tunnel;
|
|
var (_, evts) = seq.Tick(step, worldReady: ready);
|
|
allEvts.AddRange(evts);
|
|
}
|
|
return allEvts;
|
|
}
|
|
|
|
[Fact]
|
|
public void Portal_FullSequence_EventsInOrder()
|
|
{
|
|
var evts = RunToOff(TeleportEntryKind.Portal);
|
|
|
|
// Required events in order: PlayEnterSound, Place, PlayExitSound, FireLoginComplete.
|
|
// EnterTunnel is optional but must come before Place if present.
|
|
int enterIdx = evts.IndexOf(TeleportAnimEvent.PlayEnterSound);
|
|
int placeIdx = evts.IndexOf(TeleportAnimEvent.Place);
|
|
int exitIdx = evts.IndexOf(TeleportAnimEvent.PlayExitSound);
|
|
int loginIdx = evts.IndexOf(TeleportAnimEvent.FireLoginComplete);
|
|
|
|
Assert.True(enterIdx >= 0, "PlayEnterSound must fire");
|
|
Assert.True(placeIdx >= 0, "Place must fire");
|
|
Assert.True(exitIdx >= 0, "PlayExitSound must fire");
|
|
Assert.True(loginIdx >= 0, "FireLoginComplete must fire");
|
|
|
|
Assert.True(enterIdx < placeIdx, "PlayEnterSound must precede Place");
|
|
Assert.True(placeIdx < exitIdx, "Place must precede PlayExitSound");
|
|
Assert.True(exitIdx < loginIdx, "PlayExitSound must precede FireLoginComplete");
|
|
}
|
|
|
|
[Fact]
|
|
public void Logout_FullSequence_EventsInOrder_WithEnterTunnelAfterFades()
|
|
{
|
|
var evts = RunToOff(TeleportEntryKind.Logout);
|
|
|
|
int enterIdx = evts.IndexOf(TeleportAnimEvent.PlayEnterSound);
|
|
int tunnelIdx = evts.IndexOf(TeleportAnimEvent.EnterTunnel);
|
|
int placeIdx = evts.IndexOf(TeleportAnimEvent.Place);
|
|
int exitIdx = evts.IndexOf(TeleportAnimEvent.PlayExitSound);
|
|
int loginIdx = evts.IndexOf(TeleportAnimEvent.FireLoginComplete);
|
|
|
|
Assert.True(enterIdx >= 0, "PlayEnterSound must fire");
|
|
Assert.True(tunnelIdx >= 0, "EnterTunnel must fire (Logout path goes through WorldFadeOut->TunnelFadeIn->Tunnel)");
|
|
Assert.True(placeIdx >= 0, "Place must fire");
|
|
Assert.True(exitIdx >= 0, "PlayExitSound must fire");
|
|
Assert.True(loginIdx >= 0, "FireLoginComplete must fire");
|
|
|
|
Assert.True(enterIdx < tunnelIdx, "PlayEnterSound must precede EnterTunnel");
|
|
Assert.True(tunnelIdx < placeIdx, "EnterTunnel must precede Place");
|
|
Assert.True(placeIdx < exitIdx, "Place must precede PlayExitSound");
|
|
Assert.True(exitIdx < loginIdx, "PlayExitSound must precede FireLoginComplete");
|
|
}
|
|
|
|
[Fact]
|
|
public void Portal_NoEventsFiredTwice()
|
|
{
|
|
var evts = RunToOff(TeleportEntryKind.Portal);
|
|
Assert.Equal(1, evts.Count(e => e == TeleportAnimEvent.PlayEnterSound));
|
|
Assert.Equal(1, evts.Count(e => e == TeleportAnimEvent.Place));
|
|
Assert.Equal(1, evts.Count(e => e == TeleportAnimEvent.PlayExitSound));
|
|
Assert.Equal(1, evts.Count(e => e == TeleportAnimEvent.FireLoginComplete));
|
|
}
|
|
|
|
[Fact]
|
|
public void Death_BehavesIdenticallyToPortal_FullSequence()
|
|
{
|
|
var portalEvts = RunToOff(TeleportEntryKind.Portal);
|
|
var deathEvts = RunToOff(TeleportEntryKind.Death);
|
|
// Same event sequence (both enter at Tunnel)
|
|
Assert.Equal(portalEvts, deathEvts);
|
|
}
|
|
|
|
[Fact]
|
|
public void Login_BehavesIdenticallyToPortal_FullSequence()
|
|
{
|
|
var portalEvts = RunToOff(TeleportEntryKind.Portal);
|
|
var loginEvts = RunToOff(TeleportEntryKind.Login);
|
|
Assert.Equal(portalEvts, loginEvts);
|
|
}
|
|
|
|
[Fact]
|
|
public void AfterOff_IsActiveIsFalse_AndStateIsOff()
|
|
{
|
|
RunToOff(TeleportEntryKind.Portal);
|
|
var seq = new TeleportAnimSequencer();
|
|
seq.Begin(TeleportEntryKind.Portal);
|
|
|
|
// Drain to Off
|
|
for (int i = 0; i < 5000 && seq.IsActive; i++)
|
|
{
|
|
bool ready = seq.State == TeleportAnimState.Tunnel;
|
|
seq.Tick(0.05f, worldReady: ready);
|
|
}
|
|
|
|
Assert.False(seq.IsActive);
|
|
Assert.Equal(TeleportAnimState.Off, seq.State);
|
|
}
|
|
}
|