sim-logic 0.1.0

A code-first application and logic layer for Sim;Engine
Documentation
use std::{collections::HashSet, time::Duration};

use sim_logic::prelude::*;

use super::support::*;

#[test]
fn click_samples_retain_event_geometry_and_deliver_once_to_shared_fixed_snapshot() -> LogicResult {
    let mut application = application()?;
    application.add_fixed_system(observe_fixed);
    let initial = register_world(&mut application, "retained-click")?;
    let mut runner = application.build_headless(initial)?;
    let clicked = sample(200.0, 150.0, 800.0)?;
    let released = sample(300.0, 250.0, 900.0)?;
    let latest = sample(400.0, 350.0, 1_100.0)?;
    let following = sample(500.0, 450.0, 1_200.0)?;

    let first = advance(
        &mut runner,
        Duration::ZERO,
        &[
            InputEvent::pointer_moved(clicked),
            InputEvent::mouse_button(MouseButton::Left, ButtonState::Pressed),
            InputEvent::pointer_moved(released),
            InputEvent::mouse_button(MouseButton::Left, ButtonState::Released),
            InputEvent::pointer_moved(latest),
        ],
    )?;
    assert_eq!(first.fixed_ticks_attempted(), 0);
    let frame = probe(&runner)?.frames[0].clone();
    assert_eq!(frame.pointer, Some(latest));
    assert_eq!(frame.presses.len(), 1);
    assert_eq!(frame.releases.len(), 1);
    assert_eq!(frame.presses[0].pointer(), Some(clicked));
    assert_eq!(frame.releases[0].pointer(), Some(released));
    assert_ne!(frame.presses[0].intent(), frame.releases[0].intent());

    advance(&mut runner, Duration::ZERO, &[])?;
    assert_eq!(probe(&runner)?.frames[1].pointer, Some(latest));
    assert!(probe(&runner)?.frames[1].presses.is_empty());
    let catch_up = advance(
        &mut runner,
        FIXED_STEP * 3,
        &[InputEvent::pointer_moved(following)],
    )?;
    assert_eq!(catch_up.fixed_ticks_attempted(), 3);
    let observations = probe(&runner)?;
    assert_eq!(observations.fixed.len(), 6);
    for tick in observations.fixed.chunks_exact(2) {
        assert_eq!(
            tick[0], tick[1],
            "systems share the same immutable snapshot"
        );
        assert_eq!(tick[0].pointer, Some(following));
    }
    assert_eq!(observations.fixed[0].presses, frame.presses);
    assert_eq!(observations.fixed[0].releases, frame.releases);
    for snapshot in &observations.fixed[2..] {
        assert!(snapshot.presses.is_empty());
        assert!(snapshot.releases.is_empty());
    }
    Ok(())
}

#[test]
fn keyboard_and_mouse_share_held_state_but_preserve_independent_edges() -> LogicResult {
    let mut runner = runner()?;
    let pointer = sample(123.0, 234.0, 800.0)?;
    advance(
        &mut runner,
        FIXED_STEP,
        &[
            InputEvent::pointer_moved(pointer),
            InputEvent::key(PhysicalKeyCode::Space, ButtonState::Pressed),
            InputEvent::mouse_button(MouseButton::Left, ButtonState::Pressed),
            InputEvent::mouse_button(MouseButton::Left, ButtonState::Pressed),
        ],
    )?;
    let first = &probe(&runner)?.fixed[0];
    assert!(first.held);
    assert_eq!(first.presses.len(), 2);
    assert_eq!(first.presses[0].pointer(), None);
    assert_eq!(first.presses[1].pointer(), Some(pointer));
    assert_ne!(first.presses[0].intent(), first.presses[1].intent());

    advance(&mut runner, FIXED_STEP, &[InputEvent::PointerLeft])?;
    let leaving = &probe(&runner)?.fixed[1];
    assert_eq!(leaving.pointer, None);
    assert!(leaving.held, "the keyboard still holds the shared action");
    assert_eq!(leaving.releases.len(), 1);
    assert_eq!(leaving.releases[0].pointer(), None);
    advance(&mut runner, FIXED_STEP, &[InputEvent::PointerLeft])?;
    assert!(probe(&runner)?.fixed[2].releases.is_empty());

    advance(
        &mut runner,
        FIXED_STEP,
        &[InputEvent::key(
            PhysicalKeyCode::Space,
            ButtonState::Released,
        )],
    )?;
    let released = &probe(&runner)?.fixed[3];
    assert!(!released.held);
    assert_eq!(released.releases.len(), 1);
    assert_eq!(released.releases[0].pointer(), None);
    Ok(())
}

