.gitignore

@@ -2,5 +2,3 @@
 /user*
 *.zip
 version.txt
-perf.data*
-flamegraph.svg

CHANGELOG.md

@@ -1,43 +1,11 @@
 # Marble Machinations Change Log
 Game store page: https://crispypin.itch.io/marble-machinations
 
-## v0.3.3 - 2025-04-21
-### added
-- option to display power direction while overlay is enabled
-- show level name in end popup
-
-### 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
-- input bytes are consumed even if the marble can't be created because another one was taking its place
-- 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
-### 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
-- 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.
-
-## v0.3.1 - 2025-04-05
-### fixed
-- broken area calculation causing crash when completing a level with a machine wider than it is tall
-
 ## v0.3.0 - 2025-04-04
 ### added
 - score number: bounding area
 - configurable key bindings for many editor actions
-- QWERTY+ASDFGH key bindings for the tile tools by default
+- QWERTY+ASDFGH keybindings for the tile tools
 - OS clipboard copy/paste, with fallback to old behavior when copying
 - cut selection
 - in-grid text comments (not yet editable in-game)

Cargo.lock

@@ -1,6 +1,6 @@
 # This file is automatically @generated by Cargo.
 # It is not intended for manual editing.
-version = 4
+version = 3
 
 [[package]]
 name = "aho-corasick"
@@ -213,7 +213,7 @@ checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"
 
 [[package]]
 name = "marble-machinations"
-version = "0.3.3"
+version = "0.3.0"
 dependencies = [
  "arboard",
  "raylib",

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "marble-machinations"
-version = "0.3.3"
+version = "0.3.0"
 edition = "2021"
 default-run = "marble-machinations"
 
@@ -10,10 +10,6 @@ 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"

Makefile

@@ -22,9 +22,3 @@ windows:
 	rm -rf ${RELEASE_DIRNAME}_win
 
 all: windows linux
-
-flamegraph:
-	cargo flamegraph --release --bin bench --features "inline_less"
-
-bench:
-	cargo run --release --bin bench

README.md

@@ -7,52 +7,34 @@ logic mostly like https://git.crispypin.cc/CrispyPin/marble
 ## todo
 ### meta
 - engine tests
-- blag post about marble movement logic?
-- standardise terminology (cycle/step/tick)
-### bugs
-
-### features
-#### 0.3.x
-- more levels
-  - packet routing?
-  - game of life sim (width;height;steps;grid -> grid)
-- shrink button
-#### 0.4.x
-- UI layout engine
-  - global scale multiplier, affected by window size
-  - background colour setting (requires color picker => after UI rework)
-  - light theme
-#### unspecified
+- blag post about marble movement logic
+### game
 - comments
   - editing
   - add to all intro levels
+- UI layout engine
+  - global scale setting
 - highlight regions with background colours
-- button + binding to flip selection that is being pasted
+- accessibility
+  - background colour setting
   - 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
+- more levels
+- scroll output bytes
 - timestamps in solutions and blueprints
+- lock tile types for early levels to make it less overwhelming
 - display tool variant more clearly (it's not obvious there are more states)
 - better text rendering
   - font selection (probably a lot of work)
 ### online stuff
 - store scores in server
-- validate solutions in server (with compute limits)
+- validate solutions in server (with limits)
 - show histograms
 - author name in solutions and blueprints
 ### undecided
-- 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?
-- 32 bit input/output?
+- blueprint rotation?
 - settable marble start direction?
-  - allows blueprint rotation
 
 ## playtesting observations
 - 'loops' introduces too many things (powering, redirection, generating zeroes)

levels/chapter_05.json

@@ -1,44 +0,0 @@
-{
-	"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"
-			}]
-		}
-	]
-}

src/config.rs

@@ -1,21 +1,11 @@
 use raylib::prelude::*;
 use serde::{Deserialize, Serialize};
 
-use crate::{
-	input::Input,
-	theme::FG_CHAPTER_TITLE,
-	ui::{text_button, toggle_button},
-	util::Scroll,
-	Globals,
-};
+use crate::{input::Input, theme::FG_CHAPTER_TITLE, ui::text_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,
 }
@@ -35,31 +25,20 @@ impl Config {
 			Some(Scroll::Up) => self.scroll_offset = self.scroll_offset.saturating_sub(64),
 			None => (),
 		}
-		let mut y = -(self.scroll_offset as i32) + 15;
-		d.draw_text("Settings", 16, y, 30, FG_CHAPTER_TITLE);
-		y += 40;
+		let y = -(self.scroll_offset as i32);
 
