Update jiggle vector generator to simplify caller usage

Author: its3mile

src/main.rs

@@ -113,30 +113,23 @@ async fn main(_spawner: Spawner) {
 
     let in_fut = async {
         let mut rng = RoscRng;
+        let movement = Movement::default();
         loop {
             // Feed controller
+            // If true, it is time to issue a mouse report
             if CONTROLLER.feed().await {
-                // To simulate more natural mouse movement, limit the maximum movement per report, and send multiple reports.
-                let reverberations = 2;
-                const JIGGLE_VECTOR_SIZE: usize = 64;
-                let mut jiggle_vector_v: heapless::Vec<i8, JIGGLE_VECTOR_SIZE> =
-                    heapless::Vec::new();
-                let mut jiggle_vector_h: heapless::Vec<i8, JIGGLE_VECTOR_SIZE> =
-                    heapless::Vec::new();
-                let movement = Movement::new();
-                for _ in 0..reverberations {
-                    movement.generate_vector(rng.next_u32(), &mut jiggle_vector_v);
-                    movement.generate_vector(rng.next_u32(), &mut jiggle_vector_h);
-                }
-
                 // See https://wiki.osdev.org/USB_Human_Interface_Devices#USB_mouse for details on mouse reports.
                 // tldr: x and y are signed 8-bit integers representing relative movement.
-                for (x, y) in jiggle_vector_h.iter().zip(jiggle_vector_v.iter()) {
+                for (dx, dy) in movement
+                    .generate_vector::<64>(rng.next_u32())
+                    .into_iter()
+                    .chain(movement.generate_vector::<64>(rng.next_u32()).into_iter())
+                {
                     // Create the mouse HID report.
                     let report = MouseReport {
                         buttons: 0,
-                        x: *x,
-                        y: *y,
+                        x: dx,
+                        y: dy,
                         wheel: 0,
                         pan: 0,
                     };

src/movement.rs

@@ -7,51 +7,94 @@ pub struct Movement {
 }
 
 impl Movement {
-    pub const fn new() -> Self {
+    pub const fn _new(upper_limit: u8, lower_limit: u8, step: i8) -> Self {
+        Self {
+            upper_limit: upper_limit,
+            lower_limit: lower_limit,
+            step: step as i8,
+        }
+    }
+
+    pub const fn default() -> Self {
         Self {
             upper_limit: 32,
             lower_limit: 6,
             step: 6,
         }
     }
 
-    /// Generate a relative movement vector suitable for use in a mouse HID report
-    /// The generated vector is a for a single axis, and returns to the starting position
-    pub fn generate_vector<const N: usize>(&self, seed: u32, vec: &mut heapless::Vec<i8, N>) {
-        // Scale rng_value into the range [LOWER, UPPER] inclusive.
-        // Use 64-bit intermediate to avoid overflow and get decent distribution.
+    fn xorshift32(&self, mut x: u32) -> u32 {
+        x ^= x << 13;
+        x ^= x >> 17;
+        x ^= x << 5;
+        x
+    }
+
+    fn scale_seed(&self, seed: u32) -> i8 {
         let range: u32 = (self.upper_limit - self.lower_limit) as u32;
         let scaled: u32 = if seed == u32::MAX {
             range
         } else {
             ((seed as u64 * range as u64) / (u32::MAX as u64)) as u32
         };
-        let x_u8 = (self.lower_limit as u32 + scaled) as u8;
-        let mut remaining: i8 = x_u8 as i8;
-
-        // Populate forward movement in STEP-sized chunks (last chunk may be smaller).
-        while remaining > 0 && !vec.is_full() {
-            let to_push: i8 = if remaining >= self.step {
-                self.step
-            } else {
-                remaining
-            };
-            if vec.push(to_push).is_err() {
-                break;
-            }
-            remaining -= to_push;
+
+        let value = (self.lower_limit as u32 + scaled) as u8;
+        value as i8
+    }
+
+    fn step_toward_zero(&self, remaining: i8, rng: u32, max_step: i8) -> i8 {
+        if remaining == 0 {
+            return 0;
+        }
+
+        let step = remaining.abs().min(max_step);
+        let jitter = ((rng & 0x3) as i8) - 1; // [-1,0,1]
+        let mut s = step + jitter;
+        s = s.clamp(1, step); // ensure at least 1 and not overshoot
+
+        if remaining < 0 { -s } else { s }
+    }
+
+    pub fn generate_vector<const N: usize>(&self, seed: u32) -> heapless::Vec<(i8, i8), N> {
+        let mut vec: heapless::Vec<(i8, i8), N> = heapless::Vec::new();
+        let mut rng = seed;
+
+        // Total magnitude per axis
+        let x_total = self.scale_seed(seed);
+        let y_total = self.scale_seed(seed.rotate_left(13));
+
+        // Determine direction: 50% chance to flip axes
+        let flip = (rng & 1) == 1; // true => invert direction
+        let (mut x_remaining, mut y_remaining) = if flip {
+            (-x_total, -y_total)
+        } else {
+            (x_total, y_total)
+        };
+
+        // ---- Forward path with jitter + easing ----
+        while (x_remaining != 0 || y_remaining != 0) && !vec.is_full() {
+            rng = self.xorshift32(rng);
+
+            let x_step = self.step_toward_zero(x_remaining, rng, self.step);
+            let y_step = self.step_toward_zero(y_remaining, rng.rotate_left(5), self.step);
+
+            x_remaining -= x_step;
+            y_remaining -= y_step;
+
+            vec.push((x_step, y_step)).ok();
         }
 
-        // Mirror back to origin. Iterate in reverse over current values and push negated values
-        // until the vector is full.
-        // Note: negating a value in the expected range (1..=16) is safe for i8.
-        let clone = vec.clone();
-        for &v in clone.iter().rev() {
+        // ---- Mirror back exactly ----
+        let len = vec.len();
+        for i in (0..len).rev() {
             if vec.is_full() {
                 break;
             }
-            // push negated value; ignore push failure because we checked is_full above
-            let _ = vec.push(-v);
+
+            let (x, y) = vec[i];
+            vec.push((-x, -y)).ok();
         }
+
+        vec
     }
 }