#[test]
fn button_without_known_position_is_valid_and_duplicate_binding_preserves_original() -> LogicResult
{
    let mut application = application()?;
    let duplicate = application
        .bind_mouse_button(MouseButton::Left, TestAction::Pause)
        .err()
        .ok_or("duplicate mouse binding should fail")?;
    assert_eq!(duplicate.button(), MouseButton::Left);
    let initial = register_world(&mut application, "unknown-position")?;
    let mut runner = application.build_headless(initial)?;
    advance(
        &mut runner,
        FIXED_STEP,
        &[InputEvent::mouse_button(
            MouseButton::Left,
            ButtonState::Pressed,
        )],
    )?;
    let snapshot = &probe(&runner)?.fixed[0];
    assert_eq!(snapshot.pointer, None);
    assert_eq!(snapshot.presses.len(), 1);
    assert_eq!(snapshot.presses[0].pointer(), None);
    assert!(!runner.is_paused());
    Ok(())
}

#[test]
fn pause_keeps_latest_position_and_held_button_without_replaying_discarded_clicks() -> LogicResult {
    let mut runner = runner()?;
    let before_pause = sample(100.0, 200.0, 800.0)?;
    let during_pause = sample(300.0, 400.0, 900.0)?;
    advance(
        &mut runner,
        Duration::ZERO,
        &[
            InputEvent::pointer_moved(before_pause),
            InputEvent::mouse_button(MouseButton::Left, ButtonState::Pressed),
            InputEvent::key(PhysicalKeyCode::Enter, ButtonState::Pressed),
        ],
    )?;
    assert!(runner.is_paused());
    let paused = advance(
        &mut runner,
        FIXED_STEP * 3,
        &[
            InputEvent::pointer_moved(during_pause),
            InputEvent::mouse_button(MouseButton::Left, ButtonState::Released),
            InputEvent::mouse_button(MouseButton::Left, ButtonState::Pressed),
        ],
    )?;
    assert_eq!(paused.fixed_ticks_attempted(), 0);
    assert_eq!(probe(&runner)?.frames[1].pointer, Some(during_pause));
    assert_eq!(probe(&runner)?.frames[1].presses.len(), 1);
    advance(
        &mut runner,
        Duration::ZERO,
        &[
            InputEvent::key(PhysicalKeyCode::Enter, ButtonState::Released),
            InputEvent::key(PhysicalKeyCode::Enter, ButtonState::Pressed),
        ],
    )?;
    assert!(!runner.is_paused());
    advance(&mut runner, FIXED_STEP, &[])?;
    let resumed = &probe(&runner)?.fixed[0];
    assert_eq!(resumed.pointer, Some(during_pause));
    assert!(resumed.held);
    assert!(resumed.presses.is_empty());
    assert!(resumed.releases.is_empty());
    Ok(())
}

