refactor led calculations

src/bomb.rs

@@ -0,0 +1,37 @@
+const BOMB_MAX_TIME: u64 = 40_000;
+const BOMB_BLINK_DURATION: u64 = 300;
+const BOMB_BLINK_SPEED: u64 = 700;
+
+pub struct Bomb {
+    last_up_planted: bool,
+    time_bomb_planted: u64,
+}
+
+impl Bomb {
+    pub fn new() -> Bomb{
+        Bomb {
+            last_up_planted: false,
+            time_bomb_planted: 0,
+        }
+    }
+
+    pub fn tick(&mut self, upstream: bool, delta_t: u64) -> u8 {
+        if upstream != self.last_up_planted {
+            // A bomb has been planted or defused reset the timer
+            self.time_bomb_planted = 0;
+            self.last_up_planted = upstream;
+        }
+
+        if upstream {
+            self.time_bomb_planted += delta_t;
+
+            let should_blink = (self.time_bomb_planted)
+                % (BOMB_BLINK_SPEED * (BOMB_MAX_TIME / self.time_bomb_planted).max(1))
+                < BOMB_BLINK_DURATION;
+
+            return if should_blink { 255 } else { 0 };
+        }
+
+        return 0;
+    }
+}

src/curves.rs

@@ -0,0 +1,12 @@
+
+pub fn qudratic_curve<T>(f64:x, f64:x2, f64: c) -> T 
+where T: Fn(f64) -> f64
+{
+    return |x| x2 * x.powi(2) + x * x + c;
+}
+
+pub fn cubic_bezier<T>(p1: (f64,f64),p2: (f64,f64)) -> T 
+where T: Fn(f64) -> f64
+{
+    return |x| (1.0 - x).powi(3) * p1.0 + 3.0 * (1.0 - x).powi(2) * x * p1.1 + 3.0 * (1.0 - x) * x.powi(2) * p2.0 + x.powi(3) * p2.1;
+}

src/flash.rs

@@ -0,0 +1,61 @@
+const FLASHED_X2: f64 = 0.00003113;
+const FLASHED_X1: f64 = -0.17396053;
+const FLASHED_X0: f64 = 244.51964267;
+
+fn interpolate_flashed(time: u64) -> u8 {
+    if time == 0 {
+        return 0;
+    }
+
+    let y = FLASHED_X2 * (time as f64).powi(2) + FLASHED_X1 * (time as f64) + FLASHED_X0;
+
+    return y.min(255.0).round() as u8;
+}
+
+fn resolve_time_from_flashed(flashed: u8) -> u64 {
+    let discriminant = FLASHED_X1.powi(2) - 4.0 * FLASHED_X2 * (FLASHED_X0 - flashed as f64);
+
+    let x = (-FLASHED_X1 - discriminant.sqrt()) / (2.0 * FLASHED_X2);
+    return x.min(5000.0) as u64;
+}
+
+pub struct Flash {
+    last_up_flashed: u8, // Used to detect changes in upstream flashed
+    time_since_last_flashed: u64,
+}
+
+impl Flash {
+    pub fn new() -> Flash {
+        Flash {
+            last_up_flashed: 0,
+            time_since_last_flashed: 0,
+        }
+    }
+
+    pub fn tick(&mut self, upstream: u8, delta_t: u64) -> u8 {
+        // Count the time since the flash started to fade
+        if upstream > 0 && upstream < 255 {
+            self.time_since_last_flashed += delta_t;
+        }
+
+        if upstream == self.last_up_flashed {
+            // Upstream value hasn't changed
+
+            if upstream == 255 {
+                // Flash is at max
+                return 255;
+            } else if upstream == 0 {
+                // Flash is off
+                return 0;
+            } else {
+                // Flash is fading
+                return interpolate_flashed(self.time_since_last_flashed);
+            }
+        }
+
+        // Upstream value has changed
+        self.time_since_last_flashed = resolve_time_from_flashed(upstream);
+        self.last_up_flashed = upstream;
+        return upstream;
+    }
+}

src/led.rs

