range refactor, clippy

src/bar.rs

@@ -15,10 +15,8 @@ impl Bar {
         let padding = 1;
         let mut bitmap = bitmap
             .window_mut(
-                padding,
+                padding..bitmap.width() - padding,
-                padding,
+                padding..bitmap.height() - padding,
-                bitmap.width() - 2 * padding,
-                bitmap.height() - 2 * padding,
             )
             .unwrap();
 

src/border_panel.rs

@@ -1,23 +1,23 @@
-use servicepoint::{CharGridMutExt, GridMut, TILE_SIZE, WindowMut};
+use servicepoint::{Bitmap, CharGrid, CharGridMutExt, TILE_SIZE, WindowMut};
 
 pub type BorderPattern = [bool; TILE_SIZE];
 
 pub const OUTER_BORDER: BorderPattern = [false, false, false, true, true, false, true, false];
 pub const INNER_BORDER: BorderPattern = [false, false, false, true, true, false, false, false];
 
-pub fn draw_border_panel<'t, C: GridMut<char>, P: GridMut<bool>>(
+pub fn draw_border_panel<'c, 'b>(
-    mut chars: WindowMut<'t, char, C>,
+    mut chars: WindowMut<'c, char, CharGrid>,
-    mut bitmap: WindowMut<'t, bool, P>,
+    mut bitmap: WindowMut<'b, bool, Bitmap>,
     label: &str,
     border_pattern: BorderPattern,
-) -> (WindowMut<'t, char, C>, WindowMut<'t, bool, P>) {
+) -> (WindowMut<'c, char, CharGrid>, WindowMut<'b, bool, Bitmap>) {
     let tile_width = chars.width();
     let tile_height = chars.height();
     let pixel_width = bitmap.width();
     let pixel_height = bitmap.height();
 
     chars
-        .window_mut(2, 0, tile_width - 4, 1)
+        .window_mut(2..tile_width - 2, 0..1)
         .unwrap()
         .set_row_str(0, label)
         .unwrap();
@@ -28,12 +28,11 @@ pub fn draw_border_panel<'t, C: GridMut<char>, P: GridMut<bool>>(
             let x = tile_x * TILE_SIZE + inner_x;
             let draw_top = tile_x <= 1 || tile_x >= label.chars().count() + 2;
 
-            for inner_y in 0..TILE_SIZE {
+            for (inner_y, val) in border_pattern.iter().enumerate() {
-                let val = border_pattern[inner_y];
                 if draw_top {
-                    bitmap.set(x, inner_y, val);
+                    bitmap.set(x, inner_y, *val);
                 }
-                bitmap.set(x, pixel_height - inner_y - 1, val);
+                bitmap.set(x, pixel_height - inner_y - 1, *val);
             }
         }
     }
@@ -42,18 +41,16 @@ pub fn draw_border_panel<'t, C: GridMut<char>, P: GridMut<bool>>(
     for tile_y in 1..tile_height - 1 {
         for inner_y in 0..TILE_SIZE {
             let y = tile_y * TILE_SIZE + inner_y;
-            for inner_x in 0..TILE_SIZE {
+            for (inner_x, val) in border_pattern.iter().enumerate() {
-                let val = border_pattern[inner_x];
+                bitmap.set(inner_x, y, *val);
-
+                bitmap.set(pixel_width - inner_x - 1, y, *val);
-                bitmap.set(inner_x, y, val);
-                bitmap.set(pixel_width - inner_x - 1, y, val);
             }
         }
     }
 
     // edges
-    for pat_index in 0..TILE_SIZE {
+    for (pat_index, pat_val) in border_pattern.iter().enumerate() {
-        if !border_pattern[pat_index] {
+        if !pat_val {
             continue;
         }
 

src/game.rs

@@ -42,7 +42,7 @@ impl Game {
                 Row::new(
                     5usize.pow(index as u32) as f64,
                     1.0 * (0.5f64.powi(index as i32)),
-                    *name,
+                    name,
                 )
             })
             .collect();
@@ -104,13 +104,11 @@ impl Game {
         let (mut text_layer, mut pixel_layer) =
             draw_border_panel(text_layer, pixel_layer, " Processes ", INNER_BORDER);
 
-        for (index, row) in self.state.rows.iter().enumerate() {
+        for row in self.state.rows.iter() {
-            let bar_window = pixel_layer
+            let bar_window;
-                .window_mut(0, index * TILE_SIZE, pixel_layer.width(), TILE_SIZE)
+            (bar_window, pixel_layer) = pixel_layer.split_vertical_mut(TILE_SIZE).unwrap();
-                .unwrap();
+            let label_window;
-            let label_window = text_layer
+            (label_window, text_layer) = text_layer.split_vertical_mut(1).unwrap();
-                .window_mut(0, index, text_layer.width(), 1)
-                .unwrap();
             row.draw(label_window, bar_window);
         }
     }

src/main.rs

@@ -40,12 +40,8 @@ fn main() {
         chars.fill('\0');
         pixels.fill(false);
 
-        let chars_view = chars
+        let chars_view = chars.window_mut(.., ..).unwrap();
-            .window_mut(0, 0, chars.width(), chars.height())
+        let pixels_view = pixels.window_mut(.., ..).unwrap();
-            .unwrap();
-        let pixels_view = pixels
-            .window_mut(0, 0, pixels.width(), pixels.height())
-            .unwrap();
         state.draw(chars_view, pixels_view);
 
         connection.send_command(&bitmap_cmd).unwrap();

src/row.rs

@@ -1,5 +1,5 @@
 use crate::{Currency, bar::Bar};
-use servicepoint::{Bitmap, CharGrid, CharGridMutExt, GridMut, WindowMut};
+use servicepoint::{Bitmap, CharGrid, CharGridMutExt, WindowMut};
 use std::time::Duration;
 
 #[derive(Debug, Clone, Copy)]
@@ -39,29 +39,22 @@ impl Row {
         completions * self.productivity
     }
 
-    pub fn draw(&self, mut chars: WindowMut<char, CharGrid>, mut bitmap: WindowMut<bool, Bitmap>) {
+    pub fn draw(&self, chars: WindowMut<char, CharGrid>, bitmap: WindowMut<bool, Bitmap>) {
         if !self.enabled {
             return;
         }
 
-        let bitmap = bitmap
+        let width = bitmap.width();
-            .window_mut(0, 0, bitmap.width() / 2, bitmap.height())
+        let (bitmap, _) = bitmap.split_horizontal_mut(width / 2).unwrap();
-            .unwrap();
         self.bar.draw(bitmap);
 
-        let mut chars = chars
+        let width = chars.width();
-            .window_mut(
+        let (_, mut chars) = chars.split_horizontal_mut(width / 2 + 1).unwrap();
-                chars.width() / 2 + 1,
-                0,
-                chars.width() / 2 - 1,
-                chars.height(),
-            )
-            .unwrap();
 
         chars
             .set_row_str(
                 0,
-                &*self.name.chars().take(chars.width()).collect::<String>(),
+                &self.name.chars().take(chars.width()).collect::<String>(),
             )
             .unwrap();
     }

src/unlocks.rs

@@ -67,14 +67,10 @@ impl UnlockSystem {
         }
     }
 
-    pub fn previous(&self) -> Option<&String> {
-        self.last_unlock.as_ref()
-    }
-
     pub fn draw(&self, chars: WindowMut<char, CharGrid>, bitmap: WindowMut<bool, Bitmap>) {
         let title = format!(" Stage {}/{} ", self.bought, self.total_unlock_count);
 
-        let (mut chars, mut bitmap) = draw_border_panel(chars, bitmap, &title, INNER_BORDER);
+        let (chars, bitmap) = draw_border_panel(chars, bitmap, &title, INNER_BORDER);
 
         let (all_unlocks_pixels, bitmap) = bitmap.split_vertical_mut(TILE_SIZE).unwrap();
         self.all_unlocks_bar.draw(all_unlocks_pixels);
@@ -103,7 +99,7 @@ impl UnlockSystem {
         self.all_unlocks_bar.progress = self.bought as f64 / self.total_unlock_count as f64;
     }
 
-    fn gen_bar_enable_unlocks(bars: &Vec<Row>) -> impl Iterator<Item = Unlock> {
+    fn gen_bar_enable_unlocks(bars: &[Row]) -> impl Iterator<Item = Unlock> {
         bars.iter().enumerate().map(|(index, bar)| Unlock {
             name: format!("Start {}", bar.name()),
             cost: 10f64.powi(index as i32),
@@ -135,7 +131,7 @@ impl UnlockSystem {
         })
     }
 
-    fn gen_bar_productivity_unlocks(bars: &Vec<Row>) -> impl Iterator<Item = Unlock> {
+    fn gen_bar_productivity_unlocks(bars: &[Row]) -> impl Iterator<Item = Unlock> {
         bars.iter().enumerate().flat_map(|(index, bar)| {
             (1..=20).map(move |level| Unlock {
                 name: format!("{} productivity {level}", bar.name()),
@@ -147,7 +143,7 @@ impl UnlockSystem {
         })
     }
 
-    fn gen_bar_speed_unlocks(bars: &Vec<Row>) -> impl Iterator<Item = Unlock> {
+    fn gen_bar_speed_unlocks(bars: &[Row]) -> impl Iterator<Item = Unlock> {
         bars.iter().enumerate().flat_map(|(index, bar)| {
             (1..=15).map(move |level| Unlock {
                 name: format!("{} speed {level}", bar.name()),