#[test]
fn replacement_preserves_pointer_and_held_state_but_retires_click_edges() -> LogicResult {
    let mut application = application()?;
    let target = register_world(&mut application, "target")?;
    application.add_fallible_frame_system(
        move |input: FrameInput<TestAction>, mut commands: Commands| -> LogicResult {
            if let Some(edge) = input.pressed(TestAction::Replace).next() {
                commands.replace_world(edge.intent(), target)?;
            }
            Ok(())
        },
    );
    let initial = register_world(&mut application, "source")?;
    let mut runner = application.build_headless(initial)?;
    let clicked = sample(110.0, 220.0, 800.0)?;
    let pointer = sample(330.0, 440.0, 900.0)?;
    let replacement = advance(
        &mut runner,
        Duration::ZERO,
        &[
            InputEvent::pointer_moved(clicked),
            InputEvent::mouse_button(MouseButton::Left, ButtonState::Pressed),
            InputEvent::pointer_moved(pointer),
            InputEvent::key(PhysicalKeyCode::Escape, ButtonState::Pressed),
        ],
    )?;
    assert!(matches!(
        replacement.transition(),
        FrameTransition::Committed { .. }
    ));
    assert_eq!(runner.active_world_name(), "target");
    assert_eq!(
        probe(&runner)?.frames[0].presses[0].pointer(),
        Some(clicked)
    );
    advance(&mut runner, FIXED_STEP, &[])?;
    let target_tick = &probe(&runner)?.fixed[0];
    assert_eq!(target_tick.pointer, Some(pointer));
    assert!(target_tick.held);
    assert!(target_tick.presses.is_empty());
    assert!(target_tick.releases.is_empty());
    assert_eq!(probe(&runner)?.frames[1].pointer, Some(pointer));
    Ok(())
}

#[test]
fn finite_pointer_samples_preserve_outside_coordinates_and_lawful_event_hashing() -> LogicResult {
    let viewport = LogicalViewport::new(800.0, 600.0)?;
    for invalid in [f32::NAN, f32::INFINITY, f32::NEG_INFINITY] {
        assert!(PointerSample::new(LogicalScreenPosition::new(invalid, 0.0), viewport).is_err());
        assert!(PointerSample::new(LogicalScreenPosition::new(0.0, invalid), viewport).is_err());
    }
    let outside = sample(-100.0, 700.0, 800.0)?;
    assert_eq!(
        outside.position(),
        LogicalScreenPosition::new(-100.0, 700.0)
    );
    assert_eq!(outside.viewport(), viewport);
    let positive_zero = InputEvent::pointer_moved(sample(0.0, 0.0, 800.0)?);
    let negative_zero = InputEvent::pointer_moved(sample(-0.0, -0.0, 800.0)?);
    assert_eq!(positive_zero, negative_zero);
    let unique = HashSet::from([positive_zero, negative_zero]);
    assert_eq!(unique.len(), 1);
    Ok(())
}

#[test]
fn world_conversion_uses_selected_camera_and_propagates_engine_projection_errors() -> LogicResult {
    let pointer = sample(600.0, 450.0, 800.0)?;
    let mut camera = Camera2d::new(Vec2::new(2.0, 3.0), 20.0)?;
    assert_eq!(pointer.world_position(camera)?, Vec2::new(12.0, -4.5));
    camera.set_rotation(0.4)?;
    camera.set_projection(sim_engine::Projection2d::new(0.6, 1.25)?);
    let world = Vec2::new(-4.0, 7.0);
    let projected = camera.projected_world_to_screen(world, 0.0, pointer.viewport())?;
    let rotated = PointerSample::new(projected, pointer.viewport())?.world_position(camera)?;
    assert!((rotated.x() - world.x()).abs() < 0.0001);
    assert!((rotated.y() - world.y()).abs() < 0.0001);

    camera.set_projection(sim_engine::Projection2d::new(
        std::f32::consts::FRAC_PI_2,
        1.0,
    )?);
    let error = pointer.world_position(camera);
    assert!(matches!(
        error,
        Err(Camera2dError::SingularProjection { .. })
    ));
    assert_eq!(
        error,
        camera.screen_to_world(pointer.position(), pointer.viewport())
    );
    Ok(())
}