matrixr 1.1.0

Animated Matrix-style terminal screensaver
Documentation
use rand::SeedableRng;
use rand::rngs::SmallRng;

use super::{
    Charset, EngineFlags, MatrixState, TAIL_FADE_DISTANCE_LIMIT, VALUE_BAR, VALUE_DOT,
    VALUE_LAMBDA, VALUE_SPACE,
};

fn seeded_rng() -> SmallRng {
    SmallRng::seed_from_u64(42)
}

#[test]
fn initializes_with_minimum_dimensions_and_sentinels() {
    let mut rng = seeded_rng();
    let state = MatrixState::new(2, 2, &mut rng);
    assert_eq!(state.width(), 10);
    assert_eq!(state.height(), 10);
    for col in (0..state.width()).step_by(2) {
        assert_eq!(state.value_at(1, col), VALUE_SPACE);
    }
}

#[test]
fn asynchronous_mode_skips_tick_one_updates() {
    let mut rng = seeded_rng();
    let mut state = MatrixState::new(80, 24, &mut rng);
    let baseline = state.clone();
    let flags = EngineFlags {
        asynchronous: true,
        deep: false,
        old_style: false,
        dynamic_chars: false,
        paused: false,
    };

    state.step(1, &flags, Charset::from_modes(false, false), &mut rng);
    assert_eq!(state, baseline);
}

#[test]
fn paused_state_keeps_matrix_unchanged() {
    let mut rng = seeded_rng();
    let mut state = MatrixState::new(80, 24, &mut rng);
    let baseline = state.clone();
    let flags = EngineFlags {
        asynchronous: false,
        deep: false,
        old_style: false,
        dynamic_chars: true,
        paused: true,
    };

    state.step(4, &flags, Charset::from_modes(false, false), &mut rng);
    assert_eq!(state, baseline);
}

#[test]
fn old_style_converts_dot_head_into_bar() {
    let mut rng = seeded_rng();
    let mut state = MatrixState::new(80, 24, &mut rng);
    let flags = EngineFlags {
        asynchronous: false,
        deep: false,
        old_style: true,
        dynamic_chars: false,
        paused: false,
    };

    state.set_value(0, 0, VALUE_DOT);
    state.step(4, &flags, Charset::from_modes(false, false), &mut rng);
    assert_eq!(state.value_at(0, 0), VALUE_BAR);
}

#[test]
fn charset_changes_only_affect_symbols_generated_after_each_toggle() {
    let mut rng = seeded_rng();
    let mut state = MatrixState::new(10, 10, &mut rng);
    state.set_value(1, 0, 'A' as i32);
    let flags = EngineFlags {
        asynchronous: false,
        deep: false,
        old_style: false,
        dynamic_chars: false,
        paused: false,
    };

    state.step(4, &flags, Charset::from_modes(true, false), &mut rng);
    state.step(
        4,
        &flags,
        Charset::from_modes(false, false).with_lambda_mode(true),
        &mut rng,
    );
    state.step(4, &flags, Charset::from_modes(false, false), &mut rng);

    assert_eq!(state.value_at(1, 0), 'A' as i32);
    assert!((0xff66..0xff9d).contains(&state.value_at(2, 0)));
    assert_eq!(state.value_at(3, 0), VALUE_LAMBDA);
    assert!((33..123).contains(&state.value_at(4, 0)));
}

#[test]
fn deep_mode_uses_smooth_fractional_motion_for_three_depth_planes() {
    let mut rng = seeded_rng();
    let mut state = MatrixState::new(10, 10, &mut rng);
    for (column, plane) in [(0, 1), (2, 2), (4, 3)] {
        state.updates[column] = plane;
        state.deep_progress[column] = 0;
        state.spaces[column] = 10;
    }
    let flags = EngineFlags {
        asynchronous: false,
        deep: true,
        old_style: false,
        dynamic_chars: false,
        paused: false,
    };
    let charset = Charset::from_modes(false, false);
    let columns = [0, 2, 4];
    let mut movement = [[false; 6]; 3];

    for tick in 1..=6 {
        let before = columns.map(|column| state.spaces[column]);
        state.step(tick as u8, &flags, charset, &mut rng);
        for (plane, column) in columns.into_iter().enumerate() {
            movement[plane][tick - 1] = state.spaces[column] < before[plane];
        }
    }

    assert_eq!(movement[0], [true; 6]);
    assert_eq!(movement[1], [false, true, true, false, true, true]);
    assert_eq!(movement[2], [false, true, false, true, false, true]);
}

#[test]
fn tail_distance_tracks_the_head_and_caps_the_fade_scan() {
    let mut rng = seeded_rng();
    let mut state = MatrixState::new(10, 10, &mut rng);
    for row in 1..=8 {
        state.set_value(row, 0, ('A' as usize + row) as i32);
    }
    state.set_head(8, 0, true);

    assert_eq!(state.tail_distance_to_head(1, 0), TAIL_FADE_DISTANCE_LIMIT);
    assert_eq!(state.tail_distance_to_head(5, 0), 3);
    assert_eq!(state.tail_distance_to_head(6, 0), 2);
    assert_eq!(state.tail_distance_to_head(7, 0), 1);
    assert_eq!(state.tail_distance_to_head(8, 0), 0);
}