sim-logic 0.1.0

A code-first application and logic layer for Sim;Engine
Documentation
use std::time::Duration;

use sim_logic::prelude::*;

use super::support::*;

#[test]
fn zero_tick_gesture_clicks_once_and_fixed_retention_remains_independently_visible() -> LogicResult
{
    let mut runner = runner(false)?;
    advance(&mut runner, Duration::ZERO, &[motion(20.0, 30.0)?, press()])?;
    assert_eq!(captured(&runner)?, Some(Target::First));
    advance(&mut runner, Duration::ZERO, &[])?;
    assert_eq!(captured(&runner)?, Some(Target::First));
    advance(&mut runner, Duration::ZERO, &[release()])?;
    assert!(probe(&runner)?.fixed.is_empty());
    let expected = events(&runner)?;
    assert_eq!(
        expected,
        [
            (EventKind::Pressed, Target::First),
            (EventKind::Clicked, Target::First),
        ]
    );
    let press = probe(&runner)?.frames[0][0].edge;
    let release = probe(&runner)?.frames[2][0].edge;
    let report = advance(&mut runner, STEP * 3, &[])?;
    assert_eq!(report.fixed_ticks_attempted(), 3);
    assert_eq!(probe(&runner)?.fixed[0], [press, release]);
    assert!(probe(&runner)?.fixed[1..].iter().all(Vec::is_empty));
    assert_eq!(events(&runner)?, expected);
    assert!(frame(&runner)?.is_empty());
    Ok(())
}

#[test]
fn frame_claims_do_not_consume_fixed_edges_that_ran_before_the_ui() -> LogicResult {
    let mut runner = runner(false)?;
    advance(
        &mut runner,
        STEP,
        &[motion(20.0, 30.0)?, press(), release()],
    )?;
    assert!(frame(&runner)?.iter().all(|entry| entry.claimed));
    assert_eq!(probe(&runner)?.fixed[0].len(), 2);
    assert_eq!(probe(&runner)?.fixed[0][0], frame(&runner)?[0].edge);
    assert_eq!(probe(&runner)?.fixed[0][1], frame(&runner)?[1].edge);
    assert_eq!(probe(&runner)?.background_presses, 0);
    assert_eq!(probe(&runner)?.background_releases, 0);
    Ok(())
}

#[test]
fn pause_preserves_frame_capture_and_cancellation_without_replaying_fixed_input() -> LogicResult {
    let mut runner = runner(false)?;
    advance(&mut runner, Duration::ZERO, &[motion(20.0, 30.0)?, press()])?;
    runner.set_paused(true);
    advance(&mut runner, STEP * 3, &[release()])?;
    assert_eq!(
        frame(&runner)?[0].event.ok_or("paused click missing")?.kind,
        EventKind::Clicked
    );
    advance(&mut runner, STEP, &[press(), InputEvent::FocusLost])?;
    assert_eq!(
        frame(&runner)?[1]
            .event
            .ok_or("paused cancellation missing")?
            .kind,
        EventKind::InputCancelled(InputCancellationReason::FocusLost)
    );
    assert_eq!(captured(&runner)?, None);
    assert!(probe(&runner)?.fixed.is_empty());
    let expected = events(&runner)?;
    runner.set_paused(false);
    advance(&mut runner, STEP, &[])?;
    assert_eq!(probe(&runner)?.fixed.len(), 1);
    assert!(probe(&runner)?.fixed[0].is_empty());
    assert_eq!(events(&runner)?, expected);
    Ok(())
}

#[test]
fn world_local_capture_is_recreated_and_an_old_held_release_cannot_click_a_reused_target()
-> LogicResult {
    let mut app = application()?;
    let target = register_world(&mut app, "after-replacement", false)?;
    app.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 app, "before-replacement", false)?;
    let mut runner = app.build_headless(initial)?;
    let generation = runner.world_generation();
    advance(&mut runner, Duration::ZERO, &[motion(20.0, 30.0)?, press()])?;
    assert_eq!(captured(&runner)?, Some(Target::First));
    let replacement = advance(
        &mut runner,
        Duration::ZERO,
        &[key(PhysicalKeyCode::Escape, ButtonState::Pressed)],
    )?;
    assert!(
        matches!(replacement.transition(), FrameTransition::Committed { target: committed, .. } if *committed == target)
    );
    assert_ne!(runner.world_generation(), generation);
    assert_eq!(captured(&runner)?, None);
    assert_eq!(events(&runner)?, [(EventKind::Pressed, Target::First)]);

    advance(&mut runner, STEP, &[release()])?;
    let unmatched = frame(&runner)?[0];
    assert!(!unmatched.claimed);
    assert_eq!(unmatched.event, None);
    assert_eq!(captured(&runner)?, None);
    assert_eq!(probe(&runner)?.fixed[0], [unmatched.edge]);
    advance(&mut runner, STEP, &[press(), release()])?;
    assert_eq!(
        events(&runner)?,
        [
            (EventKind::Pressed, Target::First),
            (EventKind::Pressed, Target::First),
            (EventKind::Clicked, Target::First),
        ]
    );
    Ok(())
}

struct PersistentInteraction {
    button: PointerButton<Target>,
    cancelled_at_boundary: Option<Target>,
    releases: Vec<(bool, bool)>,
}

#[test]
fn application_owned_capture_can_suppress_the_old_release_across_world_replacement() -> LogicResult
{
    let mut app = application()?;
    app.register_app_resource(PersistentInteraction {
        button: PointerButton::new(MouseButton::Left),
        cancelled_at_boundary: None,
        releases: Vec::new(),
    })?;
    let target = register_world(&mut app, "persistent-after", false)?;
    app.add_fallible_frame_system(
        move |input: FrameInput<TestAction>,
              mut persistent: AppResMut<PersistentInteraction>,
              mut commands: Commands|
              -> LogicResult {
            for edge in input.edges() {
                if edge.action() == TestAction::Replace && edge.state() == ButtonState::Pressed {
                    persistent.cancelled_at_boundary = persistent.button.cancel();
                    commands.replace_world(edge.intent(), target)?;
                }
                let outcome = persistent.button.process(edge, Some(Target::First));
                if edge.control() == InputControl::MouseButton(MouseButton::Left)
                    && edge.state() == ButtonState::Released
                {
                    persistent.releases.push((
                        outcome.claimed(),
                        matches!(outcome.event(), Some(PointerButtonEvent::Clicked { .. })),
                    ));
                }
            }
            Ok(())
        },
    );
    let initial = register_world(&mut app, "persistent-before", false)?;
    let mut runner = app.build_headless(initial)?;
    advance(
        &mut runner,
        Duration::ZERO,
        &[
            motion(20.0, 30.0)?,
            press(),
            key(PhysicalKeyCode::Escape, ButtonState::Pressed),
        ],
    )?;
    assert_eq!(runner.active_world_name(), "persistent-after");
    let persistent = runner
        .app_resource::<PersistentInteraction>()
        .ok_or("persistent interaction missing")?;
    assert_eq!(persistent.cancelled_at_boundary, Some(Target::First));
    assert_eq!(persistent.button.captured(), None);
    advance(&mut runner, STEP, &[release(), press(), release()])?;
    let persistent = runner
        .app_resource::<PersistentInteraction>()
        .ok_or("persistent interaction missing")?;
    assert_eq!(persistent.releases, [(true, false), (true, true)]);
    Ok(())
}