@@ -0,0 +1,42 @@
+use super::{flash::Flash, bomb::Bomb,state::State};
+use std::{sync::atomic::Ordering, thread};
+
+fn build_led_package(len: u32, color: (u8, u8, u8)) -> Vec<u8> {
+    let mut packet: Vec<u8> = vec![1, 1];
+
+    // loop through leds
+    for i in 0..len {
+        packet.push(i as u8);
+        packet.push(color.0);
+        packet.push(color.1);
+        packet.push(color.2);
+    }
+
+    return packet;
+}
+
+pub fn led_loop(fps: u32, addr: &str, len: u32, state: State) -> ! {
+    let socket = std::net::UdpSocket::bind("0.0.0.0:0").unwrap();
+    let sleep_time: u64 = (1000 / fps).into();
+
+    let mut flash = Flash::new();
+    let mut bomb = Bomb::new();
+
+    loop {
+        thread::sleep(std::time::Duration::from_millis(sleep_time));
+
+        let upstream_flashed = u8::try_from(state.flashed.load(Ordering::Relaxed)).unwrap_or(0);
+        let interpolated_flashed = flash.tick(upstream_flashed, sleep_time);
+
+        let planted = state.bomb_planted.load(Ordering::Relaxed);
+        // let planted = true;
+        let bomb_blink = bomb.tick(planted, sleep_time);
+
+        // Merge flashed and bomb blink
+        let color = (interpolated_flashed.max(bomb_blink), interpolated_flashed, interpolated_flashed);
+
+        let packet = build_led_package(len, color);
+
+        socket.send_to(&packet, addr).unwrap();
+    }
+}

src/main.rs

@@ -1,32 +1,19 @@
 #[macro_use]
 extern crate rocket;
-use std::sync::atomic::AtomicBool;
-use std::sync::atomic::AtomicU16;
 use std::sync::atomic::Ordering;
-use std::sync::Arc;
 
 use rocket::serde::json::{json, Json, Value};
+use state::State;
 use std::thread;
 
 mod gamestate;
-
-#[derive(Clone)]
-struct State {
-    flashed: Arc<AtomicU16>,
-    bomb_planted: Arc<AtomicBool>,
-}
-
-impl State {
-    fn new() -> State {
-        State {
-            flashed: Arc::new(AtomicU16::new(0)),
-            bomb_planted: Arc::new(AtomicBool::new(false)),
-        }
-    }
-}
+mod led;
+mod state;
+mod flash;
+mod bomb;
 
 #[post("/gsi", data = "<data>")]
-fn gsi(data: Json<gamestate::GamestateData>, gobal_state: &rocket::State<State>) -> Value {
+fn gsi(data: Json<gamestate::GamestateData>, gobal_state: &rocket::State<state::State>) -> Value {
     let flashed = match &data.player {
         Some(player) => match &player.state {
             Some(state) => state.flashed,
@@ -53,20 +40,6 @@ fn gsi(data: Json<gamestate::GamestateData>, gobal_state: &rocket::State<State>)
     json!({ "status": "ok"})
 }
 
-fn build_led_package(len: u32, color: (u8, u8, u8)) -> Vec<u8> {
-    let mut packet: Vec<u8> = vec![1, 1];
-
-    // loop through leds
-    for i in 0..len {
-        packet.push(i as u8);
-        packet.push(color.0);
-        packet.push(color.1);
-        packet.push(color.2);
-    }
-
-    return packet;
-}
-
 #[launch]
 fn rocket() -> _ {
     let state: State = State::new();
@@ -74,26 +47,13 @@ fn rocket() -> _ {
     let addr = "192.168.0.59:21324";
 
     thread::spawn(move || {
-        let socket = std::net::UdpSocket::bind("0.0.0.0:0").unwrap();
-        loop {
-            thread::sleep(std::time::Duration::from_millis(50));
-
-            let flashed = u8::try_from(state_clone.flashed.load(Ordering::Relaxed)).unwrap_or(0);
-            if flashed > 0 {
-                let packet = build_led_package(36, (flashed, flashed, flashed));
-                socket.send_to(&packet, addr).unwrap();
-                continue;
-            }
-
-            let planted = state_clone.bomb_planted.load(Ordering::Relaxed);
-
-            if planted {
-                let packet = build_led_package(36, (255, 0, 0));
-                socket.send_to(&packet, addr).unwrap();
-                continue;
-            }
-        }
+        led::led_loop(30,addr,36, state_clone);
     });
 
-    rocket::build().manage(state).mount("/", routes![gsi])
+    let figment = rocket::figment::Figment::from(rocket::Config::default())
+        .merge(("log_level", "critical"));
+
+    rocket::custom(figment)
+        .manage(state)
+        .mount("/", routes![gsi])
 }

src/state.rs

@@ -0,0 +1,16 @@
+use std::sync::{atomic::{AtomicU16, AtomicBool}, Arc};
+
+#[derive(Clone)]
+pub struct State {
+    pub flashed: Arc<AtomicU16>,
+    pub bomb_planted: Arc<AtomicBool>,
+}
+
+impl State {
+    pub fn new() -> State {
+        State {
+            flashed: Arc::new(AtomicU16::new(0)),
+            bomb_planted: Arc::new(AtomicBool::new(false)),
+        }
+    }
+}