Rotate the right side

The actual bike is going to be a long loop which folds from the end of
the left side to the back end of the right side. This requires that the
colors get moved around for proper mirroring.

bike-lights/core/src/lib.rs

@@ -132,7 +132,12 @@ pub enum FadeDirection {
     FadeOut,
 }
 
-pub struct LeftBlinker {
+pub enum BlinkerDirection {
+    Left,
+    Right,
+}
+
+pub struct Blinker {
     fade_in: Fade,
     fade_out: Fade,
     direction: FadeDirection,
@@ -141,31 +146,53 @@ pub struct LeftBlinker {
     frames: u8,
 }
 
-impl LeftBlinker {
+impl Blinker {
     fn new(
         starting_dashboard: DashboardPattern,
         starting_body: Pattern,
+        direction: BlinkerDirection,
         time: std::time::Instant,
     ) -> Self {
         let mut ending_dashboard = starting_dashboard.clone();
+
+        match direction {
+            BlinkerDirection::Left => {
                 ending_dashboard[0].r = LEFT_DASHBOARD[0].r;
                 ending_dashboard[0].g = LEFT_DASHBOARD[0].g;
                 ending_dashboard[0].b = LEFT_DASHBOARD[0].b;
+            }
+            BlinkerDirection::Right => {
+                ending_dashboard[2].r = RIGHT_DASHBOARD[2].r;
+                ending_dashboard[2].g = RIGHT_DASHBOARD[2].g;
+                ending_dashboard[2].b = RIGHT_DASHBOARD[2].b;
+            }
+        }
 
         let mut ending_body = starting_body.clone();
+        match direction {
+            BlinkerDirection::Left => {
                 for i in 0..30 {
                     ending_body[i].r = LEFT[i].r;
                     ending_body[i].g = LEFT[i].g;
                     ending_body[i].b = LEFT[i].b;
                 }
+            }
+            BlinkerDirection::Right => {
+                for i in 30..60 {
+                    ending_body[i].r = RIGHT[i].r;
+                    ending_body[i].g = RIGHT[i].g;
+                    ending_body[i].b = RIGHT[i].b;
+                }
+            }
+        }
 
-        LeftBlinker {
+        Blinker {
             fade_in: Fade::new(
                 starting_dashboard.clone(),
                 starting_body.clone(),
                 ending_dashboard.clone(),
                 ending_body.clone(),
-                LEFT_FRAMES,
+                BLINKER_FRAMES,
                 time,
             ),
             fade_out: Fade::new(
@@ -173,17 +200,17 @@ impl LeftBlinker {
                 ending_body.clone(),
                 starting_dashboard.clone(),
                 starting_body.clone(),
-                LEFT_FRAMES,
+                BLINKER_FRAMES,
                 time,
             ),
             direction: FadeDirection::FadeIn,
             start_time: time,
-            frames: LEFT_FRAMES,
+            frames: BLINKER_FRAMES,
         }
     }
 }
 
-impl Animation for LeftBlinker {
+impl Animation for Blinker {
     fn tick(&mut self, time: std::time::Instant) -> (DashboardPattern, Pattern) {
         let frames: u8 = ((time - self.start_time).as_millis() as f64 / FPS as f64) as u8;
         if frames > self.frames {
@@ -249,7 +276,7 @@ impl App {
         }
     }
 
-    fn update_state(&mut self, time: std::time::Instant) {
+    fn update_animation(&mut self, time: std::time::Instant) {
         match self.state {
             State::Pattern(0) => {
                 self.current_animation = Box::new(Fade::new(
@@ -283,21 +310,27 @@ impl App {
                 ));
             }
             State::LeftBlinker => {
-                self.current_animation = Box::new(LeftBlinker::new(
+                self.current_animation = Box::new(Blinker::new(
                     self.dashboard_lights.clone(),
                     self.lights.clone(),
+                    BlinkerDirection::Left,
+                    time,
+                ));
+            }
+            State::RightBlinker => {
+                self.current_animation = Box::new(Blinker::new(
+                    self.dashboard_lights.clone(),
+                    self.lights.clone(),
+                    BlinkerDirection::Right,
                     time,
                 ));
             }
-            State::RightBlinker => (),
             State::BrakeLeftBlinker => (),
             State::BrakeRightBlinker => (),
         }
     }
 
-    pub fn tick(&mut self, time: std::time::Instant) {
+    fn update_state(&mut self, event: Event) {
-        match self.ui.check_event() {
-            Some(event) => {
         match event {
             Event::Brake => {
                 if self.state == State::Brake {
@@ -306,7 +339,7 @@ impl App {
                     self.state = State::Brake;
                 }
             }
-                    Event::BrakeRelease => self.state = State::Pattern(0),
+            Event::BrakeRelease => self.state = self.home_state.clone(),
             Event::LeftBlinker => match self.state {
                 State::Brake => self.state = State::BrakeLeftBlinker,
                 State::BrakeLeftBlinker => self.state = State::Brake,
@@ -332,9 +365,20 @@ impl App {
                 }
                 _ => (),
             },
-                    Event::RightBlinker => {}
+            Event::RightBlinker => match self.state {
+                State::Brake => self.state = State::BrakeRightBlinker,
+                State::BrakeRightBlinker => self.state = State::Brake,
+                State::RightBlinker => self.state = self.home_state.clone(),
+                _ => self.state = State::RightBlinker,
+            },
         }
-                self.update_state(time);
+    }
+
+    pub fn tick(&mut self, time: std::time::Instant) {
+        match self.ui.check_event() {
+            Some(event) => {
+                self.update_state(event);
+                self.update_animation(time);
             }
             None => {}
         };

bike-lights/simulator/src/main.rs

@@ -170,7 +170,9 @@ impl BikeLights {
         let s: Self = Object::builder().build();
 
         s.set_width_request(WIDTH);
-        s.set_height_request(200);
+        s.set_height_request(640);
+
+        let center = WIDTH as f64 / 2.;
 
         s.set_draw_func({
             let s = s.clone();
@@ -182,7 +184,7 @@ impl BikeLights {
                         lights[i].g as f64 / 256.,
                         lights[i].b as f64 / 256.,
                     );
-                    context.rectangle(5. + 20. * i as f64, 5., 15., 15.);
+                    context.rectangle(center - 45., 5. + 20. * i as f64, 15., 15.);
                     let _ = context.fill();
                 }
                 for i in 0..30 {
@@ -191,7 +193,7 @@ impl BikeLights {
                         lights[i + 30].g as f64 / 256.,
                         lights[i + 30].b as f64 / 256.,
                     );
-                    context.rectangle(5. + 20. * i as f64, 30., 15., 15.);
+                    context.rectangle(center + 15., 5. + 20. * (30. - (i + 1) as f64), 15., 15.);
                     let _ = context.fill();
                 }
             }