From 660746f16be18c744c5b88e35ec35b38482db8e0 Mon Sep 17 00:00:00 2001
From: CrispyPin <crispin@tasa.se>
Date: Sat, 12 Apr 2025 16:36:27 +0200
Subject: [PATCH 01/23] split step into functions and set up stuff for
 flamegraph to be usable

---
 .gitignore           |   2 +
 Cargo.toml           |   4 ++
 Makefile             |   6 ++
 src/marble_engine.rs | 157 ++++++++++++++++++++++++++++---------------
 4 files changed, 115 insertions(+), 54 deletions(-)

diff --git a/.gitignore b/.gitignore
index ab75dc1..9374d18 100644
--- a/.gitignore
+++ b/.gitignore
@@ -2,3 +2,5 @@
 /user*
 *.zip
 version.txt
+perf.data*
+flamegraph.svg
diff --git a/Cargo.toml b/Cargo.toml
index d7d32d7..91b6fc2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,6 +10,10 @@ raylib = "5.5"
 serde = { version = "1.0.210", features = ["derive"] }
 serde_json = "1.0.128"
 
+[features]
+# affects simulation sub-steps, used for profiling
+inline_less = []
+
 [[bin]]
 name = "bench"
 path = "src/benchmark.rs"
diff --git a/Makefile b/Makefile
index 69bf9cf..e5a2446 100644
--- a/Makefile
+++ b/Makefile
@@ -22,3 +22,9 @@ windows:
 	rm -rf ${RELEASE_DIRNAME}_win
 
 all: windows linux
+
+flamegraph:
+	cargo flamegraph --release --bin bench --features "inline_less"
+
+bench:
+	cargo run --release --bin bench
diff --git a/src/marble_engine.rs b/src/marble_engine.rs
index e18c13f..aee8eee 100644
--- a/src/marble_engine.rs
+++ b/src/marble_engine.rs
@@ -12,13 +12,19 @@ use tile::*;
 pub struct Machine {
 	grid: Grid,
 	marbles: Vec<Pos>,
-	powered: Vec<Pos>,
 	input: Vec<u8>,
 	input_index: usize,
 	output: Vec<u8>,
 	steps: usize,
 	pub subtick_index: usize,
 	pub debug_subticks: Vec<DebugSubTick>,
+	// used across steps
+	powered: Vec<Pos>,
+	// used within steps
+	new_marbles: Vec<(Pos, MarbleValue, Direction)>,
+	influenced_direction: Vec<(bool, DirInfluence)>,
+	claim_positions: Vec<Pos>,
+	removed_marbles: Vec<usize>,
 }
 
 #[derive(Debug)]
@@ -27,18 +33,29 @@ pub struct DebugSubTick {
 	pub pos: Option<Pos>,
 }
 
+#[derive(Clone, Copy, Debug)]
+enum DirInfluence {
+	None,
+	One(Direction),
+	Multiple,
+}
+
 impl Machine {
 	pub fn new_empty() -> Self {
 		Self {
 			grid: Grid::new_empty(5, 5),
 			marbles: Vec::new(),
-			powered: Vec::new(),
 			input: Vec::new(),
 			input_index: 0,
 			output: Vec::new(),
 			steps: 0,
 			subtick_index: 0,
 			debug_subticks: Vec::new(),
+			powered: Vec::new(),
+			new_marbles: Vec::new(),
+			influenced_direction: Vec::new(),
+			claim_positions: Vec::new(),
+			removed_marbles: Vec::new(),
 		}
 	}
 
@@ -119,9 +136,51 @@ impl Machine {
 			});
 		}
 
+		self.step_power_complete();
+
+		if self.marbles.is_empty() {
+			return;
+		}
+
+		self.step_find_bounces();
+		self.step_apply_direct_bounces();
+
+		self.step_prepare_creating_marbles();
 		let old_marbles = self.marbles.len();
 
