344 lines
13 KiB
C#
344 lines
13 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);
|
|
}
|
|
}
|