computercraft_websocket_control 0.1.1

a crate which aims to control Computer Craft computers via websocket
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

#![allow(unused)]
use std::time::{Duration, Instant};

use computercraft_websocket_control::{ColorId, Ports, Side, ToErrorsResult};
use futures::future::join_all;
use tokio::time::sleep;

async fn tick(
    state: &mut f32,
    ports: Ports<'_>,
    dt: Duration,
) -> Result<(), computercraft_websocket_control::Errors> {
    // tokio::time::sleep(Duration::from_secs_f32((1.0 - dt.as_secs_f32()).max(0.))).await;

    // println!("{:?}", dt);
    let mut ports = ports.all_ports();

    let a = join_all(ports.iter_mut().map(|(_id, p)| p.get_redstone(Side::Left)))
        .await
        .into_iter()
        .collect::<Result<Vec<_>, _>>()?;
    join_all(
        ports
            .iter_mut()
            .enumerate()
            .map(|(id, (_id, p))| p.set_redstone(Side::Right, (a[id] + 1).min(15))),
    )
    .await
    .into_iter()
    .collect::<Result<_, _>>()?;

    *state += dt.as_secs_f32() * 4.;
    while *state > 31. {
        *state -= 31.;
    }

    let rs_level = if *state < 16. {
        *state as i32
    } else {
        (31. - *state) as i32
    };

    let mut futs = Vec::new();
    for (_id, ws) in &mut ports {
        let fut = ws.set_redstone(Side::Front, rs_level);
        // dbg!(std::mem::size_of_val(&fut));
        futs.push(fut);
    }
    let rtn = futures::future::join_all(futs).await;
    for r in rtn {
        r?;
    }

    let mut futs = Vec::new();
    for (_id, ws) in &mut ports {
        let fut = ws.gps_locate();
        // dbg!(std::mem::size_of_val(&fut));
        futs.push(fut);
    }
    let rtn = futures::future::join_all(futs).await;
    for r in rtn {
        r?;
    }

    Ok(())
}

async fn tick1(
    state: &mut (),
    ports: Ports<'_>,
    dt: Duration,
) -> Result<(), computercraft_websocket_control::Errors> {
    let mut ports = ports.all_ports();
    // dbg!(ports.len());
    for (id, p) in &mut ports {
        // if let Ok(msg) = p.get_peripheral(Side::Top).await {
        //     dbg!(msg);
        // }
        // dbg!(
        //     p.monitor_write(Side::Top, 5, 5, ColorId::C04, ColorId::C05, "ads")
        //         .await
        // );

        dbg!(p.monitor_get_size(Side::Top).await);
    }
    // dbg!();
    Ok(())
}

async fn tick3(
    state: &mut Instant,
    mut ports: Ports<'_>,
    dt: Duration,
) -> Result<(), computercraft_websocket_control::Errors> {
    dbg!(ports.len());
    sleep(Duration::from_secs_f32(1.0)).await;
    let mut t = *state;
    let mut p1 = ports.get_port("p1").to_errors_result()?;

    let mut counter = 0;

    if t.elapsed().as_secs_f32() > 2.0 {
        let (xmax, ymax) = p1.monitor_get_size(Side::Top).await?.to_errors_result()?;
        for x in 1..=xmax {
            for y in 1..=ymax {
                if counter > 100 {
                    sleep(Duration::from_secs_f32(0.04)).await;
                    counter = 0;
                }
                counter += 1;
                p1.monitor_write(
                    Side::Top,
                    x,
                    y,
                    ColorId::LightBlue,
                    ColorId::Blue,
                    ' '.into(),
                )
                .await?;
            }
        }
        t = Instant::now();
    }

    *state = t;
    Ok(())
}

fn main() {}