vinzenz/servicepoint-idle
0
0
Fork 0
Code Issues Pull requests Actions Packages Projects Releases Wiki Activity

range refactor, clippy

Browse source
This commit is contained in:
Vinzenz Schroeter 2025-07-08 20:01:39 +02:00
parent 2a4f92c9b3
commit 0bf317dd6d
6 changed files with 35 additions and 57 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
src/bar.rs
View file

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

31
src/border_panel.rs
View file

@ -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>>(
mut chars: WindowMut<'t, char, C>,
mut bitmap: WindowMut<'t, bool, P>,
pub fn draw_border_panel<'c, 'b>(
mut chars: WindowMut<'c, char, CharGrid>,
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 {
let val = border_pattern[inner_y];
for (inner_y, val) in border_pattern.iter().enumerate() {
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 {
let val = border_pattern[inner_x];
bitmap.set(inner_x, y, val);
bitmap.set(pixel_width - inner_x - 1, y, val);
for (inner_x, val) in border_pattern.iter().enumerate() {
bitmap.set(inner_x, y, *val);
bitmap.set(pixel_width - inner_x - 1, y, *val);
}
}
}
// edges
for pat_index in 0..TILE_SIZE {
if !border_pattern[pat_index] {
for (pat_index, pat_val) in border_pattern.iter().enumerate() {
if !pat_val {
continue;
}

14
src/game.rs
View file

@ -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() {
let bar_window = pixel_layer
.window_mut(0, index * TILE_SIZE, pixel_layer.width(), TILE_SIZE)
.unwrap();
let label_window = text_layer
.window_mut(0, index, text_layer.width(), 1)
.unwrap();
for row in self.state.rows.iter() {
let bar_window;
(bar_window, pixel_layer) = pixel_layer.split_vertical_mut(TILE_SIZE).unwrap();
let label_window;
(label_window, text_layer) = text_layer.split_vertical_mut(1).unwrap();
row.draw(label_window, bar_window);
}
}

8
src/main.rs
View file

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

21
src/row.rs
View file

@ -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
.window_mut(0, 0, bitmap.width() / 2, bitmap.height())
.unwrap();
let width = bitmap.width();
let (bitmap, _) = bitmap.split_horizontal_mut(width / 2).unwrap();
self.bar.draw(bitmap);
let mut chars = chars
.window_mut(
chars.width() / 2 + 1,
0,
chars.width() / 2 - 1,
chars.height(),
)
.unwrap();
let width = chars.width();
let (_, mut chars) = chars.split_horizontal_mut(width / 2 + 1).unwrap();
chars
.set_row_str(
0,
&*self.name.chars().take(chars.width()).collect::<String>(),
&self.name.chars().take(chars.width()).collect::<String>(),
)
.unwrap();
}

12
src/unlocks.rs
View file

@ -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()),