-		let mut new_marbles = Vec::new();
+		self.step_create_marbles();
+
+		// #### movement ####
+		// mark claims to figure out what spaces can be moved to
+		self.step_mark_claims(old_marbles);
+		self.step_move_marbles(old_marbles);
+
+		for pos in self.claim_positions.drain(..) {
+			if let Some(Tile::Open(_, claim_state)) = self.grid.get_mut(pos) {
+				*claim_state = Claim::Free;
+			}
+		}
+
+		// remove marbles
+		for &i in self.removed_marbles.iter().rev() {
+			self.grid.set(self.marbles[i], Tile::BLANK);
+			self.marbles.swap_remove(i);
+		}
+
+		self.step_propagate_power();
+
+		#[cfg(debug_assertions)]
+		{
+			self.debug_subticks.push(DebugSubTick {
+				grid: self.grid.clone(),
+				pos: None,
+			});
+			self.subtick_index = self.debug_subticks.len() - 1;
+		}
+	}
+
+	#[cfg_attr(feature = "inline_less", inline(never), no_mangle)]
+	fn step_power_complete(&mut self) {
 		// activate all powered machines
 		for &pos in &self.powered {
 			match self.grid.get_mut(pos) {
@@ -157,7 +216,7 @@ impl Machine {
 										MathOp::Div => val_a.checked_div(val_b).unwrap_or_default(),
 										MathOp::Rem => val_a.checked_rem(val_b).unwrap_or_default(),
 									};
-									new_marbles.push((front_pos, value, dir));
+									self.new_marbles.push((front_pos, value, dir));
 								}
 							}
 							PTile::IO => {
@@ -165,12 +224,12 @@ impl Machine {
 								{
 									let value = self.input[self.input_index] as MarbleValue;
 									self.input_index += 1;
-									new_marbles.push((front_pos, value, dir));
+									self.new_marbles.push((front_pos, value, dir));
 								}
 							}
 							PTile::Silo => {
 								if front_tile == &Tile::BLANK {
-									new_marbles.push((front_pos, 0, dir));
+									self.new_marbles.push((front_pos, 0, dir));
 								}
 							}
 							PTile::Flipper => {
@@ -198,21 +257,13 @@ impl Machine {
 			};
 		}
 		self.powered.clear();
+	}
 
-		if self.marbles.is_empty() {
-			return;
-		}
-
-		#[derive(Clone, Copy, Debug)]
-		enum DirInfluence {
-			None,
-			One(Direction),
-			Multiple,
-		}
+	#[cfg_attr(feature = "inline_less", inline(never), no_mangle)]
+	fn step_find_bounces(&mut self) {
 		// #### find all direct bounces ####
-		let mut will_reverse_direction = vec![false; self.marbles.len()];
 		// todo store in tile to remove search through self.marbles
-		let mut influenced_direction = vec![DirInfluence::None; self.marbles.len()];
+		self.influenced_direction = vec![(false, DirInfluence::None); self.marbles.len()];
 
 		for (i, &pos) in self.marbles.iter().enumerate() {
 			let Some(Tile::Marble { value: _, dir }) = self.grid.get(pos) else {
@@ -229,11 +280,11 @@ impl Machine {
 				} => {
 					if other_dir != dir {
 						// this marble is facing another marble, and will therefore definitely bounce
-						will_reverse_direction[i] = true;
+						self.influenced_direction[i].0 = true;
 						// the other marble will bounce too, either
 						let other_index =
 							self.marbles.iter().position(|m| *m == front_pos).unwrap();
-						let influence = &mut influenced_direction[other_index];
+						let influence = &mut self.influenced_direction[other_index].1;
 						*influence = match *influence {
 							DirInfluence::None => DirInfluence::One(dir),
 							DirInfluence::One(_) => DirInfluence::Multiple,
@@ -244,38 +295,49 @@ impl Machine {
 				Tile::Arrow(arrow_dir) => {
 					if arrow_dir == dir.opposite() {
 						// bounce on a reverse facing arrow
-						will_reverse_direction[i] = true;
+						self.influenced_direction[i].0 = true;
 					}
 				}
 				_ => (),
 			}
 		}
+	}
+
+	#[cfg_attr(feature = "inline_less", inline(never), no_mangle)]
+	fn step_apply_direct_bounces(&mut self) {
 		// #### apply all direct bounces ####
 		for (i, &pos) in self.marbles.iter().enumerate() {
 			let Some(Tile::Marble { value: _, dir }) = self.grid.get_mut(pos) else {
 				unreachable!()
 			};
-			if will_reverse_direction[i] {
+			if self.influenced_direction[i].0 {
 				*dir = dir.opposite();
-			} else if let DirInfluence::One(new_dir) = influenced_direction[i] {
+			} else if let DirInfluence::One(new_dir) = self.influenced_direction[i].1 {
 				*dir = new_dir;
 			}
 		}
+	}
 
+	#[cfg_attr(feature = "inline_less", inline(never), no_mangle)]
+	fn step_prepare_creating_marbles(&mut self) {
 		// #### new marbles ####
-		let mut claim_positions = Vec::new();
+		// self.claim_positions.clear(); // already drained
 		// prepare creating the new marbles
-		for &(pos, _val, _dir) in &new_marbles {
+		for &(pos, _val, _dir) in &self.new_marbles {
 			let Some(Tile::Open(OpenTile::Blank, claim)) = self.grid.get_mut(pos) else {
 				unreachable!()
 			};
 			if claim.claim_indirect() {
-				claim_positions.push(pos);
+				self.claim_positions.push(pos);
 			}
 		}
+	}
+
+	#[cfg_attr(feature = "inline_less", inline(never), no_mangle)]
+	fn step_create_marbles(&mut self) {
 		// create new marbles
 		// new marbles are past old_marbles index, so will not move this step
-		for (pos, value, dir) in new_marbles {
+		for (pos, value, dir) in self.new_marbles.drain(..) {
 			let Some(Tile::Open(OpenTile::Blank, Claim::ClaimedIndirect)) = self.grid.get_mut(pos)
 			else {
 				continue;
@@ -283,9 +345,10 @@ impl Machine {
 			self.grid.set(pos, Tile::Marble { value, dir });
 			self.marbles.push(pos);
 		}
+	}
 
-		// #### movement ####
-		// mark claims to figure out what spaces can be moved to
+	#[cfg_attr(feature = "inline_less", inline(never), no_mangle)]
+	fn step_mark_claims(&mut self, old_marbles: usize) {
 		for &pos in &self.marbles[..old_marbles] {
 			let Some(Tile::Marble { value: _, dir }) = self.grid.get(pos) else {
 				unreachable!()
@@ -296,7 +359,7 @@ impl Machine {
 			};
 			if let Tile::Open(_type, claim) = front_tile {
 				if claim.claim() {
-					claim_positions.push(front_pos);
+					self.claim_positions.push(front_pos);
 				}
 			} else {
 				let target_pos = match front_tile {
@@ -310,13 +373,16 @@ impl Machine {
 				};
 				if let Tile::Open(_type, claim) = target_tile {
 					if claim.claim_indirect() {
-						claim_positions.push(front_pos);
+						self.claim_positions.push(front_pos);
 					}
 				}
 			}
 		}
+	}
 
-		let mut removed_marbles = Vec::new();
+	#[cfg_attr(feature = "inline_less", inline(never), no_mangle)]
+	fn step_move_marbles(&mut self, old_marbles: usize) {
+		self.removed_marbles.clear();
 		// move marbles
 		for (i, pos) in self.marbles[..old_marbles].iter_mut().enumerate() {
 			let Some(Tile::Marble { value, dir }) = self.grid.get(*pos) else {
@@ -369,11 +435,11 @@ impl Machine {
 						target_pos = dir.step(front_pos);
 					}
 					Tile::Powerable(PTile::Silo, _) => {
-						removed_marbles.push(i);
+						self.removed_marbles.push(i);
 						continue;
 					}
 					Tile::Powerable(PTile::IO, _) => {
-						removed_marbles.push(i);
+						self.removed_marbles.push(i);
 						self.output.push(value as u8);
 						continue;
 					}
@@ -390,19 +456,10 @@ impl Machine {
 				}
 			}
 		}
+	}
 
-		for pos in claim_positions {
-			if let Some(Tile::Open(_, claim_state)) = self.grid.get_mut(pos) {
-				*claim_state = Claim::Free;
-			}
-		}
-
-		// remove marbles
-		for &i in removed_marbles.iter().rev() {
-			self.grid.set(self.marbles[i], Tile::BLANK);
-			self.marbles.swap_remove(i);
-		}
-
+	#[cfg_attr(feature = "inline_less", inline(never), no_mangle)]
+	fn step_propagate_power(&mut self) {
 		// propagate power
 		let mut i = 0;
 		while i < self.powered.len() {
@@ -527,13 +584,5 @@ impl Machine {
 			}
 			i += 1;
 		}
-		#[cfg(debug_assertions)]
-		{
-			self.debug_subticks.push(DebugSubTick {
-				grid: self.grid.clone(),
-				pos: None,
-			});
-			self.subtick_index = self.debug_subticks.len() - 1;
-		}
 	}
 }

From a7556785673f5ff2264b4afd8d6a621f11fed42e Mon Sep 17 00:00:00 2001
From: CrispyPin <crispin@tasa.se>
Date: Sat, 12 Apr 2025 20:51:55 +0200
Subject: [PATCH 02/23] prevent bindings from triggering when a modifier is
 held down that matches a different binding

---
 src/input.rs  |  62 ++++++++++---
 src/layout.rs | 245 ++++++++++++++++++++++++++++++++++++++++++++++++++
 src/lib.rs    |   3 +-
 src/ui2.rs    | 142 +++++++++++++++++++++++++++++
 4 files changed, 440 insertions(+), 12 deletions(-)
 create mode 100644 src/layout.rs
 create mode 100644 src/ui2.rs

diff --git a/src/input.rs b/src/input.rs
index 4d695b0..bc4241b 100644
--- a/src/input.rs
+++ b/src/input.rs
@@ -54,6 +54,7 @@ impl Default for Input {
 		let mut bindings = [(); ActionId::SIZE].map(|_| Vec::new());
 		let mut bind_key = |action, mods, trigger| {
 			bindings[action as usize].push(Binding {
+				blocking_modifiers: Vec::new(),
 				modifiers: mods,
 				trigger,
 			});
@@ -141,21 +142,26 @@ impl Input {
 				if text_button(d, &globals.mouse, buttons_x + 85, y, 45, "edit") {
 					self.editing_binding = Some((action, binding_index, BindingEdit::Init));
 				}
+				//
 				let trigger = format!("{:?}", binding.trigger);
-				d.draw_text(&trigger, binding_text_x, y + 5, 20, Color::LIMEGREEN);
-				let x = binding_text_x + 10 + d.measure_text(&trigger, 20);
+				let mut x = binding_text_x;
+				d.draw_text(&trigger, x, y + 5, 20, Color::LIMEGREEN);
+				x += 10 + d.measure_text(&trigger, 20);
+				//
 				let modifiers = format!("{:?}", binding.modifiers);
 				d.draw_text(&modifiers, x, y + 5, 20, Color::LIGHTBLUE);
+				x += 10 + d.measure_text(&modifiers, 20);
+				//
 				let conflicts = conflicts(&self.bindings, binding, action);
 				if !conflicts.is_empty() {
-					let x = x + 10 + d.measure_text(&modifiers, 20);
-					d.draw_text(
-						&format!("also used by: {conflicts:?}"),
-						x,
-						y + 5,
-						20,
-						Color::ORANGERED,
-					);
+					let conflict_text = format!("also used by: {conflicts:?}");
+					d.draw_text(&conflict_text, x, y + 5, 20, Color::ORANGERED);
+					x += 10 + d.measure_text(&conflict_text, 20);
+				}
+				//
+				if !binding.blocking_modifiers.is_empty() {
+					let blocking_text = format!("not while: {:?}", binding.blocking_modifiers);
+					d.draw_text(&blocking_text, x, y + 5, 20, Color::GRAY);
 				}
 				y += 32;
 			}
@@ -193,6 +199,7 @@ impl Input {
 					BindingEdit::Init => {
 						if key.just_pressed(d) {
 							*edit_state = BindingEdit::Adding(Binding {
+								blocking_modifiers: Vec::new(),
 								modifiers: Vec::new(),
 								trigger: key,
 							});
@@ -218,6 +225,7 @@ impl Input {
 							globals.mouse.is_over(ok_btn_rect) && key == Button::MouseLeft;
 						if key.just_pressed(d) && !clicking_ok {
 							*edit_state = BindingEdit::Adding(Binding {
+								blocking_modifiers: Vec::new(),
 								modifiers: Vec::new(),
 								trigger: key,
 							});
@@ -255,6 +263,7 @@ impl Input {
 						binding_list.push(binding.clone());
 					}
 					self.editing_binding = None;
+					self.update_modifier_blocks();
 				}
 			}
 			if text_button(d, &globals.mouse, x + 100, y + 40, 80, "cancel") {
@@ -268,7 +277,9 @@ impl Input {
 			let bindings = &self.bindings[i];
 			let mut is_active = false;
 			for binding in bindings {
-				if binding.modifiers.iter().all(|&m| m.is_down(rl)) {
+				if binding.modifiers.iter().all(|&m| m.is_down(rl))
+					&& !binding.blocking_modifiers.iter().any(|&m| m.is_down(rl))
+				{
 					is_active |= binding.trigger.is_down(rl);
 				}
 			}
@@ -299,6 +310,33 @@ impl Input {
 	pub fn is_released(&self, action: ActionId) -> bool {
 		self.states[action as usize] == BindingState::Released
 	}
+
+	/// Must be called after any binding has changed.
+	/// Ensures a binding "S" is not triggered by "Ctrl+S", if "Ctrl+S" is bound to something else.
+	pub fn update_modifier_blocks(&mut self) {
+		for i in 0..ActionId::SIZE {
+			let bindings = &self.bindings[i];
+			for binding_index in 0..bindings.len() {
+				let binding = &self.bindings[i][binding_index];
+				let mut blocking_mods = Vec::new();
+				for i in 0..ActionId::SIZE {
+					let other_bindings = &self.bindings[i];
+					for other_binding in other_bindings {
+						if other_binding.trigger == binding.trigger {
+							for modifier in &other_binding.modifiers {
+								if !blocking_mods.contains(modifier)
+									&& !binding.modifiers.contains(modifier)
+								{
+									blocking_mods.push(*modifier);
+								}
+							}
+						}
+					}
+				}
+				self.bindings[i][binding_index].blocking_modifiers = blocking_mods;
+			}
+		}
+	}
 }
 
 fn conflicts(
@@ -338,6 +376,8 @@ impl ActionId {
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub struct Binding {
+	#[serde(skip)]
+	blocking_modifiers: Vec<Button>,
 	modifiers: Vec<Button>,
 	trigger: Button,
 }
diff --git a/src/layout.rs b/src/layout.rs
new file mode 100644
index 0000000..a72a4c1
--- /dev/null
+++ b/src/layout.rs
@@ -0,0 +1,245 @@
+use raylib::{
+	color::Color,
+	drawing::{RaylibDraw, RaylibDrawHandle},
+	RaylibHandle,
+};
+
+#[derive(Debug, Default)]
+pub struct Ui {
+	root: Node,
+	width: i32,
+	height: i32,
+	dirty: bool,
+}
+
+#[derive(Debug, Default, Clone, Copy)]
+pub enum Axis {
+	#[default]
+	Horizontal,
+	Vertical,
+}
+
+impl Ui {
+	pub fn new() -> Self {
+		Self::default()
+	}
+
+	pub fn update(&mut self, rl: &RaylibHandle) {
+		let w = rl.get_screen_width();
+		let h = rl.get_screen_height();
+		if w != self.width || h != self.height {
+			self.dirty = true;
+		}
+		self.width = w;
+		self.height = h;
+
+		if self.dirty {
+			self.dirty = false;
+			self.layout();
+		}
+	}
+
+	fn layout(&mut self) {
+		// fit sizing widths
+		self.root.layout_width();
+		// grow & shrink widths
+		// wrap text
+		self.root.layout_height();
+		// fit sizing heights
+		// grow & shrink heights
+		// positions
+		self.root.layout_position(0, 0);
+	}
+
+	pub fn draw(&self, rl: &mut RaylibDrawHandle) {
+		self.root.draw(rl);
+	}
+
+	pub fn set_root(&mut self, node: Node) {
+		// self.nodes = nodes;
+		self.root = node;
+		self.dirty = true;
+	}
+}
+
+#[derive(Debug, Default, Clone)]
+pub enum SizeAxis {
+	#[default]
+	Fit,
+	Fixed(i32),
+	// Grow(),
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct Node {
+	// id: NodeId,
+	hidden: bool,
+	children: Vec<Node>,
+	computed_width: i32,
+	computed_height: i32,
+	computed_x: i32,
+	computed_y: i32,
+	// min_width: i32,
+	// min_height: i32,
+	// pref_width: i32,
+	// pref_height: i32,
+	// max_width: i32,
+	// max_height: i32,
+	width: SizeAxis,
+	height: SizeAxis,
+	padding: i32,
+	color: Color,
+	name: String, // todo replace with identification enum
+	axis: Axis,
+}
+
+impl Node {
+	pub fn new() -> Self {
+		Self::default()
+	}
+
+	fn layout_width(&mut self) -> i32 {
+		self.computed_width = match self.width {
+			SizeAxis::Fixed(val) => val,
+			SizeAxis::Fit => match self.axis {
+				Axis::Horizontal => {
+					let mut width = self.padding;
+					for c in &mut self.children {
+						width += c.layout_width();
+						width += self.padding;
+					}
+					width
+				}
+				Axis::Vertical => {
+					let mut width = self.padding;
+					for c in &mut self.children {
+						width = width.max(c.layout_width());
+					}
+					width + self.padding * 2
+				}
+			},
+		};
+		self.computed_width
+	}
+
+	fn layout_height(&mut self) -> i32 {
+		self.computed_height = match self.height {
+			SizeAxis::Fixed(val) => val,
+			SizeAxis::Fit => match self.axis {
+				Axis::Horizontal => {
+					let mut height = self.padding;
+					for c in &mut self.children {
+						height = height.max(c.layout_height());
+					}
+					height + self.padding * 2
+				}
+				Axis::Vertical => {
+					let mut height = self.padding;
+					for c in &mut self.children {
+						height += c.layout_height();
+						height += self.padding;
+					}
+					height
+				}
+			},
+		};
+		self.computed_height
+	}
+
+	fn layout_position(&mut self, root_x: i32, root_y: i32) {
+		self.computed_x = root_x;
+		self.computed_y = root_y;
+		let mut x = root_x + self.padding;
+		let mut y = root_y + self.padding;
+		for c in &mut self.children {
+			c.layout_position(x, y);
+			match self.axis {
+				Axis::Horizontal => x += c.computed_width + self.padding,
+				Axis::Vertical => y += c.computed_height + self.padding,
+			}
+		}
+	}
+
+	fn draw(&self, d: &mut RaylibDrawHandle) {
+		d.draw_rectangle(
+			self.computed_x,
+			self.computed_y,
+			self.computed_width,
+			self.computed_height,
+			self.color,
+		);
+		// todo text/image content
+		for c in &self.children {
+			c.draw(d);
+		}
+	}
+
+	pub fn name(mut self, text: &str) -> Self {
+		self.name = text.to_owned();
+		self
+	}
+
+	pub fn width(mut self, width: SizeAxis) -> Self {
+		self.width = width;
+		self
+	}
+
+	pub fn height(mut self, height: SizeAxis) -> Self {
+		self.height = height;
+		self
+	}
+
+	pub fn exact(mut self, width: i32, height: i32) -> Self {
+		self.height = SizeAxis::Fixed(height);
+		self.width = SizeAxis::Fixed(width);
+		self
+	}
+
+	pub fn axis(mut self, axis: Axis) -> Self {
+		self.axis = axis;
+		self
+	}
+
+	// pub fn exact_width(mut self, val: i32) -> Self {
+	// 	self.min_width = val;
+	// 	self.pref_width = val;
+	// 	self.max_width = val;
+	// 	self
+	// }
+
+	// pub fn shrink_width(mut self, val: i32) -> Self {
+	// 	self.min_width = val;
+	// 	self.pref_width = val;
+	// 	self.max_width = val;
+	// 	self
+	// }
+
+	// pub fn grow_width(mut self, val: i32) -> Self {
+	// 	self.min_width = val;
+	// 	self.pref_width = val;
+	// 	self.max_width = i32::MAX;
+	// 	self
+	// }
+
+	// pub fn grow_height(mut self, val: i32) -> Self {
+	// 	self.min_height = val;
+	// 	self.pref_height = val;
+	// 	self.max_height = i32::MAX;
+	// 	self
+	// }
+
+	pub fn color(mut self, col: Color) -> Self {
+		self.color = col;
+		self
+	}
+
+	pub fn with_children(mut self, children: Vec<Node>) -> Self {
+		self.children = children;
+		self
+	}
+
+	pub fn pad(mut self, padding: i32) -> Self {
+		self.padding = padding;
+		self
+	}
+}
diff --git a/src/lib.rs b/src/lib.rs
index c2f29c2..fb0cef0 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -36,10 +36,11 @@ impl Globals {
 		textures.load_dir("assets/digits", rl, thread);
 
 		let config_path = userdata_dir().join(CONFIG_FILE_NAME);
-		let config = fs::read_to_string(config_path)
+		let mut config: Config = fs::read_to_string(config_path)
 			.ok()
 			.and_then(|s| serde_json::from_str(&s).ok())
 			.unwrap_or_default();
+		config.input.update_modifier_blocks();
 
 		Self {
 			clipboard: Clipboard::new()
diff --git a/src/ui2.rs b/src/ui2.rs
new file mode 100644
index 0000000..d9a7dbd
--- /dev/null
+++ b/src/ui2.rs
@@ -0,0 +1,142 @@
+use raylib::{
+	color::Color,
+	drawing::{RaylibDraw, RaylibDrawHandle},
+	RaylibHandle,
+};
+
+pub type EId = String;
+// pub enum EId{
+// }
+
+#[derive(Debug, Default)]
+pub struct UiCtx {
+	active: Option<EId>,
+	hovered: Option<EId>,
+	kb_selected: Option<EId>,
+	layout: LayoutState,
+	draw_queue: Vec<DrawCommand>,
+}
+
+#[derive(Debug, Default, Clone, Copy)]
+pub enum Axis {
+	#[default]
+	Horizontal,
+	Vertical,
+}
+
+#[derive(Debug, Clone)]
+pub enum DrawCommand {
+	Rect(Rect, Color),
+	Text(String),
+}
+
+#[derive(Debug, Clone)]
+pub struct Rect {
+	x: i32,
+	y: i32,
+	width: i32,
+	height: i32,
+}
+
+#[derive(Debug, Default, Clone)]
+pub struct LayoutState {
+	pub direction: Axis,
+	cursor_x: i32,
+	cursor_y: i32,
+	width: i32,
+	height: i32,
+	pub padding: i32,
+}
+
+type Widget = fn(&mut UiCtx) -> ();
+// type Widget = FnMut<;
+
+impl UiCtx {
+	pub fn layout(&mut self) -> &mut LayoutState {
+		&mut self.layout
+	}
+
+	pub fn begin(&mut self, d: &mut RaylibDrawHandle) {
+		self.layout = LayoutState::default();
+	}
+
+	pub fn draw(&mut self, d: &mut RaylibDrawHandle) {
+		while let Some(cmd) = self.draw_queue.pop() {
+			match cmd {
+				DrawCommand::Rect(r, col) => d.draw_rectangle(r.x, r.y, r.width, r.height, col),
+				DrawCommand::Text(_) => todo!(),
+			}
+		}
+	}
+
+	pub fn padded_container(&mut self, color: Color, axis: Axis, widget: Widget) {
+		self.layout.padding = 4;
+		self.layout.direction = axis;
+		self.layout.width = 0;
+		self.layout.height = 0;
+		let old_layout_state = self.layout.clone();
+		widget(self);
+		let width = self.layout.width;
+		let height = self.layout.height;
+		self.layout = old_layout_state;
+		self.layout.update_size_with_child(width, height);
+		// old_layout_state.update_size_with_child(self.layout.width, self.layout.height);
+		// old_layout_state.step(self.layout.width, self.layout.height);
+		self.draw_queue
+			.push(DrawCommand::Rect(self.layout.rect(), color));
+		self.layout.step(width, height);
+		// self.layout.step(width, height);
+	}
+
+	pub fn square(&mut self, color: Color, width: i32) {
+		let height = 50;
+		// self.layout.update_size_with_child(width, height);
+		self.layout.width = width;
+		self.layout.height = height;
+		self.draw_queue.push(DrawCommand::Rect(
+			self.layout.rect(),
+			color,
+		));
+		self.layout.step(width, height)
+		// self.layout.width = width;
+		// self.layout.height = height;
+		// self.layout.step(width, height)
+	}
+}
+
+impl LayoutState {
+	fn step(&mut self, width: i32, height: i32) {
+		match self.direction {
+			Axis::Horizontal => self.cursor_x += width + self.padding,
+			Axis::Vertical => self.cursor_y += height + self.padding,
+		}
+	}
+
+	fn update_size_with_child(&mut self, width: i32, height: i32) {
+		match self.direction {
+			Axis::Horizontal => {
+				self.width += width + self.padding;
+				self.height = self.height.max(height + self.padding);
+			}
+			Axis::Vertical => {
+				self.width = self.width.max(width + self.padding);
+				self.height += height + self.padding;
+			}
+		}
+	}
+
+	fn rect(&self) -> Rect {
+		Rect::new(self.cursor_x, self.cursor_y, self.width, self.height)
+	}
+}
+
+impl Rect {
+	pub fn new(x: i32, y: i32, width: i32, height: i32) -> Self {
+		Self {
+			x,
+			y,
+			width,
+			height,
+		}
+	}
+}

From 8bc770b5648e4976d5a8c754f9f044e2e7d54122 Mon Sep 17 00:00:00 2001
From: CrispyPin <crispin@tasa.se>
Date: Sat, 12 Apr 2025 20:58:36 +0200
Subject: [PATCH 03/23] update changelog

---
 CHANGELOG.md | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 17cb141..7f243f2 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,8 @@
 Game store page: https://crispypin.itch.io/marble-machinations
 
 ## [unreleased]
+### fixed
+- When two input bindings had the same trigger but one has a strict subset of the others modifiers, both would activate when the one with more modifiers was pressed. For example (Ctrl+S -> Save) would also trigger (S -> Wire Tool). Now, Shift+S will still trigger Wire Tool, unless Shift+S (or eg. Shift+Ctrl+S) is bound to something else.
 
 ## v0.3.1 - 2025-04-05
 ### fixed

From 69fe8546f523cdbb67c1f12bf0cc488f1dfd814b Mon Sep 17 00:00:00 2001
From: CrispyPin <crispin@tasa.se>
Date: Sat, 12 Apr 2025 21:10:29 +0200
Subject: [PATCH 04/23] update todo list

---
 README.md | 21 +++++++++++++++------
 1 file changed, 15 insertions(+), 6 deletions(-)

diff --git a/README.md b/README.md
index e6d4c93..d93ce2c 100644
--- a/README.md
+++ b/README.md
@@ -11,22 +11,30 @@ logic mostly like https://git.crispypin.cc/CrispyPin/marble
 ### bugs
 - modifier-less bindings trigger when typing in a text box, makes renaming existing blueprints basically impossible
 ### features
+#### 0.3.x
+- more levels
+  - deadfish
+  - brainfuck
+  - packet routing?
+  - game of life sim? (width;height;steps;grid -> grid)
+#### 0.4.0
+- UI layout engine
+  - global scale setting
+#### unspecified
+- show orphaned solutions
 - comments
   - editing
   - add to all intro levels
 - highlight regions with background colours
-- UI layout engine
-  - global scale setting
 - button + binding to flip selection that is being pasted
 - accessibility
-  - background colour setting
+  - background colour setting (requires color picker => after UI rework)
   - hotkeys for everything (no mouse needed to play)
     - menu navigation (requires UI rework)
     - speed up/down
     - grid cursor movement and placement
     - grid zoom and pan
-- more levels
-- scroll output bytes
+- UI: scroll output bytes
 - timestamps in solutions and blueprints
 - display tool variant more clearly (it's not obvious there are more states)
 - better text rendering
@@ -40,8 +48,9 @@ logic mostly like https://git.crispypin.cc/CrispyPin/marble
 - hide some tile tools in early levels to make it less overwhelming
 - footprint score (tiles that were non-empty at any point in the run)
 - option to use 8-bit marbles?
-- blueprint rotation?
+- 32 bit input/output?
 - settable marble start direction?
+  - allows blueprint rotation
 
 ## playtesting observations
 - 'loops' introduces too many things (powering, redirection, generating zeroes)

From 522a027f7a3659fa5a177a9c3445d44617d7f851 Mon Sep 17 00:00:00 2001
From: CrispyPin <crispin@tasa.se>
Date: Sun, 13 Apr 2025 00:32:05 +0200
Subject: [PATCH 05/23] allow collapsing chapters in level list

---
 CHANGELOG.md |   2 +
 src/level.rs |   6 ++
 src/main.rs  | 158 ++++++++++++++++++++++++++-------------------------
 3 files changed, 89 insertions(+), 77 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 7f243f2..75eb77f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,8 @@
 Game store page: https://crispypin.itch.io/marble-machinations
 
 ## [unreleased]
+### added
+- click to collapse chapters in level list
 ### fixed
 - When two input bindings had the same trigger but one has a strict subset of the others modifiers, both would activate when the one with more modifiers was pressed. For example (Ctrl+S -> Save) would also trigger (S -> Wire Tool). Now, Shift+S will still trigger Wire Tool, unless Shift+S (or eg. Shift+Ctrl+S) is bound to something else.
 
diff --git a/src/level.rs b/src/level.rs
index 0ef9b12..0a60a84 100644
--- a/src/level.rs
+++ b/src/level.rs
@@ -6,6 +6,8 @@ use crate::board::Board;
 pub struct Chapter {
 	pub title: String,
 	pub levels: Vec<Level>,
+	#[serde(default = "default_true")]
+	pub visible: bool,
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -81,3 +83,7 @@ impl Stage {
 		&self.output
 	}
 }
+
+fn default_true() -> bool {
+	true
+}
diff --git a/src/main.rs b/src/main.rs
index 872e913..86e4830 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -10,7 +10,7 @@ use marble_machinations::*;
 
 use config::Config;
 use editor::{Editor, ExitState};
-use level::{Chapter, Level};
+use level::Chapter;
 use solution::Solution;
 use theme::*;
 use ui::{simple_option_button, tex32_button, text_button, text_input, ShapedText, Tooltip};
@@ -19,11 +19,11 @@ use util::*;
 const TITLE_TEXT: &str = concat!("Marble Machinations v", env!("CARGO_PKG_VERSION"));
 
 struct Game {
-	levels: Vec<LevelListEntry>,
-	level_scroll: usize,
+	chapters: Vec<Chapter>,
+	level_scroll: i32,
 	solutions: HashMap<String, Vec<Solution>>,
 	open_editor: Option<Editor>,
-	selected_level: usize,
+	selected_level: (usize, usize),
 	selected_solution: usize,
 	delete_solution: Option<usize>,
 	editing_solution_name: bool,
@@ -32,12 +32,6 @@ struct Game {
 	edit_settings: Option<Config>,
 }
 
-#[derive(Debug)]
-enum LevelListEntry {
-	Level(Level),
-	Chapter(String, usize),
-}
-
 fn main() {
 	let (mut rl, thread) = raylib::init().resizable().title(TITLE_TEXT).build();
 	rl.set_target_fps(60);
@@ -52,15 +46,15 @@ fn main() {
 
 impl Game {
 	fn new(rl: &mut RaylibHandle, thread: &RaylibThread) -> Self {
-		let levels = get_levels();
+		let chapters = get_chapters();
 		let solutions = get_solutions();
 
 		Self {
-			levels,
+			chapters,
 			level_scroll: 0,
 			solutions,
 			open_editor: None,
-			selected_level: 0,
+			selected_level: (0, 0),
 			selected_solution: 0,
 			delete_solution: None,
 			editing_solution_name: false,
@@ -147,71 +141,89 @@ impl Game {
 
 		const ENTRY_SPACING: i32 = 65;
 		let fit_on_screen = (d.get_screen_height() / ENTRY_SPACING) as usize;
-		let max_scroll = self.levels.len().saturating_sub(fit_on_screen);
+		let max_scroll = self
+			.chapters
+			.iter()
+			.map(|c| 1 + if c.visible { c.levels.len() } else { 0 })
+			.sum::<usize>()
+			.saturating_sub(fit_on_screen) as i32
+			* ENTRY_SPACING;
 		if self.globals.mouse.pos().x < level_list_width as f32 {
 			if self.globals.mouse.scroll() == Some(Scroll::Down) && self.level_scroll < max_scroll {
-				self.level_scroll += 1;
+				self.level_scroll += ENTRY_SPACING;
 			}
 			if self.globals.mouse.scroll() == Some(Scroll::Up) && self.level_scroll > 0 {
-				self.level_scroll -= 1;
+				self.level_scroll -= ENTRY_SPACING;
 			}
 		}
 
-		for (row_index, level_index) in (self.level_scroll..self.levels.len()).enumerate() {
-			let level = &mut self.levels[level_index];
-			let y = 10 + row_index as i32 * ENTRY_SPACING;
-			let bounds = Rectangle {
-				x: 5.,
-				y: y as f32 - 5.,
-				width: level_list_width as f32 - 10.,
-				height: ENTRY_SPACING as f32 - 5.,
-			};
+		let mut y = 10 - self.level_scroll;
+		for (chapter_i, chapter) in self.chapters.iter_mut().enumerate() {
+			let bounds = rect(5, y - 5, level_list_width - 10, ENTRY_SPACING - 5);
+			d.draw_rectangle_rec(bounds, BG_DARK);
+			d.draw_text(&chapter.title, 10, y, 30, FG_CHAPTER_TITLE);
+			let subtitle = format!("{} levels", chapter.levels.len());
+			d.draw_text(&subtitle, 10, y + 30, 20, Color::WHITE);
+			y += ENTRY_SPACING;
 			let clicked_this =
 				self.globals.mouse.left_click() && self.globals.mouse.is_over(bounds);
-			match level {
-				LevelListEntry::Chapter(title, level_count) => {
-					d.draw_rectangle_rec(bounds, BG_DARK);
-					d.draw_text(title, 10, y, 30, FG_CHAPTER_TITLE);
-					let subtitle = format!("{level_count} levels");
-					d.draw_text(&subtitle, 10, y + 30, 20, Color::WHITE);
-				}
-				LevelListEntry::Level(level) => {
-					if clicked_this && self.selected_level != level_index {
-						self.editing_solution_name = false;
-						self.selected_level = level_index;
-						self.selected_solution = 0;
-						self.delete_solution = None;
-						// select the last solution of the level, if there is one
-						if let Some(solutions) = self.solutions.get(level.id()) {
-							self.selected_solution = solutions.len().saturating_sub(1);
-						}
-					}
-					d.draw_rectangle_rec(bounds, widget_bg(self.selected_level == level_index));
 
-					let mut title_color = Color::WHITE;
+			if clicked_this {
+				chapter.visible = !chapter.visible;
+			}
+
+			if !chapter.visible {
+				continue;
+			}
+
+			for (level_index, level) in chapter.levels.iter().enumerate() {
+				let bounds = rect(5, y - 5, level_list_width - 10, ENTRY_SPACING - 5);
+				let clicked_this =
+					self.globals.mouse.left_click() && self.globals.mouse.is_over(bounds);
+
+				if clicked_this && self.selected_level != (chapter_i, level_index) {
+					self.editing_solution_name = false;
+					self.selected_level = (chapter_i, level_index);
+					self.selected_solution = 0;
+					self.delete_solution = None;
+					// select the last solution of the level, if there is one
 					if let Some(solutions) = self.solutions.get(level.id()) {
-						if solutions.iter().any(|s| s.score.is_some()) {
-							title_color = Color::LIGHTGREEN;
-						}
+						self.selected_solution = solutions.len().saturating_sub(1);
 					}
-					d.draw_text(level.name(), 10, y, 30, title_color);
-					let solution_count = self
-						.solutions
-						.get(level.id())
-						.map(Vec::len)
-						.unwrap_or_default();
-					let subtext = format!("solutions: {solution_count}");
-					let subtext_color = if solution_count > 0 {
-						Color::GOLD
-					} else {
-						Color::LIGHTGRAY
-					};
-					d.draw_text(&subtext, 10, y + 30, 20, subtext_color);
 				}
+				d.draw_rectangle_rec(
+					bounds,
+					widget_bg(self.selected_level == (chapter_i, level_index)),
+				);
+
+				let mut title_color = Color::WHITE;
+				if let Some(solutions) = self.solutions.get(level.id()) {
+					if solutions.iter().any(|s| s.score.is_some()) {
+						title_color = Color::LIGHTGREEN;
+					}
+				}
+				d.draw_text(level.name(), 10, y, 30, title_color);
+				let solution_count = self
+					.solutions
+					.get(level.id())
+					.map(Vec::len)
+					.unwrap_or_default();
+				let subtext = format!("solutions: {solution_count}");
+				let subtext_color = if solution_count > 0 {
+					Color::GOLD
+				} else {
+					Color::LIGHTGRAY
+				};
+				d.draw_text(&subtext, 10, y + 30, 20, subtext_color);
+				y += ENTRY_SPACING;
 			}
 		}
 
-		if let Some(LevelListEntry::Level(level)) = self.levels.get(self.selected_level) {
+		if let Some(level) = self
+			.chapters
+			.get(self.selected_level.0)
+			.and_then(|c| c.levels.get(self.selected_level.1))
+		{
 			d.draw_text(level.name(), level_list_width + 10, 10, 40, Color::CYAN);
 			d.draw_text(level.id(), level_list_width + 10, 50, 10, Color::GRAY);
 
@@ -343,7 +355,7 @@ impl Game {
 	}
 }
 
-fn get_levels() -> Vec<LevelListEntry> {
+fn get_chapters() -> Vec<Chapter> {
 	let mut chapters = Vec::<Chapter>::new();
 	for d in read_dir("levels").unwrap().flatten() {
 		if let Ok(text) = read_to_string(d.path()) {
@@ -354,12 +366,6 @@ fn get_levels() -> Vec<LevelListEntry> {
 	}
 	chapters.sort_unstable_by_key(|c| c.title.clone());
 
-	let mut level_list = Vec::new();
-	for c in chapters {
-		level_list.push(LevelListEntry::Chapter(c.title, c.levels.len()));
-		level_list.extend(c.levels.into_iter().map(LevelListEntry::Level));
-	}
-
 	// user levels
 	let mut custom_levels = Vec::new();
 	let custom_level_dir = userdata_dir().join("levels");
@@ -372,15 +378,13 @@ fn get_levels() -> Vec<LevelListEntry> {
 			}
 		}
 	}
-	level_list.push(LevelListEntry::Chapter(
-		"Custom levels".into(),
-		custom_levels.len(),
-	));
-	for l in custom_levels {
-		level_list.push(LevelListEntry::Level(l));
-	}
+	chapters.push(Chapter {
+		title: "Custom levels".into(),
+		levels: custom_levels,
+		visible: true,
+	});
 
-	level_list
+	chapters
 }
 
 fn get_solutions() -> HashMap<String, Vec<Solution>> {

From 563c819900510c47c1c4a55c981f1c7fc0977737 Mon Sep 17 00:00:00 2001
From: CrispyPin <crispin@tasa.se>
Date: Sun, 13 Apr 2025 01:11:17 +0200
Subject: [PATCH 06/23] show solutions with no matching level under a 'missing
 levels' chapter

---
 CHANGELOG.md |  1 +
 README.md    |  1 -
 src/level.rs | 14 ++++++++++++++
 src/main.rs  | 37 ++++++++++++++++++++++++++++++++++---
 4 files changed, 49 insertions(+), 4 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 75eb77f..b6e086f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,6 +3,7 @@ Game store page: https://crispypin.itch.io/marble-machinations
 
 ## [unreleased]
 ### added
+- create "missing levels" section allowing access to solutions to levels that are no longer available
 - click to collapse chapters in level list
 ### fixed
 - When two input bindings had the same trigger but one has a strict subset of the others modifiers, both would activate when the one with more modifiers was pressed. For example (Ctrl+S -> Save) would also trigger (S -> Wire Tool). Now, Shift+S will still trigger Wire Tool, unless Shift+S (or eg. Shift+Ctrl+S) is bound to something else.
diff --git a/README.md b/README.md
index d93ce2c..ecedb81 100644
--- a/README.md
+++ b/README.md
@@ -21,7 +21,6 @@ logic mostly like https://git.crispypin.cc/CrispyPin/marble
 - UI layout engine
   - global scale setting
 #### unspecified
-- show orphaned solutions
 - comments
   - editing
   - add to all intro levels
diff --git a/src/level.rs b/src/level.rs
index 0a60a84..b8d37f7 100644
--- a/src/level.rs
+++ b/src/level.rs
@@ -49,6 +49,20 @@ impl IOData {
 }
 
 impl Level {
+	pub fn new_orphan(id: &str) -> Self {
+		Self {
+			id: id.to_owned(),
+			name: id.to_owned(),
+			description: String::from(
+				"No level with this id was found, but there are saved solutions pointing to it.\n
+Because input values and expected output is not available, this functions as a sandbox.\n
+This allows you to recover any machines you have built here.",
+			),
+			init_board: None,
+			stages: Vec::new(),
+		}
+	}
+
 	pub fn id(&self) -> &str {
 		&self.id
 	}
diff --git a/src/main.rs b/src/main.rs
index 86e4830..5db9b89 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -10,7 +10,7 @@ use marble_machinations::*;
 
 use config::Config;
 use editor::{Editor, ExitState};
-use level::Chapter;
+use level::{Chapter, Level};
 use solution::Solution;
 use theme::*;
 use ui::{simple_option_button, tex32_button, text_button, text_input, ShapedText, Tooltip};
@@ -46,8 +46,11 @@ fn main() {
 
 impl Game {
 	fn new(rl: &mut RaylibHandle, thread: &RaylibThread) -> Self {
-		let chapters = get_chapters();
+		let mut chapters = get_chapters();
 		let solutions = get_solutions();
+		if let Some(orphans) = find_orphans(&chapters, &solutions) {
+			chapters.push(orphans);
+		}
 
 		Self {
 			chapters,
@@ -407,9 +410,37 @@ fn get_solutions() -> HashMap<String, Vec<Solution>> {
 					}
 					solutions.sort_unstable_by_key(Solution::id);
 				}
-				by_level.insert(level_name, solutions);
+				if !solutions.is_empty() {
+					by_level.insert(level_name, solutions);
+				}
 			}
 		}
 	}
 	by_level
 }
+
+fn find_orphans(
+	chapters: &[Chapter],
+	solutions: &HashMap<String, Vec<Solution>>,
+) -> Option<Chapter> {
+	let mut orphan_levels = Vec::new();
+	'outer: for id in solutions.keys() {
+		for c in chapters {
+			for l in &c.levels {
+				if l.id() == id {
+					continue 'outer;
+				}
+			}
+		}
+		orphan_levels.push(Level::new_orphan(id))
+	}
+	if orphan_levels.is_empty() {
+		None
+	} else {
+		Some(Chapter {
+			title: "Missing levels".into(),
+			levels: orphan_levels,
+			visible: false,
+		})
+	}
+}

From 454c836b3844287d2a04d5d29a9f5b245212f47d Mon Sep 17 00:00:00 2001
From: CrispyPin <crispin@tasa.se>
Date: Sun, 13 Apr 2025 21:14:45 +0200
Subject: [PATCH 07/23] collapse chapters that are completely solved by default

---
 README.md   |  1 +
 src/main.rs | 25 ++++++++++++++++++-------
 2 files changed, 19 insertions(+), 7 deletions(-)

diff --git a/README.md b/README.md
index ecedb81..b24b022 100644
--- a/README.md
+++ b/README.md
@@ -44,6 +44,7 @@ logic mostly like https://git.crispypin.cc/CrispyPin/marble
 - show histograms
 - author name in solutions and blueprints
 ### undecided
+- option to skip (speed through with settable multiplier) first N stages, for when you are debugging something that happens in later stages
 - hide some tile tools in early levels to make it less overwhelming
 - footprint score (tiles that were non-empty at any point in the run)
 - option to use 8-bit marbles?
diff --git a/src/main.rs b/src/main.rs
index 5db9b89..6d0e32c 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -46,11 +46,8 @@ fn main() {
 
 impl Game {
 	fn new(rl: &mut RaylibHandle, thread: &RaylibThread) -> Self {
-		let mut chapters = get_chapters();
 		let solutions = get_solutions();
-		if let Some(orphans) = find_orphans(&chapters, &solutions) {
-			chapters.push(orphans);
-		}
+		let chapters = get_chapters(&solutions);
 
 		Self {
 			chapters,
@@ -358,11 +355,23 @@ impl Game {
 	}
 }
 
-fn get_chapters() -> Vec<Chapter> {
+fn get_chapters(solutions: &HashMap<String, Vec<Solution>>) -> Vec<Chapter> {
 	let mut chapters = Vec::<Chapter>::new();
 	for d in read_dir("levels").unwrap().flatten() {
 		if let Ok(text) = read_to_string(d.path()) {
-			if let Ok(chapter) = serde_json::from_str(&text) {
+			if let Ok(mut chapter) = serde_json::from_str::<Chapter>(&text) {
+				chapter.visible = false;
+				for level in &chapter.levels {
+					if solutions
+						.get(level.id())
+						.map(|s| s.iter().any(|s| s.score.is_some()))
+						!= Some(true)
+					{
+						// only expand chapters where at least one level has no complete solutions
+						chapter.visible = true;
+						break;
+					}
+				}
 				chapters.push(chapter);
 			}
 		}
@@ -386,7 +395,9 @@ fn get_chapters() -> Vec<Chapter> {
 		levels: custom_levels,
 		visible: true,
 	});
-
+	if let Some(orphans) = find_orphans(&chapters, solutions) {
+		chapters.push(orphans);
+	}
 	chapters
 }
 

From 44494f4d01f228c94f5564b2bb614afbb87a7596 Mon Sep 17 00:00:00 2001
From: CrispyPin <crispin@tasa.se>
Date: Sun, 13 Apr 2025 22:25:53 +0200
Subject: [PATCH 08/23] add key bindings for eraser, selection, blueprint list
 and 'none' tool

---
 CHANGELOG.md  |  3 ++-
 src/editor.rs | 44 +++++++++++++++++++++++++-------------------
 src/input.rs  | 11 +++++++++--
 3 files changed, 36 insertions(+), 22 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index b6e086f..58f2ef8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -5,6 +5,7 @@ Game store page: https://crispypin.itch.io/marble-machinations
 ### added
 - create "missing levels" section allowing access to solutions to levels that are no longer available
 - click to collapse chapters in level list
+- input bindings for eraser (X), selection (B), blueprint list (Ctrl B), no tool (no default binding)
 ### fixed
 - When two input bindings had the same trigger but one has a strict subset of the others modifiers, both would activate when the one with more modifiers was pressed. For example (Ctrl+S -> Save) would also trigger (S -> Wire Tool). Now, Shift+S will still trigger Wire Tool, unless Shift+S (or eg. Shift+Ctrl+S) is bound to something else.
 
@@ -16,7 +17,7 @@ Game store page: https://crispypin.itch.io/marble-machinations
 ### added
 - score number: bounding area
 - configurable key bindings for many editor actions
-- QWERTY+ASDFGH keybindings for the tile tools by default
+- QWERTY+ASDFGH key bindings for the tile tools by default
 - OS clipboard copy/paste, with fallback to old behavior when copying
 - cut selection
 - in-grid text comments (not yet editable in-game)
diff --git a/src/editor.rs b/src/editor.rs
index 4db5372..47537d6 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -1060,7 +1060,7 @@ impl Editor {
 
 			self.tooltip.add(276, y, 40, 40, "Delete");
 			if simple_button((d, &self.mouse), 276, y, 40, 40)
-				|| globals.is_pressed(ActionId::Erase)
+				|| globals.is_pressed(ActionId::EraseSelection)
 			{
 				erase_selection = true;
 			}
@@ -1091,7 +1091,7 @@ impl Editor {
 		                       texture: &str,
 		                       tooltip: &'static str,
 		                       tool_option: Tool,
-		                       action: Option<ActionId>| {
+		                       action: ActionId| {
 			let border = 4.;
 			let gap = 2.;
 			let button_size = 32. + border * 2.;
@@ -1111,20 +1111,26 @@ impl Editor {
 				tool_option,
 				&mut self.active_tool,
 				border,
-				action.map(|a| globals.is_pressed(a)).unwrap_or(false),
+				globals.is_pressed(action),
 			)
 		};
-		tool_button((0, -2), "eraser", "Eraser", Tool::Erase, None);
+		tool_button((0, -2), "eraser", "Eraser", Tool::Erase, ActionId::Eraser);
 		tool_button(
 			(1, -2),
 			"selection",
 			"Select",
 			Tool::SelectArea(Selection::default()),
-			None,
+			ActionId::Selection,
 		);
 
-		tool_button((0, -1), "blueprint", "Blueprints", Tool::Blueprint, None);
-		tool_button((1, -1), "transparent", "None", Tool::None, None);
+		tool_button(
+			(0, -1),
+			"blueprint",
+			"Blueprints",
+			Tool::Blueprint,
+			ActionId::Blueprints,
+		);
+		tool_button((1, -1), "transparent", "None", Tool::None, ActionId::NoTool);
 
 		if !hide_tile_tools {
 			tool_button(
@@ -1132,42 +1138,42 @@ impl Editor {
 				"block",
 				"Block",
 				Tool::SetTile(Tile::from_char('#')),
-				Some(ActionId::TileBlock),
+				ActionId::TileBlock,
 			);
 			tool_button(
 				(0, 1),
 				"silo_off",
 				"Silo",
 				Tool::SetTile(Tile::from_char('B')),
-				Some(ActionId::TileSilo),
+				ActionId::TileSilo,
 			);
 			tool_button(
 				(0, 2),
 				"button_off",
 				"Button",
 				Tool::SetTile(Tile::from_char('*')),
-				Some(ActionId::TileButton),
+				ActionId::TileButton,
 			);
 			tool_button(
 				(0, 3),
 				"io_tile_off",
 				"Input/Output silo",
 				Tool::SetTile(Tile::from_char('I')),
-				Some(ActionId::TileIOSilo),
+				ActionId::TileIOSilo,
 			);
 			tool_button(
 				(0, 4),
 				"flipper_off",
 				"Flipper",
 				Tool::SetTile(Tile::from_char('F')),
-				Some(ActionId::TileFlipper),
+				ActionId::TileFlipper,
 			);
 			tool_button(
 				(0, 5),
 				"digit_tool",
 				"Digit",
 				Tool::Digits(None),
-				Some(ActionId::TileDigit),
+				ActionId::TileDigit,
 			);
 
 			tool_button(
@@ -1175,14 +1181,14 @@ impl Editor {
 				"marble",
 				"Marble",
 				Tool::SetTile(Tile::from_char('o')),
-				Some(ActionId::TileMarble),
+				ActionId::TileMarble,
 			);
 			match tool_button(
 				(1, 1),
 				self.tool_wire.texture_name_off(),
 				self.tool_wire.human_name(),
 				Tool::Wire,
-				Some(ActionId::TileGroupWire),
+				ActionId::TileGroupWire,
 			) {
 				Some(Scroll::Down) => self.tool_wire.next(),
 				Some(Scroll::Up) => self.tool_wire.prev(),
@@ -1194,7 +1200,7 @@ impl Editor {
 				self.tool_arrow.arrow_tile_texture_name(),
 				self.tool_arrow.arrow_tile_human_name(),
 				Tool::Arrow,
-				Some(ActionId::TileGroupArrow),
+				ActionId::TileGroupArrow,
 			) {
 				Some(Scroll::Down) => self.tool_arrow = self.tool_arrow.right(),
 				Some(Scroll::Up) => self.tool_arrow = self.tool_arrow.left(),
@@ -1205,7 +1211,7 @@ impl Editor {
 				self.tool_mirror.texture_name(),
 				self.tool_mirror.human_name(),
 				Tool::Mirror,
-				Some(ActionId::TileGroupMirror),
+				ActionId::TileGroupMirror,
 			)
 			.is_some()
 			{
@@ -1216,7 +1222,7 @@ impl Editor {
 				self.tool_math.texture_name_off(),
 				self.tool_math.human_name(),
 				Tool::Math,
-				Some(ActionId::TileGroupMath),
+				ActionId::TileGroupMath,
 			) {
 				Some(Scroll::Down) => self.tool_math.next(),
 				Some(Scroll::Up) => self.tool_math.prev(),
@@ -1227,7 +1233,7 @@ impl Editor {
 				self.tool_comparator.texture_name_off(),
 				self.tool_comparator.human_name(),
 				Tool::Comparator,
-				Some(ActionId::TileGroupCompare),
+				ActionId::TileGroupCompare,
 			) {
 				Some(Scroll::Down) => self.tool_comparator.next(),
 				Some(Scroll::Up) => self.tool_comparator.prev(),
diff --git a/src/input.rs b/src/input.rs
index bc4241b..6ad84c6 100644
--- a/src/input.rs
+++ b/src/input.rs
@@ -23,7 +23,7 @@ pub enum ActionId {
 	Copy,
 	Cut,
 	Paste,
-	Erase,
+	EraseSelection,
 	ToggleMenu,
 	Save,
 	StartSim,
@@ -32,6 +32,10 @@ pub enum ActionId {
 	CycleGroup,
 	CycleGroupRevMod,
 
+	Eraser,
+	Selection,
+	Blueprints,
+	NoTool,
 	TileBlock,
 	TileSilo,
 	TileButton,
@@ -65,7 +69,7 @@ impl Default for Input {
 		bind_key(ActionId::Copy, vec![LCtrl], C);
 		bind_key(ActionId::Cut, vec![LCtrl], X);
 		bind_key(ActionId::Paste, vec![LCtrl], V);
-		bind_key(ActionId::Erase, vec![], Backspace);
+		bind_key(ActionId::EraseSelection, vec![], Backspace);
 		bind_key(ActionId::ToggleMenu, vec![], Escape);
 		bind_key(ActionId::Save, vec![LCtrl], S);
 		bind_key(ActionId::StartSim, vec![], Enter);
@@ -73,6 +77,9 @@ impl Default for Input {
 		bind_key(ActionId::StepSim, vec![], Space);
 		bind_key(ActionId::CycleGroup, vec![], Tab);
 		bind_key(ActionId::CycleGroupRevMod, vec![], LShift);
+		bind_key(ActionId::Eraser, vec![], X);
+		bind_key(ActionId::Blueprints, vec![LCtrl], B);
+		bind_key(ActionId::Selection, vec![], B);
 		bind_key(ActionId::TileBlock, vec![], Q);
 		bind_key(ActionId::TileSilo, vec![], W);
 		bind_key(ActionId::TileButton, vec![], E);

From 31783cc10f28baee7c6f0cd06cce9b032296b8a0 Mon Sep 17 00:00:00 2001
From: CrispyPin <crispin@tasa.se>
Date: Sun, 13 Apr 2025 22:34:42 +0200
Subject: [PATCH 09/23] fix stop sim binding not working when bound to the same
 thing as start

---
 CHANGELOG.md  |  1 +
 src/editor.rs | 21 ++++++++++++---------
 2 files changed, 13 insertions(+), 9 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 58f2ef8..651c1b8 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,7 @@ Game store page: https://crispypin.itch.io/marble-machinations
 - click to collapse chapters in level list
 - input bindings for eraser (X), selection (B), blueprint list (Ctrl B), no tool (no default binding)
 ### fixed
+- when start and stop are bound to the same thing (as by default), only start works
 - When two input bindings had the same trigger but one has a strict subset of the others modifiers, both would activate when the one with more modifiers was pressed. For example (Ctrl+S -> Save) would also trigger (S -> Wire Tool). Now, Shift+S will still trigger Wire Tool, unless Shift+S (or eg. Shift+Ctrl+S) is bound to something else.
 
 ## v0.3.1 - 2025-04-05
diff --git a/src/editor.rs b/src/editor.rs
index 47537d6..f8fa6a1 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -478,22 +478,25 @@ impl Editor {
 		if globals.is_pressed(ActionId::StepSim) {
 			self.step_pressed()
 		}
-		if globals.is_pressed(ActionId::StartSim) {
-			match self.sim_state {
-				SimState::Editing => {
+		match self.sim_state {
+			SimState::Editing => {
+				if globals.is_pressed(ActionId::StartSim) {
 					self.init_sim();
 					self.sim_state = SimState::Running;
 				}
-				SimState::Stepping => self.sim_state = SimState::Running,
-				SimState::Running => (),
 			}
-		} else if globals.is_pressed(ActionId::StopSim) {
-			match self.sim_state {
-				SimState::Running | SimState::Stepping => {
+			SimState::Stepping => {
+				if globals.is_pressed(ActionId::StartSim) {
+					self.sim_state = SimState::Running
+				} else if globals.is_pressed(ActionId::StopSim) {
 					self.sim_state = SimState::Editing;
 					self.popup = Popup::None;
 				}
-				SimState::Editing => (),
+			}
+			SimState::Running => {
+				if globals.is_pressed(ActionId::StopSim) {
+					self.sim_state = SimState::Editing;
+				}
 			}
 		}
 

From 7222993156de40c1017f3a6cb912273f1e3e4f98 Mon Sep 17 00:00:00 2001
From: CrispyPin <crispin@tasa.se>
Date: Sun, 13 Apr 2025 23:08:31 +0200
Subject: [PATCH 10/23] remove accidentally included prototype files

---
 src/layout.rs | 245 --------------------------------------------------
 src/ui2.rs    | 142 -----------------------------
 2 files changed, 387 deletions(-)
 delete mode 100644 src/layout.rs
 delete mode 100644 src/ui2.rs

diff --git a/src/layout.rs b/src/layout.rs
deleted file mode 100644
index a72a4c1..0000000
--- a/src/layout.rs
+++ /dev/null
@@ -1,245 +0,0 @@
-use raylib::{
-	color::Color,
-	drawing::{RaylibDraw, RaylibDrawHandle},
-	RaylibHandle,
-};
-
-#[derive(Debug, Default)]
-pub struct Ui {
-	root: Node,
-	width: i32,
-	height: i32,
-	dirty: bool,
-}
-
-#[derive(Debug, Default, Clone, Copy)]
-pub enum Axis {
-	#[default]
-	Horizontal,
-	Vertical,
-}
-
-impl Ui {
-	pub fn new() -> Self {
-		Self::default()
-	}
-
-	pub fn update(&mut self, rl: &RaylibHandle) {
-		let w = rl.get_screen_width();
-		let h = rl.get_screen_height();
-		if w != self.width || h != self.height {
-			self.dirty = true;
-		}
-		self.width = w;
-		self.height = h;
-
-		if self.dirty {
-			self.dirty = false;
-			self.layout();
-		}
-	}
-
-	fn layout(&mut self) {
-		// fit sizing widths
-		self.root.layout_width();
-		// grow & shrink widths
-		// wrap text
-		self.root.layout_height();
-		// fit sizing heights
-		// grow & shrink heights
-		// positions
-		self.root.layout_position(0, 0);
-	}
-
-	pub fn draw(&self, rl: &mut RaylibDrawHandle) {
-		self.root.draw(rl);
-	}
-
-	pub fn set_root(&mut self, node: Node) {
-		// self.nodes = nodes;
-		self.root = node;
-		self.dirty = true;
-	}
-}
-
-#[derive(Debug, Default, Clone)]
-pub enum SizeAxis {
-	#[default]
-	Fit,
-	Fixed(i32),
-	// Grow(),
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct Node {
-	// id: NodeId,
-	hidden: bool,
-	children: Vec<Node>,
-	computed_width: i32,
-	computed_height: i32,
-	computed_x: i32,
-	computed_y: i32,
-	// min_width: i32,
-	// min_height: i32,
-	// pref_width: i32,
-	// pref_height: i32,
-	// max_width: i32,
-	// max_height: i32,
-	width: SizeAxis,
-	height: SizeAxis,
-	padding: i32,
-	color: Color,
-	name: String, // todo replace with identification enum
-	axis: Axis,
-}
-
-impl Node {
-	pub fn new() -> Self {
-		Self::default()
-	}
-
-	fn layout_width(&mut self) -> i32 {
-		self.computed_width = match self.width {
-			SizeAxis::Fixed(val) => val,
-			SizeAxis::Fit => match self.axis {
-				Axis::Horizontal => {
-					let mut width = self.padding;
-					for c in &mut self.children {
-						width += c.layout_width();
-						width += self.padding;
-					}
-					width
-				}
-				Axis::Vertical => {
-					let mut width = self.padding;
-					for c in &mut self.children {
-						width = width.max(c.layout_width());
-					}
-					width + self.padding * 2
-				}
-			},
-		};
-		self.computed_width
-	}
-
-	fn layout_height(&mut self) -> i32 {
-		self.computed_height = match self.height {
-			SizeAxis::Fixed(val) => val,
-			SizeAxis::Fit => match self.axis {
-				Axis::Horizontal => {
-					let mut height = self.padding;
-					for c in &mut self.children {
-						height = height.max(c.layout_height());
-					}
-					height + self.padding * 2
-				}
-				Axis::Vertical => {
-					let mut height = self.padding;
-					for c in &mut self.children {
-						height += c.layout_height();
-						height += self.padding;
-					}
-					height
-				}
-			},
-		};
-		self.computed_height
-	}
-
-	fn layout_position(&mut self, root_x: i32, root_y: i32) {
-		self.computed_x = root_x;
-		self.computed_y = root_y;
-		let mut x = root_x + self.padding;
-		let mut y = root_y + self.padding;
-		for c in &mut self.children {
-			c.layout_position(x, y);
-			match self.axis {
-				Axis::Horizontal => x += c.computed_width + self.padding,
-				Axis::Vertical => y += c.computed_height + self.padding,
-			}
-		}
-	}
-
-	fn draw(&self, d: &mut RaylibDrawHandle) {
-		d.draw_rectangle(
-			self.computed_x,
-			self.computed_y,
-			self.computed_width,
-			self.computed_height,
-			self.color,
-		);
-		// todo text/image content
-		for c in &self.children {
-			c.draw(d);
-		}
-	}
-
-	pub fn name(mut self, text: &str) -> Self {
-		self.name = text.to_owned();
-		self
-	}
-
-	pub fn width(mut self, width: SizeAxis) -> Self {
-		self.width = width;
-		self
-	}
-
-	pub fn height(mut self, height: SizeAxis) -> Self {
-		self.height = height;
-		self
-	}
-
-	pub fn exact(mut self, width: i32, height: i32) -> Self {
-		self.height = SizeAxis::Fixed(height);
-		self.width = SizeAxis::Fixed(width);
-		self
-	}
-
-	pub fn axis(mut self, axis: Axis) -> Self {
-		self.axis = axis;
-		self
-	}
-
-	// pub fn exact_width(mut self, val: i32) -> Self {
-	// 	self.min_width = val;
-	// 	self.pref_width = val;
-	// 	self.max_width = val;
-	// 	self
-	// }
-
-	// pub fn shrink_width(mut self, val: i32) -> Self {
-	// 	self.min_width = val;
-	// 	self.pref_width = val;
-	// 	self.max_width = val;
-	// 	self
-	// }
-
-	// pub fn grow_width(mut self, val: i32) -> Self {
-	// 	self.min_width = val;
-	// 	self.pref_width = val;
-	// 	self.max_width = i32::MAX;
-	// 	self
-	// }
-
-	// pub fn grow_height(mut self, val: i32) -> Self {
-	// 	self.min_height = val;
-	// 	self.pref_height = val;
-	// 	self.max_height = i32::MAX;
-	// 	self
-	// }
-
-	pub fn color(mut self, col: Color) -> Self {
-		self.color = col;
-		self
-	}
-
-	pub fn with_children(mut self, children: Vec<Node>) -> Self {
-		self.children = children;
-		self
-	}
-
-	pub fn pad(mut self, padding: i32) -> Self {
-		self.padding = padding;
-		self
-	}
-}
diff --git a/src/ui2.rs b/src/ui2.rs
deleted file mode 100644
index d9a7dbd..0000000
--- a/src/ui2.rs
+++ /dev/null
@@ -1,142 +0,0 @@
-use raylib::{
-	color::Color,
-	drawing::{RaylibDraw, RaylibDrawHandle},
-	RaylibHandle,
-};
-
-pub type EId = String;
-// pub enum EId{
-// }
-
-#[derive(Debug, Default)]
-pub struct UiCtx {
-	active: Option<EId>,
-	hovered: Option<EId>,
-	kb_selected: Option<EId>,
-	layout: LayoutState,
-	draw_queue: Vec<DrawCommand>,
-}
-
-#[derive(Debug, Default, Clone, Copy)]
-pub enum Axis {
-	#[default]
-	Horizontal,
-	Vertical,
-}
-
-#[derive(Debug, Clone)]
-pub enum DrawCommand {
-	Rect(Rect, Color),
-	Text(String),
-}
-
-#[derive(Debug, Clone)]
-pub struct Rect {
-	x: i32,
-	y: i32,
-	width: i32,
-	height: i32,
-}
-
-#[derive(Debug, Default, Clone)]
-pub struct LayoutState {
-	pub direction: Axis,
-	cursor_x: i32,
-	cursor_y: i32,
-	width: i32,
-	height: i32,
-	pub padding: i32,
-}
-
-type Widget = fn(&mut UiCtx) -> ();
-// type Widget = FnMut<;
-
-impl UiCtx {
-	pub fn layout(&mut self) -> &mut LayoutState {
-		&mut self.layout
-	}
-
-	pub fn begin(&mut self, d: &mut RaylibDrawHandle) {
-		self.layout = LayoutState::default();
-	}
-
-	pub fn draw(&mut self, d: &mut RaylibDrawHandle) {
-		while let Some(cmd) = self.draw_queue.pop() {
-			match cmd {
-				DrawCommand::Rect(r, col) => d.draw_rectangle(r.x, r.y, r.width, r.height, col),
-				DrawCommand::Text(_) => todo!(),
-			}
-		}
-	}
-
-	pub fn padded_container(&mut self, color: Color, axis: Axis, widget: Widget) {
-		self.layout.padding = 4;
-		self.layout.direction = axis;
-		self.layout.width = 0;
-		self.layout.height = 0;
-		let old_layout_state = self.layout.clone();
-		widget(self);
-		let width = self.layout.width;
-		let height = self.layout.height;
-		self.layout = old_layout_state;
-		self.layout.update_size_with_child(width, height);
-		// old_layout_state.update_size_with_child(self.layout.width, self.layout.height);
-		// old_layout_state.step(self.layout.width, self.layout.height);
-		self.draw_queue
-			.push(DrawCommand::Rect(self.layout.rect(), color));
-		self.layout.step(width, height);
-		// self.layout.step(width, height);
-	}
-
-	pub fn square(&mut self, color: Color, width: i32) {
-		let height = 50;
-		// self.layout.update_size_with_child(width, height);
-		self.layout.width = width;
-		self.layout.height = height;
-		self.draw_queue.push(DrawCommand::Rect(
-			self.layout.rect(),
-			color,
-		));
-		self.layout.step(width, height)
-		// self.layout.width = width;
-		// self.layout.height = height;
-		// self.layout.step(width, height)
-	}
-}
-
-impl LayoutState {
-	fn step(&mut self, width: i32, height: i32) {
-		match self.direction {
-			Axis::Horizontal => self.cursor_x += width + self.padding,
-			Axis::Vertical => self.cursor_y += height + self.padding,
-		}
-	}
-
-	fn update_size_with_child(&mut self, width: i32, height: i32) {
-		match self.direction {
-			Axis::Horizontal => {
-				self.width += width + self.padding;
-				self.height = self.height.max(height + self.padding);
-			}
-			Axis::Vertical => {
-				self.width = self.width.max(width + self.padding);
-				self.height += height + self.padding;
-			}
-		}
-	}
-
-	fn rect(&self) -> Rect {
-		Rect::new(self.cursor_x, self.cursor_y, self.width, self.height)
-	}
-}
-
-impl Rect {
-	pub fn new(x: i32, y: i32, width: i32, height: i32) -> Self {
-		Self {
-			x,
-			y,
-			width,
-			height,
-		}
-	}
-}

From 5f5a831569815d5f0d7f9b2913561a764e6b4306 Mon Sep 17 00:00:00 2001
From: CrispyPin <crispin@tasa.se>
Date: Sun, 13 Apr 2025 23:26:06 +0200
Subject: [PATCH 11/23] ignore (but print a warning about) invalid action ids
 in the config file, instead of failing to deserialize and reverting to
 default

---
 CHANGELOG.md |  1 +
 src/input.rs | 20 ++++++++++++++------
 2 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 651c1b8..8b00185 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,6 +7,7 @@ Game store page: https://crispypin.itch.io/marble-machinations
 - click to collapse chapters in level list
 - input bindings for eraser (X), selection (B), blueprint list (Ctrl B), no tool (no default binding)
 ### fixed
+- invalid action ids in the config file key bindings caused everything to revert to default.
 - when start and stop are bound to the same thing (as by default), only start works
 - When two input bindings had the same trigger but one has a strict subset of the others modifiers, both would activate when the one with more modifiers was pressed. For example (Ctrl+S -> Save) would also trigger (S -> Wire Tool). Now, Shift+S will still trigger Wire Tool, unless Shift+S (or eg. Shift+Ctrl+S) is bound to something else.
 
diff --git a/src/input.rs b/src/input.rs
index 6ad84c6..1353373 100644
--- a/src/input.rs
+++ b/src/input.rs
@@ -110,7 +110,7 @@ enum BindingState {
 	Released,
 }
 
-type InputMap = BTreeMap<ActionId, Vec<Binding>>;
+type InputMap = BTreeMap<String, Vec<Binding>>;
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(from = "InputMap", into = "InputMap")]
@@ -390,10 +390,15 @@ pub struct Binding {
 }
 
 impl From<InputMap> for Input {
-	fn from(value: InputMap) -> Self {
+	fn from(map: InputMap) -> Self {
 		let mut new = Self::default();
-		for (action, loaded_bindings) in value {
-			new.bindings[action as usize] = loaded_bindings;
+		for (action, loaded_bindings) in map {
+			let temp_json = format!("\"{action}\"");
+			if let Ok(action) = serde_json::from_str::<ActionId>(&temp_json) {
+				new.bindings[action as usize] = loaded_bindings;
+			} else {
+				println!("'{action}' is not a valid action id, bindings discarded");
+			}
 		}
 		new
 	}
@@ -405,8 +410,11 @@ impl From<Input> for InputMap {
 			.bindings
 			.iter()
 			.enumerate()
-			// for this to panic, the .bindings array would have to be larger than ActionId::SIZE
-			.map(|(i, b)| (ActionId::from_usize(i).unwrap(), b.clone()))
+			.map(|(i, b)| {
+				// for this to panic, the .bindings array would have to be larger than ActionId::SIZE
+				let action = ActionId::from_usize(i).unwrap();
+				(format!("{action:?}"), b.clone())
+			})
 			.collect()
 	}
 }

From 0223250c88712915cf9e843613671f768fda01fe Mon Sep 17 00:00:00 2001
From: CrispyPin <crispin@tasa.se>
Date: Mon, 14 Apr 2025 19:40:01 +0200
Subject: [PATCH 12/23] add brainfuck and deadfish levels

---
 CHANGELOG.md           |  3 ++-
 README.md              |  4 +---
 levels/chapter_05.json | 44 ++++++++++++++++++++++++++++++++++++++++++
 3 files changed, 47 insertions(+), 4 deletions(-)
 create mode 100644 levels/chapter_05.json

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 8b00185..6dbdfd5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,7 +3,8 @@ Game store page: https://crispypin.itch.io/marble-machinations
 
 ## [unreleased]
 ### added
-- create "missing levels" section allowing access to solutions to levels that are no longer available
+- "weird machines" chapter with levels for [deadfish](https://esolangs.org/wiki/Deadfish) and [brainfuck](https://esolangs.org/wiki/Brainfuck)
+- "missing levels" section giving access to solutions to levels that are no longer available
 - click to collapse chapters in level list
 - input bindings for eraser (X), selection (B), blueprint list (Ctrl B), no tool (no default binding)
 ### fixed
diff --git a/README.md b/README.md
index b24b022..4808bb9 100644
--- a/README.md
+++ b/README.md
@@ -13,10 +13,8 @@ logic mostly like https://git.crispypin.cc/CrispyPin/marble
 ### features
 #### 0.3.x
 - more levels
-  - deadfish
-  - brainfuck
   - packet routing?
-  - game of life sim? (width;height;steps;grid -> grid)
+  - game of life sim (width;height;steps;grid -> grid)
 #### 0.4.0
 - UI layout engine
   - global scale setting
diff --git a/levels/chapter_05.json b/levels/chapter_05.json
new file mode 100644
index 0000000..e08eeb8
--- /dev/null
+++ b/levels/chapter_05.json
@@ -0,0 +1,44 @@
+{
+	"title": "5. Weird machines",
+	"levels": [
+		{
+			"id": "deadfish",
+			"name": "Deadfish",
+			"description": "Deadfish is a very small joke programming language. It is often used as a test program for other esoteric programming languages. Marble machinations is now one of them.\n\n There are four commands:\ni: increment the accumulator\nd: decrement the accumulator\ns: square the accumulator\no: output the accumulator\n\n if the value becomes -1 or 256, it should be set to zero.\n\nThe test cases are taken from esolangs.org/wiki/Deadfish",
+			"stages": [{
+				"input": "iiso",
+				"output": "4"
+			},{
+				"input": "iissso",
+				"output": "0"
+			},{
+				"input": "diissisdo",
+				"output": "288"
+			},{
+				"input": "iissisdddddddddddddddddddddddddddddddddo",
+				"output": "0"
+			}]
+		},
+		{
+			"id": "brainfuck",
+			"name": "Brainfuck",
+			"description": "The language brainfuck operates on a 'tape' of bytes, with a pointer that can be moved left and right. Level input is formatted as '<program>#<input>'.\n(separator # is 35)\n\n+ (43): increment\n- (45): decrement\n< (60): move left\n> (62): move right\n, (44): input\n. (46): output\n[ (91): skip to matching ] if current value is zero\n] (93): jump to matching [ if current value is not zero\n\nmaximum memory needed: 32 bytes\nlongest program: 106 commands",
+			"stages":[{
+				"input": ">><[]++++++++-.#",
+				"output": [7]
+			},{
+				"input": ",>,>,>,.<.<.<.#woem",
+				"output": "meow"
+			},{
+				"input": "++++[++++.]#",
+				"output": [8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 68, 72, 76, 80, 84, 88, 92, 96, 100, 104, 108, 112, 116, 120, 124, 128, 132, 136, 140, 144, 148, 152, 156, 160, 164, 168, 172, 176, 180, 184, 188, 192, 196, 200, 204, 208, 212, 216, 220, 224, 228, 232, 236, 240, 244, 248, 252, 0]
+			},{
+				"input": "-[>,]<+[-.<+]-#reverse cat program",
+				"output": "margorp tac esrever"
+			},{
+				"input": "++++++++[>++++[>++>+++>+++>+<<<<-]>+>+>->>+[<]<-]>>.>---.+++++++..+++.>>.<-.<.+++.------.--------.>>+.>++.#",
+				"output": "Hello World!\n"
+			}]
+		}
+	]
+}
\ No newline at end of file

From df58b6271287f5abf42804ac599e5e956d8edc24 Mon Sep 17 00:00:00 2001
From: CrispyPin <crispin@tasa.se>
Date: Mon, 14 Apr 2025 19:41:39 +0200
Subject: [PATCH 13/23] bump version to 0.3.2

---
 CHANGELOG.md | 2 +-
 Cargo.lock   | 2 +-
 Cargo.toml   | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 6dbdfd5..3c3a30d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,7 +1,7 @@
 # Marble Machinations Change Log
 Game store page: https://crispypin.itch.io/marble-machinations
 
-## [unreleased]
+## v0.3.2 - 2025-04-14
 ### added
 - "weird machines" chapter with levels for [deadfish](https://esolangs.org/wiki/Deadfish) and [brainfuck](https://esolangs.org/wiki/Brainfuck)
 - "missing levels" section giving access to solutions to levels that are no longer available
diff --git a/Cargo.lock b/Cargo.lock
index 0481cd8..afd877d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -213,7 +213,7 @@ checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
 
 [[package]]
 name = "marble-machinations"
-version = "0.3.1"
+version = "0.3.2"
 dependencies = [
  "arboard",
  "raylib",
diff --git a/Cargo.toml b/Cargo.toml
index 91b6fc2..9ec68ee 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "marble-machinations"
-version = "0.3.1"
+version = "0.3.2"
 edition = "2021"
 default-run = "marble-machinations"
 

From 62fcb538a65fb8ed5a06e0cdfa145a4b667fa2f4 Mon Sep 17 00:00:00 2001
From: CrispyPin <crispin@tasa.se>
Date: Tue, 15 Apr 2025 22:12:45 +0200
Subject: [PATCH 14/23] fix bindings not updating blocking data after a binding
 is deleted

---
 CHANGELOG.md | 6 +++++-
 src/input.rs | 1 +
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3c3a30d..f1a4c48 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,6 +1,10 @@
 # Marble Machinations Change Log
 Game store page: https://crispypin.itch.io/marble-machinations
 
+## [unreleased]
+### fixed
+- after removing a binding that was a superset of another, the remaining one did not stop being blocked by the removed ones additional modifiers until another binding was added or edited
+
 ## v0.3.2 - 2025-04-14
 ### added
 - "weird machines" chapter with levels for [deadfish](https://esolangs.org/wiki/Deadfish) and [brainfuck](https://esolangs.org/wiki/Brainfuck)
@@ -10,7 +14,7 @@ Game store page: https://crispypin.itch.io/marble-machinations
 ### fixed
 - invalid action ids in the config file key bindings caused everything to revert to default.
 - when start and stop are bound to the same thing (as by default), only start works
-- When two input bindings had the same trigger but one has a strict subset of the others modifiers, both would activate when the one with more modifiers was pressed. For example (Ctrl+S -> Save) would also trigger (S -> Wire Tool). Now, Shift+S will still trigger Wire Tool, unless Shift+S (or eg. Shift+Ctrl+S) is bound to something else.
+- when two input bindings had the same trigger but one has a strict subset of the others modifiers, both would activate when the one with more modifiers was pressed. For example (Ctrl+S -> Save) would also trigger (S -> Wire Tool). Now, Shift+S will still trigger Wire Tool, unless Shift+S (or eg. Shift+Ctrl+S) is bound to something else.
 
 ## v0.3.1 - 2025-04-05
 ### fixed
diff --git a/src/input.rs b/src/input.rs
index 1353373..927790d 100644
--- a/src/input.rs
+++ b/src/input.rs
@@ -144,6 +144,7 @@ impl Input {
 			for (binding_index, binding) in self.bindings[action_index].iter().enumerate() {
 				if text_button(d, &globals.mouse, buttons_x, y, 80, "remove") {
 					self.bindings[action_index].remove(binding_index);
+					self.update_modifier_blocks();
 					return;
 				}
 				if text_button(d, &globals.mouse, buttons_x + 85, y, 45, "edit") {

From 509b577aaa765e932154d71b78f0cacb1ce3c5ed Mon Sep 17 00:00:00 2001
From: CrispyPin <crispin@tasa.se>
Date: Wed, 16 Apr 2025 22:30:22 +0200
Subject: [PATCH 15/23] disable all input bindings while in a text edit box

---
 CHANGELOG.md  |   1 +
 README.md     |   4 +-
 src/editor.rs | 120 ++++++++++++++++++++++++++++++++++----------------
 src/input.rs  |  15 ++++---
 src/main.rs   |   2 +-
 src/ui.rs     |  13 ++++--
 6 files changed, 104 insertions(+), 51 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f1a4c48..fc9425d 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,6 +3,7 @@ Game store page: https://crispypin.itch.io/marble-machinations
 
 ## [unreleased]
 ### fixed
+- keybindings activated even when typing in a text field, making especially renaming blueprints difficult
 - after removing a binding that was a superset of another, the remaining one did not stop being blocked by the removed ones additional modifiers until another binding was added or edited
 
 ## v0.3.2 - 2025-04-14
diff --git a/README.md b/README.md
index 4808bb9..f873cb3 100644
--- a/README.md
+++ b/README.md
@@ -7,9 +7,9 @@ logic mostly like https://git.crispypin.cc/CrispyPin/marble
 ## todo
 ### meta
 - engine tests
-- blag post about marble movement logic
+- blag post about marble movement logic?
 ### bugs
-- modifier-less bindings trigger when typing in a text box, makes renaming existing blueprints basically impossible
+
 ### features
 #### 0.3.x
 - more levels
diff --git a/src/editor.rs b/src/editor.rs
index f8fa6a1..ac41159 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -574,27 +574,35 @@ impl Editor {
 		}
 	}
 
-	fn draw_board(&self, d: &mut RaylibDrawHandle, textures: &Textures) {
+	fn draw_board(&self, d: &mut RaylibDrawHandle, globals: &Globals) {
 		if self.sim_state == SimState::Editing {
 			self.source_board
 				.grid
-				.draw(d, textures, self.view_offset, self.zoom);
+				.draw(d, &globals.textures, self.view_offset, self.zoom);
 		} else {
 			if self.machine.debug_subticks.is_empty() {
 				self.machine
 					.grid()
-					.draw(d, textures, self.view_offset, self.zoom);
+					.draw(d, &globals.textures, self.view_offset, self.zoom);
 			} else {
 				let subframe = &self.machine.debug_subticks[self.machine.subtick_index];
-				subframe.grid.draw(d, textures, self.view_offset, self.zoom);
+				subframe
+					.grid
+					.draw(d, &globals.textures, self.view_offset, self.zoom);
 				if let Some(pos) = subframe.pos {
 					let p = self.pos_to_screen(pos.to_vec());
-					d.draw_texture_ex(textures.get("selection"), p, 0., self.zoom, Color::ORANGE);
+					d.draw_texture_ex(
+						globals.get_tex("selection"),
+						p,
+						0.,
+						self.zoom,
+						Color::ORANGE,
+					);
 				}
 			}
 			if self.draw_overlay {
 				self.machine
-					.draw_marble_values(d, textures, self.view_offset, self.zoom);
+					.draw_marble_values(d, &globals.textures, self.view_offset, self.zoom);
 			}
 		}
 		if self.draw_overlay {
@@ -620,13 +628,13 @@ impl Editor {
 			}
 		}
 
-		self.draw_board(d, &globals.textures);
-		self.board_overlay(d, &globals.textures);
+		self.draw_board(d, globals);
+		self.board_overlay(d, globals);
 		self.draw_bottom_bar(d, globals);
 		self.draw_top_bar(d, globals);
 
 		if self.active_tool == Tool::Blueprint {
-			self.draw_blueprint_sidebar(d, &globals.textures);
+			self.draw_blueprint_sidebar(d, globals);
 		}
 
 		self.mouse.update(d);
@@ -676,7 +684,7 @@ impl Editor {
 		self.tooltip.draw(d);
 	}
 
-	fn draw_blueprint_sidebar(&mut self, d: &mut RaylibDrawHandle, textures: &Textures) {
+	fn draw_blueprint_sidebar(&mut self, d: &mut RaylibDrawHandle, globals: &mut Globals) {
 		let sidebar_height = d.get_screen_height() - FOOTER_HEIGHT - HEADER_HEIGHT - 40;
 		d.draw_rectangle(
 			0,
@@ -700,7 +708,7 @@ impl Editor {
 			if tex32_button(
 				(d, &self.mouse),
 				(5, y),
-				textures.get("rubbish"),
+				globals.get_tex("rubbish"),
 				(&mut self.tooltip, "Delete"),
 			) {
 				b.remove_file();
@@ -711,7 +719,7 @@ impl Editor {
 			let mut text_selected = is_selected && self.blueprint_name_selected;
 			text_input(
 				d,
-				&self.mouse,
+				globals,
 				Rectangle::new(42., y as f32, 200., 32.),
 				&mut b.name,
 				&mut text_selected,
@@ -730,7 +738,7 @@ impl Editor {
 			);
 
 			d.draw_texture_ex(
-				textures.get("blueprint"),
+				globals.get_tex("blueprint"),
 				Vector2::new((42 + 205) as f32, y as f32),
 				0.,
 				2.,
@@ -789,8 +797,7 @@ impl Editor {
 		}
 	}
 
-	fn draw_top_bar(&mut self, d: &mut RaylibDrawHandle, globals: &Globals) {
-		let textures = &globals.textures;
+	fn draw_top_bar(&mut self, d: &mut RaylibDrawHandle, globals: &mut Globals) {
 		// background
 		d.draw_rectangle(
 			0,
@@ -803,7 +810,7 @@ impl Editor {
 		if tex32_button(
 			(d, &self.mouse),
 			(4, 4),
-			textures.get("exit"),
+			globals.get_tex("exit"),
 			(&mut self.tooltip, "exit"),
 		) {
 			if self.exit_menu {
@@ -816,7 +823,7 @@ impl Editor {
 			if tex32_button(
 				(d, &self.mouse),
 				(40, 4),
-				textures.get("cancel"),
+				globals.get_tex("cancel"),
 				(&mut self.tooltip, "cancel"),
 			) {
 				self.exit_menu = false;
@@ -824,7 +831,7 @@ impl Editor {
 		} else if tex32_button(
 			(d, &self.mouse),
 			(40, 4),
-			textures.get("save"),
+			globals.get_tex("save"),
 			(&mut self.tooltip, "save"),
 		) || globals.is_pressed(ActionId::Save)
 		{
@@ -844,7 +851,7 @@ impl Editor {
 			if tex32_button(
 				(d, &self.mouse),
 				(150, 4),
-				textures.get(undo_icon),
+				globals.get_tex(undo_icon),
 				(&mut self.tooltip, "Undo"),
 			) {
 				self.undo()
@@ -858,7 +865,7 @@ impl Editor {
 			if tex32_button(
 				(d, &self.mouse),
 				(186, 4),
-				textures.get(redo_icon),
+				globals.get_tex(redo_icon),
 				(&mut self.tooltip, "Redo"),
 			) {
 				self.redo()
@@ -873,7 +880,7 @@ impl Editor {
 		if tex32_button(
 			(d, &self.mouse),
 			(223, 4),
-			textures.get(overlay_btn_icon),
+			globals.get_tex(overlay_btn_icon),
 			(&mut self.tooltip, "Toggle overlay"),
 		) {
 			self.draw_overlay = !self.draw_overlay;
@@ -883,7 +890,7 @@ impl Editor {
 			if tex32_button(
 				(d, &self.mouse),
 				(260, 4),
-				textures.get("pause"),
+				globals.get_tex("pause"),
 				(&mut self.tooltip, "Pause"),
 			) {
 				self.sim_state = SimState::Stepping;
@@ -891,7 +898,7 @@ impl Editor {
 		} else if tex32_button(
 			(d, &self.mouse),
 			(260, 4),
-			textures.get("play"),
+			globals.get_tex("play"),
 			(&mut self.tooltip, "Start"),
 		) {
 			if self.sim_state == SimState::Editing {
@@ -904,7 +911,7 @@ impl Editor {
 			&& tex32_button(
 				(d, &self.mouse),
 				(296, 4),
-				textures.get("stop"),
+				globals.get_tex("stop"),
 				(&mut self.tooltip, "Stop"),
 			) {
 			self.sim_state = SimState::Editing;
@@ -914,14 +921,21 @@ impl Editor {
 		if tex32_button(
 			(d, &self.mouse),
 			(332, 4),
-			textures.get("step"),
+			globals.get_tex("step"),
 			(&mut self.tooltip, "Step"),
 		) {
 			self.step_pressed();
 		}
 
 		self.tooltip.add(368, 4, 48, 32, "Speed");
-		draw_usize(d, textures, 1 << self.sim_speed, (368, 4), SPEED_DIGITS, 1);
+		draw_usize(
+			d,
+			&globals.textures,
+			1 << self.sim_speed,
+			(368, 4),
+			SPEED_DIGITS,
+			1,
+		);
 		slider(
 			(d, &self.mouse),
 			rect(368, 24, 48, 12),
@@ -931,20 +945,48 @@ impl Editor {
 		);
 
 		self.tooltip.add(420, 4, 180, 32, "Steps");
-		draw_usize(d, textures, self.machine.step_count(), (420, 4), 9, 2);
+		draw_usize(
+			d,
+			&globals.textures,
+			self.machine.step_count(),
+			(420, 4),
+			9,
+			2,
+		);
 		if self.stage > Some(0) {
 			self.tooltip.add(420, 44, 180, 32, "Total steps");
 			let total_steps = self.total_steps + self.machine.step_count();
-			draw_usize(d, textures, total_steps, (420, 44), 9, 2);
+			draw_usize(d, &globals.textures, total_steps, (420, 44), 9, 2);
 		}
 
-		draw_usize(d, textures, self.step_time as usize, (260, 42), 9, 1);
-		draw_usize(d, textures, self.max_step_time as usize, (260, 60), 9, 1);
+		draw_usize(
+			d,
+			&globals.textures,
+			self.step_time as usize,
+			(260, 42),
+			9,
+			1,
+		);
+		draw_usize(
+			d,
+			&globals.textures,
+			self.max_step_time as usize,
+			(260, 60),
+			9,
+			1,
+		);
 		#[cfg(debug_assertions)]
 		{
-			draw_usize(d, textures, self.machine.subtick_index, (260, 80), 9, 1);
+			draw_usize(
+				d,
+				&globals.textures,
+				self.machine.subtick_index,
+				(260, 80),
+				9,
+				1,
+			);
 			let subtick_count = self.machine.debug_subticks.len();
-			draw_usize(d, textures, subtick_count, (260, 100), 9, 1);
+			draw_usize(d, &globals.textures, subtick_count, (260, 100), 9, 1);
 		}
 
 		d.draw_text("input:", 603, 8, 10, Color::WHITE);
@@ -967,7 +1009,7 @@ impl Editor {
 			}
 			if text_input(
 				d,
-				&self.mouse,
+				globals,
 				Rectangle::new(input_x as f32, 5., (width - input_x - 5) as f32, 30.),
 				&mut input_text,
 				&mut self.input_text_selected,
@@ -1021,7 +1063,7 @@ impl Editor {
 			hide_tile_tools = true;
 			text_input(
 				d,
-				&self.mouse,
+				globals,
 				Rectangle::new(100., footer_top + 10., 240., 30.),
 				&mut self.new_blueprint_name,
 				&mut self.blueprint_name_selected,
@@ -1317,7 +1359,7 @@ impl Editor {
 		}
 	}
 
-	fn board_overlay(&mut self, d: &mut RaylibDrawHandle, textures: &Textures) {
+	fn board_overlay(&mut self, d: &mut RaylibDrawHandle, globals: &Globals) {
 		let footer_top = (d.get_screen_height() - FOOTER_HEIGHT) as f32;
 
 		let tile_size = TILE_TEXTURE_SIZE * self.zoom;
@@ -1336,7 +1378,7 @@ impl Editor {
 					offset.x -= offset.x.rem(tile_size);
 					offset.y -= offset.y.rem(tile_size);
 					offset += view_offset;
-					board.grid.draw(d, textures, offset, self.zoom);
+					board.grid.draw(d, &globals.textures, offset, self.zoom);
 					board.draw_comments(d, offset, self.zoom);
 					if self.mouse.left_click() {
 						let tile_pos = (self.mouse.pos() - self.view_offset) / tile_size;
@@ -1350,7 +1392,7 @@ impl Editor {
 			if let Tool::Digits(Some(pos)) = &mut self.active_tool {
 				let tile_screen_pos = pos.to_vec() * tile_size + self.view_offset;
 				d.draw_texture_ex(
-					textures.get("selection"),
+					globals.get_tex("selection"),
 					tile_screen_pos,
 					0.,
 					self.zoom,
@@ -1403,7 +1445,7 @@ impl Editor {
 					};
 
 					d.draw_texture_ex(
-						textures.get(tex),
+						globals.get_tex(tex),
 						tile_screen_pos,
 						0.,
 						self.zoom,
@@ -1473,7 +1515,7 @@ impl Editor {
 						offset.x -= offset.x.rem(tile_size);
 						offset.y -= offset.y.rem(tile_size);
 						offset += view_offset;
-						bp.board.grid.draw(d, textures, offset, self.zoom);
+						bp.board.grid.draw(d, &globals.textures, offset, self.zoom);
 						bp.board.draw_comments(d, offset, self.zoom);
 					}
 					if self.mouse.pos().x < SIDEBAR_WIDTH as f32 {
diff --git a/src/input.rs b/src/input.rs
index 927790d..b8e3f6b 100644
--- a/src/input.rs
+++ b/src/input.rs
@@ -97,6 +97,7 @@ impl Default for Input {
 			bindings,
 			states: Default::default(),
 			editing_binding: None,
+			in_text_edit: false,
 		}
 	}
 }
@@ -118,6 +119,7 @@ pub struct Input {
 	bindings: [Vec<Binding>; ActionId::SIZE],
 	states: [BindingState; ActionId::SIZE],
 	editing_binding: Option<(ActionId, usize, BindingEdit)>,
+	pub in_text_edit: bool,
 }
 
 #[derive(Clone, Debug)]
@@ -284,11 +286,13 @@ impl Input {
 		for i in 0..ActionId::SIZE {
 			let bindings = &self.bindings[i];
 			let mut is_active = false;
-			for binding in bindings {
-				if binding.modifiers.iter().all(|&m| m.is_down(rl))
-					&& !binding.blocking_modifiers.iter().any(|&m| m.is_down(rl))
-				{
-					is_active |= binding.trigger.is_down(rl);
+			if !self.in_text_edit {
+				for binding in bindings {
+					if binding.modifiers.iter().all(|&m| m.is_down(rl))
+						&& !binding.blocking_modifiers.iter().any(|&m| m.is_down(rl))
+					{
+						is_active |= binding.trigger.is_down(rl);
+					}
 				}
 			}
 			let state = &mut self.states[i];
@@ -304,6 +308,7 @@ impl Input {
 				}
 			}
 		}
+		self.in_text_edit = false;
 	}
 
 	pub fn is_pressed(&self, action: ActionId) -> bool {
diff --git a/src/main.rs b/src/main.rs
index 6d0e32c..c0978e6 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -315,7 +315,7 @@ impl Game {
 					let bounds = Rectangle::new(column_x as f32, y as f32, 220., 30.);
 					if text_input(
 						d,
-						&self.globals.mouse,
+						&mut self.globals,
 						bounds,
 						&mut solution.name,
 						&mut self.editing_solution_name,
diff --git a/src/ui.rs b/src/ui.rs
index 32c80f0..47199b0 100644
--- a/src/ui.rs
+++ b/src/ui.rs
@@ -1,6 +1,10 @@
 use std::ops::Range;
 
-use crate::{theme::*, util::draw_scaled_texture, util::MouseInput, util::Scroll, util::Textures};
+use crate::{
+	theme::*,
+	util::{draw_scaled_texture, MouseInput, Scroll, Textures},
+	Globals,
+};
 use raylib::prelude::*;
 
 #[derive(Debug)]
@@ -225,7 +229,7 @@ where
 
 pub fn text_input(
 	d: &mut RaylibDrawHandle,
-	mouse: &MouseInput,
+	globals: &mut Globals,
 	bounds: Rectangle,
 	text: &mut String,
 	is_selected: &mut bool,
@@ -262,12 +266,13 @@ pub fn text_input(
 			Color::WHITE,
 		);
 	};
-	if editable && mouse.left_click() && (mouse.is_over(bounds) || *is_selected) {
+	if editable && globals.mouse.left_click() && (globals.mouse.is_over(bounds) || *is_selected) {
 		*is_selected = !*is_selected;
 	}
 
 	if *is_selected {
-		if d.is_key_pressed(KeyboardKey::KEY_ESCAPE) {
+		globals.config.input.in_text_edit = true;
+		if d.is_key_pressed(KeyboardKey::KEY_ESCAPE) || d.is_key_pressed(KeyboardKey::KEY_ENTER) {
 			*is_selected = false;
 		}
 		if d.is_key_pressed(KeyboardKey::KEY_BACKSPACE) && !text.is_empty() {

From f0b878e93d0426f8d02b18723002271679c4fce0 Mon Sep 17 00:00:00 2001
From: CrispyPin <crispin@tasa.se>
Date: Sun, 20 Apr 2025 19:54:53 +0200
Subject: [PATCH 16/23] fix crash when saving config before user dir exists

---
 CHANGELOG.md |  1 +
 README.md    | 10 ++++++++--
 src/main.rs  | 11 ++++++++---
 3 files changed, 17 insertions(+), 5 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fc9425d..e3ad623 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -3,6 +3,7 @@ Game store page: https://crispypin.itch.io/marble-machinations
 
 ## [unreleased]
 ### fixed
+- crash when saving config if no user dir exists
 - keybindings activated even when typing in a text field, making especially renaming blueprints difficult
 - after removing a binding that was a superset of another, the remaining one did not stop being blocked by the removed ones additional modifiers until another binding was added or edited
 
diff --git a/README.md b/README.md
index f873cb3..f2233e7 100644
--- a/README.md
+++ b/README.md
@@ -9,12 +9,17 @@ logic mostly like https://git.crispypin.cc/CrispyPin/marble
 - engine tests
 - blag post about marble movement logic?
 ### bugs
-
+- input tiles still consume input when their marble creation is blocked
+- Shift+A and A+Shift conflict
+- rigt side grid rendering broken
 ### features
 #### 0.3.x
 - more levels
   - packet routing?
   - game of life sim (width;height;steps;grid -> grid)
+- show level name in end popup
+- hide timing debug info by default
+- shrink button
 #### 0.4.0
 - UI layout engine
   - global scale setting
@@ -26,6 +31,7 @@ logic mostly like https://git.crispypin.cc/CrispyPin/marble
 - button + binding to flip selection that is being pasted
 - accessibility
   - background colour setting (requires color picker => after UI rework)
+  - light theme for UI
   - hotkeys for everything (no mouse needed to play)
     - menu navigation (requires UI rework)
     - speed up/down
@@ -42,7 +48,7 @@ logic mostly like https://git.crispypin.cc/CrispyPin/marble
 - show histograms
 - author name in solutions and blueprints
 ### undecided
-- option to skip (speed through with settable multiplier) first N stages, for when you are debugging something that happens in later stages
+- option to skip (speed through with settable multiplier) first N stages or cycles, for when you are debugging something that happens in later stages
 - hide some tile tools in early levels to make it less overwhelming
 - footprint score (tiles that were non-empty at any point in the run)
 - option to use 8-bit marbles?
diff --git a/src/main.rs b/src/main.rs
index c0978e6..6d2b0eb 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -1,6 +1,6 @@
 use std::{
 	collections::HashMap,
-	fs::{read_dir, read_to_string, File},
+	fs::{create_dir_all, read_dir, read_to_string, File},
 	io::Write,
 };
 
@@ -348,10 +348,15 @@ impl Game {
 	}
 
 	fn save_config(&self) {
+		_ = create_dir_all(userdata_dir());
 		let path = userdata_dir().join(CONFIG_FILE_NAME);
 		let json = serde_json::to_string_pretty(&self.globals.config).unwrap();
-		let mut f = File::create(path).unwrap();
-		f.write_all(json.as_bytes()).unwrap();
+		match File::create(path) {
+			Ok(mut f) => {
+				_ = f.write_all(json.as_bytes());
+			}
+			Err(e) => println!("error saving config: {e}"),
+		}
 	}
 }
 

From 80ab3b676eead4f52507380e9607e033ce2d9f96 Mon Sep 17 00:00:00 2001
From: CrispyPin <crispin@tasa.se>
Date: Sun, 20 Apr 2025 20:35:22 +0200
Subject: [PATCH 17/23] fix input being consumed even when marble creation is
 blocked; made multiple simultaneous inputs use the same value

---
 CHANGELOG.md         |  4 ++++
 README.md            |  1 -
 src/marble_engine.rs | 22 +++++++++++++---------
 tests/main.rs        | 17 ++++++++++++++++-
 4 files changed, 33 insertions(+), 11 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index e3ad623..f91ab89 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,7 +2,11 @@
 Game store page: https://crispypin.itch.io/marble-machinations
 
 ## [unreleased]
+### changed
+- when multiple I/O silos (or multiple directions of one) are activated in the same tick, they will all output the same value instead of pulling input in an arbitrary order
+
 ### fixed
+- input bytes are consumed even if the marble can't be created because another one was taking its place
 - crash when saving config if no user dir exists
 - keybindings activated even when typing in a text field, making especially renaming blueprints difficult
 - after removing a binding that was a superset of another, the remaining one did not stop being blocked by the removed ones additional modifiers until another binding was added or edited
diff --git a/README.md b/README.md
index f2233e7..5114600 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,6 @@ logic mostly like https://git.crispypin.cc/CrispyPin/marble
 - engine tests
 - blag post about marble movement logic?
 ### bugs
-- input tiles still consume input when their marble creation is blocked
 - Shift+A and A+Shift conflict
 - rigt side grid rendering broken
 ### features
diff --git a/src/marble_engine.rs b/src/marble_engine.rs
index aee8eee..7bd40a3 100644
--- a/src/marble_engine.rs
+++ b/src/marble_engine.rs
@@ -21,7 +21,7 @@ pub struct Machine {
 	// used across steps
 	powered: Vec<Pos>,
 	// used within steps
-	new_marbles: Vec<(Pos, MarbleValue, Direction)>,
+	new_marbles: Vec<(Pos, MarbleValue, Direction, bool)>,
 	influenced_direction: Vec<(bool, DirInfluence)>,
 	claim_positions: Vec<Pos>,
 	removed_marbles: Vec<usize>,
@@ -216,20 +216,19 @@ impl Machine {
 										MathOp::Div => val_a.checked_div(val_b).unwrap_or_default(),
 										MathOp::Rem => val_a.checked_rem(val_b).unwrap_or_default(),
 									};
-									self.new_marbles.push((front_pos, value, dir));
+									self.new_marbles.push((front_pos, value, dir, false));
 								}
 							}
 							PTile::IO => {
 								if front_tile == &Tile::BLANK && self.input_index < self.input.len()
 								{
 									let value = self.input[self.input_index] as MarbleValue;
-									self.input_index += 1;
-									self.new_marbles.push((front_pos, value, dir));
+									self.new_marbles.push((front_pos, value, dir, true));
 								}
 							}
 							PTile::Silo => {
 								if front_tile == &Tile::BLANK {
-									self.new_marbles.push((front_pos, 0, dir));
+									self.new_marbles.push((front_pos, 0, dir, false));
 								}
 							}
 							PTile::Flipper => {
@@ -321,9 +320,9 @@ impl Machine {
 	#[cfg_attr(feature = "inline_less", inline(never), no_mangle)]
 	fn step_prepare_creating_marbles(&mut self) {
 		// #### new marbles ####
-		// self.claim_positions.clear(); // already drained
-		// prepare creating the new marbles
-		for &(pos, _val, _dir) in &self.new_marbles {
+		self.claim_positions.clear(); // already drained
+								// prepare creating the new marbles
+		for &(pos, _val, _dir, _is_input) in &self.new_marbles {
 			let Some(Tile::Open(OpenTile::Blank, claim)) = self.grid.get_mut(pos) else {
 				unreachable!()
 			};
@@ -336,15 +335,20 @@ impl Machine {
 	#[cfg_attr(feature = "inline_less", inline(never), no_mangle)]
 	fn step_create_marbles(&mut self) {
 		// create new marbles
+		let mut advance_input = false;
 		// new marbles are past old_marbles index, so will not move this step
-		for (pos, value, dir) in self.new_marbles.drain(..) {
+		for (pos, value, dir, is_input) in self.new_marbles.drain(..) {
 			let Some(Tile::Open(OpenTile::Blank, Claim::ClaimedIndirect)) = self.grid.get_mut(pos)
 			else {
 				continue;
 			};
+			advance_input |= is_input;
 			self.grid.set(pos, Tile::Marble { value, dir });
 			self.marbles.push(pos);
 		}
+		if advance_input {
+			self.input_index += 1;
+		}
 	}
 
 	#[cfg_attr(feature = "inline_less", inline(never), no_mangle)]
diff --git a/tests/main.rs b/tests/main.rs
index 1951b9f..1d194f2 100644
--- a/tests/main.rs
+++ b/tests/main.rs
@@ -1,8 +1,9 @@
 use marble_machinations::marble_engine::{grid::Grid, Machine};
 
-fn no_input_test(steps: usize, output: &[u8], grid: &str) {
+fn do_test(steps: usize, input: &[u8], output: &[u8], grid: &str) {
 	let mut engine = Machine::new_empty();
 	engine.set_grid(Grid::from_ascii(grid));
+	engine.set_input(input.to_owned());
 	for _ in 0..(steps - 1) {
 		engine.step();
 	}
@@ -11,11 +12,25 @@ fn no_input_test(steps: usize, output: &[u8], grid: &str) {
 	assert_eq!(engine.output(), output, "expected output");
 }
 
+fn no_input_test(steps: usize, output: &[u8], grid: &str) {
+	do_test(steps, &[], output, grid)
+}
+
 #[test]
 fn creating_marbles_cause_indirect_claim() {
 	no_input_test(3, &[1], "  o  \n|-*-|\n| 1 |\n-B B-\n  I\n");
 }
 
+#[test]
+fn bug_input_consumed_when_marble_creation_blocked() {
+	do_test(
+		4,
+		&[1, 2, 3],
+		&[1, 1],
+		"#  +-+\nIIo| I\n  *+B\nII\n++*\n#    #\n",
+	);
+}
+
 #[test]
 fn bug_overlapping_marble_creation_blocks_tile_forever() {
 	no_input_test(

From 2c7e844d00b7e15b9618561dccbb89279778c19d Mon Sep 17 00:00:00 2001
From: CrispyPin <crispin@tasa.se>
Date: Sun, 20 Apr 2025 20:45:57 +0200
Subject: [PATCH 18/23] fix right edge grid rendering

---
 CHANGELOG.md              | 3 ++-
 README.md                 | 1 -
 src/editor.rs             | 6 ++++--
 src/marble_engine/grid.rs | 8 ++++----
 4 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index f91ab89..82fa303 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -7,8 +7,9 @@ Game store page: https://crispypin.itch.io/marble-machinations
 
 ### fixed
 - input bytes are consumed even if the marble can't be created because another one was taking its place
-- crash when saving config if no user dir exists
 - keybindings activated even when typing in a text field, making especially renaming blueprints difficult
+- grid rendering broken on right edge of the screen at some zoom levels and window sizes
+- crash when saving config if no user dir exists
 - after removing a binding that was a superset of another, the remaining one did not stop being blocked by the removed ones additional modifiers until another binding was added or edited
 
 ## v0.3.2 - 2025-04-14
diff --git a/README.md b/README.md
index 5114600..be7dc44 100644
--- a/README.md
+++ b/README.md
@@ -10,7 +10,6 @@ logic mostly like https://git.crispypin.cc/CrispyPin/marble
 - blag post about marble movement logic?
 ### bugs
 - Shift+A and A+Shift conflict
-- rigt side grid rendering broken
 ### features
 #### 0.3.x
 - more levels
diff --git a/src/editor.rs b/src/editor.rs
index ac41159..3dcf0ac 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -618,11 +618,13 @@ impl Editor {
 			let tile_size = TILE_TEXTURE_SIZE * self.zoom;
 			let grid_spill_x = (self.view_offset.x).rem(tile_size) - tile_size;
 			let grid_spill_y = (self.view_offset.y).rem(tile_size) - tile_size;
-			for y in 0..=(d.get_screen_height() / tile_size as i32) {
+			let hlines = d.get_screen_height() / tile_size as i32 + 3;
+			let vlines = d.get_screen_width() / tile_size as i32 + 3;
+			for y in 0..hlines {
 				let y = y * tile_size as i32 + grid_spill_y as i32;
 				d.draw_line(0, y, d.get_screen_width(), y, FG_GRID);
 			}
-			for x in 0..=(d.get_screen_width() / tile_size as i32) {
+			for x in 0..vlines {
 				let x = x * tile_size as i32 + grid_spill_x as i32;
 				d.draw_line(x, 0, x, d.get_screen_height(), FG_GRID);
 			}
diff --git a/src/marble_engine/grid.rs b/src/marble_engine/grid.rs
index 63f2f64..466a3a8 100644
--- a/src/marble_engine/grid.rs
+++ b/src/marble_engine/grid.rs
@@ -289,12 +289,12 @@ impl Grid {
 		let tile_size = (TILE_TEXTURE_SIZE * scale) as i32;
 
 		let start_x = (-offset.x as i32) / tile_size - 1;
-		let tile_width = d.get_screen_width() / tile_size + 2;
+		let tiles_width = d.get_screen_width() / tile_size + 3;
 		let start_y = (-offset.y as i32) / tile_size - 1;
-		let tile_height = d.get_screen_height() / tile_size + 2;
+		let tiles_height = d.get_screen_height() / tile_size + 3;
 
-		for x in start_x..(start_x + tile_width) {
-			for y in start_y..(start_y + tile_height) {
+		for x in start_x..(start_x + tiles_width) {
+			for y in start_y..(start_y + tiles_height) {
 				let px = x * tile_size + offset.x as i32;
 				let py = y * tile_size + offset.y as i32;
 				if let Some(tile) = self.get((x, y).into()) {

From 440cd7a759ec279af9fde50d3fe42172ef647e10 Mon Sep 17 00:00:00 2001
From: CrispyPin <crispin@tasa.se>
Date: Mon, 21 Apr 2025 00:01:20 +0200
Subject: [PATCH 19/23] fix bindings not taking into account press order,
 making some bindings ambiguous

---
 CHANGELOG.md  |   1 +
 README.md     |   2 +-
 src/config.rs |   1 +
 src/input.rs  | 104 +++++++++++++++++++++++++++++++++-----------------
 4 files changed, 72 insertions(+), 36 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 82fa303..fee8542 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -10,6 +10,7 @@ Game store page: https://crispypin.itch.io/marble-machinations
 - keybindings activated even when typing in a text field, making especially renaming blueprints difficult
 - grid rendering broken on right edge of the screen at some zoom levels and window sizes
 - crash when saving config if no user dir exists
+- bindings did not properly take into account order of pressing, so Shift+A and A+Shift were treated as the same thing
 - after removing a binding that was a superset of another, the remaining one did not stop being blocked by the removed ones additional modifiers until another binding was added or edited
 
 ## v0.3.2 - 2025-04-14
diff --git a/README.md b/README.md
index be7dc44..9d5b549 100644
--- a/README.md
+++ b/README.md
@@ -9,7 +9,7 @@ logic mostly like https://git.crispypin.cc/CrispyPin/marble
 - engine tests
 - blag post about marble movement logic?
 ### bugs
-- Shift+A and A+Shift conflict
+
 ### features
 #### 0.3.x
 - more levels
diff --git a/src/config.rs b/src/config.rs
index 8200b00..cc5f45b 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -39,6 +39,7 @@ impl Config {
 			return MenuReturn::ReturnCancel;
 		}
 
+		// self.input.update(d);
 		self.input.draw_edit(d, globals, y);
 		MenuReturn::Stay
 	}
diff --git a/src/input.rs b/src/input.rs
index b8e3f6b..e092537 100644
--- a/src/input.rs
+++ b/src/input.rs
@@ -94,8 +94,9 @@ impl Default for Input {
 		bind_key(ActionId::TileGroupCompare, vec![], H);
 
 		Self {
-			bindings,
-			states: Default::default(),
+			action_bindings: bindings,
+			action_states: [BindingState::Off; ActionId::SIZE],
+			key_states: [BindingState::Off; Button::SIZE],
 			editing_binding: None,
 			in_text_edit: false,
 		}
@@ -116,8 +117,9 @@ type InputMap = BTreeMap<String, Vec<Binding>>;
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(from = "InputMap", into = "InputMap")]
 pub struct Input {
-	bindings: [Vec<Binding>; ActionId::SIZE],
-	states: [BindingState; ActionId::SIZE],
+	action_bindings: [Vec<Binding>; ActionId::SIZE],
+	action_states: [BindingState; ActionId::SIZE],
+	key_states: [BindingState; Button::SIZE],
 	editing_binding: Option<(ActionId, usize, BindingEdit)>,
 	pub in_text_edit: bool,
 }
@@ -142,10 +144,13 @@ impl Input {
 		for action_index in 0..ActionId::SIZE {
 			let action = ActionId::from_usize(action_index).unwrap();
 
+			// if self.action_states[action_index] == BindingState::Pressed {
+			// 	d.draw_rectangle(200, y, 20, 20, Color::LIMEGREEN);
+			// }
 			d.draw_text(&format!("{action:?}"), 16, y, 20, Color::ORANGE);
-			for (binding_index, binding) in self.bindings[action_index].iter().enumerate() {
+			for (binding_index, binding) in self.action_bindings[action_index].iter().enumerate() {
 				if text_button(d, &globals.mouse, buttons_x, y, 80, "remove") {
-					self.bindings[action_index].remove(binding_index);
+					self.action_bindings[action_index].remove(binding_index);
 					self.update_modifier_blocks();
 					return;
 				}
@@ -162,7 +167,7 @@ impl Input {
 				d.draw_text(&modifiers, x, y + 5, 20, Color::LIGHTBLUE);
 				x += 10 + d.measure_text(&modifiers, 20);
 				//
-				let conflicts = conflicts(&self.bindings, binding, action);
+				let conflicts = conflicts(&self.action_bindings, binding, action);
 				if !conflicts.is_empty() {
 					let conflict_text = format!("also used by: {conflicts:?}");
 					d.draw_text(&conflict_text, x, y + 5, 20, Color::ORANGERED);
@@ -176,8 +181,11 @@ impl Input {
 				y += 32;
 			}
 			if text_button(d, &globals.mouse, buttons_x, y, 130, "add binding") {
-				self.editing_binding =
-					Some((action, self.bindings[action_index].len(), BindingEdit::Init));
+				self.editing_binding = Some((
+					action,
+					self.action_bindings[action_index].len(),
+					BindingEdit::Init,
+				));
 			}
 			y += 45;
 		}
@@ -253,7 +261,7 @@ impl Input {
 				let text = format!("{:?} + {:?}", b.modifiers, b.trigger);
 				d.draw_text(&text, x + 5, y + 5, 20, colour);
 
-				let conflicts = conflicts(&self.bindings, b, *action);
+				let conflicts = conflicts(&self.action_bindings, b, *action);
 				if !conflicts.is_empty() {
 					d.draw_text(
 						&format!("conflicts: {conflicts:?}"),
@@ -266,7 +274,7 @@ impl Input {
 			}
 			if text_button(d, &globals.mouse, ok_btn_x, ok_btn_y, ok_btn_width, "ok") {
 				if let BindingEdit::Releasing(binding) = edit_state {
-					let binding_list = &mut self.bindings[*action as usize];
+					let binding_list = &mut self.action_bindings[*action as usize];
 					if *binding_index < binding_list.len() {
 						binding_list[*binding_index] = binding.clone();
 					} else {
@@ -283,20 +291,10 @@ impl Input {
 	}
 
 	pub fn update(&mut self, rl: &RaylibHandle) {
-		for i in 0..ActionId::SIZE {
-			let bindings = &self.bindings[i];
-			let mut is_active = false;
-			if !self.in_text_edit {
-				for binding in bindings {
-					if binding.modifiers.iter().all(|&m| m.is_down(rl))
-						&& !binding.blocking_modifiers.iter().any(|&m| m.is_down(rl))
-					{
-						is_active |= binding.trigger.is_down(rl);
-					}
-				}
-			}
-			let state = &mut self.states[i];
-			*state = if is_active {
+		for i in 0..Button::SIZE {
+			let button = Button::from_usize(i).unwrap();
+			let state = &mut self.key_states[i];
+			*state = if button.is_down(rl) {
 				match state {
 					BindingState::Off | BindingState::Released => BindingState::Pressed,
 					BindingState::Pressed | BindingState::Held => BindingState::Held,
@@ -308,32 +306,52 @@ impl Input {
 				}
 			}
 		}
+		for i in 0..ActionId::SIZE {
+			let bindings = &self.action_bindings[i];
+			let mut is_active = BindingState::Off;
+			if !self.in_text_edit {
+				for binding in bindings {
+					if binding
+						.modifiers
+						.iter()
+						.all(|&m| self.key_states[m as usize] == BindingState::Held)
+						&& binding
+							.blocking_modifiers
+							.iter()
+							.all(|&m| self.key_states[m as usize] == BindingState::Off)
+					{
+						is_active = is_active.or(self.key_states[binding.trigger as usize]);
+					}
+				}
+			}
+			self.action_states[i] = is_active;
+		}
 		self.in_text_edit = false;
 	}
 
 	pub fn is_pressed(&self, action: ActionId) -> bool {
-		self.states[action as usize] == BindingState::Pressed
+		self.action_states[action as usize] == BindingState::Pressed
 	}
 
 	pub fn is_held(&self, action: ActionId) -> bool {
-		self.states[action as usize] == BindingState::Pressed
-			|| self.states[action as usize] == BindingState::Held
+		self.action_states[action as usize] == BindingState::Pressed
+			|| self.action_states[action as usize] == BindingState::Held
 	}
 
 	pub fn is_released(&self, action: ActionId) -> bool {
-		self.states[action as usize] == BindingState::Released
+		self.action_states[action as usize] == BindingState::Released
 	}
 
 	/// Must be called after any binding has changed.
 	/// Ensures a binding "S" is not triggered by "Ctrl+S", if "Ctrl+S" is bound to something else.
 	pub fn update_modifier_blocks(&mut self) {
 		for i in 0..ActionId::SIZE {
-			let bindings = &self.bindings[i];
+			let bindings = &self.action_bindings[i];
 			for binding_index in 0..bindings.len() {
-				let binding = &self.bindings[i][binding_index];
+				let binding = &self.action_bindings[i][binding_index];
 				let mut blocking_mods = Vec::new();
 				for i in 0..ActionId::SIZE {
-					let other_bindings = &self.bindings[i];
+					let other_bindings = &self.action_bindings[i];
 					for other_binding in other_bindings {
 						if other_binding.trigger == binding.trigger {
 							for modifier in &other_binding.modifiers {
@@ -346,7 +364,7 @@ impl Input {
 						}
 					}
 				}
-				self.bindings[i][binding_index].blocking_modifiers = blocking_mods;
+				self.action_bindings[i][binding_index].blocking_modifiers = blocking_mods;
 			}
 		}
 	}
@@ -395,13 +413,29 @@ pub struct Binding {
 	trigger: Button,
 }
 
+impl BindingState {
+	fn or(self, rhs: Self) -> Self {
+		use BindingState::*;
+		match (self, rhs) {
+			(Off, other) => other,
+			(other, Off) => other,
+			(Held, _) => Held,
+			(_, Held) => Held,
+			(Pressed, Pressed) => Pressed,
+			(Released, Released) => Released,
+			(Pressed, Released) => Held,
+			(Released, Pressed) => Held,
+		}
+	}
+}
+
 impl From<InputMap> for Input {
 	fn from(map: InputMap) -> Self {
 		let mut new = Self::default();
 		for (action, loaded_bindings) in map {
 			let temp_json = format!("\"{action}\"");
 			if let Ok(action) = serde_json::from_str::<ActionId>(&temp_json) {
-				new.bindings[action as usize] = loaded_bindings;
+				new.action_bindings[action as usize] = loaded_bindings;
 			} else {
 				println!("'{action}' is not a valid action id, bindings discarded");
 			}
@@ -413,7 +447,7 @@ impl From<InputMap> for Input {
 impl From<Input> for InputMap {
 	fn from(value: Input) -> Self {
 		value
-			.bindings
+			.action_bindings
 			.iter()
 			.enumerate()
 			.map(|(i, b)| {

From c8fc484e9c6324b0b4fab9c7469a7a06bf861e8d Mon Sep 17 00:00:00 2001
From: CrispyPin <crispin@tasa.se>
Date: Mon, 21 Apr 2025 00:23:19 +0200
Subject: [PATCH 20/23] add config options to show/hide timing debug info and
 power directions

---
 CHANGELOG.md              |  4 ++
 README.md                 |  1 -
 src/config.rs             | 34 ++++++++++++---
 src/editor.rs             | 91 +++++++++++++++++++++------------------
 src/input.rs              |  3 +-
 src/marble_engine/grid.rs |  8 ++--
 src/ui.rs                 | 38 +++++++++++++---
 7 files changed, 115 insertions(+), 64 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index fee8542..47e2c19 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,7 +2,11 @@
 Game store page: https://crispypin.itch.io/marble-machinations
 
 ## [unreleased]
+### added
+- option to display power direction while overlay is enabled
+
 ### changed
+- hide tick timing numbers by default
 - when multiple I/O silos (or multiple directions of one) are activated in the same tick, they will all output the same value instead of pulling input in an arbitrary order
 
 ### fixed
diff --git a/README.md b/README.md
index 9d5b549..a78b159 100644
--- a/README.md
+++ b/README.md
@@ -16,7 +16,6 @@ logic mostly like https://git.crispypin.cc/CrispyPin/marble
   - packet routing?
   - game of life sim (width;height;steps;grid -> grid)
 - show level name in end popup
-- hide timing debug info by default
 - shrink button
 #### 0.4.0
 - UI layout engine
diff --git a/src/config.rs b/src/config.rs
index cc5f45b..674611f 100644
--- a/src/config.rs
+++ b/src/config.rs
@@ -1,11 +1,21 @@
 use raylib::prelude::*;
 use serde::{Deserialize, Serialize};
 
-use crate::{input::Input, theme::FG_CHAPTER_TITLE, ui::text_button, util::Scroll, Globals};
+use crate::{
+	input::Input,
+	theme::FG_CHAPTER_TITLE,
+	ui::{text_button, toggle_button},
+	util::Scroll,
+	Globals,
+};
 
 #[derive(Default, Debug, Clone, Serialize, Deserialize)]
 pub struct Config {
 	pub input: Input,
+	#[serde(default)]
+	pub show_debug_timing: bool,
+	#[serde(default)]
+	pub show_power_direction: bool,
 	#[serde(skip)]
 	scroll_offset: u32,
 }
@@ -25,19 +35,29 @@ impl Config {
 			Some(Scroll::Up) => self.scroll_offset = self.scroll_offset.saturating_sub(64),
 			None => (),
 		}
-		let y = -(self.scroll_offset as i32);
+		let mut y = -(self.scroll_offset as i32) + 15;
+		d.draw_text("Settings", 16, y, 30, FG_CHAPTER_TITLE);
+		y += 40;
 
-		d.draw_text("Settings", 16, y + 16, 30, FG_CHAPTER_TITLE);
-
-		if text_button(d, &globals.mouse, 10, y + 60, 80, "apply") {
+		if text_button(d, &globals.mouse, 10, y, 80, "apply") {
 			return MenuReturn::StaySave;
 		}
-		if text_button(d, &globals.mouse, 100, y + 60, 80, "done") {
+		if text_button(d, &globals.mouse, 100, y, 80, "done") {
 			return MenuReturn::ReturnSave;
 		}
-		if text_button(d, &globals.mouse, 190, y + 60, 80, "cancel") {
+		if text_button(d, &globals.mouse, 190, y, 80, "cancel") {
 			return MenuReturn::ReturnCancel;
 		}
+		y += 40;
+
+		let mut toggle = |value, text| {
+			toggle_button((d, &globals.mouse), 10, y, 30, 30, value);
+			d.draw_text(text, 50, y + 5, 20, Color::WHITE);
+			y += 40;
+		};
+
+		toggle(&mut self.show_power_direction, "show power directions");
+		toggle(&mut self.show_debug_timing, "show debug timing");
 
 		// self.input.update(d);
 		self.input.draw_edit(d, globals, y);
diff --git a/src/editor.rs b/src/editor.rs
index 3dcf0ac..87f8581 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -74,8 +74,8 @@ pub struct Editor {
 	undo_history: Vec<Action>,
 	undo_index: usize,
 	// debug/profiling
-	step_time: u128,
-	max_step_time: u128,
+	step_time: usize,
+	max_step_time: usize,
 	start_time: Instant,
 }
 
@@ -472,8 +472,8 @@ impl Editor {
 				.as_micros()
 				.checked_div(steps_taken)
 				.unwrap_or_default();
-			self.step_time = avg_step_time;
-			self.max_step_time = avg_step_time.max(self.max_step_time);
+			self.step_time = avg_step_time as usize;
+			self.max_step_time = self.step_time.max(self.max_step_time);
 		}
 		if globals.is_pressed(ActionId::StepSim) {
 			self.step_pressed()
@@ -575,20 +575,33 @@ impl Editor {
 	}
 
 	fn draw_board(&self, d: &mut RaylibDrawHandle, globals: &Globals) {
+		let draw_power = globals.config.show_power_direction && self.draw_overlay;
 		if self.sim_state == SimState::Editing {
-			self.source_board
-				.grid
-				.draw(d, &globals.textures, self.view_offset, self.zoom);
+			self.source_board.grid.draw(
+				d,
+				&globals.textures,
+				self.view_offset,
+				self.zoom,
+				draw_power,
+			);
 		} else {
 			if self.machine.debug_subticks.is_empty() {
-				self.machine
-					.grid()
-					.draw(d, &globals.textures, self.view_offset, self.zoom);
+				self.machine.grid().draw(
+					d,
+					&globals.textures,
+					self.view_offset,
+					self.zoom,
+					draw_power,
+				);
 			} else {
 				let subframe = &self.machine.debug_subticks[self.machine.subtick_index];
-				subframe
-					.grid
-					.draw(d, &globals.textures, self.view_offset, self.zoom);
+				subframe.grid.draw(
+					d,
+					&globals.textures,
+					self.view_offset,
+					self.zoom,
+					draw_power,
+				);
 				if let Some(pos) = subframe.pos {
 					let p = self.pos_to_screen(pos.to_vec());
 					d.draw_texture_ex(
@@ -961,34 +974,22 @@ impl Editor {
 			draw_usize(d, &globals.textures, total_steps, (420, 44), 9, 2);
 		}
 
-		draw_usize(
-			d,
-			&globals.textures,
-			self.step_time as usize,
-			(260, 42),
-			9,
-			1,
-		);
-		draw_usize(
-			d,
-			&globals.textures,
-			self.max_step_time as usize,
-			(260, 60),
-			9,
-			1,
-		);
-		#[cfg(debug_assertions)]
-		{
-			draw_usize(
-				d,
-				&globals.textures,
-				self.machine.subtick_index,
-				(260, 80),
-				9,
-				1,
-			);
-			let subtick_count = self.machine.debug_subticks.len();
-			draw_usize(d, &globals.textures, subtick_count, (260, 100), 9, 1);
+		if globals.config.show_debug_timing {
+			draw_usize(d, &globals.textures, self.step_time, (260, 42), 9, 1);
+			draw_usize(d, &globals.textures, self.max_step_time, (260, 60), 9, 1);
+			#[cfg(debug_assertions)]
+			{
+				draw_usize(
+					d,
+					&globals.textures,
+					self.machine.subtick_index,
+					(260, 80),
+					9,
+					1,
+				);
+				let subtick_count = self.machine.debug_subticks.len();
+				draw_usize(d, &globals.textures, subtick_count, (260, 100), 9, 1);
+			}
 		}
 
 		d.draw_text("input:", 603, 8, 10, Color::WHITE);
@@ -1380,7 +1381,9 @@ impl Editor {
 					offset.x -= offset.x.rem(tile_size);
 					offset.y -= offset.y.rem(tile_size);
 					offset += view_offset;
-					board.grid.draw(d, &globals.textures, offset, self.zoom);
+					board
+						.grid
+						.draw(d, &globals.textures, offset, self.zoom, false);
 					board.draw_comments(d, offset, self.zoom);
 					if self.mouse.left_click() {
 						let tile_pos = (self.mouse.pos() - self.view_offset) / tile_size;
@@ -1517,7 +1520,9 @@ impl Editor {
 						offset.x -= offset.x.rem(tile_size);
 						offset.y -= offset.y.rem(tile_size);
 						offset += view_offset;
-						bp.board.grid.draw(d, &globals.textures, offset, self.zoom);
+						bp.board
+							.grid
+							.draw(d, &globals.textures, offset, self.zoom, false);
 						bp.board.draw_comments(d, offset, self.zoom);
 					}
 					if self.mouse.pos().x < SIDEBAR_WIDTH as f32 {
diff --git a/src/input.rs b/src/input.rs
index e092537..a769625 100644
--- a/src/input.rs
+++ b/src/input.rs
@@ -132,8 +132,7 @@ enum BindingEdit {
 }
 
 impl Input {
-	pub fn draw_edit(&mut self, d: &mut RaylibDrawHandle, globals: &mut Globals, y: i32) {
-		let mut y = y + 96;
+	pub fn draw_edit(&mut self, d: &mut RaylibDrawHandle, globals: &mut Globals, mut y: i32) {
 		if self.editing_binding.is_some() {
 			globals.mouse.clear();
 		}
diff --git a/src/marble_engine/grid.rs b/src/marble_engine/grid.rs
index 466a3a8..1a60af9 100644
--- a/src/marble_engine/grid.rs
+++ b/src/marble_engine/grid.rs
@@ -285,7 +285,7 @@ impl Grid {
 		out
 	}
 
-	pub fn draw(&self, d: &mut RaylibDrawHandle, textures: &Textures, offset: Vector2, scale: f32) {
+	pub fn draw(&self, d: &mut RaylibDrawHandle, textures: &Textures, offset: Vector2, scale: f32, power_directions: bool) {
 		let tile_size = (TILE_TEXTURE_SIZE * scale) as i32;
 
 		let start_x = (-offset.x as i32) / tile_size - 1;
@@ -304,14 +304,14 @@ impl Grid {
 					}
 					let texture = textures.get(texname);
 					draw_scaled_texture(d, texture, px, py, scale);
-					#[cfg(debug_assertions)]
-					// todo some in-game option to show power direction
+					if power_directions
+					{
 					if let Tile::Powerable(_, state) = &tile {
 						for dir in Direction::ALL {
 							if state.get_dir(dir) {
 								let texture = textures.get(dir.debug_arrow_texture_name());
 								draw_scaled_texture(d, texture, px, py, scale);
-							}
+							}}
 						}
 					}
 				} else {
diff --git a/src/ui.rs b/src/ui.rs
index 47199b0..360e2ee 100644
--- a/src/ui.rs
+++ b/src/ui.rs
@@ -2,7 +2,7 @@ use std::ops::Range;
 
 use crate::{
 	theme::*,
-	util::{draw_scaled_texture, MouseInput, Scroll, Textures},
+	util::{draw_scaled_texture, rect, MouseInput, Scroll, Textures},
 	Globals,
 };
 use raylib::prelude::*;
@@ -160,6 +160,35 @@ impl Tooltip {
 	}
 }
 
+pub fn toggle_button(
+	(d, mouse): (&mut RaylibDrawHandle, &MouseInput),
+	x: i32,
+	y: i32,
+	width: i32,
+	height: i32,
+	val: &mut bool,
+) {
+	let margin = 5;
+	let mouse_pos = mouse.pos();
+	let bounds = rect(x, y, width, height);
+
+	let hover = bounds.check_collision_point_rec(mouse_pos);
+	d.draw_rectangle(x, y, width, height, widget_bg(hover));
+	let pressed = hover && mouse.left_click();
+	if pressed {
+		*val = !*val;
+	}
+	if *val {
+		d.draw_rectangle(
+			x + margin,
+			y + margin,
+			width - margin * 2,
+			height - margin * 2,
+			Color::WHITE,
+		);
+	}
+}
+
 pub fn simple_button(
 	(d, mouse): (&mut RaylibDrawHandle, &MouseInput),
 	x: i32,
@@ -168,12 +197,7 @@ pub fn simple_button(
 	height: i32,
 ) -> bool {
 	let mouse_pos = mouse.pos();
-	let bounds = Rectangle {
-		x: x as f32,
-		y: y as f32,
-		width: width as f32,
-		height: height as f32,
-	};
+	let bounds = rect(x, y, width, height);
 	let hover = bounds.check_collision_point_rec(mouse_pos);
 	let pressed = hover && mouse.left_click();
 	d.draw_rectangle(x, y, width, height, widget_bg(hover));

From 1eb7a34537d18ab9920d5f35eb1da8729c7103c0 Mon Sep 17 00:00:00 2001
From: CrispyPin <crispin@tasa.se>
Date: Mon, 21 Apr 2025 00:39:19 +0200
Subject: [PATCH 21/23] show level name in end popup

---
 CHANGELOG.md              |  1 +
 README.md                 |  1 -
 src/editor.rs             | 60 +++++++++++++++++++--------------------
 src/marble_engine/grid.rs | 25 ++++++++++------
 src/solution.rs           |  2 +-
 5 files changed, 47 insertions(+), 42 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 47e2c19..ca5144f 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,7 @@ Game store page: https://crispypin.itch.io/marble-machinations
 ## [unreleased]
 ### added
 - option to display power direction while overlay is enabled
+- show level name in end popup
 
 ### changed
 - hide tick timing numbers by default
diff --git a/README.md b/README.md
index a78b159..94d6f75 100644
--- a/README.md
+++ b/README.md
@@ -15,7 +15,6 @@ logic mostly like https://git.crispypin.cc/CrispyPin/marble
 - more levels
   - packet routing?
   - game of life sim (width;height;steps;grid -> grid)
-- show level name in end popup
 - shrink button
 #### 0.4.0
 - UI layout engine
diff --git a/src/editor.rs b/src/editor.rs
index 87f8581..e3a34fa 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -24,7 +24,7 @@ const HEADER_HEIGHT: i32 = 40;
 const FOOTER_HEIGHT: i32 = 95;
 const SIDEBAR_WIDTH: i32 = 200 + 32 * 2 + 5 * 4;
 const END_POPUP_WIDTH: i32 = 320;
-const END_POPUP_HEIGHT: i32 = 225;
+const END_POPUP_HEIGHT: i32 = 255;
 
 const MAX_ZOOM: f32 = 8.;
 const MIN_ZOOM: f32 = 0.25;
@@ -85,10 +85,10 @@ enum Action {
 	SetArea(ResizeDeltas, Pos, Board, Board),
 }
 
-#[derive(Debug, PartialEq, Clone, Copy)]
+#[derive(Debug, PartialEq, Clone)]
 enum Popup {
 	None,
-	Success,
+	Success(Score),
 	Failure,
 	LevelInfo,
 	PauseMenu,
@@ -316,7 +316,7 @@ impl Editor {
 		self.machine.step();
 
 		if let Some(i) = self.stage {
-			if matches!(self.popup, Popup::Failure | Popup::Success) {
+			if matches!(self.popup, Popup::Failure | Popup::Success(_)) {
 				self.popup = Popup::None;
 				self.dismissed_end = true;
 			}
@@ -328,15 +328,16 @@ impl Editor {
 						self.total_steps += self.machine.step_count();
 						self.reset_machine();
 					} else {
-						self.popup = Popup::Success;
 						println!("completed in {:?}", self.start_time.elapsed());
 						self.exit_state = ExitState::Save;
 						self.sim_state = SimState::Stepping;
-						self.score = Some(Score {
+						let score = Score {
 							cycles: self.total_steps + self.machine.step_count(),
 							tiles: self.source_board.grid.count_tiles(),
 							bounds_area: self.source_board.grid.used_bounds_area(),
-						});
+						};
+						self.score = Some(score.clone());
+						self.popup = Popup::Success(score);
 					}
 				} else if !stage.output().as_bytes().starts_with(self.machine.output()) {
 					self.popup = Popup::Failure;
@@ -439,7 +440,7 @@ impl Editor {
 
 		if globals.is_pressed(ActionId::ToggleMenu) {
 			self.popup = match self.popup {
-				Popup::Success | Popup::Failure => {
+				Popup::Success(_) | Popup::Failure => {
 					self.dismissed_end = true;
 					Popup::None
 				}
@@ -666,7 +667,7 @@ impl Editor {
 		}
 
 		match self.popup {
-			Popup::Success | Popup::Failure => {
+			Popup::Success(_) | Popup::Failure => {
 				self.draw_end_popup(d, &globals.textures);
 			}
 			Popup::LevelInfo => {
@@ -766,38 +767,35 @@ impl Editor {
 	fn draw_end_popup(&mut self, d: &mut RaylibDrawHandle, textures: &Textures) {
 		let bounds = screen_centered_rect(d, END_POPUP_WIDTH, END_POPUP_HEIGHT);
 		let x = bounds.x as i32;
-		let y = bounds.y as i32;
+		let mut y = bounds.y as i32 + 10;
 		d.draw_rectangle_rec(bounds, BG_DARK);
-		if self.popup == Popup::Success {
-			d.draw_text("Level Complete!", x + 45, y + 10, 30, Color::LIME);
-			if let Some(score) = &self.score {
-				d.draw_text("cycles", x + 15, y + 40, 20, Color::WHITE);
-				draw_usize(d, textures, score.cycles, (x + 110, y + 40), 9, 2);
-				d.draw_text("tiles", x + 15, y + 80, 20, Color::WHITE);
-				draw_usize(d, textures, score.tiles, (x + 110, y + 80), 9, 2);
-				d.draw_text("bounds", x + 15, y + 120, 20, Color::WHITE);
-				draw_usize(d, textures, score.bounds_area, (x + 110, y + 120), 9, 2);
-			}
-			let y = y + 60;
-			if simple_button((d, &self.mouse), x + 10, y + 110, 140, 45) {
+		if let Popup::Success(score) = &self.popup {
+			d.draw_text("Level Complete!", x + 45, y, 30, Color::LIME);
+			y += 30;
+			d.draw_text(self.level.name(), x + 10, y, 20, Color::GRAY);
+			y += 30;
+			d.draw_text("cycles", x + 15, y, 20, Color::WHITE);
+			draw_usize(d, textures, score.cycles, (x + 110, y), 9, 2);
+			y += 40;
+			d.draw_text("tiles", x + 15, y, 20, Color::WHITE);
+			draw_usize(d, textures, score.tiles, (x + 110, y), 9, 2);
+			y += 40;
+			d.draw_text("bounds", x + 15, y, 20, Color::WHITE);
+			draw_usize(d, textures, score.bounds_area, (x + 110, y), 9, 2);
+			y += 40;
+			if simple_button((d, &self.mouse), x + 10, y, 140, 50) {
 				self.popup = Popup::None;
 				self.dismissed_end = true;
 			}
-			d.draw_text("continue\nediting", x + 15, y + 115, 20, Color::WHITE);
+			d.draw_text("continue\nediting", x + 15, y + 5, 20, Color::WHITE);
 
-			if simple_button(
-				(d, &self.mouse),
-				x + END_POPUP_WIDTH / 2 + 5,
-				y + 110,
-				140,
-				45,
-			) {
+			if simple_button((d, &self.mouse), x + END_POPUP_WIDTH / 2 + 5, y, 140, 50) {
 				self.exit_state = ExitState::ExitAndSave;
 			}
 			d.draw_text(
 				"return to\nlevel list",
 				x + END_POPUP_WIDTH / 2 + 10,
-				y + 115,
+				y + 5,
 				20,
 				Color::WHITE,
 			);
diff --git a/src/marble_engine/grid.rs b/src/marble_engine/grid.rs
index 1a60af9..75a1475 100644
--- a/src/marble_engine/grid.rs
+++ b/src/marble_engine/grid.rs
@@ -285,7 +285,14 @@ impl Grid {
 		out
 	}
 
-	pub fn draw(&self, d: &mut RaylibDrawHandle, textures: &Textures, offset: Vector2, scale: f32, power_directions: bool) {
+	pub fn draw(
+		&self,
+		d: &mut RaylibDrawHandle,
+		textures: &Textures,
+		offset: Vector2,
+		scale: f32,
+		power_directions: bool,
+	) {
 		let tile_size = (TILE_TEXTURE_SIZE * scale) as i32;
 
 		let start_x = (-offset.x as i32) / tile_size - 1;
@@ -304,14 +311,14 @@ impl Grid {
 					}
 					let texture = textures.get(texname);
 					draw_scaled_texture(d, texture, px, py, scale);
-					if power_directions
-					{
-					if let Tile::Powerable(_, state) = &tile {
-						for dir in Direction::ALL {
-							if state.get_dir(dir) {
-								let texture = textures.get(dir.debug_arrow_texture_name());
-								draw_scaled_texture(d, texture, px, py, scale);
-							}}
+					if power_directions {
+						if let Tile::Powerable(_, state) = &tile {
+							for dir in Direction::ALL {
+								if state.get_dir(dir) {
+									let texture = textures.get(dir.debug_arrow_texture_name());
+									draw_scaled_texture(d, texture, px, py, scale);
+								}
+							}
 						}
 					}
 				} else {
diff --git a/src/solution.rs b/src/solution.rs
index 9601c82..0308fb3 100644
--- a/src/solution.rs
+++ b/src/solution.rs
@@ -18,7 +18,7 @@ pub struct Solution {
 	pub score: Option<Score>,
 }
 
-#[derive(Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
 pub struct Score {
 	pub cycles: usize,
 	pub tiles: usize,

From 7d9d0a01f73b46bb1e64b928d4e6e1bac0939d69 Mon Sep 17 00:00:00 2001
From: CrispyPin <crispin@tasa.se>
Date: Mon, 21 Apr 2025 18:28:13 +0200
Subject: [PATCH 22/23] update readme

---
 README.md | 26 ++++++++++++++------------
 1 file changed, 14 insertions(+), 12 deletions(-)

diff --git a/README.md b/README.md
index 94d6f75..d29aba8 100644
--- a/README.md
+++ b/README.md
@@ -8,6 +8,7 @@ logic mostly like https://git.crispypin.cc/CrispyPin/marble
 ### meta
 - engine tests
 - blag post about marble movement logic?
+- standardise terminology (cycle/step/tick)
 ### bugs
 
 ### features
@@ -16,23 +17,24 @@ logic mostly like https://git.crispypin.cc/CrispyPin/marble
   - packet routing?
   - game of life sim (width;height;steps;grid -> grid)
 - shrink button
-#### 0.4.0
+#### 0.4.x
 - UI layout engine
-  - global scale setting
+  - global scale multiplier, affected by window size
+  - background colour setting (requires color picker => after UI rework)
+  - light theme
 #### unspecified
 - comments
   - editing
   - add to all intro levels
 - highlight regions with background colours
 - button + binding to flip selection that is being pasted
-- accessibility
-  - background colour setting (requires color picker => after UI rework)
-  - light theme for UI
-  - hotkeys for everything (no mouse needed to play)
-    - menu navigation (requires UI rework)
-    - speed up/down
-    - grid cursor movement and placement
-    - grid zoom and pan
+- hotkeys for everything (no mouse needed to play)
+  - menu navigation (requires UI rework)
+  - speed up/down
+  - keybinds for specific tool variants
+  - grid cursor movement and placement
+  - grid zoom and pan
+- config settings page categories (mostly for keybindings)
 - UI: scroll output bytes
 - timestamps in solutions and blueprints
 - display tool variant more clearly (it's not obvious there are more states)
@@ -40,11 +42,11 @@ logic mostly like https://git.crispypin.cc/CrispyPin/marble
   - font selection (probably a lot of work)
 ### online stuff
 - store scores in server
-- validate solutions in server (with limits)
+- validate solutions in server (with compute limits)
 - show histograms
 - author name in solutions and blueprints
 ### undecided
-- option to skip (speed through with settable multiplier) first N stages or cycles, for when you are debugging something that happens in later stages
+- option to skip (fast-forward through with settable multiplier) first N stages or cycles, for when you are debugging something that happens in later stages
 - hide some tile tools in early levels to make it less overwhelming
 - footprint score (tiles that were non-empty at any point in the run)
 - option to use 8-bit marbles?

From 1cc8e999b7a42be87c9af9324f971a391ee6c82f Mon Sep 17 00:00:00 2001
From: CrispyPin <crispin@tasa.se>
Date: Mon, 21 Apr 2025 18:57:20 +0200
Subject: [PATCH 23/23] bump version to 0.3.3

---
 CHANGELOG.md | 2 +-
 Cargo.lock   | 2 +-
 Cargo.toml   | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index ca5144f..a707217 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,7 +1,7 @@
 # Marble Machinations Change Log
 Game store page: https://crispypin.itch.io/marble-machinations
 
-## [unreleased]
+## v0.3.3 - 2025-04-21
 ### added
 - option to display power direction while overlay is enabled
 - show level name in end popup
diff --git a/Cargo.lock b/Cargo.lock
index afd877d..e27bf23 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -213,7 +213,7 @@ checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
 
 [[package]]
 name = "marble-machinations"
-version = "0.3.2"
+version = "0.3.3"
 dependencies = [
  "arboard",
  "raylib",
diff --git a/Cargo.toml b/Cargo.toml
index 9ec68ee..9fd920c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "marble-machinations"
-version = "0.3.2"
+version = "0.3.3"
 edition = "2021"
 default-run = "marble-machinations"