Skip to main content

wackasm_opencomputers/
signal.rs

1//! Events: key presses, screen touches, network messages, components
2//! appearing, and so on. OpenComputers queues them per computer.
3
4use std::time::Duration;
5
6use crate::{
7    component::Address,
8    sys,
9    value::{Number, Value},
10};
11
12/// A signal, decoded when it is one of OpenComputers' standard ones.
13#[derive(Clone, Debug, PartialEq)]
14pub enum Signal {
15    KeyDown { keyboard: Address, char: u32, code: u32, player: String },
16    KeyUp { keyboard: Address, char: u32, code: u32, player: String },
17    Clipboard { keyboard: Address, text: String, player: String },
18    Touch { screen: Address, x: Number, y: Number, button: i64, player: String },
19    Drag { screen: Address, x: Number, y: Number, button: i64, player: String },
20    Drop { screen: Address, x: Number, y: Number, button: i64, player: String },
21    Scroll { screen: Address, x: Number, y: Number, direction: i64, player: String },
22    Walk { screen: Address, x: Number, y: Number, player: Option<String> },
23    ComponentAdded { address: Address, kind: String },
24    ComponentRemoved { address: Address, kind: String },
25    ComponentAvailable { kind: String },
26    ComponentUnavailable { kind: String },
27    RedstoneChanged { address: Address, side: i64, old: i64, new: i64, color: Option<i64> },
28    Motion { address: Address, x: Number, y: Number, z: Number, entity: Option<String> },
29    ModemMessage { receiver: Address, sender: Address, port: i64, distance: Number, data: Vec<Value> },
30    InventoryChanged { slot: i64 },
31    /// A Computer Pattern Provider (AE2) was handed the inputs for a job;
32    /// see [`crate::pattern_provider`]. `pattern` is the pattern's index, from 1.
33    PatternRequest { provider: Address, job: i64, pattern: i64 },
34    /// Anything else, as sent.
35    Other { name: String, args: Vec<Value> },
36}
37
38impl Signal {
39    /// Decodes `[name, args...]`.
40    pub fn parse(name: String, args: Vec<Value>) -> Signal {
41        Self::typed(&name, &args).unwrap_or(Signal::Other { name, args })
42    }
43
44    fn typed(name: &str, a: &[Value]) -> Option<Signal> {
45        let s = |i: usize| a.get(i)?.as_str().map(str::to_owned);
46        let addr = |i: usize| s(i).map(Address);
47        let n = |i: usize| a.get(i)?.as_number();
48        let int = |i: usize| n(i).map(Number::as_i64);
49        let ch = |i: usize| n(i).map(Number::as_u32);
50        Some(match name {
51            "key_down" => Signal::KeyDown { keyboard: addr(0)?, char: ch(1)?, code: ch(2)?, player: s(3)? },
52            "key_up" => Signal::KeyUp { keyboard: addr(0)?, char: ch(1)?, code: ch(2)?, player: s(3)? },
53            "clipboard" => Signal::Clipboard { keyboard: addr(0)?, text: s(1)?, player: s(2)? },
54            "touch" => Signal::Touch { screen: addr(0)?, x: n(1)?, y: n(2)?, button: int(3)?, player: s(4)? },
55            "drag" => Signal::Drag { screen: addr(0)?, x: n(1)?, y: n(2)?, button: int(3)?, player: s(4)? },
56            "drop" => Signal::Drop { screen: addr(0)?, x: n(1)?, y: n(2)?, button: int(3)?, player: s(4)? },
57            "scroll" => Signal::Scroll { screen: addr(0)?, x: n(1)?, y: n(2)?, direction: int(3)?, player: s(4)? },
58            "walk" => Signal::Walk { screen: addr(0)?, x: n(1)?, y: n(2)?, player: s(3) },
59            "component_added" => Signal::ComponentAdded { address: addr(0)?, kind: s(1)? },
60            "component_removed" => Signal::ComponentRemoved { address: addr(0)?, kind: s(1)? },
61            "component_available" => Signal::ComponentAvailable { kind: s(0)? },
62            "component_unavailable" => Signal::ComponentUnavailable { kind: s(0)? },
63            "redstone_changed" => Signal::RedstoneChanged {
64                address: addr(0)?,
65                side: int(1)?,
66                old: int(2)?,
67                new: int(3)?,
68                color: int(4),
69            },
70            "motion" => Signal::Motion { address: addr(0)?, x: n(1)?, y: n(2)?, z: n(3)?, entity: s(4) },
71            "modem_message" => Signal::ModemMessage {
72                receiver: addr(0)?,
73                sender: addr(1)?,
74                port: int(2)?,
75                distance: n(3)?,
76                data: a.get(4..).unwrap_or_default().to_vec(),
77            },
78            "inventory_changed" => Signal::InventoryChanged { slot: int(0)? },
79            "pattern_request" => Signal::PatternRequest { provider: addr(0)?, job: int(1)?, pattern: int(2)? },
80            _ => return None,
81        })
82    }
83
84    /// The typed key press, if this is one: `(char, code)`.
85    pub fn key_down(&self) -> Option<(char, u32)> {
86        match self {
87            Signal::KeyDown { char, code, .. } => Some((char::from_u32(*char).unwrap_or('\0'), *code)),
88            _ => None,
89        }
90    }
91}
92
93/// Waits for the next signal. `None` waits forever; a timeout that passes
94/// returns `None`.
95pub fn pull(timeout: Option<Duration>) -> Option<Signal> {
96    let ms = timeout.map_or(-1, |t| t.as_millis().min(i64::MAX as u128) as i64);
97    if unsafe { sys::pull_signal_ms(ms) } != sys::STATUS_OK {
98        return None;
99    }
100    match Value::decode(&sys::response()) {
101        Some(Value::Array(mut items)) if !items.is_empty() => {
102            let name = match items.remove(0) {
103                Value::String(s) => s.to_string_lossy(),
104                _ => return None,
105            };
106            Some(Signal::parse(name, items))
107        }
108        _ => None,
109    }
110}
111
112/// Waits for a signal that `filter` accepts, discarding others, until the
113/// timeout (if any) runs out.
114pub fn pull_filtered(timeout: Option<Duration>, mut filter: impl FnMut(&Signal) -> bool) -> Option<Signal> {
115    let deadline = timeout.map(|t| crate::computer::uptime() + t);
116    loop {
117        let left = match deadline {
118            Some(d) => Some(d.checked_sub(crate::computer::uptime())?),
119            None => None,
120        };
121        let signal = pull(left)?;
122        if filter(&signal) {
123            return Some(signal);
124        }
125    }
126}
127
128/// Queues a signal on this computer. `false` if the queue is full.
129pub fn push(name: &str, args: Vec<Value>) -> bool {
130    let mut signal = vec![Value::from(name)];
131    signal.extend(args);
132    let bytes = Value::Array(signal).encode();
133    unsafe { sys::push_signal(bytes.as_ptr(), bytes.len()) == sys::STATUS_OK }
134}