pite-script 0.3.0

Embedded Python 3.12 scripting bridge (PyO3) and game API for Pite.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99

// SPDX-License-Identifier: MIT OR Apache-2.0
use std::collections::HashSet;
use std::sync::{LazyLock, RwLock};

static INPUT: LazyLock<RwLock<InputState>> = LazyLock::new(|| RwLock::new(InputState::default()));

#[derive(Debug, Default)]
pub struct InputState {
    held: HashSet<String>,
    pressed: HashSet<String>,
    released: HashSet<String>,
    mouse: (f64, f64),
}

pub fn input_begin_frame() {
    let mut state = INPUT.write().unwrap();
    state.pressed.clear();
    state.released.clear();
}

/// Drop all key state (held + edges). The editor calls this on play/stop
/// transitions so a key held across the transition never sticks.
pub fn input_clear() {
    let mut state = INPUT.write().unwrap();
    state.held.clear();
    state.pressed.clear();
    state.released.clear();
}

pub fn input_set_key(name: &str, held: bool) {
    let mut state = INPUT.write().unwrap();
    if held && state.held.insert(name.to_string()) {
        state.pressed.insert(name.to_string());
    } else if !held && state.held.remove(name) {
        state.released.insert(name.to_string());
    }
}

pub fn input_set_mouse(x: f64, y: f64) {
    INPUT.write().unwrap().mouse = (x, y);
}

pub fn input_held(key: &str) -> bool {
    INPUT.read().unwrap().held.contains(key)
}

pub fn input_pressed(key: &str) -> bool {
    INPUT.read().unwrap().pressed.contains(key)
}

pub fn input_released(key: &str) -> bool {
    INPUT.read().unwrap().released.contains(key)
}

pub fn input_mouse() -> (f64, f64) {
    INPUT.read().unwrap().mouse
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn key_edges_last_one_frame() {
        let _guard = crate::host::HOST_SERIAL.lock().unwrap();
        input_begin_frame();
        input_set_key("T-KeyEdgesLastOneFrame", false);
        input_begin_frame();
        assert!(!input_held("T-KeyEdgesLastOneFrame"));
        input_set_key("T-KeyEdgesLastOneFrame", true);
        assert!(input_held("T-KeyEdgesLastOneFrame"));
        assert!(input_pressed("T-KeyEdgesLastOneFrame"));
        input_begin_frame();
        assert!(input_held("T-KeyEdgesLastOneFrame"));
        assert!(!input_pressed("T-KeyEdgesLastOneFrame"));
        input_set_key("T-KeyEdgesLastOneFrame", false);
        assert!(!input_held("T-KeyEdgesLastOneFrame"));
        assert!(input_released("T-KeyEdgesLastOneFrame"));
        input_begin_frame();
        assert!(!input_released("T-KeyEdgesLastOneFrame"));
    }

    #[test]
    fn clear_drops_held_and_edges() {
        let _guard = crate::host::HOST_SERIAL.lock().unwrap();
        input_begin_frame();
        input_set_key("T-ClearDropsState", true);
        assert!(input_held("T-ClearDropsState"));
        assert!(input_pressed("T-ClearDropsState"));
        input_clear();
        assert!(!input_held("T-ClearDropsState"));
        assert!(!input_pressed("T-ClearDropsState"));
        assert!(!input_released("T-ClearDropsState"));
        // Releasing after a clear must not resurrect a release edge.
        input_set_key("T-ClearDropsState", false);
        assert!(!input_released("T-ClearDropsState"));
        input_begin_frame();
    }
}