-		if text_button(d, &globals.mouse, 10, y, 80, "apply") {
+		d.draw_text("Settings", 16, y + 16, 30, FG_CHAPTER_TITLE);
+
+		if text_button(d, &globals.mouse, 10, y + 60, 80, "apply") {
 			return MenuReturn::StaySave;
 		}
-		if text_button(d, &globals.mouse, 100, y, 80, "done") {
+		if text_button(d, &globals.mouse, 100, y + 60, 80, "done") {
 			return MenuReturn::ReturnSave;
 		}
-		if text_button(d, &globals.mouse, 190, y, 80, "cancel") {
+		if text_button(d, &globals.mouse, 190, y + 60, 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);
 		MenuReturn::Stay
 	}

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 = 255;
+const END_POPUP_HEIGHT: i32 = 225;
 
 const MAX_ZOOM: f32 = 8.;
 const MIN_ZOOM: f32 = 0.25;
@@ -74,8 +74,8 @@ pub struct Editor {
 	undo_history: Vec<Action>,
 	undo_index: usize,
 	// debug/profiling
-	step_time: usize,
-	max_step_time: usize,
+	step_time: u128,
+	max_step_time: u128,
 	start_time: Instant,
 }
 
@@ -85,10 +85,10 @@ enum Action {
 	SetArea(ResizeDeltas, Pos, Board, Board),
 }
 
-#[derive(Debug, PartialEq, Clone)]
+#[derive(Debug, PartialEq, Clone, Copy)]
 enum Popup {
 	None,
-	Success(Score),
+	Success,
 	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,16 +328,15 @@ 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;
-						let score = Score {
+						self.score = Some(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;
@@ -440,7 +439,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
 				}
@@ -473,31 +472,28 @@ impl Editor {
 				.as_micros()
 				.checked_div(steps_taken)
 				.unwrap_or_default();
-			self.step_time = avg_step_time as usize;
-			self.max_step_time = self.step_time.max(self.max_step_time);
+			self.step_time = avg_step_time;
+			self.max_step_time = avg_step_time.max(self.max_step_time);
 		}
 		if globals.is_pressed(ActionId::StepSim) {
 			self.step_pressed()
 		}
+		if globals.is_pressed(ActionId::StartSim) {
 			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 => (),
 			}
-			SimState::Stepping => {
-				if globals.is_pressed(ActionId::StartSim) {
-					self.sim_state = SimState::Running
 		} else if globals.is_pressed(ActionId::StopSim) {
+			match self.sim_state {
+				SimState::Running | SimState::Stepping => {
 					self.sim_state = SimState::Editing;
 					self.popup = Popup::None;
 				}
-			}
-			SimState::Running => {
-				if globals.is_pressed(ActionId::StopSim) {
-					self.sim_state = SimState::Editing;
-				}
+				SimState::Editing => (),
 			}
 		}
 
@@ -575,48 +571,27 @@ impl Editor {
 		}
 	}
 
-	fn draw_board(&self, d: &mut RaylibDrawHandle, globals: &Globals) {
-		let draw_power = globals.config.show_power_direction && self.draw_overlay;
+	fn draw_board(&self, d: &mut RaylibDrawHandle, textures: &Textures) {
 		if self.sim_state == SimState::Editing {
-			self.source_board.grid.draw(
-				d,
-				&globals.textures,
-				self.view_offset,
-				self.zoom,
-				draw_power,
-			);
+			self.source_board
+				.grid
+				.draw(d, textures, self.view_offset, self.zoom);
 		} else {
 			if self.machine.debug_subticks.is_empty() {
-				self.machine.grid().draw(
-					d,
-					&globals.textures,
-					self.view_offset,
-					self.zoom,
-					draw_power,
-				);
+				self.machine
+					.grid()
+					.draw(d, textures, self.view_offset, self.zoom);
 			} else {
 				let subframe = &self.machine.debug_subticks[self.machine.subtick_index];
-				subframe.grid.draw(
-					d,
-					&globals.textures,
-					self.view_offset,
-					self.zoom,
-					draw_power,
-				);
+				subframe.grid.draw(d, 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(
-						globals.get_tex("selection"),
-						p,
-						0.,
-						self.zoom,
-						Color::ORANGE,
-					);
+					d.draw_texture_ex(textures.get("selection"), p, 0., self.zoom, Color::ORANGE);
 				}
 			}
 			if self.draw_overlay {
 				self.machine
-					.draw_marble_values(d, &globals.textures, self.view_offset, self.zoom);
+					.draw_marble_values(d, textures, self.view_offset, self.zoom);
 			}
 		}
 		if self.draw_overlay {
@@ -632,25 +607,23 @@ 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;
-			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 {
+			for y in 0..=(d.get_screen_height() / tile_size as i32) {
 				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..vlines {
+			for x in 0..=(d.get_screen_width() / tile_size as i32) {
 				let x = x * tile_size as i32 + grid_spill_x as i32;
 				d.draw_line(x, 0, x, d.get_screen_height(), FG_GRID);
 			}
 		}
 
-		self.draw_board(d, globals);
-		self.board_overlay(d, globals);
+		self.draw_board(d, &globals.textures);
+		self.board_overlay(d, &globals.textures);
 		self.draw_bottom_bar(d, globals);
 		self.draw_top_bar(d, globals);
 
 		if self.active_tool == Tool::Blueprint {
-			self.draw_blueprint_sidebar(d, globals);
+			self.draw_blueprint_sidebar(d, &globals.textures);
 		}
 
 		self.mouse.update(d);
@@ -667,7 +640,7 @@ impl Editor {
 		}
 
 		match self.popup {
-			Popup::Success(_) | Popup::Failure => {
+			Popup::Success | Popup::Failure => {
 				self.draw_end_popup(d, &globals.textures);
 			}
 			Popup::LevelInfo => {
@@ -700,7 +673,7 @@ impl Editor {
 		self.tooltip.draw(d);
 	}
 
-	fn draw_blueprint_sidebar(&mut self, d: &mut RaylibDrawHandle, globals: &mut Globals) {
+	fn draw_blueprint_sidebar(&mut self, d: &mut RaylibDrawHandle, textures: &Textures) {
 		let sidebar_height = d.get_screen_height() - FOOTER_HEIGHT - HEADER_HEIGHT - 40;
 		d.draw_rectangle(
 			0,
@@ -724,7 +697,7 @@ impl Editor {
 			if tex32_button(
 				(d, &self.mouse),
 				(5, y),
-				globals.get_tex("rubbish"),
+				textures.get("rubbish"),
 				(&mut self.tooltip, "Delete"),
 			) {
 				b.remove_file();
@@ -735,7 +708,7 @@ impl Editor {
 			let mut text_selected = is_selected && self.blueprint_name_selected;
 			text_input(
 				d,
-				globals,
+				&self.mouse,
 				Rectangle::new(42., y as f32, 200., 32.),
 				&mut b.name,
 				&mut text_selected,
@@ -754,7 +727,7 @@ impl Editor {
 			);
 
 			d.draw_texture_ex(
-				globals.get_tex("blueprint"),
+				textures.get("blueprint"),
 				Vector2::new((42 + 205) as f32, y as f32),
 				0.,
 				2.,
@@ -767,35 +740,38 @@ 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 mut y = bounds.y as i32 + 10;
+		let y = bounds.y as i32;
 		d.draw_rectangle_rec(bounds, BG_DARK);
-		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) {
+		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) {
 				self.popup = Popup::None;
 				self.dismissed_end = true;
 			}
-			d.draw_text("continue\nediting", x + 15, y + 5, 20, Color::WHITE);
+			d.draw_text("continue\nediting", x + 15, y + 115, 20, Color::WHITE);
 
-			if simple_button((d, &self.mouse), x + END_POPUP_WIDTH / 2 + 5, y, 140, 50) {
+			if simple_button(
+				(d, &self.mouse),
+				x + END_POPUP_WIDTH / 2 + 5,
+				y + 110,
+				140,
+				45,
+			) {
 				self.exit_state = ExitState::ExitAndSave;
 			}
 			d.draw_text(
 				"return to\nlevel list",
 				x + END_POPUP_WIDTH / 2 + 10,
-				y + 5,
+				y + 115,
 				20,
 				Color::WHITE,
 			);
@@ -810,7 +786,8 @@ impl Editor {
 		}
 	}
 
-	fn draw_top_bar(&mut self, d: &mut RaylibDrawHandle, globals: &mut Globals) {
+	fn draw_top_bar(&mut self, d: &mut RaylibDrawHandle, globals: &Globals) {
+		let textures = &globals.textures;
 		// background
 		d.draw_rectangle(
 			0,
@@ -823,7 +800,7 @@ impl Editor {
 		if tex32_button(
 			(d, &self.mouse),
 			(4, 4),
-			globals.get_tex("exit"),
+			textures.get("exit"),
 			(&mut self.tooltip, "exit"),
 		) {
 			if self.exit_menu {
@@ -836,7 +813,7 @@ impl Editor {
 			if tex32_button(
 				(d, &self.mouse),
 				(40, 4),
-				globals.get_tex("cancel"),
+				textures.get("cancel"),
 				(&mut self.tooltip, "cancel"),
 			) {
 				self.exit_menu = false;
@@ -844,7 +821,7 @@ impl Editor {
 		} else if tex32_button(
 			(d, &self.mouse),
 			(40, 4),
-			globals.get_tex("save"),
+			textures.get("save"),
 			(&mut self.tooltip, "save"),
 		) || globals.is_pressed(ActionId::Save)
 		{
@@ -864,7 +841,7 @@ impl Editor {
 			if tex32_button(
 				(d, &self.mouse),
 				(150, 4),
-				globals.get_tex(undo_icon),
+				textures.get(undo_icon),
 				(&mut self.tooltip, "Undo"),
 			) {
 				self.undo()
@@ -878,7 +855,7 @@ impl Editor {
 			if tex32_button(
 				(d, &self.mouse),
 				(186, 4),
-				globals.get_tex(redo_icon),
+				textures.get(redo_icon),
 				(&mut self.tooltip, "Redo"),
 			) {
 				self.redo()
@@ -893,7 +870,7 @@ impl Editor {
 		if tex32_button(
 			(d, &self.mouse),
 			(223, 4),
-			globals.get_tex(overlay_btn_icon),
+			textures.get(overlay_btn_icon),
 			(&mut self.tooltip, "Toggle overlay"),
 		) {
 			self.draw_overlay = !self.draw_overlay;
@@ -903,7 +880,7 @@ impl Editor {
 			if tex32_button(
 				(d, &self.mouse),
 				(260, 4),
-				globals.get_tex("pause"),
+				textures.get("pause"),
 				(&mut self.tooltip, "Pause"),
 			) {
 				self.sim_state = SimState::Stepping;
@@ -911,7 +888,7 @@ impl Editor {
 		} else if tex32_button(
 			(d, &self.mouse),
 			(260, 4),
-			globals.get_tex("play"),
+			textures.get("play"),
 			(&mut self.tooltip, "Start"),
 		) {
 			if self.sim_state == SimState::Editing {
@@ -924,7 +901,7 @@ impl Editor {
 			&& tex32_button(
 				(d, &self.mouse),
 				(296, 4),
-				globals.get_tex("stop"),
+				textures.get("stop"),
 				(&mut self.tooltip, "Stop"),
 			) {
 			self.sim_state = SimState::Editing;
@@ -934,21 +911,14 @@ impl Editor {
 		if tex32_button(
 			(d, &self.mouse),
 			(332, 4),
-			globals.get_tex("step"),
+			textures.get("step"),
 			(&mut self.tooltip, "Step"),
 		) {
 			self.step_pressed();
 		}
 
 		self.tooltip.add(368, 4, 48, 32, "Speed");
-		draw_usize(
-			d,
-			&globals.textures,
-			1 << self.sim_speed,
-			(368, 4),
-			SPEED_DIGITS,
-			1,
-		);
+		draw_usize(d, textures, 1 << self.sim_speed, (368, 4), SPEED_DIGITS, 1);
 		slider(
 			(d, &self.mouse),
 			rect(368, 24, 48, 12),
@@ -958,36 +928,20 @@ impl Editor {
 		);
 
 		self.tooltip.add(420, 4, 180, 32, "Steps");
-		draw_usize(
-			d,
-			&globals.textures,
-			self.machine.step_count(),
-			(420, 4),
-			9,
-			2,
-		);
+		draw_usize(d, 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, &globals.textures, total_steps, (420, 44), 9, 2);
+			draw_usize(d, textures, total_steps, (420, 44), 9, 2);
 		}
 
-		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);
+		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);
 		#[cfg(debug_assertions)]
 		{
-				draw_usize(
-					d,
-					&globals.textures,
-					self.machine.subtick_index,
-					(260, 80),
-					9,
-					1,
-				);
+			draw_usize(d, 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);
-			}
+			draw_usize(d, textures, subtick_count, (260, 100), 9, 1);
 		}
 
 		d.draw_text("input:", 603, 8, 10, Color::WHITE);
@@ -1010,7 +964,7 @@ impl Editor {
 			}
 			if text_input(
 				d,
-				globals,
+				&self.mouse,
 				Rectangle::new(input_x as f32, 5., (width - input_x - 5) as f32, 30.),
 				&mut input_text,
 				&mut self.input_text_selected,
@@ -1064,7 +1018,7 @@ impl Editor {
 			hide_tile_tools = true;
 			text_input(
 				d,
-				globals,
+				&self.mouse,
 				Rectangle::new(100., footer_top + 10., 240., 30.),
 				&mut self.new_blueprint_name,
 				&mut self.blueprint_name_selected,
@@ -1106,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::EraseSelection)
+				|| globals.is_pressed(ActionId::Erase)
 			{
 				erase_selection = true;
 			}
@@ -1137,7 +1091,7 @@ impl Editor {
 		                       texture: &str,
 		                       tooltip: &'static str,
 		                       tool_option: Tool,
-		                       action: ActionId| {
+		                       action: Option<ActionId>| {
 			let border = 4.;
 			let gap = 2.;
 			let button_size = 32. + border * 2.;
@@ -1157,26 +1111,20 @@ impl Editor {
 				tool_option,
 				&mut self.active_tool,
 				border,
-				globals.is_pressed(action),
+				action.map(|a| globals.is_pressed(a)).unwrap_or(false),
 			)
 		};
-		tool_button((0, -2), "eraser", "Eraser", Tool::Erase, ActionId::Eraser);
+		tool_button((0, -2), "eraser", "Eraser", Tool::Erase, None);
 		tool_button(
 			(1, -2),
 			"selection",
 			"Select",
 			Tool::SelectArea(Selection::default()),
-			ActionId::Selection,
+			None,
 		);
 
-		tool_button(
-			(0, -1),
-			"blueprint",
-			"Blueprints",
-			Tool::Blueprint,
-			ActionId::Blueprints,
-		);
-		tool_button((1, -1), "transparent", "None", Tool::None, ActionId::NoTool);
+		tool_button((0, -1), "blueprint", "Blueprints", Tool::Blueprint, None);
+		tool_button((1, -1), "transparent", "None", Tool::None, None);
 
 		if !hide_tile_tools {
 			tool_button(
@@ -1184,42 +1132,42 @@ impl Editor {
 				"block",
 				"Block",
 				Tool::SetTile(Tile::from_char('#')),
-				ActionId::TileBlock,
+				Some(ActionId::TileBlock),
 			);
 			tool_button(
 				(0, 1),
 				"silo_off",
 				"Silo",
 				Tool::SetTile(Tile::from_char('B')),
-				ActionId::TileSilo,
+				Some(ActionId::TileSilo),
 			);
 			tool_button(
 				(0, 2),
 				"button_off",
 				"Button",
 				Tool::SetTile(Tile::from_char('*')),
-				ActionId::TileButton,
+				Some(ActionId::TileButton),
 			);
 			tool_button(
 				(0, 3),
 				"io_tile_off",
 				"Input/Output silo",
 				Tool::SetTile(Tile::from_char('I')),
-				ActionId::TileIOSilo,
+				Some(ActionId::TileIOSilo),
 			);
 			tool_button(
 				(0, 4),
 				"flipper_off",
 				"Flipper",
 				Tool::SetTile(Tile::from_char('F')),
-				ActionId::TileFlipper,
+				Some(ActionId::TileFlipper),
 			);
 			tool_button(
 				(0, 5),
 				"digit_tool",
 				"Digit",
 				Tool::Digits(None),
-				ActionId::TileDigit,
+				Some(ActionId::TileDigit),
 			);
 
 			tool_button(
@@ -1227,14 +1175,14 @@ impl Editor {
 				"marble",
 				"Marble",
 				Tool::SetTile(Tile::from_char('o')),
-				ActionId::TileMarble,
+				Some(ActionId::TileMarble),
 			);
 			match tool_button(
 				(1, 1),
 				self.tool_wire.texture_name_off(),
 				self.tool_wire.human_name(),
 				Tool::Wire,
-				ActionId::TileGroupWire,
+				Some(ActionId::TileGroupWire),
 			) {
 				Some(Scroll::Down) => self.tool_wire.next(),
 				Some(Scroll::Up) => self.tool_wire.prev(),
@@ -1246,7 +1194,7 @@ impl Editor {
 				self.tool_arrow.arrow_tile_texture_name(),
 				self.tool_arrow.arrow_tile_human_name(),
 				Tool::Arrow,
-				ActionId::TileGroupArrow,
+				Some(ActionId::TileGroupArrow),
 			) {
 				Some(Scroll::Down) => self.tool_arrow = self.tool_arrow.right(),
 				Some(Scroll::Up) => self.tool_arrow = self.tool_arrow.left(),
@@ -1257,7 +1205,7 @@ impl Editor {
 				self.tool_mirror.texture_name(),
 				self.tool_mirror.human_name(),
 				Tool::Mirror,
-				ActionId::TileGroupMirror,
+				Some(ActionId::TileGroupMirror),
 			)
 			.is_some()
 			{
@@ -1268,7 +1216,7 @@ impl Editor {
 				self.tool_math.texture_name_off(),
 				self.tool_math.human_name(),
 				Tool::Math,
-				ActionId::TileGroupMath,
+				Some(ActionId::TileGroupMath),
 			) {
 				Some(Scroll::Down) => self.tool_math.next(),
 				Some(Scroll::Up) => self.tool_math.prev(),
@@ -1279,7 +1227,7 @@ impl Editor {
 				self.tool_comparator.texture_name_off(),
 				self.tool_comparator.human_name(),
 				Tool::Comparator,
-				ActionId::TileGroupCompare,
+				Some(ActionId::TileGroupCompare),
 			) {
 				Some(Scroll::Down) => self.tool_comparator.next(),
 				Some(Scroll::Up) => self.tool_comparator.prev(),
@@ -1360,7 +1308,7 @@ impl Editor {
 		}
 	}
 
-	fn board_overlay(&mut self, d: &mut RaylibDrawHandle, globals: &Globals) {
+	fn board_overlay(&mut self, d: &mut RaylibDrawHandle, textures: &Textures) {
 		let footer_top = (d.get_screen_height() - FOOTER_HEIGHT) as f32;
 
 		let tile_size = TILE_TEXTURE_SIZE * self.zoom;
@@ -1379,9 +1327,7 @@ 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, false);
+					board.grid.draw(d, 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;
@@ -1395,7 +1341,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(
-					globals.get_tex("selection"),
+					textures.get("selection"),
 					tile_screen_pos,
 					0.,
 					self.zoom,
@@ -1448,7 +1394,7 @@ impl Editor {
 					};
 
 					d.draw_texture_ex(
-						globals.get_tex(tex),
+						textures.get(tex),
 						tile_screen_pos,
 						0.,
 						self.zoom,
@@ -1518,9 +1464,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, &globals.textures, offset, self.zoom, false);
+						bp.board.grid.draw(d, textures, offset, self.zoom);
 						bp.board.draw_comments(d, offset, self.zoom);
 					}
 					if self.mouse.pos().x < SIDEBAR_WIDTH as f32 {

src/input.rs

@@ -23,7 +23,7 @@ pub enum ActionId {
 	Copy,
 	Cut,
 	Paste,
-	EraseSelection,
+	Erase,
 	ToggleMenu,
 	Save,
 	StartSim,
@@ -32,10 +32,6 @@ pub enum ActionId {
 	CycleGroup,
 	CycleGroupRevMod,
 
-	Eraser,
-	Selection,
-	Blueprints,
-	NoTool,
 	TileBlock,
 	TileSilo,
 	TileButton,
@@ -58,7 +54,6 @@ 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,
 			});
@@ -69,7 +64,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::EraseSelection, vec![], Backspace);
+		bind_key(ActionId::Erase, vec![], Backspace);
 		bind_key(ActionId::ToggleMenu, vec![], Escape);
 		bind_key(ActionId::Save, vec![LCtrl], S);
 		bind_key(ActionId::StartSim, vec![], Enter);
@@ -77,9 +72,6 @@ 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);
@@ -94,11 +86,9 @@ impl Default for Input {
 		bind_key(ActionId::TileGroupCompare, vec![], H);
 
 		Self {
-			action_bindings: bindings,
-			action_states: [BindingState::Off; ActionId::SIZE],
-			key_states: [BindingState::Off; Button::SIZE],
+			bindings,
+			states: Default::default(),
 			editing_binding: None,
-			in_text_edit: false,
 		}
 	}
 }
@@ -112,16 +102,14 @@ enum BindingState {
 	Released,
 }
 
-type InputMap = BTreeMap<String, Vec<Binding>>;
+type InputMap = BTreeMap<ActionId, Vec<Binding>>;
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 #[serde(from = "InputMap", into = "InputMap")]
 pub struct Input {
-	action_bindings: [Vec<Binding>; ActionId::SIZE],
-	action_states: [BindingState; ActionId::SIZE],
-	key_states: [BindingState; Button::SIZE],
+	bindings: [Vec<Binding>; ActionId::SIZE],
+	states: [BindingState; ActionId::SIZE],
 	editing_binding: Option<(ActionId, usize, BindingEdit)>,
-	pub in_text_edit: bool,
 }
 
 #[derive(Clone, Debug)]
@@ -132,7 +120,8 @@ enum BindingEdit {
 }
 
 impl Input {
-	pub fn draw_edit(&mut self, d: &mut RaylibDrawHandle, globals: &mut Globals, mut y: i32) {
+	pub fn draw_edit(&mut self, d: &mut RaylibDrawHandle, globals: &mut Globals, y: i32) {
+		let mut y = y + 96;
 		if self.editing_binding.is_some() {
 			globals.mouse.clear();
 		}
@@ -143,48 +132,36 @@ 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.action_bindings[action_index].iter().enumerate() {
+			for (binding_index, binding) in self.bindings[action_index].iter().enumerate() {
 				if text_button(d, &globals.mouse, buttons_x, y, 80, "remove") {
-					self.action_bindings[action_index].remove(binding_index);
-					self.update_modifier_blocks();
+					self.bindings[action_index].remove(binding_index);
 					return;
 				}
 				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);
-				let mut x = binding_text_x;
-				d.draw_text(&trigger, x, y + 5, 20, Color::LIMEGREEN);
-				x += 10 + d.measure_text(&trigger, 20);
-				//
+				d.draw_text(&trigger, binding_text_x, y + 5, 20, Color::LIMEGREEN);
+				let x = binding_text_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.action_bindings, binding, action);
+				let conflicts = conflicts(&self.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);
-					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);
+					let x = x + 10 + d.measure_text(&modifiers, 20);
+					d.draw_text(
+						&format!("also used by: {conflicts:?}"),
+						x,
+						y + 5,
+						20,
+						Color::ORANGERED,
+					);
 				}
 				y += 32;
 			}
 			if text_button(d, &globals.mouse, buttons_x, y, 130, "add binding") {
-				self.editing_binding = Some((
-					action,
-					self.action_bindings[action_index].len(),
-					BindingEdit::Init,
-				));
+				self.editing_binding =
+					Some((action, self.bindings[action_index].len(), BindingEdit::Init));
 			}
 			y += 45;
 		}
@@ -216,7 +193,6 @@ impl Input {
 					BindingEdit::Init => {
 						if key.just_pressed(d) {
 							*edit_state = BindingEdit::Adding(Binding {
-								blocking_modifiers: Vec::new(),
 								modifiers: Vec::new(),
 								trigger: key,
 							});
@@ -242,7 +218,6 @@ 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,
 							});
@@ -260,7 +235,7 @@ impl Input {
 				let text = format!("{:?} + {:?}", b.modifiers, b.trigger);
 				d.draw_text(&text, x + 5, y + 5, 20, colour);
 
-				let conflicts = conflicts(&self.action_bindings, b, *action);
+				let conflicts = conflicts(&self.bindings, b, *action);
 				if !conflicts.is_empty() {
 					d.draw_text(
 						&format!("conflicts: {conflicts:?}"),
@@ -273,14 +248,13 @@ 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.action_bindings[*action as usize];
+					let binding_list = &mut self.bindings[*action as usize];
 					if *binding_index < binding_list.len() {
 						binding_list[*binding_index] = binding.clone();
 					} else {
 						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") {
@@ -290,10 +264,16 @@ impl Input {
 	}
 
 	pub fn update(&mut self, rl: &RaylibHandle) {
-		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) {
+		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)) {
+					is_active |= binding.trigger.is_down(rl);
+				}
+			}
+			let state = &mut self.states[i];
+			*state = if is_active {
 				match state {
 					BindingState::Off | BindingState::Released => BindingState::Pressed,
 					BindingState::Pressed | BindingState::Held => BindingState::Held,
@@ -305,67 +285,19 @@ 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.action_states[action as usize] == BindingState::Pressed
+		self.states[action as usize] == BindingState::Pressed
 	}
 
 	pub fn is_held(&self, action: ActionId) -> bool {
-		self.action_states[action as usize] == BindingState::Pressed
-			|| self.action_states[action as usize] == BindingState::Held
+		self.states[action as usize] == BindingState::Pressed
+			|| self.states[action as usize] == BindingState::Held
 	}
 
 	pub fn is_released(&self, action: ActionId) -> bool {
-		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.action_bindings[i];
-			for binding_index in 0..bindings.len() {
-				let binding = &self.action_bindings[i][binding_index];
-				let mut blocking_mods = Vec::new();
-				for i in 0..ActionId::SIZE {
-					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 {
-								if !blocking_mods.contains(modifier)
-									&& !binding.modifiers.contains(modifier)
-								{
-									blocking_mods.push(*modifier);
-								}
-							}
-						}
-					}
-				}
-				self.action_bindings[i][binding_index].blocking_modifiers = blocking_mods;
-			}
-		}
+		self.states[action as usize] == BindingState::Released
 	}
 }
 
@@ -406,38 +338,15 @@ impl ActionId {
 
 #[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
 pub struct Binding {
-	#[serde(skip)]
-	blocking_modifiers: Vec<Button>,
 	modifiers: Vec<Button>,
 	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 {
+	fn from(value: 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.action_bindings[action as usize] = loaded_bindings;
-			} else {
-				println!("'{action}' is not a valid action id, bindings discarded");
-			}
+		for (action, loaded_bindings) in value {
+			new.bindings[action as usize] = loaded_bindings;
 		}
 		new
 	}
@@ -446,14 +355,11 @@ impl From<InputMap> for Input {
 impl From<Input> for InputMap {
 	fn from(value: Input) -> Self {
 		value
-			.action_bindings
+			.bindings
 			.iter()
 			.enumerate()
-			.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())
-			})
+			.map(|(i, b)| (ActionId::from_usize(i).unwrap(), b.clone()))
 			.collect()
 	}
 }

src/level.rs

@@ -6,8 +6,6 @@ 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)]
@@ -49,20 +47,6 @@ 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
 	}
@@ -97,7 +81,3 @@ impl Stage {
 		&self.output
 	}
 }
-
-fn default_true() -> bool {
-	true
-}

src/lib.rs

@@ -36,11 +36,10 @@ impl Globals {
 		textures.load_dir("assets/digits", rl, thread);
 
 		let config_path = userdata_dir().join(CONFIG_FILE_NAME);
-		let mut config: Config = fs::read_to_string(config_path)
+		let 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()

src/main.rs

@@ -1,6 +1,6 @@
 use std::{
 	collections::HashMap,
-	fs::{create_dir_all, read_dir, read_to_string, File},
+	fs::{read_dir, read_to_string, File},
 	io::Write,
 };
 
@@ -19,11 +19,11 @@ use util::*;
 const TITLE_TEXT: &str = concat!("Marble Machinations v", env!("CARGO_PKG_VERSION"));
 
 struct Game {
-	chapters: Vec<Chapter>,
-	level_scroll: i32,
+	levels: Vec<LevelListEntry>,
+	level_scroll: usize,
 	solutions: HashMap<String, Vec<Solution>>,
 	open_editor: Option<Editor>,
-	selected_level: (usize, usize),
+	selected_level: usize,
 	selected_solution: usize,
 	delete_solution: Option<usize>,
 	editing_solution_name: bool,
@@ -32,6 +32,12 @@ 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);
@@ -46,15 +52,15 @@ fn main() {
 
 impl Game {
 	fn new(rl: &mut RaylibHandle, thread: &RaylibThread) -> Self {
+		let levels = get_levels();
 		let solutions = get_solutions();
-		let chapters = get_chapters(&solutions);
 
 		Self {
-			chapters,
+			levels,
 			level_scroll: 0,
 			solutions,
 			open_editor: None,
-			selected_level: (0, 0),
+			selected_level: 0,
 			selected_solution: 0,
 			delete_solution: None,
 			editing_solution_name: false,
@@ -141,49 +147,38 @@ impl Game {
 
 		const ENTRY_SPACING: i32 = 65;
 		let fit_on_screen = (d.get_screen_height() / ENTRY_SPACING) as usize;
-		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;
+		let max_scroll = self.levels.len().saturating_sub(fit_on_screen);
 		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 += ENTRY_SPACING;
+				self.level_scroll += 1;
 			}
 			if self.globals.mouse.scroll() == Some(Scroll::Up) && self.level_scroll > 0 {
-				self.level_scroll -= ENTRY_SPACING;
+				self.level_scroll -= 1;
 			}
 		}
 
-		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);
+		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 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(&chapter.title, 10, y, 30, FG_CHAPTER_TITLE);
-			let subtitle = format!("{} levels", chapter.levels.len());
+					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);
-			y += ENTRY_SPACING;
-			let clicked_this =
-				self.globals.mouse.left_click() && self.globals.mouse.is_over(bounds);
-
-			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) {
+				LevelListEntry::Level(level) => {
+					if clicked_this && self.selected_level != level_index {
 						self.editing_solution_name = false;
-					self.selected_level = (chapter_i, level_index);
+						self.selected_level = level_index;
 						self.selected_solution = 0;
 						self.delete_solution = None;
 						// select the last solution of the level, if there is one
@@ -191,10 +186,7 @@ impl Game {
 							self.selected_solution = solutions.len().saturating_sub(1);
 						}
 					}
-				d.draw_rectangle_rec(
-					bounds,
-					widget_bg(self.selected_level == (chapter_i, level_index)),
-				);
+					d.draw_rectangle_rec(bounds, widget_bg(self.selected_level == level_index));
 
 					let mut title_color = Color::WHITE;
 					if let Some(solutions) = self.solutions.get(level.id()) {
@@ -215,15 +207,11 @@ impl Game {
 						Color::LIGHTGRAY
 					};
 					d.draw_text(&subtext, 10, y + 30, 20, subtext_color);
-				y += ENTRY_SPACING;
+				}
 			}
 		}
 
-		if let Some(level) = self
-			.chapters
-			.get(self.selected_level.0)
-			.and_then(|c| c.levels.get(self.selected_level.1))
-		{
+		if let Some(LevelListEntry::Level(level)) = self.levels.get(self.selected_level) {
 			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);
 
@@ -315,7 +303,7 @@ impl Game {
 					let bounds = Rectangle::new(column_x as f32, y as f32, 220., 30.);
 					if text_input(
 						d,
-						&mut self.globals,
+						&self.globals.mouse,
 						bounds,
 						&mut solution.name,
 						&mut self.editing_solution_name,
@@ -348,41 +336,30 @@ 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();
-		match File::create(path) {
-			Ok(mut f) => {
-				_ = f.write_all(json.as_bytes());
-			}
-			Err(e) => println!("error saving config: {e}"),
-		}
+		let mut f = File::create(path).unwrap();
+		f.write_all(json.as_bytes()).unwrap();
 	}
 }
 
-fn get_chapters(solutions: &HashMap<String, Vec<Solution>>) -> Vec<Chapter> {
+fn get_levels() -> Vec<LevelListEntry> {
 	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(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;
-					}
-				}
+			if let Ok(chapter) = serde_json::from_str(&text) {
 				chapters.push(chapter);
 			}
 		}
 	}
 	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");
@@ -395,15 +372,15 @@ fn get_chapters(solutions: &HashMap<String, Vec<Solution>>) -> Vec<Chapter> {
 			}
 		}
 	}
-	chapters.push(Chapter {
-		title: "Custom levels".into(),
-		levels: custom_levels,
-		visible: true,
-	});
-	if let Some(orphans) = find_orphans(&chapters, solutions) {
-		chapters.push(orphans);
+	level_list.push(LevelListEntry::Chapter(
+		"Custom levels".into(),
+		custom_levels.len(),
+	));
+	for l in custom_levels {
+		level_list.push(LevelListEntry::Level(l));
 	}
-	chapters
+
+	level_list
 }
 
 fn get_solutions() -> HashMap<String, Vec<Solution>> {
@@ -426,37 +403,9 @@ fn get_solutions() -> HashMap<String, Vec<Solution>> {
 					}
 					solutions.sort_unstable_by_key(Solution::id);
 				}
-				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,
-		})
-	}
-}

src/marble_engine.rs

@@ -12,19 +12,13 @@ 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, bool)>,
-	influenced_direction: Vec<(bool, DirInfluence)>,
-	claim_positions: Vec<Pos>,
-	removed_marbles: Vec<usize>,
 }
 
 #[derive(Debug)]
@@ -33,29 +27,18 @@ 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(),
 		}
 	}
 
@@ -136,51 +119,9 @@ 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();
 
-		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) {
+		let mut new_marbles = Vec::new();
 		// activate all powered machines
 		for &pos in &self.powered {
 			match self.grid.get_mut(pos) {
@@ -216,19 +157,20 @@ 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, false));
+									new_marbles.push((front_pos, value, dir));
 								}
 							}
 							PTile::IO => {
 								if front_tile == &Tile::BLANK && self.input_index < self.input.len()
 								{
 									let value = self.input[self.input_index] as MarbleValue;
-									self.new_marbles.push((front_pos, value, dir, true));
+									self.input_index += 1;
+									new_marbles.push((front_pos, value, dir));
 								}
 							}
 							PTile::Silo => {
 								if front_tile == &Tile::BLANK {
-									self.new_marbles.push((front_pos, 0, dir, false));
+									new_marbles.push((front_pos, 0, dir));
 								}
 							}
 							PTile::Flipper => {
@@ -256,13 +198,21 @@ impl Machine {
 			};
 		}
 		self.powered.clear();
+
+		if self.marbles.is_empty() {
+			return;
 		}
 
-	#[cfg_attr(feature = "inline_less", inline(never), no_mangle)]
-	fn step_find_bounces(&mut self) {
+		#[derive(Clone, Copy, Debug)]
+		enum DirInfluence {
+			None,
+			One(Direction),
+			Multiple,
+		}
 		// #### find all direct bounces ####
+		let mut will_reverse_direction = vec![false; self.marbles.len()];
 		// todo store in tile to remove search through self.marbles
-		self.influenced_direction = vec![(false, DirInfluence::None); self.marbles.len()];
+		let mut influenced_direction = vec![DirInfluence::None; self.marbles.len()];
 
 		for (i, &pos) in self.marbles.iter().enumerate() {
 			let Some(Tile::Marble { value: _, dir }) = self.grid.get(pos) else {
@@ -279,11 +229,11 @@ impl Machine {
 				} => {
 					if other_dir != dir {
 						// this marble is facing another marble, and will therefore definitely bounce
-						self.influenced_direction[i].0 = true;
+						will_reverse_direction[i] = true;
 						// the other marble will bounce too, either
 						let other_index =
 							self.marbles.iter().position(|m| *m == front_pos).unwrap();
-						let influence = &mut self.influenced_direction[other_index].1;
+						let influence = &mut influenced_direction[other_index];
 						*influence = match *influence {
 							DirInfluence::None => DirInfluence::One(dir),
 							DirInfluence::One(_) => DirInfluence::Multiple,
@@ -294,65 +244,48 @@ impl Machine {
 				Tile::Arrow(arrow_dir) => {
 					if arrow_dir == dir.opposite() {
 						// bounce on a reverse facing arrow
-						self.influenced_direction[i].0 = true;
+						will_reverse_direction[i] = 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 self.influenced_direction[i].0 {
+			if will_reverse_direction[i] {
 				*dir = dir.opposite();
-			} else if let DirInfluence::One(new_dir) = self.influenced_direction[i].1 {
+			} else if let DirInfluence::One(new_dir) = influenced_direction[i] {
 				*dir = new_dir;
 			}
 		}
-	}
 
-	#[cfg_attr(feature = "inline_less", inline(never), no_mangle)]
-	fn step_prepare_creating_marbles(&mut self) {
 		// #### new marbles ####
-		self.claim_positions.clear(); // already drained
+		let mut claim_positions = Vec::new();
 		// prepare creating the new marbles
-		for &(pos, _val, _dir, _is_input) in &self.new_marbles {
+		for &(pos, _val, _dir) in &new_marbles {
 			let Some(Tile::Open(OpenTile::Blank, claim)) = self.grid.get_mut(pos) else {
 				unreachable!()
 			};
 			if claim.claim_indirect() {
-				self.claim_positions.push(pos);
+				claim_positions.push(pos);
 			}
 		}
-	}
-
-	#[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, is_input) in self.new_marbles.drain(..) {
+		for (pos, value, dir) in new_marbles {
 			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)]
-	fn step_mark_claims(&mut self, old_marbles: usize) {
+		// #### movement ####
+		// mark claims to figure out what spaces can be moved to
 		for &pos in &self.marbles[..old_marbles] {
 			let Some(Tile::Marble { value: _, dir }) = self.grid.get(pos) else {
 				unreachable!()
@@ -363,7 +296,7 @@ impl Machine {
 			};
 			if let Tile::Open(_type, claim) = front_tile {
 				if claim.claim() {
-					self.claim_positions.push(front_pos);
+					claim_positions.push(front_pos);
 				}
 			} else {
 				let target_pos = match front_tile {
@@ -377,16 +310,13 @@ impl Machine {
 				};
 				if let Tile::Open(_type, claim) = target_tile {
 					if claim.claim_indirect() {
-						self.claim_positions.push(front_pos);
-					}
+						claim_positions.push(front_pos);
 					}
 				}
 			}
 		}
 
-	#[cfg_attr(feature = "inline_less", inline(never), no_mangle)]
-	fn step_move_marbles(&mut self, old_marbles: usize) {
-		self.removed_marbles.clear();
+		let mut removed_marbles = Vec::new();
 		// move marbles
 		for (i, pos) in self.marbles[..old_marbles].iter_mut().enumerate() {
 			let Some(Tile::Marble { value, dir }) = self.grid.get(*pos) else {
@@ -439,11 +369,11 @@ impl Machine {
 						target_pos = dir.step(front_pos);
 					}
 					Tile::Powerable(PTile::Silo, _) => {
-						self.removed_marbles.push(i);
+						removed_marbles.push(i);
 						continue;
 					}
 					Tile::Powerable(PTile::IO, _) => {
-						self.removed_marbles.push(i);
+						removed_marbles.push(i);
 						self.output.push(value as u8);
 						continue;
 					}
@@ -460,10 +390,19 @@ 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() {
@@ -588,5 +527,13 @@ 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;
+		}
 	}
 }

src/marble_engine/grid.rs

@@ -124,9 +124,9 @@ impl Grid {
 	}
 
 	pub fn used_bounds_area(&self) -> usize {
-		let row_clear = |y| {
-			for x in 0..self.width {
-				if !self.get_unchecked((x, y).into()).is_blank() {
+		let row_clear = |a, max, f: fn(usize, usize) -> (usize, usize)| {
+			for b in 0..max {
+				if !self.get_unchecked(f(a, b).into()).is_blank() {
 					return false;
 				}
 			}
@@ -134,37 +134,29 @@ impl Grid {
 		};
 		let mut height = self.height;
 		for y in 0..self.height {
-			if row_clear(y) {
+			if row_clear(y, self.width, |y, x| (x, y)) {
 				height -= 1;
 			} else {
 				break;
 			}
 		}
 		for y in (0..self.height).rev() {
-			if row_clear(y) {
+			if row_clear(y, self.width, |y, x| (x, y)) {
 				height -= 1;
 			} else {
 				break;
 			}
 		}
-		let col_clear = |x| {
-			for y in 0..self.height {
-				if !self.get_unchecked((x, y).into()).is_blank() {
-					return false;
-				}
-			}
-			true
-		};
 		let mut width = self.width;
 		for x in 0..self.width {
-			if col_clear(x) {
+			if row_clear(x, self.height, |x, y| (x, y)) {
 				width -= 1;
 			} else {
 				break;
 			}
 		}
 		for x in (0..self.width).rev() {
-			if col_clear(x) {
+			if row_clear(x, self.width, |x, y| (x, y)) {
 				width -= 1;
 			} else {
 				break;
@@ -285,23 +277,16 @@ 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) {
 		let tile_size = (TILE_TEXTURE_SIZE * scale) as i32;
 
 		let start_x = (-offset.x as i32) / tile_size - 1;
-		let tiles_width = d.get_screen_width() / tile_size + 3;
+		let tile_width = d.get_screen_width() / tile_size + 2;
 		let start_y = (-offset.y as i32) / tile_size - 1;
-		let tiles_height = d.get_screen_height() / tile_size + 3;
+		let tile_height = d.get_screen_height() / tile_size + 2;
 
-		for x in start_x..(start_x + tiles_width) {
-			for y in start_y..(start_y + tiles_height) {
+		for x in start_x..(start_x + tile_width) {
+			for y in start_y..(start_y + tile_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()) {
@@ -311,7 +296,8 @@ impl Grid {
 					}
 					let texture = textures.get(texname);
 					draw_scaled_texture(d, texture, px, py, scale);
-					if power_directions {
+					#[cfg(debug_assertions)]
+					// todo some in-game option to show power direction
 					if let Tile::Powerable(_, state) = &tile {
 						for dir in Direction::ALL {
 							if state.get_dir(dir) {
@@ -320,7 +306,6 @@ impl Grid {
 							}
 						}
 					}
-					}
 				} else {
 					d.draw_rectangle(px, py, tile_size, tile_size, Color::new(0, 0, 0, 80));
 				}

src/solution.rs

@@ -18,7 +18,7 @@ pub struct Solution {
 	pub score: Option<Score>,
 }
 
-#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Score {
 	pub cycles: usize,
 	pub tiles: usize,

src/ui.rs

@@ -1,10 +1,6 @@
 use std::ops::Range;
 
-use crate::{
-	theme::*,
-	util::{draw_scaled_texture, rect, MouseInput, Scroll, Textures},
-	Globals,
-};
+use crate::{theme::*, util::draw_scaled_texture, util::MouseInput, util::Scroll, util::Textures};
 use raylib::prelude::*;
 
 #[derive(Debug)]
@@ -160,35 +156,6 @@ 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,
@@ -197,7 +164,12 @@ pub fn simple_button(
 	height: i32,
 ) -> bool {
 	let mouse_pos = mouse.pos();
-	let bounds = rect(x, y, width, height);
+	let bounds = Rectangle {
+		x: x as f32,
+		y: y as f32,
+		width: width as f32,
+		height: height as f32,
+	};
 	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));
@@ -253,7 +225,7 @@ where
 
 pub fn text_input(
 	d: &mut RaylibDrawHandle,
-	globals: &mut Globals,
+	mouse: &MouseInput,
 	bounds: Rectangle,
 	text: &mut String,
 	is_selected: &mut bool,
@@ -290,13 +262,12 @@ pub fn text_input(
 			Color::WHITE,
 		);
 	};
-	if editable && globals.mouse.left_click() && (globals.mouse.is_over(bounds) || *is_selected) {
+	if editable && mouse.left_click() && (mouse.is_over(bounds) || *is_selected) {
 		*is_selected = !*is_selected;
 	}
 
 	if *is_selected {
-		globals.config.input.in_text_edit = true;
-		if d.is_key_pressed(KeyboardKey::KEY_ESCAPE) || d.is_key_pressed(KeyboardKey::KEY_ENTER) {
+		if d.is_key_pressed(KeyboardKey::KEY_ESCAPE) {
 			*is_selected = false;
 		}
 		if d.is_key_pressed(KeyboardKey::KEY_BACKSPACE) && !text.is_empty() {

tests/main.rs

@@ -1,9 +1,8 @@
 use marble_machinations::marble_engine::{grid::Grid, Machine};
 
-fn do_test(steps: usize, input: &[u8], output: &[u8], grid: &str) {
+fn no_input_test(steps: usize, 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();
 	}
@@ -12,25 +11,11 @@ fn do_test(steps: usize, input: &[u8], 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(