funman300
7cda2a9f1a
- Collapse nested-if patterns into let-chains across 13 plugins (42 instances) - Add #[allow(clippy::too_many_arguments)] to 5 Bevy systems in card_plugin and input_plugin where ECS parameter count exceeds the lint threshold - Gate Theme import in table_plugin under #[cfg(test)] — only used by test-only colour helpers; removing the unconditional import silences the unused-import lint without breaking the test suite - Wrap ButtonInput<MouseButton> in Option<> in update_input_platform so that tests using MinimalPlugins (no InputPlugin) no longer panic on startup All 789 tests pass; cargo clippy --workspace -- -D warnings is clean. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>
852 lines
28 KiB
Rust
852 lines
28 KiB
Rust
//! Smooth animations: card slide (linear lerp), win cascade, achievement toast.
|
|
//!
|
|
//! `CardAnim` is the only animation component used by other plugins — import
|
|
//! it directly when adding animations outside this file.
|
|
//!
|
|
//! # Toast queue (Task #67)
|
|
//!
|
|
//! Multiple `InfoToastEvent`s can fire in a single frame. To prevent overlapping
|
|
//! text, they are enqueued in `ToastQueue` and shown one at a time by
|
|
//! `drive_toast_display`. Each toast lives for 2.5 seconds; the next is shown
|
|
//! immediately after the previous despawns.
|
|
|
|
use std::collections::VecDeque;
|
|
|
|
use bevy::prelude::*;
|
|
use solitaire_data::AnimSpeed;
|
|
|
|
use crate::achievement_plugin::display_name_for;
|
|
use crate::auto_complete_plugin::AutoCompleteState;
|
|
use crate::card_plugin::CardEntity;
|
|
use crate::challenge_plugin::ChallengeAdvancedEvent;
|
|
use crate::daily_challenge_plugin::{DailyChallengeCompletedEvent, DailyGoalAnnouncementEvent};
|
|
use crate::events::{InfoToastEvent, NewGameConfirmEvent, XpAwardedEvent};
|
|
use crate::events::{AchievementUnlockedEvent, GameWonEvent};
|
|
use crate::game_plugin::GameMutation;
|
|
use crate::layout::LayoutResource;
|
|
use crate::pause_plugin::PausedResource;
|
|
use crate::progress_plugin::LevelUpEvent;
|
|
use crate::settings_plugin::{SettingsChangedEvent, SettingsResource};
|
|
use crate::time_attack_plugin::TimeAttackEndedEvent;
|
|
use crate::weekly_goals_plugin::WeeklyGoalCompletedEvent;
|
|
|
|
/// Duration of a card slide (move) animation in seconds at Normal speed.
|
|
pub const SLIDE_SECS: f32 = 0.15;
|
|
|
|
/// The effective slide duration, updated whenever `Settings::animation_speed` changes.
|
|
#[derive(Resource, Debug, Clone, Copy)]
|
|
pub struct EffectiveSlideDuration {
|
|
pub slide_secs: f32,
|
|
}
|
|
|
|
impl Default for EffectiveSlideDuration {
|
|
fn default() -> Self {
|
|
Self { slide_secs: SLIDE_SECS }
|
|
}
|
|
}
|
|
|
|
fn anim_speed_to_secs(speed: &AnimSpeed) -> f32 {
|
|
match speed {
|
|
AnimSpeed::Normal => SLIDE_SECS,
|
|
AnimSpeed::Fast => 0.07,
|
|
AnimSpeed::Instant => 0.0,
|
|
}
|
|
}
|
|
|
|
const WIN_TOAST_SECS: f32 = 4.0;
|
|
const ACHIEVEMENT_TOAST_SECS: f32 = 3.0;
|
|
const LEVELUP_TOAST_SECS: f32 = 3.0;
|
|
const DAILY_TOAST_SECS: f32 = 3.0;
|
|
const WEEKLY_TOAST_SECS: f32 = 3.0;
|
|
const TIME_ATTACK_TOAST_SECS: f32 = 5.0;
|
|
const CHALLENGE_TOAST_SECS: f32 = 3.0;
|
|
const VOLUME_TOAST_SECS: f32 = 1.4;
|
|
|
|
/// Per-card stagger interval for the win cascade at Normal speed (seconds).
|
|
const CASCADE_STAGGER_NORMAL: f32 = 0.05;
|
|
/// Duration of each card's cascade slide at Normal speed (seconds).
|
|
const CASCADE_DURATION_NORMAL: f32 = 0.5;
|
|
|
|
/// Returns the per-card stagger delay for the win cascade at the given `AnimSpeed`.
|
|
///
|
|
/// | `AnimSpeed` | Returned value |
|
|
/// |-------------|----------------|
|
|
/// | `Normal` | 0.05 s |
|
|
/// | `Fast` | 0.025 s |
|
|
/// | `Instant` | 0.0 s |
|
|
pub fn cascade_step_secs(speed: AnimSpeed) -> f32 {
|
|
match speed {
|
|
AnimSpeed::Normal => CASCADE_STAGGER_NORMAL,
|
|
AnimSpeed::Fast => CASCADE_STAGGER_NORMAL / 2.0,
|
|
AnimSpeed::Instant => 0.0,
|
|
}
|
|
}
|
|
|
|
/// Returns the slide duration for each card in the win cascade at the given `AnimSpeed`.
|
|
///
|
|
/// | `AnimSpeed` | Returned value |
|
|
/// |-------------|----------------|
|
|
/// | `Normal` | 0.5 s |
|
|
/// | `Fast` | 0.25 s |
|
|
/// | `Instant` | 0.0 s |
|
|
pub fn cascade_duration_secs(speed: AnimSpeed) -> f32 {
|
|
match speed {
|
|
AnimSpeed::Normal => CASCADE_DURATION_NORMAL,
|
|
AnimSpeed::Fast => CASCADE_DURATION_NORMAL / 2.0,
|
|
AnimSpeed::Instant => 0.0,
|
|
}
|
|
}
|
|
|
|
/// Linear-lerp slide animation.
|
|
///
|
|
/// After `delay` seconds the card moves from `start` to `target` over
|
|
/// `duration` seconds. The component removes itself when the slide completes.
|
|
#[derive(Component, Debug, Clone)]
|
|
pub struct CardAnim {
|
|
pub start: Vec3,
|
|
pub target: Vec3,
|
|
pub elapsed: f32,
|
|
pub duration: f32,
|
|
/// Additional wait before the slide begins.
|
|
pub delay: f32,
|
|
}
|
|
|
|
/// Marker on a toast overlay UI node.
|
|
#[derive(Component, Debug)]
|
|
pub struct ToastOverlay;
|
|
|
|
/// Auto-dismiss countdown (seconds remaining). Attached to toast entities.
|
|
#[derive(Component, Debug)]
|
|
pub struct ToastTimer(pub f32);
|
|
|
|
/// Marker applied to `InfoToastEvent`-sourced toast entities managed by the queue.
|
|
///
|
|
/// Only one `ToastEntity` is alive at a time; the next is spawned after the
|
|
/// previous despawns.
|
|
#[derive(Component, Debug)]
|
|
pub struct ToastEntity;
|
|
|
|
/// FIFO queue of pending `InfoToastEvent` messages.
|
|
///
|
|
/// Systems that want to display a short informational string should fire
|
|
/// `InfoToastEvent` — `enqueue_toasts` will push it here. `drive_toast_display`
|
|
/// pops one message at a time and shows it for 2.5 seconds.
|
|
#[derive(Resource, Debug, Default)]
|
|
pub struct ToastQueue(pub VecDeque<String>);
|
|
|
|
/// Tracks the currently visible queued toast.
|
|
///
|
|
/// `None` when no toast is showing. When `Some`, `entity` is the spawned UI
|
|
/// node and `timer` counts down to zero (seconds remaining).
|
|
#[derive(Resource, Debug, Default)]
|
|
pub struct ActiveToast {
|
|
/// The entity holding the visible toast node.
|
|
pub entity: Option<Entity>,
|
|
/// Seconds remaining before the toast is dismissed.
|
|
pub timer: f32,
|
|
}
|
|
|
|
/// Duration of each queued info-toast in seconds.
|
|
const QUEUED_TOAST_SECS: f32 = 2.5;
|
|
|
|
/// Drives all linear card animations (`CardAnim`), toast notifications, deal stagger, win cascade, and the auto-complete card-slide sequence.
|
|
pub struct AnimationPlugin;
|
|
|
|
impl Plugin for AnimationPlugin {
|
|
fn build(&self, app: &mut App) {
|
|
// Register the events this plugin consumes so tests that don't include
|
|
// GamePlugin can still run AnimationPlugin in isolation. Double-registration
|
|
// is idempotent in Bevy.
|
|
app.add_message::<GameWonEvent>()
|
|
.add_message::<AchievementUnlockedEvent>()
|
|
.add_message::<LevelUpEvent>()
|
|
.add_message::<DailyChallengeCompletedEvent>()
|
|
.add_message::<DailyGoalAnnouncementEvent>()
|
|
.add_message::<WeeklyGoalCompletedEvent>()
|
|
.add_message::<TimeAttackEndedEvent>()
|
|
.add_message::<ChallengeAdvancedEvent>()
|
|
.add_message::<SettingsChangedEvent>()
|
|
.add_message::<NewGameConfirmEvent>()
|
|
.add_message::<InfoToastEvent>()
|
|
.add_message::<XpAwardedEvent>()
|
|
.init_resource::<EffectiveSlideDuration>()
|
|
.init_resource::<ToastQueue>()
|
|
.init_resource::<ActiveToast>()
|
|
.add_systems(Startup, init_slide_duration)
|
|
.add_systems(
|
|
Update,
|
|
(
|
|
advance_card_anims,
|
|
sync_slide_duration,
|
|
handle_win_cascade,
|
|
handle_achievement_toast,
|
|
handle_levelup_toast,
|
|
handle_daily_goal_announcement_toast,
|
|
handle_daily_toast,
|
|
handle_weekly_toast,
|
|
handle_time_attack_toast,
|
|
handle_challenge_toast,
|
|
handle_settings_toast,
|
|
handle_auto_complete_toast,
|
|
handle_new_game_confirm_toast,
|
|
handle_xp_awarded_toast,
|
|
tick_toasts,
|
|
(enqueue_toasts, drive_toast_display).chain(),
|
|
)
|
|
.after(GameMutation),
|
|
);
|
|
}
|
|
}
|
|
|
|
fn init_slide_duration(
|
|
settings: Option<Res<SettingsResource>>,
|
|
mut dur: ResMut<EffectiveSlideDuration>,
|
|
) {
|
|
if let Some(s) = settings {
|
|
dur.slide_secs = anim_speed_to_secs(&s.0.animation_speed);
|
|
}
|
|
}
|
|
|
|
fn sync_slide_duration(
|
|
mut events: MessageReader<SettingsChangedEvent>,
|
|
mut dur: ResMut<EffectiveSlideDuration>,
|
|
) {
|
|
for ev in events.read() {
|
|
dur.slide_secs = anim_speed_to_secs(&ev.0.animation_speed);
|
|
}
|
|
}
|
|
|
|
/// Advances all in-flight `CardAnim` slide animations.
|
|
///
|
|
/// Skipped while the game is paused so cards do not move while the pause
|
|
/// overlay is open.
|
|
fn advance_card_anims(
|
|
mut commands: Commands,
|
|
time: Res<Time>,
|
|
paused: Option<Res<PausedResource>>,
|
|
mut anims: Query<(Entity, &mut Transform, &mut CardAnim)>,
|
|
) {
|
|
if paused.is_some_and(|p| p.0) {
|
|
return;
|
|
}
|
|
let dt = time.delta_secs();
|
|
for (entity, mut transform, mut anim) in &mut anims {
|
|
if anim.delay > 0.0 {
|
|
anim.delay = (anim.delay - dt).max(0.0);
|
|
continue;
|
|
}
|
|
anim.elapsed += dt;
|
|
let t = (anim.elapsed / anim.duration).min(1.0);
|
|
transform.translation = anim.start.lerp(anim.target, t);
|
|
if t >= 1.0 {
|
|
commands.entity(entity).remove::<CardAnim>();
|
|
}
|
|
}
|
|
}
|
|
|
|
fn handle_win_cascade(
|
|
mut commands: Commands,
|
|
mut events: MessageReader<GameWonEvent>,
|
|
cards: Query<(Entity, &Transform), With<CardEntity>>,
|
|
layout: Option<Res<LayoutResource>>,
|
|
settings: Option<Res<SettingsResource>>,
|
|
) {
|
|
let Some(ev) = events.read().next() else {
|
|
return;
|
|
};
|
|
|
|
let margin = layout.as_ref().map_or(800.0, |l| l.0.card_size.x * 8.0);
|
|
|
|
// Eight off-screen destinations spread around the window edges.
|
|
let targets: [Vec3; 8] = [
|
|
Vec3::new(margin, margin, 300.0),
|
|
Vec3::new(-margin, margin, 300.0),
|
|
Vec3::new(margin, -margin, 300.0),
|
|
Vec3::new(-margin, -margin, 300.0),
|
|
Vec3::new(0.0, margin, 300.0),
|
|
Vec3::new(0.0, -margin, 300.0),
|
|
Vec3::new(margin, 0.0, 300.0),
|
|
Vec3::new(-margin, 0.0, 300.0),
|
|
];
|
|
|
|
let m = ev.time_seconds / 60;
|
|
let s = ev.time_seconds % 60;
|
|
let win_msg = format!("You Win! Score: {} Time: {m}:{s:02}", ev.score);
|
|
spawn_toast(&mut commands, win_msg, WIN_TOAST_SECS);
|
|
|
|
let step = settings.as_ref().map_or(CASCADE_STAGGER_NORMAL, |s| cascade_step_secs(s.0.animation_speed.clone()));
|
|
let duration = settings.as_ref().map_or(CASCADE_DURATION_NORMAL, |s| cascade_duration_secs(s.0.animation_speed.clone()));
|
|
|
|
for (i, (entity, transform)) in cards.iter().enumerate() {
|
|
commands.entity(entity).insert(CardAnim {
|
|
start: transform.translation,
|
|
target: targets[i % 8],
|
|
elapsed: 0.0,
|
|
duration,
|
|
delay: i as f32 * step,
|
|
});
|
|
}
|
|
}
|
|
|
|
fn handle_achievement_toast(
|
|
mut commands: Commands,
|
|
mut events: MessageReader<AchievementUnlockedEvent>,
|
|
) {
|
|
for ev in events.read() {
|
|
spawn_toast(
|
|
&mut commands,
|
|
format!("Achievement: {}", display_name_for(&ev.0.id)),
|
|
ACHIEVEMENT_TOAST_SECS,
|
|
);
|
|
}
|
|
}
|
|
|
|
fn handle_levelup_toast(mut commands: Commands, mut events: MessageReader<LevelUpEvent>) {
|
|
for ev in events.read() {
|
|
spawn_toast(
|
|
&mut commands,
|
|
format!("Level Up! → {}", ev.new_level),
|
|
LEVELUP_TOAST_SECS,
|
|
);
|
|
}
|
|
}
|
|
|
|
fn handle_daily_goal_announcement_toast(
|
|
mut commands: Commands,
|
|
mut events: MessageReader<DailyGoalAnnouncementEvent>,
|
|
) {
|
|
for ev in events.read() {
|
|
spawn_toast(&mut commands, format!("Goal: {}", ev.0), DAILY_TOAST_SECS);
|
|
}
|
|
}
|
|
|
|
fn handle_daily_toast(
|
|
mut commands: Commands,
|
|
mut events: MessageReader<DailyChallengeCompletedEvent>,
|
|
) {
|
|
for ev in events.read() {
|
|
spawn_toast(
|
|
&mut commands,
|
|
format!("Daily Challenge Complete! (Streak: {})", ev.streak),
|
|
DAILY_TOAST_SECS,
|
|
);
|
|
}
|
|
}
|
|
|
|
fn handle_weekly_toast(
|
|
mut commands: Commands,
|
|
mut events: MessageReader<WeeklyGoalCompletedEvent>,
|
|
) {
|
|
for ev in events.read() {
|
|
spawn_toast(
|
|
&mut commands,
|
|
format!("Weekly Goal: {}", ev.description),
|
|
WEEKLY_TOAST_SECS,
|
|
);
|
|
}
|
|
}
|
|
|
|
fn handle_time_attack_toast(
|
|
mut commands: Commands,
|
|
mut events: MessageReader<TimeAttackEndedEvent>,
|
|
) {
|
|
for ev in events.read() {
|
|
spawn_toast(
|
|
&mut commands,
|
|
format!("Time Attack: {} win{}", ev.wins, if ev.wins == 1 { "" } else { "s" }),
|
|
TIME_ATTACK_TOAST_SECS,
|
|
);
|
|
}
|
|
}
|
|
|
|
fn handle_challenge_toast(
|
|
mut commands: Commands,
|
|
mut events: MessageReader<ChallengeAdvancedEvent>,
|
|
) {
|
|
for ev in events.read() {
|
|
spawn_toast(
|
|
&mut commands,
|
|
format!("Challenge {} cleared!", ev.previous_index.saturating_add(1)),
|
|
CHALLENGE_TOAST_SECS,
|
|
);
|
|
}
|
|
}
|
|
|
|
fn handle_settings_toast(
|
|
mut commands: Commands,
|
|
mut events: MessageReader<SettingsChangedEvent>,
|
|
mut last_sfx: Local<Option<f32>>,
|
|
mut last_music: Local<Option<f32>>,
|
|
) {
|
|
for ev in events.read() {
|
|
let sfx = ev.0.sfx_volume;
|
|
let music = ev.0.music_volume;
|
|
let sfx_changed = last_sfx.is_none_or(|prev| (prev - sfx).abs() > f32::EPSILON);
|
|
let music_changed = last_music.is_none_or(|prev| (prev - music).abs() > f32::EPSILON);
|
|
*last_sfx = Some(sfx);
|
|
*last_music = Some(music);
|
|
if sfx_changed {
|
|
let pct = (sfx * 100.0).round() as i32;
|
|
spawn_toast(&mut commands, format!("SFX: {pct}%"), VOLUME_TOAST_SECS);
|
|
}
|
|
if music_changed {
|
|
let pct = (music * 100.0).round() as i32;
|
|
spawn_toast(&mut commands, format!("Music: {pct}%"), VOLUME_TOAST_SECS);
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Shows a one-time "Auto-completing..." toast when auto-complete activates.
|
|
fn handle_auto_complete_toast(
|
|
mut commands: Commands,
|
|
state: Option<Res<AutoCompleteState>>,
|
|
mut shown: Local<bool>,
|
|
) {
|
|
let Some(s) = state else { return };
|
|
if s.is_changed() {
|
|
if s.active {
|
|
if !*shown {
|
|
*shown = true;
|
|
spawn_toast(&mut commands, "Auto-completing…".to_string(), 2.0);
|
|
}
|
|
} else {
|
|
*shown = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
fn handle_new_game_confirm_toast(
|
|
mut commands: Commands,
|
|
mut events: MessageReader<NewGameConfirmEvent>,
|
|
) {
|
|
for _ in events.read() {
|
|
spawn_toast(&mut commands, "Press N again to start a new game".to_string(), 3.0);
|
|
}
|
|
}
|
|
|
|
/// Reads every incoming `InfoToastEvent` and appends its text to `ToastQueue`.
|
|
///
|
|
/// This is the first half of the two-system toast queue (Task #67). The queue
|
|
/// decouples event production from rendering so multiple simultaneous events do
|
|
/// not cause overlapping toast text on screen.
|
|
fn enqueue_toasts(
|
|
mut events: MessageReader<InfoToastEvent>,
|
|
mut queue: ResMut<ToastQueue>,
|
|
) {
|
|
for ev in events.read() {
|
|
queue.0.push_back(ev.0.clone());
|
|
}
|
|
}
|
|
|
|
/// Shows one queued toast at a time, despawning it after `QUEUED_TOAST_SECS`.
|
|
///
|
|
/// This is the second half of the two-system toast queue (Task #67). When the
|
|
/// active toast's timer reaches zero the entity is despawned and the next
|
|
/// message in `ToastQueue` is shown.
|
|
/// Pops and displays queued toasts one at a time, despawning each after
|
|
/// `QUEUED_TOAST_SECS`.
|
|
///
|
|
/// Skipped while the game is paused so the active toast timer freezes and no
|
|
/// new messages are dequeued.
|
|
fn drive_toast_display(
|
|
mut commands: Commands,
|
|
time: Res<Time>,
|
|
paused: Option<Res<PausedResource>>,
|
|
mut queue: ResMut<ToastQueue>,
|
|
mut active: ResMut<ActiveToast>,
|
|
) {
|
|
if paused.is_some_and(|p| p.0) {
|
|
return;
|
|
}
|
|
let dt = time.delta_secs();
|
|
|
|
// Tick down the active toast timer.
|
|
if let Some(entity) = active.entity {
|
|
active.timer -= dt;
|
|
if active.timer <= 0.0 {
|
|
// Despawn the toast entity and clear the active slot.
|
|
commands.entity(entity).despawn();
|
|
active.entity = None;
|
|
active.timer = 0.0;
|
|
}
|
|
}
|
|
|
|
// If no active toast and the queue has messages, show the next one.
|
|
if active.entity.is_none()
|
|
&& let Some(message) = queue.0.pop_front() {
|
|
let entity = spawn_queued_toast(&mut commands, message);
|
|
active.entity = Some(entity);
|
|
active.timer = QUEUED_TOAST_SECS;
|
|
}
|
|
}
|
|
|
|
/// Spawns a centered top-of-screen `ToastEntity` for the queued toast system.
|
|
fn spawn_queued_toast(commands: &mut Commands, message: String) -> Entity {
|
|
commands
|
|
.spawn((
|
|
ToastEntity,
|
|
Node {
|
|
position_type: PositionType::Absolute,
|
|
left: Val::Percent(15.0),
|
|
top: Val::Percent(8.0),
|
|
width: Val::Percent(70.0),
|
|
padding: UiRect::axes(Val::Px(16.0), Val::Px(8.0)),
|
|
justify_content: JustifyContent::Center,
|
|
align_items: AlignItems::Center,
|
|
..default()
|
|
},
|
|
BackgroundColor(Color::srgba(0.0, 0.0, 0.0, 0.60)),
|
|
ZIndex(400),
|
|
))
|
|
.with_children(|b| {
|
|
b.spawn((
|
|
Text::new(message),
|
|
TextFont { font_size: 22.0, ..default() },
|
|
TextColor(Color::srgb(1.0, 1.0, 1.0)),
|
|
));
|
|
})
|
|
.id()
|
|
}
|
|
|
|
fn handle_xp_awarded_toast(mut commands: Commands, mut events: MessageReader<XpAwardedEvent>) {
|
|
for ev in events.read() {
|
|
spawn_toast(&mut commands, format!("+{} XP", ev.amount), 3.0);
|
|
}
|
|
}
|
|
|
|
/// Ticks down `ToastTimer` on each toast and despawns it when the timer expires.
|
|
///
|
|
/// Skipped while the game is paused so toast countdowns freeze along with the
|
|
/// rest of the animation systems.
|
|
fn tick_toasts(
|
|
mut commands: Commands,
|
|
time: Res<Time>,
|
|
paused: Option<Res<PausedResource>>,
|
|
mut toasts: Query<(Entity, &mut ToastTimer)>,
|
|
) {
|
|
if paused.is_some_and(|p| p.0) {
|
|
return;
|
|
}
|
|
let dt = time.delta_secs();
|
|
for (entity, mut timer) in &mut toasts {
|
|
timer.0 -= dt;
|
|
if timer.0 <= 0.0 {
|
|
commands.entity(entity).despawn();
|
|
}
|
|
}
|
|
}
|
|
|
|
fn spawn_toast(commands: &mut Commands, message: String, duration_secs: f32) {
|
|
commands
|
|
.spawn((
|
|
ToastOverlay,
|
|
ToastTimer(duration_secs),
|
|
Node {
|
|
position_type: PositionType::Absolute,
|
|
left: Val::Percent(25.0),
|
|
top: Val::Percent(42.0),
|
|
width: Val::Percent(50.0),
|
|
padding: UiRect::axes(Val::Px(16.0), Val::Px(10.0)),
|
|
justify_content: JustifyContent::Center,
|
|
align_items: AlignItems::Center,
|
|
..default()
|
|
},
|
|
BackgroundColor(Color::srgba(0.0, 0.0, 0.0, 0.72)),
|
|
))
|
|
.with_children(|b| {
|
|
b.spawn((
|
|
Text::new(message),
|
|
TextFont {
|
|
font_size: 32.0,
|
|
..default()
|
|
},
|
|
TextColor(Color::srgb(1.0, 0.87, 0.0)),
|
|
));
|
|
});
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::card_plugin::CardPlugin;
|
|
use crate::game_plugin::GamePlugin;
|
|
use crate::table_plugin::TablePlugin;
|
|
|
|
fn app_with_anim() -> App {
|
|
let mut app = App::new();
|
|
app.add_plugins(MinimalPlugins)
|
|
.add_plugins(GamePlugin)
|
|
.add_plugins(TablePlugin)
|
|
.add_plugins(CardPlugin)
|
|
.add_plugins(AnimationPlugin);
|
|
app.update(); // PostStartup: spawns cards
|
|
app
|
|
}
|
|
|
|
#[test]
|
|
fn card_anim_at_half_elapsed_reaches_midpoint() {
|
|
let mut app = App::new();
|
|
app.add_plugins(MinimalPlugins).add_plugins(AnimationPlugin);
|
|
|
|
let start = Vec3::ZERO;
|
|
let target = Vec3::new(100.0, 0.0, 0.0);
|
|
// elapsed = 0.5, duration = 1.0 → t = 0.5 even when dt=0
|
|
let entity = app
|
|
.world_mut()
|
|
.spawn((
|
|
Transform::from_translation(start),
|
|
CardAnim { start, target, elapsed: 0.5, duration: 1.0, delay: 0.0 },
|
|
))
|
|
.id();
|
|
|
|
app.update();
|
|
|
|
let pos = app.world().entity(entity).get::<Transform>().unwrap().translation;
|
|
assert!((pos.x - 50.0).abs() < 1e-3, "expected midpoint x=50, got {}", pos.x);
|
|
assert!(
|
|
app.world().entity(entity).get::<CardAnim>().is_some(),
|
|
"animation not yet complete"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn card_anim_removed_and_at_target_when_elapsed_equals_duration() {
|
|
let mut app = App::new();
|
|
app.add_plugins(MinimalPlugins).add_plugins(AnimationPlugin);
|
|
|
|
let target = Vec3::new(10.0, 0.0, 0.0);
|
|
let entity = app
|
|
.world_mut()
|
|
.spawn((
|
|
Transform::from_translation(Vec3::ZERO),
|
|
CardAnim { start: Vec3::ZERO, target, elapsed: 1.0, duration: 1.0, delay: 0.0 },
|
|
))
|
|
.id();
|
|
|
|
app.update();
|
|
|
|
assert!(
|
|
app.world().entity(entity).get::<CardAnim>().is_none(),
|
|
"CardAnim should be removed when done"
|
|
);
|
|
let pos = app.world().entity(entity).get::<Transform>().unwrap().translation;
|
|
assert!((pos.x - 10.0).abs() < 1e-3);
|
|
}
|
|
|
|
#[test]
|
|
fn card_anim_does_not_move_during_delay() {
|
|
let mut app = App::new();
|
|
app.add_plugins(MinimalPlugins).add_plugins(AnimationPlugin);
|
|
|
|
let entity = app
|
|
.world_mut()
|
|
.spawn((
|
|
Transform::from_translation(Vec3::ZERO),
|
|
CardAnim {
|
|
start: Vec3::ZERO,
|
|
target: Vec3::new(100.0, 0.0, 0.0),
|
|
elapsed: 0.0,
|
|
duration: 0.15,
|
|
delay: 100.0, // large delay — card must not move
|
|
},
|
|
))
|
|
.id();
|
|
|
|
app.update();
|
|
|
|
let pos = app.world().entity(entity).get::<Transform>().unwrap().translation;
|
|
assert!(pos.x.abs() < 1e-3, "card must not move during delay period");
|
|
}
|
|
|
|
#[test]
|
|
fn anim_speed_fast_is_less_than_normal() {
|
|
assert!(anim_speed_to_secs(&AnimSpeed::Fast) < anim_speed_to_secs(&AnimSpeed::Normal));
|
|
}
|
|
|
|
#[test]
|
|
fn anim_speed_instant_is_zero() {
|
|
assert_eq!(anim_speed_to_secs(&AnimSpeed::Instant), 0.0);
|
|
}
|
|
|
|
#[test]
|
|
fn toast_dismissed_after_timer_reaches_zero() {
|
|
let mut app = App::new();
|
|
app.add_plugins(MinimalPlugins).add_plugins(AnimationPlugin);
|
|
|
|
// Manually spawn a toast with a timer that's already expired.
|
|
app.world_mut().spawn((ToastOverlay, ToastTimer(-0.001)));
|
|
app.update();
|
|
|
|
// The toast entity must have been despawned.
|
|
let remaining = app
|
|
.world_mut()
|
|
.query::<&ToastTimer>()
|
|
.iter(app.world())
|
|
.count();
|
|
assert_eq!(remaining, 0, "expired toast must be despawned");
|
|
}
|
|
|
|
#[test]
|
|
fn toast_not_dismissed_before_timer_reaches_zero() {
|
|
let mut app = App::new();
|
|
app.add_plugins(MinimalPlugins).add_plugins(AnimationPlugin);
|
|
|
|
// Large positive timer — should survive one update.
|
|
app.world_mut().spawn((ToastOverlay, ToastTimer(100.0)));
|
|
app.update();
|
|
|
|
let remaining = app
|
|
.world_mut()
|
|
.query::<&ToastTimer>()
|
|
.iter(app.world())
|
|
.count();
|
|
assert_eq!(remaining, 1, "unexpired toast must not be despawned");
|
|
}
|
|
|
|
#[test]
|
|
fn info_toast_event_spawns_toast_overlay() {
|
|
let mut app = App::new();
|
|
app.add_plugins(MinimalPlugins).add_plugins(AnimationPlugin);
|
|
|
|
app.world_mut().write_message(InfoToastEvent("hello".to_string()));
|
|
app.update();
|
|
|
|
let count = app
|
|
.world_mut()
|
|
.query::<&ToastOverlay>()
|
|
.iter(app.world())
|
|
.count();
|
|
// Existing non-queued toasts (achievement, win, etc.) still spawn
|
|
// a ToastOverlay immediately, so the assertion is >= 0 here.
|
|
// The queue-based path spawns a ToastEntity instead.
|
|
let _ = count;
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Task #67 — Toast queue pure-function tests
|
|
// -----------------------------------------------------------------------
|
|
|
|
fn queue_app() -> App {
|
|
let mut app = App::new();
|
|
app.add_plugins(MinimalPlugins).add_plugins(AnimationPlugin);
|
|
app.update();
|
|
app
|
|
}
|
|
|
|
#[test]
|
|
fn toast_queue_empty_initially() {
|
|
let app = queue_app();
|
|
let queue = app.world().resource::<ToastQueue>();
|
|
assert!(queue.0.is_empty(), "ToastQueue must start empty");
|
|
}
|
|
|
|
#[test]
|
|
fn toast_queue_enqueues_on_event() {
|
|
let mut app = queue_app();
|
|
app.world_mut()
|
|
.write_message(InfoToastEvent("test message".to_string()));
|
|
app.update();
|
|
// After one update the message should have been consumed (shown) or is
|
|
// still in the queue — either way we verify the system processed it by
|
|
// checking the ActiveToast resource holds an entity.
|
|
let active = app.world().resource::<ActiveToast>();
|
|
assert!(
|
|
active.entity.is_some(),
|
|
"an InfoToastEvent must activate a toast within one update"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn toast_queue_dequeues_in_order() {
|
|
// Push two messages directly into the queue and verify FIFO order.
|
|
let mut queue = ToastQueue::default();
|
|
queue.0.push_back("first".to_string());
|
|
queue.0.push_back("second".to_string());
|
|
|
|
assert_eq!(queue.0.pop_front().as_deref(), Some("first"));
|
|
assert_eq!(queue.0.pop_front().as_deref(), Some("second"));
|
|
assert!(queue.0.is_empty());
|
|
}
|
|
|
|
#[test]
|
|
fn settings_changed_event_updates_slide_duration() {
|
|
use solitaire_data::Settings;
|
|
let mut app = App::new();
|
|
app.add_plugins(MinimalPlugins).add_plugins(AnimationPlugin);
|
|
|
|
let fast_settings = Settings { animation_speed: AnimSpeed::Fast, ..Default::default() };
|
|
app.world_mut().write_message(SettingsChangedEvent(fast_settings));
|
|
app.update();
|
|
|
|
let dur = app.world().resource::<EffectiveSlideDuration>().slide_secs;
|
|
assert!((dur - anim_speed_to_secs(&AnimSpeed::Fast)).abs() < 1e-6);
|
|
}
|
|
|
|
#[test]
|
|
fn win_cascade_adds_anim_to_all_52_cards() {
|
|
let mut app = app_with_anim();
|
|
|
|
let before = app
|
|
.world_mut()
|
|
.query::<&CardAnim>()
|
|
.iter(app.world())
|
|
.count();
|
|
assert_eq!(before, 0, "no animations before win");
|
|
|
|
app.world_mut()
|
|
.write_message(GameWonEvent { score: 500, time_seconds: 60 });
|
|
app.update();
|
|
|
|
let after = app
|
|
.world_mut()
|
|
.query::<&CardAnim>()
|
|
.iter(app.world())
|
|
.count();
|
|
assert_eq!(after, 52, "all 52 cards should have cascade animations");
|
|
}
|
|
|
|
// -----------------------------------------------------------------------
|
|
// Task #52 — cascade timing helper tests
|
|
// -----------------------------------------------------------------------
|
|
|
|
#[test]
|
|
fn cascade_step_normal_is_expected_value() {
|
|
assert!((cascade_step_secs(AnimSpeed::Normal) - 0.05).abs() < 1e-6);
|
|
}
|
|
|
|
#[test]
|
|
fn cascade_step_fast_is_half_normal() {
|
|
let normal = cascade_step_secs(AnimSpeed::Normal);
|
|
let fast = cascade_step_secs(AnimSpeed::Fast);
|
|
assert!(
|
|
(fast - normal / 2.0).abs() < 1e-6,
|
|
"Fast cascade step must be half of Normal; normal={normal} fast={fast}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn cascade_step_instant_is_zero() {
|
|
assert_eq!(cascade_step_secs(AnimSpeed::Instant), 0.0);
|
|
}
|
|
|
|
#[test]
|
|
fn cascade_duration_normal_is_expected_value() {
|
|
assert!((cascade_duration_secs(AnimSpeed::Normal) - 0.5).abs() < 1e-6);
|
|
}
|
|
|
|
#[test]
|
|
fn cascade_duration_fast_is_half_normal() {
|
|
let normal = cascade_duration_secs(AnimSpeed::Normal);
|
|
let fast = cascade_duration_secs(AnimSpeed::Fast);
|
|
assert!(
|
|
(fast - normal / 2.0).abs() < 1e-6,
|
|
"Fast cascade duration must be half of Normal; normal={normal} fast={fast}"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn cascade_duration_instant_is_zero() {
|
|
assert_eq!(cascade_duration_secs(AnimSpeed::Instant), 0.0);
|
|
}
|
|
}
|