rayengine-core 0.0.3

Display-independent game primitives for rayengine
Documentation
use super::*;

fn region() -> SpriteRegion {
    SpriteRegion::new(4, 8, 16, 12).unwrap()
}
fn clip(mode: PlaybackMode) -> Arc<AnimationClip> {
    Arc::new(
        AnimationClip::new(
            "walk",
            [100, 200, 300]
                .into_iter()
                .map(|ms| SpriteFrame {
                    region: region(),
                    duration: Duration::from_millis(ms),
                })
                .collect(),
            mode,
        )
        .unwrap(),
    )
}

#[test]
fn regions_validate_dimensions_overflow_and_texture_edges() {
    for (x, y, w, h) in [
        (0, 0, 0, 1),
        (0, 0, 1, 0),
        (u32::MAX, 0, 1, 1),
        (0, u32::MAX, 1, 1),
    ] {
        assert_eq!(
            SpriteRegion::new(x, y, w, h),
            Err(SpriteError::InvalidRegion)
        );
    }
    let r = region();
    assert!(r.fits(20, 20));
    assert!(!r.fits(19, 20));
    assert!(!r.fits(20, 19));
    assert!(!r.fits(0, 0));
}

#[test]
fn clips_reject_blank_empty_zero_and_overflowing_timing() {
    assert_eq!(
        AnimationClip::new(" \n", vec![], PlaybackMode::Loop).unwrap_err(),
        SpriteError::EmptyName
    );
    assert_eq!(
        AnimationClip::new("idle", vec![], PlaybackMode::Loop).unwrap_err(),
        SpriteError::EmptyClip
    );
    let frame = SpriteFrame {
        region: region(),
        duration: Duration::ZERO,
    };
    assert_eq!(
        AnimationClip::new("idle", vec![frame], PlaybackMode::Once).unwrap_err(),
        SpriteError::ZeroDuration
    );
    let frames = vec![
        SpriteFrame {
            duration: Duration::MAX,
            ..frame
        },
        SpriteFrame {
            duration: Duration::from_nanos(1),
            ..frame
        },
    ];
    assert_eq!(
        AnimationClip::new("idle", frames, PlaybackMode::Loop).unwrap_err(),
        SpriteError::DurationOverflow
    );
}

#[test]
fn variable_timing_exact_boundaries_and_multiple_loops() {
    let mut p = AnimationPlayer::new(clip(PlaybackMode::Loop));
    assert_eq!(p.frame_index(), 0);
    assert!(p.advance(Duration::from_millis(100)).is_none());
    assert_eq!(p.frame_index(), 1);
    p.advance(Duration::from_millis(199));
    assert_eq!(p.frame_index(), 1);
    p.advance(Duration::from_millis(1));
    assert_eq!(p.frame_index(), 2);
    p.advance(Duration::from_millis(300));
    assert_eq!(p.frame_index(), 0);
    assert_eq!(p.elapsed(), Duration::ZERO);
    p.advance(Duration::from_millis(600 * 10_000 + 350));
    assert_eq!(p.frame_index(), 2);
    assert_eq!(p.elapsed(), Duration::from_millis(350));
    assert!(!p.is_finished());
}

#[test]
fn one_shot_holds_last_frame_and_completes_only_once_until_reset() {
    for dt in [Duration::from_millis(600), Duration::MAX] {
        let mut p = AnimationPlayer::new(clip(PlaybackMode::Once));
        let event = p.advance(dt).unwrap();
        assert_eq!(event.clip.name(), "walk");
        assert!(Arc::ptr_eq(&event.clip, p.clip()));
        assert!(p.is_finished());
        assert_eq!(p.frame_index(), 2);
        assert_eq!(p.elapsed(), p.clip().duration());
        assert!(p.advance(Duration::MAX).is_none());
        p.pause();
        p.resume();
        assert!(p.advance(dt).is_none());
        p.reset();
        assert!(!p.is_finished());
        assert_eq!(p.frame_index(), 0);
        assert!(p.advance(dt).is_some());
    }
}

#[test]
fn pause_resume_reset_and_play_have_explicit_state() {
    let mut p = AnimationPlayer::new(clip(PlaybackMode::Once));
    p.advance(Duration::from_millis(120));
    p.pause();
    assert!(p.advance(Duration::MAX).is_none());
    assert_eq!(p.elapsed(), Duration::from_millis(120));
    p.resume();
    p.advance(Duration::from_millis(180));
    assert_eq!(p.frame_index(), 2);
    p.pause();
    p.reset();
    assert!(p.is_paused());
    assert_eq!(p.elapsed(), Duration::ZERO);
    p.play(clip(PlaybackMode::Loop));
    assert!(!p.is_paused());
    assert!(!p.is_finished());
    assert_eq!(p.frame_index(), 0);
}

#[test]
fn huge_time_steps_and_single_nanosecond_frames_do_not_overflow() {
    let tiny = AnimationClip::new(
        "tiny",
        vec![SpriteFrame {
            region: region(),
            duration: Duration::from_nanos(1),
        }],
        PlaybackMode::Loop,
    )
    .unwrap();
    let mut p = AnimationPlayer::new(tiny);
    assert!(p.advance(Duration::MAX).is_none());
    assert_eq!(p.elapsed(), Duration::ZERO);
    assert_eq!(p.frame_index(), 0);
    let long = AnimationClip::new(
        "long",
        vec![SpriteFrame {
            region: region(),
            duration: Duration::MAX,
        }],
        PlaybackMode::Loop,
    )
    .unwrap();
    p.play(long);
    p.advance(Duration::MAX - Duration::from_nanos(1));
    p.advance(Duration::MAX);
    assert_eq!(p.elapsed(), Duration::MAX - Duration::from_nanos(1));
}

#[test]
fn reads_are_inert_and_shared_players_are_independent() {
    let clip = clip(PlaybackMode::Loop);
    let mut a = AnimationPlayer::new(Arc::clone(&clip));
    let b = AnimationPlayer::new(clip);
    a.advance(Duration::from_millis(350));
    for _ in 0..100 {
        assert_eq!(a.frame_index(), 2);
        assert_eq!(a.frame().region, region());
    }
    assert_eq!(a.elapsed(), Duration::from_millis(350));
    assert_eq!(b.frame_index(), 0);
    assert_eq!(b.elapsed(), Duration::ZERO);
    assert!(a.advance(Duration::ZERO).is_none());
    assert_eq!(a.frame_index(), 2);
}

#[test]
fn transforms_require_finite_geometry_and_positive_size() {
    assert!(SpriteTransform::default().is_valid());
    assert!(
        SpriteTransform {
            origin: Vec2::splat(-100.0),
            flip_x: true,
            flip_y: true,
            ..SpriteTransform::default()
        }
        .is_valid()
    );
    for t in [
        SpriteTransform {
            size: Vec2::ZERO,
            ..SpriteTransform::default()
        },
        SpriteTransform {
            size: Vec2::new(-1.0, 1.0),
            ..SpriteTransform::default()
        },
        SpriteTransform {
            size: Vec2::splat(f32::NAN),
            ..SpriteTransform::default()
        },
        SpriteTransform {
            position: Vec2::splat(f32::INFINITY),
            ..SpriteTransform::default()
        },
        SpriteTransform {
            origin: Vec2::splat(f32::NAN),
            ..SpriteTransform::default()
        },
        SpriteTransform {
            rotation: f32::NAN,
            ..SpriteTransform::default()
        },
        SpriteTransform {
            rotation: f32::MAX,
            ..SpriteTransform::default()
        },
    ] {
        assert!(!t.is_valid());
    }
}