add bounding area score to solution results

add selection cut button and binding
show input conflicts in binding menu
2025-04-03 16:05:08 +02:00 · 2025-04-03 15:39:25 +02:00 · 2025-04-03 14:25:00 +02:00 · 2025-04-03 14:02:12 +02:00 · 2025-04-03 13:53:15 +02:00 · 2025-04-03 13:45:49 +02:00
34 changed files with 2068 additions and 584 deletions
--- a/.gitignore
+++ b/.gitignore
@ -1,4 +1,4 @@
 /target
-/user
+/user*
 *.zip
 version.txt
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -0,0 +1,29 @@
+# Marble Machinations Change Log
+Game store page: https://crispypin.itch.io/marble-machinations
+
+## [Unreleased]
+### added
+- score number: bounding area
+- configurable key bindings for many editor actions
+- 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)
+- changelog file
+- (dev) sub-tick visualisation in debug mode
+- (dev) tests and benchmarks
+### fixed
+- equal comparator did not output one of two incoming signals in some cases, depending on wire length and update order
+### changed
+- made early levels (1-5) easier and more tutorial-like
+- comparators can now power other tiles without a wire between, including other comparators
+- directly moving marbles (to adjactent tile without anything between) now have priority over new marbles being created, instead of the two events cancelling each other
+
+## v0.2.1 - 2025-03-14
+### added
+- "Simple comparison" level
+### fixed
+- phantom marble (empty tile causing other marbles to bounce away) appearing after multiple machines tried to output to the same location at once
+
+## v0.2.0 - 2024-12-24
+*everything else*
--- a/Cargo.lock
+++ b/Cargo.lock
@ -2,12 +2,6 @@
 # It is not intended for manual editing.
 version = 3

-[[package]]
-name = "ahash"
-version = "0.3.8"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8fd72866655d1904d6b0997d0b07ba561047d070fbe29de039031c641b61217"
-
 [[package]]
 name = "aho-corasick"
 version = "1.1.3"
@ -18,10 +12,19 @@ dependencies = [
 ]

 [[package]]
-name = "arrayvec"
-version = "0.5.2"
+name = "arboard"
+version = "3.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23b62fc65de8e4e7f52534fb52b0f3ed04746ae267519eef2a83941e8085068b"
+checksum = "df099ccb16cd014ff054ac1bf392c67feeef57164b05c42f037cd40f5d4357f4"
+dependencies = [
+ "clipboard-win",
+ "log",
+ "objc2",
+ "objc2-app-kit",
+ "objc2-foundation",
+ "parking_lot",
+ "x11rb",
+]

 [[package]]
 name = "autocfg"
@ -31,16 +34,14 @@ checksum = "ace50bade8e6234aa140d9a2f552bbee1db4d353f69b8217bc503490fc1a9f26"

 [[package]]
 name = "bindgen"
-version = "0.69.4"
+version = "0.70.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a00dc851838a2120612785d195287475a3ac45514741da670b735818822129a0"
+checksum = "f49d8fed880d473ea71efb9bf597651e77201bdd4893efe54c9e5d65ae04ce6f"
 dependencies = [
 "bitflags",
 "cexpr",
 "clang-sys",
 "itertools",
- "lazy_static",
- "lazycell",
 "log",
 "prettyplease",
 "proc-macro2",
@ -48,8 +49,7 @@ dependencies = [
 "regex",
 "rustc-hash",
 "shlex",
- "syn 2.0.79",
- "which",
+ "syn",
 ]

 [[package]]
@ -58,6 +58,15 @@ version = "2.6.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b048fb63fd8b5923fc5aa7b340d8e156aec7ec02f0c78fa8a6ddc2613f6f71de"

+[[package]]
+name = "block2"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2c132eebf10f5cad5289222520a4a058514204aed6d791f1cf4fe8088b82d15f"
+dependencies = [
+ "objc2",
+]
+
 [[package]]
 name = "cc"
 version = "1.1.24"
@ -76,12 +85,6 @@ dependencies = [
 "nom",
 ]

-[[package]]
-name = "cfg-if"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4785bdd1c96b2a846b2bd7cc02e86b6b3dbf14e7e53446c4f54c92a361040822"
-
 [[package]]
 name = "cfg-if"
 version = "1.0.0"
@ -99,6 +102,15 @@ dependencies = [
 "libloading",
 ]

+[[package]]
+name = "clipboard-win"
+version = "5.4.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "15efe7a882b08f34e38556b14f2fb3daa98769d06c7f0c1b076dfd0d983bc892"
+dependencies = [
+ "error-code",
+]
+
 [[package]]
 name = "cmake"
 version = "0.1.51"
@ -108,28 +120,6 @@ dependencies = [
 "cc",
 ]

-[[package]]
-name = "crossbeam-queue"
-version = "0.2.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "774ba60a54c213d409d5353bda12d49cd68d14e45036a285234c8d6f91f92570"
-dependencies = [
- "cfg-if 0.1.10",
- "crossbeam-utils",
- "maybe-uninit",
-]
-
-[[package]]
-name = "crossbeam-utils"
-version = "0.7.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c3c7c73a2d1e9fc0886a08b93e98eb643461230d5f1925e4036204d5f2e261a8"
-dependencies = [
- "autocfg",
- "cfg-if 0.1.10",
- "lazy_static",
-]
-
 [[package]]
 name = "either"
 version = "1.13.0"
@ -147,10 +137,20 @@ dependencies = [
 ]

 [[package]]
-name = "fs_extra"
-version = "1.3.0"
+name = "error-code"
+version = "3.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "42703706b716c37f96a77aea830392ad231f44c9e9a67872fa5548707e11b11c"
+checksum = "a5d9305ccc6942a704f4335694ecd3de2ea531b114ac2d51f5f843750787a92f"
+
+[[package]]
+name = "gethostname"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0176e0459c2e4a1fe232f984bca6890e681076abb9934f6cea7c326f3fc47818"
+dependencies = [
+ "libc",
+ "windows-targets 0.48.5",
+]

 [[package]]
 name = "glob"
@ -158,31 +158,6 @@ version = "0.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "d2fabcfbdc87f4758337ca535fb41a6d701b65693ce38287d856d1674551ec9b"

-[[package]]
-name = "hashbrown"
-version = "0.7.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "96282e96bfcd3da0d3aa9938bedf1e50df3269b6db08b4876d2da0bb1a0841cf"
-dependencies = [
- "ahash",
- "autocfg",
-]
-
-[[package]]
-name = "hibitset"
-version = "0.6.4"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f3ede5cfa60c958e60330d65163adbc4211e15a2653ad80eb0cce878de120121"
-
-[[package]]
-name = "home"
-version = "0.5.9"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e3d1354bf6b7235cb4a0576c2619fd4ed18183f689b12b006a0ee7329eeff9a5"
-dependencies = [
- "windows-sys",
-]
-
 [[package]]
 name = "itertools"
 version = "0.12.1"
@ -198,18 +173,6 @@ version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"

-[[package]]
-name = "lazy_static"
-version = "1.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bbd2bcb4c963f2ddae06a2efc7e9f3591312473c50c6685e1f298068316e66fe"
-
-[[package]]
-name = "lazycell"
-version = "1.3.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "830d08ce1d1d941e6b30645f1a0eb5643013d835ce3779a5fc208261dbe10f55"
-
 [[package]]
 name = "libc"
 version = "0.2.159"
@ -222,8 +185,8 @@ version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4979f22fdb869068da03c9f7528f8297c6fd2606bc3a4affe42e6a823fdb8da4"
 dependencies = [
- "cfg-if 1.0.0",
- "windows-targets",
+ "cfg-if",
+ "windows-targets 0.52.6",
 ]

 [[package]]
@ -250,19 +213,14 @@ checksum = "a7a70ba024b9dc04c27ea2f0c0548feb474ec5c54bba33a7f72f873a39d07b24"

 [[package]]
 name = "marble-machinations"
-version = "0.2.0"
+version = "0.2.1"
 dependencies = [
+ "arboard",
 "raylib",
 "serde",
 "serde_json",
 ]

-[[package]]
-name = "maybe-uninit"
-version = "2.0.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "60302e4db3a61da70c0cb7991976248362f30319e88850c487b9b95bbf059e00"
-
 [[package]]
 name = "memchr"
 version = "2.7.4"
@ -275,12 +233,6 @@ version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "68354c5c6bd36d73ff3feceb05efa59b6acb7626617f4962be322a825e61f79a"

-[[package]]
-name = "mopa"
-version = "0.2.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a785740271256c230f57462d3b83e52f998433a7062fc18f96d5999474a9f915"
-
 [[package]]
 name = "nom"
 version = "7.1.3"
@ -292,12 +244,102 @@ dependencies = [
 ]

 [[package]]
-name = "once_cell"
-version = "1.20.1"
+name = "objc-sys"
+version = "0.3.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82881c4be219ab5faaf2ad5e5e5ecdff8c66bd7402ca3160975c93b24961afd1"
+checksum = "cdb91bdd390c7ce1a8607f35f3ca7151b65afc0ff5ff3b34fa350f7d7c7e4310"
+
+[[package]]
+name = "objc2"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "46a785d4eeff09c14c487497c162e92766fbb3e4059a71840cecc03d9a50b804"
 dependencies = [
- "portable-atomic",
+ "objc-sys",
+ "objc2-encode",
+]
+
+[[package]]
+name = "objc2-app-kit"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4e89ad9e3d7d297152b17d39ed92cd50ca8063a89a9fa569046d41568891eff"
+dependencies = [
+ "bitflags",
+ "block2",
+ "libc",
+ "objc2",
+ "objc2-core-data",
+ "objc2-core-image",
+ "objc2-foundation",
+ "objc2-quartz-core",
+]
+
+[[package]]
+name = "objc2-core-data"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "617fbf49e071c178c0b24c080767db52958f716d9eabdf0890523aeae54773ef"
+dependencies = [
+ "bitflags",
+ "block2",
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-core-image"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55260963a527c99f1819c4f8e3b47fe04f9650694ef348ffd2227e8196d34c80"
+dependencies = [
+ "block2",
+ "objc2",
+ "objc2-foundation",
+ "objc2-metal",
+]
+
+[[package]]
+name = "objc2-encode"
+version = "4.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ef25abbcd74fb2609453eb695bd2f860d389e457f67dc17cafc8b8cbc89d0c33"
+
+[[package]]
+name = "objc2-foundation"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ee638a5da3799329310ad4cfa62fbf045d5f56e3ef5ba4149e7452dcf89d5a8"
+dependencies = [
+ "bitflags",
+ "block2",
+ "libc",
+ "objc2",
+]
+
+[[package]]
+name = "objc2-metal"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd0cba1276f6023976a406a14ffa85e1fdd19df6b0f737b063b95f6c8c7aadd6"
+dependencies = [
+ "bitflags",
+ "block2",
+ "objc2",
+ "objc2-foundation",
+]
+
+[[package]]
+name = "objc2-quartz-core"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e42bee7bff906b14b167da2bac5efe6b6a07e6f7c0a21a7308d40c960242dc7a"
+dependencies = [
+ "bitflags",
+ "block2",
+ "objc2",
+ "objc2-foundation",
+ "objc2-metal",
 ]

 [[package]]
@ -316,18 +358,18 @@ version = "0.9.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1e401f977ab385c9e4e3ab30627d6f26d00e2c73eef317493c4ec6d468726cf8"
 dependencies = [
- "cfg-if 1.0.0",
+ "cfg-if",
 "libc",
 "redox_syscall",
 "smallvec",
- "windows-targets",
+ "windows-targets 0.52.6",
 ]

 [[package]]
-name = "portable-atomic"
-version = "1.9.0"
+name = "paste"
+version = "1.0.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cc9c68a3f6da06753e9335d63e27f6b9754dd1920d941135b7ea8224f141adb2"
+checksum = "57c0d7b74b563b49d38dae00a0c37d4d6de9b432382b2892f0574ddcae73fd0a"

 [[package]]
 name = "prettyplease"
@ -336,14 +378,14 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "479cf940fbbb3426c32c5d5176f62ad57549a0bb84773423ba8be9d089f5faba"
 dependencies = [
 "proc-macro2",
- "syn 2.0.79",
+ "syn",
 ]

 [[package]]
 name = "proc-macro2"
-version = "1.0.86"
+version = "1.0.94"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
+checksum = "a31971752e70b8b2686d7e46ec17fb38dad4051d94024c88df49b667caea9c84"
 dependencies = [
 "unicode-ident",
 ]
@ -359,29 +401,26 @@ dependencies = [

 [[package]]
 name = "raylib"
-version = "5.0.2"
+version = "5.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e2a7a6734329d7b872a418fe4cb08ca282eb66a6f4a3430bd4ee4e6a8cac6632"
+checksum = "e5c54335590d1b6e6fbdbccee09dafdfd76a1111fc3c709eca949e71e81f7a8a"
 dependencies = [
- "cfg-if 1.0.0",
- "lazy_static",
- "libc",
- "parking_lot",
+ "cfg-if",
+ "paste",
 "raylib-sys",
- "specs",
- "specs-derive",
+ "seq-macro",
+ "thiserror",
 ]

 [[package]]
 name = "raylib-sys"
-version = "5.0.2"
+version = "5.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "db5c6001cfaeec17210713227d11f3b1ba4b723bb12cff47d1b93c4060e10ad0"
+checksum = "3ce5adc950b042db67f1f78f24f7e76563652ce24db032afe9ca9e534d8b7a13"
 dependencies = [
 "bindgen",
 "cc",
 "cmake",
- "fs_extra",
 ]

 [[package]]
@ -453,6 +492,12 @@ version = "1.2.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "94143f37725109f92c262ed2cf5e59bce7498c01bcc1502d7b9afe439a4e9f49"

+[[package]]
+name = "seq-macro"
+version = "0.3.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc711410fbe7399f390ca1c3b60ad0f53f80e95c5eb935e52268a0e2cd49acc"
+
 [[package]]
 name = "serde"
 version = "1.0.210"
@ -470,7 +515,7 @@ checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
 dependencies = [
 "proc-macro2",
 "quote",
- "syn 2.0.79",
+ "syn",
 ]

 [[package]]
@ -491,62 +536,17 @@ version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0fda2ff0d084019ba4d7c6f371c95d8fd75ce3524c3cb8fb653a3023f6323e64"

-[[package]]
-name = "shred"
-version = "0.10.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5f08237e667ac94ad20f8878b5943d91a93ccb231428446c57c21c57779016d"
-dependencies = [
- "arrayvec",
- "hashbrown",
- "mopa",
- "smallvec",
- "tynm",
-]
-
-[[package]]
-name = "shrev"
-version = "1.1.3"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5ea33232fdcf1bf691ca33450e5a94dde13e1a8cbb8caabc5e4f9d761e10b1a"
-
 [[package]]
 name = "smallvec"
 version = "1.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"

-[[package]]
-name = "specs"
-version = "0.16.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fff28a29366aff703d5da8a7e2c8875dc8453ac1118f842cbc0fa70c7db51240"
-dependencies = [
- "crossbeam-queue",
- "hashbrown",
- "hibitset",
- "log",
- "shred",
- "shrev",
- "tuple_utils",
-]
-
-[[package]]
-name = "specs-derive"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e23e09360f3d2190fec4222cd9e19d3158d5da948c0d1ea362df617dd103511"
-dependencies = [
- "proc-macro2",
- "quote",
- "syn 1.0.109",
-]
-
 [[package]]
 name = "syn"
-version = "1.0.109"
+version = "2.0.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+checksum = "b09a44accad81e1ba1cd74a32461ba89dee89095ba17b32f5d03683b1b1fc2a0"
 dependencies = [
 "proc-macro2",
 "quote",
@ -554,29 +554,23 @@ dependencies = [
 ]

 [[package]]
-name = "syn"
-version = "2.0.79"
+name = "thiserror"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "89132cd0bf050864e1d38dc3bbc07a0eb8e7530af26344d3d2bbbef83499f590"
+checksum = "b6aaf5339b578ea85b50e080feb250a3e8ae8cfcdff9a461c9ec2904bc923f52"
 dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
+ "thiserror-impl",
 ]

 [[package]]
-name = "tuple_utils"
-version = "0.3.0"
+name = "thiserror-impl"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44834418e2c5b16f47bedf35c28e148db099187dd5feee6367fb2525863af4f1"
-
-[[package]]
-name = "tynm"
-version = "0.1.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd30d05e69d1478e13fe3e7a853409cfec82cebc2cf9b8d613b3c6b0081781ed"
+checksum = "4fee6c4efc90059e10f81e6d42c60a18f76588c3d74cb83a0b242a2b6c7504c1"
 dependencies = [
- "nom",
+ "proc-macro2",
+ "quote",
+ "syn",
 ]

 [[package]]
@ -585,25 +579,28 @@ version = "1.0.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e91b56cd4cadaeb79bbf1a5645f6b4f8dc5bde8834ad5894a8db35fda9efa1fe"

-[[package]]
-name = "which"
-version = "4.4.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87ba24419a2078cd2b0f2ede2691b6c66d8e47836da3b6db8265ebad47afbfc7"
-dependencies = [
- "either",
- "home",
- "once_cell",
- "rustix",
-]
-
 [[package]]
 name = "windows-sys"
 version = "0.52.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "282be5f36a8ce781fad8c8ae18fa3f9beff57ec1b52cb3de0789201425d9a33d"
 dependencies = [
- "windows-targets",
+ "windows-targets 0.52.6",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9a2fa6e2155d7247be68c096456083145c183cbbbc2764150dda45a87197940c"
+dependencies = [
+ "windows_aarch64_gnullvm 0.48.5",
+ "windows_aarch64_msvc 0.48.5",
+ "windows_i686_gnu 0.48.5",
+ "windows_i686_msvc 0.48.5",
+ "windows_x86_64_gnu 0.48.5",
+ "windows_x86_64_gnullvm 0.48.5",
+ "windows_x86_64_msvc 0.48.5",
 ]

 [[package]]
@ -612,28 +609,46 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
 dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
+ "windows_aarch64_gnullvm 0.52.6",
+ "windows_aarch64_msvc 0.52.6",
+ "windows_i686_gnu 0.52.6",
 "windows_i686_gnullvm",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
+ "windows_i686_msvc 0.52.6",
+ "windows_x86_64_gnu 0.52.6",
+ "windows_x86_64_gnullvm 0.52.6",
+ "windows_x86_64_msvc 0.52.6",
 ]

+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2b38e32f0abccf9987a4e3079dfb67dcd799fb61361e53e2882c3cbaf0d905d8"
+
 [[package]]
 name = "windows_aarch64_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"

+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc35310971f3b2dbbf3f0690a219f40e2d9afcf64f9ab7cc1be722937c26b4bc"
+
 [[package]]
 name = "windows_aarch64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"

+[[package]]
+name = "windows_i686_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a75915e7def60c94dcef72200b9a8e58e5091744960da64ec734a6c6e9b3743e"
+
 [[package]]
 name = "windows_i686_gnu"
 version = "0.52.6"
@ -646,26 +661,67 @@ version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"

+[[package]]
+name = "windows_i686_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8f55c233f70c4b27f66c523580f78f1004e8b5a8b659e05a4eb49d4166cca406"
+
 [[package]]
 name = "windows_i686_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"

+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "53d40abd2583d23e4718fddf1ebec84dbff8381c07cae67ff7768bbf19c6718e"
+
 [[package]]
 name = "windows_x86_64_gnu"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"

+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b7b52767868a23d5bab768e390dc5f5c55825b6d30b86c844ff2dc7414044cc"
+
 [[package]]
 name = "windows_x86_64_gnullvm"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"

+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.48.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ed94fce61571a4006852b7389a063ab983c02eb1bb37b47f8272ce92d06d9538"
+
 [[package]]
 name = "windows_x86_64_msvc"
 version = "0.52.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
+
+[[package]]
+name = "x11rb"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5d91ffca73ee7f68ce055750bf9f6eca0780b8c85eff9bc046a3b0da41755e12"
+dependencies = [
+ "gethostname",
+ "rustix",
+ "x11rb-protocol",
+]
+
+[[package]]
+name = "x11rb-protocol"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ec107c4503ea0b4a98ef47356329af139c0a4f7750e621cf2973cd3385ebcb3d"
--- a/Cargo.toml
+++ b/Cargo.toml
@ -1,9 +1,15 @@
 [package]
 name = "marble-machinations"
-version = "0.2.0"
+version = "0.2.1"
 edition = "2021"
+default-run = "marble-machinations"

 [dependencies]
-raylib = "5.0.2"
+arboard = { version = "3.4.1", default-features = false }
+raylib = "5.5"
 serde = { version = "1.0.210", features = ["derive"] }
 serde_json = "1.0.128"
+
+[[bin]]
+name = "bench"
+path = "src/benchmark.rs"
--- a/4
+++ b/4
@ -9,7 +9,7 @@ linux:
 	cargo build --release
 	mkdir ${RELEASE_DIRNAME}
 	cp target/release/${BIN_NAME} ${RELEASE_DIRNAME}/
-	cp -r assets levels ${RELEASE_DIRNAME}/
+	cp -r assets levels CHANGELOG.md ${RELEASE_DIRNAME}/
 	zip -r ${RELEASE_DIRNAME}_linux.zip ${RELEASE_DIRNAME}/
 	rm -rf ${RELEASE_DIRNAME}

@ -17,7 +17,7 @@ windows:
 	cargo build --release --target=${TARGET_W64}
 	mkdir ${RELEASE_DIRNAME}_win
 	cp target/${TARGET_W64}/release/${BIN_NAME}.exe ${RELEASE_DIRNAME}_win/
-	cp -r assets levels ${RELEASE_DIRNAME}_win/
+	cp -r assets levels CHANGELOG.md ${RELEASE_DIRNAME}_win/
 	zip -r ${RELEASE_DIRNAME}_win.zip ${RELEASE_DIRNAME}_win/
 	rm -rf ${RELEASE_DIRNAME}_win

--- a/README.md
+++ b/README.md
@ -1,25 +1,44 @@
 # Marble Machinations
-(working title)

 logic mostly like https://git.crispypin.cc/CrispyPin/marble

 ## todo
+### meta
+- itch page text
+- engine tests
+- 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
 - accessibility
-  - ui scaling
  - background colour setting
-  - configurable hotkeys
  - hotkeys for everything (no mouse needed to play)
-  - font selection (possibly a lot of work)
 - more levels
 - scroll output bytes
- make direct power (comparator -> machine) work, (needs storing power direction in machine tiles)
- cut selections, copy to system clipboard
 - 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 limits)
+- show histograms
+- author name in solutions and blueprints
+#### undecided
+- footprint score (tiles that were non-empty at any point in the run)
 - option to use 8-bit marbles?
 - blueprint rotation?
+- settable marble start direction?
+
+## playtesting observations
+- 'loops' introduces too many things (powering, redirection, generating zeroes)
+- players expect buttons to be triggered even when theres something blocking the marble on the other side
+- math tile is not intuitive

 ## file hierarchy
 ```
--- a/assets/cut.png
+++ b/assets/cut.png
--- a/assets/debug_arrow_down.png
+++ b/assets/debug_arrow_down.png
--- a/assets/debug_arrow_left.png
+++ b/assets/debug_arrow_left.png
--- a/assets/debug_arrow_right.png
+++ b/assets/debug_arrow_right.png
--- a/assets/debug_arrow_up.png
+++ b/assets/debug_arrow_up.png
--- a/benchmarks/aoc_2024_1a_level.json
+++ b/benchmarks/aoc_2024_1a_level.json
--- a/benchmarks/aoc_2024_1a_solution.json
+++ b/benchmarks/aoc_2024_1a_solution.json
--- a/levels/chapter_01.json
+++ b/levels/chapter_01.json
@ -5,7 +5,14 @@
 			"id": "output",
 			"name": "Zero",
 			"description": "learn how to output data",
-			"init_board": "\n o \n\n I\n\n",
+			"init_board": {
+				"comments": [
+					{ "text": "Welcome :3", "x": 3, "y": 0 },
+					{ "text": "< This is a marble,\n  it will move down when you start the machine", "x": 3, "y": 2 },
+					{ "text": "< This is an input/output silo\n  when a marble enters it, it disappears\n  and the value it held is added to the level output", "x": 3, "y": 5 }
+				],
+				"grid": "\n\n  o  \n\n\n  I\n\n\n"
+			},
 			"stages": [{
 				"input": [],
 				"output": [0]
@ -15,6 +22,14 @@
 			"id": "digits",
 			"name": "Digits",
 			"description": "place digits and use number keys to assign them values",
+			"init_board": {
+				"grid": "           \n\n\n       o\n     o\n   o\n       1\n   4 8 7\n\n   I I I\n\n\n\n",
+				"comments": [
+					{ "text": "Digit tiles are consumed by marbles that pass over them,\n adding their value to the end of the marble's number", "x": 8, "y": 5 },
+					{ "text": "Try selecting this 7 with the digit tool (#) in your toolbar\n then change it to a 6 using your keyboard number keys", "x": 8, "y": 7 },
+					{ "text": "You can also use the arrow keys to move the selection around,\n if you need to type more numbers", "x": 8, "y": 10 }
+				]
+			},
 			"stages": [{
 				"input": [],
 				"output": [4, 8, 16]
@ -24,7 +39,14 @@
 			"id": "loop",
 			"name": "Loop",
 			"description": "repeated output",
-			"init_board": "\n   \n o\n\n\n\n ^ \n\n",
+			"init_board": {
+				"grid": "           \n\n\n   v\n   o\n\n   *B  I\n\n\n   ^\n\n\n\n",
+				"comments": [
+					{ "text": "Arrows change the direction of marbles that collide with them", "x": 4, "y": 3 },
+					{ "text": " v Buttons are activated by marbles, and can power other machines", "x": 3, "y": 5 },
+					{ "text": "^ Silos create new marbles when powered", "x": 4, "y": 7 }
+				]
+			},
 			"stages": [{
 				"input": [],
 				"output": [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
@ -34,6 +56,12 @@
 			"id": "copy_input",
 			"name": "Copy Cat",
 			"description": "read input and output the same thing",
+			"init_board": {
+			    "grid": "           \n\n\n   v\n   o\n\n   *I  I\n\n\n   ^\n\n\n\n",
+				"comments": [
+					{ "text": "^ When an input/output silo is powered, it creates a new marble,\n containing the next value from the level input as a number", "x": 4, "y": 7 }
+				]
+			},
 			"stages": [{
 				"input": "Hello, world!",
 				"output": "Hello, world!"
@ -49,6 +77,10 @@
 			"id": "increment_input",
 			"name": "Incrementer",
 			"description": "Add one to each input number",
+			"init_board": {
+			    "grid": "         \n\n\n   o\n   5\n\n   *|\n    A2\n\n\n\n",
+				"comments": []
+			},
 			"stages": [{
 				"input": [93, 47, 71],
 				"output": [94, 48, 72]
@ -57,10 +89,29 @@
 				"output": [45, 128, 131, 212, 154, 157, 37, 197, 237, 237, 24, 57, 104, 206, 13, 50, 7, 42, 131, 60, 39, 12, 24, 213]
 			}]
 		},
+		{
+			"id": "comparator",
+			"name": "Simple comparison",
+			"description": "The input is two numbers, output 1 if the first one is larger, otherwise output 0.",
+			"init_board": "      \n o    \n   2  \n *-L- \n   5  \n      \n",
+			"stages": [{
+				"input": [5, 8],
+				"output": [0]
+			},{
+				"input": [38, 19],
+				"output": [1]
+			},{
+				"input": [0, 0],
+				"output": [0]
+			},{
+				"input": [124, 8],
+				"output": [1]
+			}]
+		},
 		{
 			"id": "copy_odd",
 			"name": "Odd Cat",
-			"description": "copy only the odd numbers from the input",
+			"description": "Copy only the odd numbers from the input",
 			"stages": [{
 				"input": [1, 2, 3, 4, 5, 6, 7],
 				"output": [1, 3, 5, 7]
--- a/meta/cover.png
+++ b/meta/cover.png
--- a/meta/min_of_list_machine.png
+++ b/meta/min_of_list_machine.png
--- a/src/benchmark.rs
+++ b/src/benchmark.rs
@ -0,0 +1,35 @@
+use std::time::Instant;
+
+use marble_machinations::{level::Level, marble_engine::Machine, solution::Solution};
+
+fn main() {
+	aoc_2024_1a();
+}
+
+fn aoc_2024_1a() {
+	println!("running aoc_2024_1a");
+	benchmark(
+		include_str!("../benchmarks/aoc_2024_1a_level.json"),
+		include_str!("../benchmarks/aoc_2024_1a_solution.json"),
+	);
+}
+
+fn benchmark(level: &str, solution: &str) {
+	let level: Level = serde_json::from_str(level).unwrap();
+	let solution: Solution = serde_json::from_str(solution).unwrap();
+	let cycle_count = solution.score.unwrap().cycles;
+	let mut machine = Machine::new_empty();
+	machine.set_grid(solution.board.grid);
+	let start_time = Instant::now();
+	for (n, stage) in level.stages().iter().enumerate() {
+		machine.set_input(stage.input().as_bytes().to_owned());
+		for _ in 0..cycle_count {
+			machine.step();
+		}
+		assert_eq!(machine.output(), stage.output().as_bytes());
+		println!("passed stage {n}");
+		machine.reset();
+	}
+	let elapsed = start_time.elapsed();
+	println!("took {elapsed:?}");
+}
--- a/src/blueprint.rs
+++ b/src/blueprint.rs
@ -6,24 +6,21 @@ use std::{

 use serde::{Deserialize, Serialize};

-use crate::{marble_engine::board::Board, userdata_dir};
+use crate::{board::Board, util::userdata_dir};

 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Blueprint {
 	id: usize,
 	pub name: String,
-	pub board: String,
-	#[serde(skip, default)]
-	tile_board: Option<Board>,
+	pub board: Board,
 }

 impl Blueprint {
-	pub fn new(content: &Board, id: usize) -> Self {
+	pub fn new(board: Board, id: usize) -> Self {
 		Self {
 			id,
 			name: format!("Blueprint {id}"),
-			board: content.serialize(),
-			tile_board: Some(content.clone()),
+			board,
 		}
 	}

@ -31,17 +28,6 @@ impl Blueprint {
 		self.id
 	}

-	pub fn convert_board(&mut self) -> &Board {
-		if self.tile_board.is_none() {
-			self.tile_board = Some(Board::parse(&self.board));
-		}
-		self.tile_board.as_ref().unwrap()
-	}
-
-	pub fn get_board(&self) -> Option<&Board> {
-		self.tile_board.as_ref()
-	}
-
 	fn path(&self) -> PathBuf {
 		let dir = userdata_dir().join("blueprints");
 		fs::create_dir_all(&dir).unwrap();
--- a/src/board.rs
+++ b/src/board.rs
@ -0,0 +1,166 @@
+use raylib::{
+	color::Color,
+	drawing::{RaylibDraw, RaylibDrawHandle},
+	math::Vector2,
+};
+use serde::{Deserialize, Serialize};
+
+use crate::{
+	marble_engine::{
+		grid::{Grid, ResizeDeltas},
+		pos::Pos,
+		tile::Tile,
+	},
+	theme::TILE_TEXTURE_SIZE,
+};
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+pub struct Comment {
+	text: String,
+	x: i32,
+	y: i32,
+}
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(from = "CompatBoard")]
+pub struct Board {
+	pub grid: Grid,
+	pub comments: Vec<Comment>,
+}
+
+#[derive(Debug, Clone, Serialize, Deserialize)]
+#[serde(untagged)]
+enum CompatBoard {
+	V1(String),
+	V2 { grid: Grid, comments: Vec<Comment> },
+}
+
+impl From<CompatBoard> for Board {
+	fn from(value: CompatBoard) -> Self {
+		match value {
+			CompatBoard::V1(string) => Self {
+				grid: Grid::from_ascii(&string),
+				comments: Vec::new(),
+			},
+			CompatBoard::V2 { grid, comments } => Self { grid, comments },
+		}
+	}
+}
+
+impl Default for Board {
+	fn default() -> Self {
+		Self {
+			grid: Grid::new_single(Tile::BLANK),
+			comments: Vec::new(),
+		}
+	}
+}
+
+impl Board {
+	pub fn new(grid: Grid) -> Self {
+		Self {
+			grid,
+			comments: Vec::new(),
+		}
+	}
+
+	pub fn single_tile(tile: Tile) -> Self {
+		Self {
+			grid: Grid::new_single(tile),
+			comments: Vec::new(),
+		}
+	}
+
+	pub fn draw_comments(&self, d: &mut RaylibDrawHandle, offset: Vector2, scale: f32) {
+		let tile_size = (TILE_TEXTURE_SIZE * scale) as i32;
+		let font_size = 10 * (scale as i32).max(1);
+		let line_space = 12 * (scale as i32).max(1);
+
+		for comment in &self.comments {
+			let x = comment.x * tile_size + offset.x as i32;
+			let y = comment.y * tile_size + offset.y as i32;
+			let y = y + (tile_size - font_size) / 2; // center vertically in the grid row
+			for (i, line) in comment.text.lines().enumerate() {
+				let y = y + line_space * i as i32;
+				d.draw_text(line, x, y, font_size, Color::ORANGE);
+			}
+		}
+	}
+
+	pub fn get_rect(&self, pos: Pos, width: usize, height: usize) -> Self {
+		let comments = self
+			.comments
+			.iter()
+			.filter(|c| c.in_area(pos, (width, height)))
+			.map(|c| {
+				let mut c = c.clone();
+				c.x -= pos.x as i32;
+				c.y -= pos.y as i32;
+				c
+			})
+			.collect();
+		Self {
+			grid: self.grid.get_rect(pos, width, height),
+			comments,
+		}
+	}
+
+	pub fn paste_board(&mut self, pos: Pos, board: &Board) {
+		// remove comments that are obscured by new board
+		let mut i = 0;
+		while i < self.comments.len() {
+			if !self.comments[i].in_area(pos, board.grid.size()) {
+				i += 1;
+			} else {
+				self.comments.remove(i);
+			}
+		}
+
+		self.grid.paste_grid(pos, &board.grid);
+		for c in &board.comments {
+			let mut comment = c.clone();
+			comment.x += pos.x as i32;
+			comment.y += pos.y as i32;
+			self.add_comment(comment);
+		}
+	}
+
+	pub fn add_comment(&mut self, comment: Comment) {
+		if self.comments.iter().any(|c| c == &comment) {
+			return;
+		}
+		self.comments.push(comment);
+	}
+
+	pub fn grow(&mut self, deltas: &ResizeDeltas) {
+		self.grid.grow(deltas);
+		for c in &mut self.comments {
+			c.x += deltas.x_neg as i32;
+			c.y += deltas.y_neg as i32;
+		}
+	}
+
+	pub fn shrink(&mut self, deltas: &ResizeDeltas) {
+		self.grid.shrink(deltas);
+		for c in &mut self.comments {
+			c.x -= deltas.x_neg as i32;
+			c.y -= deltas.y_neg as i32;
+		}
+	}
+
+	pub fn from_user_str(source: &str) -> Self {
+		serde_json::from_str(source).unwrap_or_else(|_| Self {
+			grid: Grid::from_ascii(source),
+			comments: Vec::new(),
+		})
+	}
+}
+
+impl Comment {
+	fn in_area(&self, pos: Pos, (width, height): (usize, usize)) -> bool {
+		self.x >= pos.x as i32
+			&& self.y >= pos.y as i32
+			&& self.x < pos.x as i32 + width as i32
+			&& self.y < pos.y as i32 + height as i32
+	}
+}
--- a/src/config.rs
+++ b/src/config.rs
@ -0,0 +1,45 @@
+use raylib::prelude::*;
+use serde::{Deserialize, Serialize};
+
+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(skip)]
+	scroll_offset: u32,
+}
+
+pub enum MenuReturn {
+	Stay,
+	StaySave,
+	ReturnSave,
+	ReturnCancel,
+}
+
+impl Config {
+	#[must_use]
+	pub fn draw_edit(&mut self, d: &mut RaylibDrawHandle, globals: &mut Globals) -> MenuReturn {
+		match globals.mouse.scroll() {
+			Some(Scroll::Down) => self.scroll_offset += 64,
+			Some(Scroll::Up) => self.scroll_offset = self.scroll_offset.saturating_sub(64),
+			None => (),
+		}
+		let y = -(self.scroll_offset as i32);
+
+		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 + 60, 80, "done") {
+			return MenuReturn::ReturnSave;
+		}
+		if text_button(d, &globals.mouse, 190, y + 60, 80, "cancel") {
+			return MenuReturn::ReturnCancel;
+		}
+
+		self.input.draw_edit(d, globals, y);
+		MenuReturn::Stay
+	}
+}
--- a/src/editor.rs
+++ b/src/editor.rs
@ -9,24 +9,26 @@ use raylib::prelude::*;

 use crate::{
 	blueprint::Blueprint,
+	board::Board,
+	input::ActionId,
 	level::Level,
-	marble_engine::{board::*, pos::*, tile::*, Machine},
+	marble_engine::{grid::*, pos::*, tile::*, Machine},
 	solution::*,
 	theme::*,
 	ui::*,
 	util::*,
-	TILE_TEXTURE_SIZE,
+	Globals,
 };

 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 = 165;
+const END_POPUP_HEIGHT: i32 = 225;

 const MAX_ZOOM: f32 = 8.;
 const MIN_ZOOM: f32 = 0.25;
-const BOARD_MARGIN: PosInt = 3;
+const BOARD_MARGIN: usize = 3;
 const MAX_SPEED_POWER: u8 = 16;
 const SPEED_DIGITS: i32 = 5;
 const MAX_FRAME_TIME_MICROS: u128 = 1_000_000 / 30;
@ -79,6 +81,7 @@ pub struct Editor {

 #[derive(Debug, Clone)]
 enum Action {
+	SetTile(ResizeDeltas, Pos, Tile, Tile),
 	SetArea(ResizeDeltas, Pos, Board, Board),
 }

@ -142,11 +145,11 @@ impl Editor {
 		info_text.set_text(level.description());

 		Self {
-			source_board: Board::parse(&solution.board),
+			source_board: solution.board.clone(),
 			machine,
 			sim_state: SimState::Editing,
 			view_offset: Vector2::zero(),
-			zoom: 1.,
+			zoom: 2.,
 			active_tool: Tool::None,
 			output_as_text,
 			input_as_text,
@ -207,6 +210,11 @@ impl Editor {
 				self.source_board.grow(&deltas);
 				self.source_board.paste_board(pos, &new);
 			}
+			Action::SetTile(deltas, pos, _old, new) => {
+				self.shift_world(deltas.x_neg as f32, deltas.y_neg as f32);
+				self.source_board.grow(&deltas);
+				self.source_board.grid.set(pos, new);
+			}
 		}
 	}

@ -222,6 +230,11 @@ impl Editor {
 				self.source_board.shrink(deltas);
 				self.shift_world(-(deltas.x_neg as f32), -(deltas.y_neg as f32));
 			}
+			Action::SetTile(deltas, pos, old, _new) => {
+				self.source_board.grid.set(*pos, *old);
+				self.source_board.shrink(deltas);
+				self.shift_world(-(deltas.x_neg as f32), -(deltas.y_neg as f32));
+			}
 		}
 	}

@ -281,7 +294,7 @@ impl Editor {

 	fn reset_machine(&mut self) {
 		self.machine.reset();
-		self.machine.set_board(self.source_board.clone());
+		self.machine.set_grid(self.source_board.grid.clone());
 		if let Some(i) = self.stage {
 			let bytes = self.level.stages()[i].input().as_bytes();
 			self.machine.set_input(bytes.to_owned());
@ -321,7 +334,8 @@ impl Editor {
 						self.sim_state = SimState::Stepping;
 						self.score = Some(Score {
 							cycles: self.total_steps + self.machine.step_count(),
-							tiles: self.source_board.count_tiles(),
+							tiles: self.source_board.grid.count_tiles(),
+							bounds_area: self.source_board.grid.used_bounds_area(),
 						});
 					}
 				} else if !stage.output().as_bytes().starts_with(self.machine.output()) {
@ -332,32 +346,10 @@ impl Editor {
 		}
 	}

-	fn rotate_tool(&mut self, shift: bool) {
-		if shift {
-			match &self.active_tool {
-				Tool::Math => self.tool_math.prev(),
-				Tool::Comparator => self.tool_comparator.prev(),
-				Tool::Arrow => self.tool_arrow = self.tool_arrow.left(),
-				Tool::Mirror => self.tool_mirror.flip(),
-				Tool::Wire => self.tool_wire.prev(),
-				_ => (),
-			}
-		} else {
-			match &self.active_tool {
-				Tool::Math => self.tool_math.next(),
-				Tool::Comparator => self.tool_comparator.next(),
-				Tool::Arrow => self.tool_arrow = self.tool_arrow.right(),
-				Tool::Mirror => self.tool_mirror.flip(),
-				Tool::Wire => self.tool_wire.next(),
-				_ => (),
-			}
-		}
-	}
-
 	pub fn center_view(&mut self, d: &RaylibHandle) {
 		let tile_size = TILE_TEXTURE_SIZE * self.zoom;
-		let tile_x = self.source_board.width() as f32 / 2. * tile_size;
-		let tile_y = self.source_board.height() as f32 / 2. * tile_size;
+		let tile_x = self.source_board.grid.width() as f32 / 2. * tile_size;
+		let tile_y = self.source_board.grid.height() as f32 / 2. * tile_size;
 		let screen_x = d.get_screen_width() as f32 / 2.;
 		let screen_y = d.get_screen_height() as f32 / 2.;
 		self.view_offset.x = (screen_x - tile_x).floor();
@ -398,7 +390,7 @@ impl Editor {
 	fn save_blueprint(&mut self, selection: (Pos, Pos)) {
 		let board = self.get_selected_as_board(selection);
 		let id = get_free_id(&self.blueprints, Blueprint::id);
-		let mut blueprint = Blueprint::new(&board, id);
+		let mut blueprint = Blueprint::new(board, id);
 		if !self.new_blueprint_name.is_empty() {
 			blueprint.name.clone_from(&self.new_blueprint_name);
 		}
@ -408,34 +400,18 @@ impl Editor {
 	}

 	fn set_area(&mut self, pos: Pos, area: Board) {
-		let old_area = self.source_board.get_rect(pos, area.width(), area.height());
+		let old_area = self
+			.source_board
+			.get_rect(pos, area.grid.width(), area.grid.height());
 		if area == old_area {
 			return;
 		}
-		let width = self.source_board.width() as PosInt;
-		let height = self.source_board.height() as PosInt;
-		let resize = ResizeDeltas {
-			x_pos: if (pos.x + BOARD_MARGIN + area.width() as PosInt) > width {
-				pos.x + BOARD_MARGIN + area.width() as PosInt - width
-			} else {
-				0
-			} as usize,
-			x_neg: if pos.x < BOARD_MARGIN {
-				BOARD_MARGIN - pos.x
-			} else {
-				0
-			} as usize,
-			y_pos: if (pos.y + BOARD_MARGIN + area.height() as PosInt) > height {
-				pos.y + BOARD_MARGIN + area.height() as PosInt - height
-			} else {
-				0
-			} as usize,
-			y_neg: if pos.y < BOARD_MARGIN {
-				BOARD_MARGIN - pos.y
-			} else {
-				0
-			} as usize,
-		};
+		let resize = ResizeDeltas::new(
+			BOARD_MARGIN,
+			self.source_board.grid.size(),
+			pos,
+			area.grid.size(),
+		);
 		let mut pos = pos;
 		pos.x += resize.x_neg as PosInt;
 		pos.y += resize.y_neg as PosInt;
@ -443,17 +419,25 @@ impl Editor {
 	}

 	fn set_tile(&mut self, pos: Pos, tile: Tile) {
-		self.set_area(pos, Board::new_single(tile));
+		let old_tile = self.source_board.grid.get_or_blank(pos);
+		if tile == old_tile {
+			return;
+		}
+		let resize = ResizeDeltas::new(BOARD_MARGIN, self.source_board.grid.size(), pos, (1, 1));
+		let mut pos = pos;
+		pos.x += resize.x_neg as PosInt;
+		pos.y += resize.y_neg as PosInt;
+		self.push_action(Action::SetTile(resize, pos, old_tile, tile));
 	}

-	pub fn update(&mut self, rl: &RaylibHandle) {
+	pub fn update(&mut self, rl: &RaylibHandle, globals: &mut Globals) {
 		self.tooltip.init_frame(rl);
-		self.mouse = MouseInput::get(rl);
-		if self.popup != Popup::None {
 		self.mouse.clear();
+		if self.popup == Popup::None {
+			self.mouse.update(rl);
 		}

-		if rl.is_key_pressed(KeyboardKey::KEY_ESCAPE) {
+		if globals.is_pressed(ActionId::ToggleMenu) {
 			self.popup = match self.popup {
 				Popup::Success | Popup::Failure => {
 					self.dismissed_end = true;
@ -491,20 +475,25 @@ impl Editor {
 			self.step_time = avg_step_time;
 			self.max_step_time = avg_step_time.max(self.max_step_time);
 		}
-		if rl.is_key_pressed(KeyboardKey::KEY_SPACE) {
+		if globals.is_pressed(ActionId::StepSim) {
 			self.step_pressed()
 		}
-		if rl.is_key_pressed(KeyboardKey::KEY_ENTER) {
+		if globals.is_pressed(ActionId::StartSim) {
 			match self.sim_state {
 				SimState::Editing => {
 					self.init_sim();
 					self.sim_state = SimState::Running;
 				}
-				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 => {
 					self.sim_state = SimState::Editing;
 					self.popup = Popup::None;
 				}
-				SimState::Stepping => self.sim_state = SimState::Running,
+				SimState::Editing => (),
 			}
 		}

@ -533,42 +522,85 @@ impl Editor {
 			self.center_view(rl);
 		}

-		if rl.is_key_pressed(KeyboardKey::KEY_R) {
-			self.rotate_tool(rl.is_key_down(KeyboardKey::KEY_LEFT_SHIFT));
+		if globals.is_pressed(ActionId::CycleGroup) {
+			if globals.is_held(ActionId::CycleGroupRevMod) {
+				match &self.active_tool {
+					Tool::Math => self.tool_math.prev(),
+					Tool::Comparator => self.tool_comparator.prev(),
+					Tool::Arrow => self.tool_arrow = self.tool_arrow.left(),
+					Tool::Mirror => self.tool_mirror.flip(),
+					Tool::Wire => self.tool_wire.prev(),
+					_ => (),
+				}
+			} else {
+				match &self.active_tool {
+					Tool::Math => self.tool_math.next(),
+					Tool::Comparator => self.tool_comparator.next(),
+					Tool::Arrow => self.tool_arrow = self.tool_arrow.right(),
+					Tool::Mirror => self.tool_mirror.flip(),
+					Tool::Wire => self.tool_wire.next(),
+					_ => (),
+				}
+			}
+		}
+
+		if !self.machine.debug_subticks.is_empty() {
+			if rl.is_key_pressed(KeyboardKey::KEY_N) {
+				self.machine.subtick_index += 1;
+				self.machine.subtick_index %= self.machine.debug_subticks.len();
+			}
+			if rl.is_key_pressed(KeyboardKey::KEY_M) {
+				self.machine.subtick_index = self.machine.subtick_index.saturating_sub(1);
+			}
 		}

 		if self.sim_state == SimState::Editing {
-			if rl.is_key_down(KeyboardKey::KEY_LEFT_CONTROL) {
-				if rl.is_key_pressed(KeyboardKey::KEY_V) {
-					if let Ok(text) = rl.get_clipboard_text() {
-						let b = Board::parse(&text);
+			if let Some(clipboard) = &mut globals.clipboard {
+				if globals.config.input.is_pressed(ActionId::Paste) {
+					if let Ok(text) = clipboard.get_text() {
+						let b = Board::from_user_str(&text);
 						self.pasting_board = Some(b);
 					}
-				} else if rl.is_key_pressed(KeyboardKey::KEY_Z) {
-					self.undo()
-				} else if rl.is_key_pressed(KeyboardKey::KEY_Y) {
-					self.redo();
 				}
 			}
+			if globals.is_pressed(ActionId::Undo) {
+				self.undo();
+			} else if globals.is_pressed(ActionId::Redo) {
+				self.redo();
+			}
 		}
 	}

 	fn draw_board(&self, d: &mut RaylibDrawHandle, textures: &Textures) {
 		if self.sim_state == SimState::Editing {
 			self.source_board
+				.grid
 				.draw(d, textures, self.view_offset, self.zoom);
 		} else {
+			if self.machine.debug_subticks.is_empty() {
 				self.machine
-				.board()
+					.grid()
 					.draw(d, 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);
+				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);
+				}
+			}
 			if self.draw_overlay {
 				self.machine
 					.draw_marble_values(d, textures, self.view_offset, self.zoom);
 			}
 		}
+		if self.draw_overlay {
+			self.source_board
+				.draw_comments(d, self.view_offset, self.zoom);
+		}
 	}

-	pub fn draw(&mut self, d: &mut RaylibDrawHandle, textures: &Textures) {
+	pub fn draw(&mut self, d: &mut RaylibDrawHandle, globals: &mut Globals) {
 		d.clear_background(BG_WORLD);

 		if self.draw_overlay && self.zoom >= 0.5 {
@ -585,16 +617,16 @@ impl Editor {
 			}
 		}

-		self.draw_board(d, textures);
-		self.board_overlay(d, textures);
-		self.draw_bottom_bar(d, textures);
-		self.draw_top_bar(d, textures);
+		self.draw_board(d, &globals.textures);
+		self.board_overlay(d, &globals.textures);
+		self.draw_bottom_bar(d, globals);
+		self.draw_top_bar(d, &globals.textures);

 		if self.active_tool == Tool::Blueprint {
-			self.draw_blueprint_sidebar(d, textures);
+			self.draw_blueprint_sidebar(d, &globals.textures);
 		}

-		self.mouse = MouseInput::get(d);
+		self.mouse.update(d);

 		if self.popup != Popup::None {
 			self.tooltip.reset();
@ -609,7 +641,7 @@ impl Editor {

 		match self.popup {
 			Popup::Success | Popup::Failure => {
-				self.draw_end_popup(d, textures);
+				self.draw_end_popup(d, &globals.textures);
 			}
 			Popup::LevelInfo => {
 				let bounds = screen_centered_rect_dyn(d, 100, 100);
@ -713,11 +745,14 @@ impl Editor {
 		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 + 45, 20, Color::WHITE);
-				draw_usize(d, textures, score.cycles, (x + 10, y + 70), 9, 2);
-				d.draw_text("tiles", x + 215, y + 45, 20, Color::WHITE);
-				draw_usize(d, textures, score.tiles, (x + 210, y + 70), 5, 2);
+				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;
@ -860,8 +895,8 @@ impl Editor {
 			self.sim_state = SimState::Running;
 		}

-		if self.sim_state != SimState::Editing {
-			if tex32_button(
+		if self.sim_state != SimState::Editing
+			&& tex32_button(
 				(d, &self.mouse),
 				(296, 4),
 				textures.get("stop"),
@ -870,7 +905,6 @@ impl Editor {
 			self.sim_state = SimState::Editing;
 			self.popup = Popup::None;
 		}
-		}

 		if tex32_button(
 			(d, &self.mouse),
@ -901,6 +935,12 @@ impl Editor {

 		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, 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);
+		}

 		d.draw_text("input:", 603, 8, 10, Color::WHITE);
 		if simple_button((d, &self.mouse), 600, 20, 35, 15) {
@ -955,7 +995,7 @@ impl Editor {
 		}
 	}

-	fn draw_bottom_bar(&mut self, d: &mut RaylibDrawHandle, textures: &Textures) {
+	fn draw_bottom_bar(&mut self, d: &mut RaylibDrawHandle, globals: &mut Globals) {
 		let height = d.get_screen_height();
 		let footer_top = (height - FOOTER_HEIGHT) as f32;
 		// background
@ -991,37 +1031,65 @@ impl Editor {
 			{
 				self.active_tool = Tool::SelectArea(Selection::default());
 			}
-			draw_scaled_texture(d, textures.get("cancel"), 104, y + 4, 2.);
+			draw_scaled_texture(d, globals.get_tex("cancel"), 104, y + 4, 2.);

 			self.tooltip.add(144, y, 40, 40, "Save blueprint");
 			if simple_button((d, &self.mouse), 144, y, 40, 40) {
 				self.save_blueprint(selection);
 			}
-			draw_scaled_texture(d, textures.get("save"), 148, y + 4, 2.);
+			draw_scaled_texture(d, globals.get_tex("save"), 148, y + 4, 2.);

 			self.tooltip.add(188, y, 40, 40, "Copy");
-			if simple_button((d, &self.mouse), 188, y, 40, 40)
-				|| (d.is_key_pressed(KeyboardKey::KEY_C)
-					&& d.is_key_down(KeyboardKey::KEY_LEFT_CONTROL))
+			let mut copy_selection = false;
+			if simple_button((d, &self.mouse), 188, y, 40, 40) || globals.is_pressed(ActionId::Copy)
 			{
+				copy_selection = true;
+			}
+			draw_scaled_texture(d, globals.get_tex("copy"), 192, y + 4, 2.);
+
+			self.tooltip.add(232, y, 40, 40, "Cut");
+			let mut erase_selection = false;
+			if simple_button((d, &self.mouse), 232, y, 40, 40) || globals.is_pressed(ActionId::Cut)
+			{
+				copy_selection = true;
+				erase_selection = true;
+			}
+			draw_scaled_texture(d, globals.get_tex("cut"), 236, y + 4, 2.);
+
+			self.tooltip.add(276, y, 40, 40, "Delete");
+			if simple_button((d, &self.mouse), 276, y, 40, 40)
+				|| globals.is_pressed(ActionId::Erase)
+			{
+				erase_selection = true;
+			}
+			draw_scaled_texture(d, globals.get_tex("eraser"), 280, y + 4, 2.);
+
+			if copy_selection {
 				let board = self.get_selected_as_board(selection);
+				if let Some(clipboard) = &mut globals.clipboard {
+					clipboard
+						.set_text(serde_json::to_string(&board).unwrap())
+						.unwrap();
+				} else {
 					self.pasting_board = Some(board);
 				}
-			draw_scaled_texture(d, textures.get("copy"), 192, y + 4, 2.);
-
-			self.tooltip.add(232, y, 40, 40, "Delete");
-			if simple_button((d, &self.mouse), 232, y, 40, 40) {
+			}
+			if erase_selection {
 				let min = selection.0.min(selection.1);
 				let max = selection.0.max(selection.1);
-				let board =
-					Board::new_empty((max.x - min.x) as usize + 1, (max.y - min.y) as usize + 1);
+				let board = Board::new(Grid::new_empty(
+					(max.x - min.x) as usize + 1,
+					(max.y - min.y) as usize + 1,
+				));
 				self.set_area(min, board);
 			}
-			draw_scaled_texture(d, textures.get("eraser"), 236, y + 4, 2.);
 		}

-		let mut tool_button =
-			|(row, col): (i32, i32), texture: &str, tooltip: &'static str, tool_option: Tool| {
+		let mut tool_button = |(row, col): (i32, i32),
+		                       texture: &str,
+		                       tooltip: &'static str,
+		                       tool_option: Tool,
+		                       action: Option<ActionId>| {
 			let border = 4.;
 			let gap = 2.;
 			let button_size = 32. + border * 2.;
@ -1037,22 +1105,24 @@ impl Editor {
 			scrollable_texture_option_button(
 				(d, &self.mouse),
 				pos,
-					textures.get(texture),
+				globals.get_tex(texture),
 				tool_option,
 				&mut self.active_tool,
 				border,
+				action.map(|a| globals.is_pressed(a)).unwrap_or(false),
 			)
 		};
-		tool_button((0, -2), "eraser", "Eraser", Tool::Erase);
+		tool_button((0, -2), "eraser", "Eraser", Tool::Erase, None);
 		tool_button(
 			(1, -2),
 			"selection",
 			"Select",
 			Tool::SelectArea(Selection::default()),
+			None,
 		);

-		tool_button((0, -1), "blueprint", "Blueprints", Tool::Blueprint);
-		tool_button((1, -1), "transparent", "None", Tool::None);
+		tool_button((0, -1), "blueprint", "Blueprints", Tool::Blueprint, None);
+		tool_button((1, -1), "transparent", "None", Tool::None, None);

 		if !hide_tile_tools {
 			tool_button(
@ -1060,44 +1130,57 @@ impl Editor {
 				"block",
 				"Block",
 				Tool::SetTile(Tile::from_char('#')),
+				Some(ActionId::TileBlock),
 			);
 			tool_button(
 				(0, 1),
 				"silo_off",
 				"Silo",
 				Tool::SetTile(Tile::from_char('B')),
+				Some(ActionId::TileSilo),
 			);
 			tool_button(
 				(0, 2),
 				"button_off",
 				"Button",
 				Tool::SetTile(Tile::from_char('*')),
+				Some(ActionId::TileButton),
 			);
 			tool_button(
 				(0, 3),
 				"io_tile_off",
 				"Input/Output silo",
 				Tool::SetTile(Tile::from_char('I')),
+				Some(ActionId::TileIOSilo),
 			);
 			tool_button(
 				(0, 4),
 				"flipper_off",
 				"Flipper",
 				Tool::SetTile(Tile::from_char('F')),
+				Some(ActionId::TileFlipper),
+			);
+			tool_button(
+				(0, 5),
+				"digit_tool",
+				"Digit",
+				Tool::Digits(None),
+				Some(ActionId::TileDigit),
 			);
-			tool_button((0, 5), "digit_tool", "Digit", Tool::Digits(None));

 			tool_button(
 				(1, 0),
 				"marble",
 				"Marble",
 				Tool::SetTile(Tile::from_char('o')),
+				Some(ActionId::TileMarble),
 			);
 			match tool_button(
 				(1, 1),
 				self.tool_wire.texture_name_off(),
 				self.tool_wire.human_name(),
 				Tool::Wire,
+				Some(ActionId::TileGroupWire),
 			) {
 				Some(Scroll::Down) => self.tool_wire.next(),
 				Some(Scroll::Up) => self.tool_wire.prev(),
@ -1109,6 +1192,7 @@ impl Editor {
 				self.tool_arrow.arrow_tile_texture_name(),
 				self.tool_arrow.arrow_tile_human_name(),
 				Tool::Arrow,
+				Some(ActionId::TileGroupArrow),
 			) {
 				Some(Scroll::Down) => self.tool_arrow = self.tool_arrow.right(),
 				Some(Scroll::Up) => self.tool_arrow = self.tool_arrow.left(),
@ -1119,6 +1203,7 @@ impl Editor {
 				self.tool_mirror.texture_name(),
 				self.tool_mirror.human_name(),
 				Tool::Mirror,
+				Some(ActionId::TileGroupMirror),
 			)
 			.is_some()
 			{
@ -1129,6 +1214,7 @@ impl Editor {
 				self.tool_math.texture_name_off(),
 				self.tool_math.human_name(),
 				Tool::Math,
+				Some(ActionId::TileGroupMath),
 			) {
 				Some(Scroll::Down) => self.tool_math.next(),
 				Some(Scroll::Up) => self.tool_math.prev(),
@ -1139,6 +1225,7 @@ impl Editor {
 				self.tool_comparator.texture_name_off(),
 				self.tool_comparator.human_name(),
 				Tool::Comparator,
+				Some(ActionId::TileGroupCompare),
 			) {
 				Some(Scroll::Down) => self.tool_comparator.next(),
 				Some(Scroll::Up) => self.tool_comparator.prev(),
@ -1238,7 +1325,8 @@ impl Editor {
 					offset.x -= offset.x.rem(tile_size);
 					offset.y -= offset.y.rem(tile_size);
 					offset += view_offset;
-					board.draw(d, textures, offset, self.zoom);
+					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;
 						let tile_pos = Vector2::new(tile_pos.x.floor(), tile_pos.y.floor());
@ -1317,18 +1405,21 @@ impl Editor {
 						Tool::None | Tool::Erase | Tool::SelectArea(_) => (),
 						Tool::SetTile(tile) => self.set_tile(pos, tile),
 						Tool::Math => {
-							self.set_tile(pos, Tile::Powerable(PTile::Math(self.tool_math), false));
+							self.set_tile(
+								pos,
+								Tile::Powerable(PTile::Math(self.tool_math), Power::OFF),
+							);
 						}
 						Tool::Comparator => self.set_tile(
 							pos,
-							Tile::Powerable(PTile::Comparator(self.tool_comparator), false),
+							Tile::Powerable(PTile::Comparator(self.tool_comparator), Power::OFF),
 						),
 						Tool::Wire => self.set_tile(pos, Tile::Wire(self.tool_wire, false)),
 						Tool::Arrow => self.set_tile(pos, Tile::Arrow(self.tool_arrow)),
 						Tool::Mirror => self.set_tile(pos, Tile::Mirror(self.tool_mirror)),
 						Tool::Digits(_pos) => {
 							self.active_tool = Tool::Digits(Some(pos));
-							let tile = self.source_board.get_or_blank(pos);
+							let tile = self.source_board.grid.get_or_blank(pos);
 							if !matches!(tile, Tile::Open(OpenTile::Digit(_), _)) {
 								self.set_tile(pos, Tile::Open(OpenTile::Digit(0), Claim::Free));
 							}
@ -1336,8 +1427,7 @@ impl Editor {
 						Tool::Blueprint => {
 							if self.mouse.pos().x > SIDEBAR_WIDTH as f32 {
 								if let Some(bp) = self.blueprints.get(self.selected_blueprint) {
-									let board = bp.get_board().unwrap().clone();
-									self.set_area(pos, board);
+									self.set_area(pos, bp.board.clone());
 								}
 							}
 						}
@ -1363,7 +1453,7 @@ impl Editor {
 					}
 				}
 				if let Tool::Blueprint = self.active_tool {
-					if let Some(bp) = self.blueprints.get_mut(self.selected_blueprint) {
+					if let Some(bp) = self.blueprints.get(self.selected_blueprint) {
 						let view_offset = Vector2::new(
 							self.view_offset.x.rem(tile_size),
 							self.view_offset.y.rem(tile_size),
@ -1372,7 +1462,8 @@ impl Editor {
 						offset.x -= offset.x.rem(tile_size);
 						offset.y -= offset.y.rem(tile_size);
 						offset += view_offset;
-						bp.convert_board().draw(d, textures, offset, self.zoom);
+						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 {
 						if self.mouse.scroll() == Some(Scroll::Down)
--- a/src/input.rs
+++ b/src/input.rs
@ -0,0 +1,646 @@
+use std::{collections::BTreeMap, mem::transmute, vec};
+
+use raylib::{
+	color::Color,
+	drawing::{RaylibDraw, RaylibDrawHandle},
+	ffi::{KeyboardKey, MouseButton},
+	RaylibHandle,
+};
+use serde::{Deserialize, Serialize};
+
+use crate::{
+	theme::{BG_DARK, BG_LIGHT},
+	ui::text_button,
+	util::{rect, screen_centered_rect},
+	Globals,
+};
+
+#[derive(Debug, Clone, Copy, Deserialize, Serialize, PartialEq, Eq, PartialOrd, Ord)]
+#[repr(u8)]
+pub enum ActionId {
+	Undo,
+	Redo,
+	Copy,
+	Cut,
+	Paste,
+	Erase,
+	ToggleMenu,
+	StartSim,
+	StopSim,
+	StepSim,
+	CycleGroup,
+	CycleGroupRevMod,
+
+	TileBlock,
+	TileSilo,
+	TileButton,
+	TileIOSilo,
+	TileFlipper,
+	TileDigit,
+	TileMarble,
+	TileGroupWire,
+	TileGroupArrow,
+	TileGroupMirror,
+	TileGroupMath,
+	TileGroupCompare,
+	// just like in C, because this way doesn't need more dependencies
+	_EnumSize,
+}
+
+impl Default for Input {
+	fn default() -> Self {
+		use Button::*;
+		let mut bindings = [(); ActionId::SIZE].map(|_| Vec::new());
+		let mut bind_key = |action, mods, trigger| {
+			bindings[action as usize].push(Binding {
+				modifiers: mods,
+				trigger,
+			});
+		};
+		bind_key(ActionId::Undo, vec![LCtrl], Z);
+		bind_key(ActionId::Redo, vec![LCtrl], Y);
+		bind_key(ActionId::Redo, vec![LCtrl, LShift], Z);
+		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::ToggleMenu, vec![], Escape);
+		bind_key(ActionId::StartSim, vec![], Enter);
+		bind_key(ActionId::StopSim, vec![], Enter);
+		bind_key(ActionId::StepSim, vec![], Space);
+		bind_key(ActionId::CycleGroup, vec![], Tab);
+		bind_key(ActionId::CycleGroupRevMod, vec![], LShift);
+		bind_key(ActionId::TileBlock, vec![], Q);
+		bind_key(ActionId::TileSilo, vec![], W);
+		bind_key(ActionId::TileButton, vec![], E);
+		bind_key(ActionId::TileIOSilo, vec![], R);
+		bind_key(ActionId::TileFlipper, vec![], T);
+		bind_key(ActionId::TileDigit, vec![], Y);
+		bind_key(ActionId::TileMarble, vec![], A);
+		bind_key(ActionId::TileGroupWire, vec![], S);
+		bind_key(ActionId::TileGroupArrow, vec![], D);
+		bind_key(ActionId::TileGroupMirror, vec![], F);
+		bind_key(ActionId::TileGroupMath, vec![], G);
+		bind_key(ActionId::TileGroupCompare, vec![], H);
+
+		Self {
+			bindings,
+			states: Default::default(),
+			editing_binding: None,
+		}
+	}
+}
+
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+enum BindingState {
+	#[default]
+	Off,
+	Pressed,
+	Held,
+	Released,
+}
+
+type InputMap = BTreeMap<ActionId, Vec<Binding>>;
+
+#[derive(Clone, Debug, Serialize, Deserialize)]
+#[serde(from = "InputMap", into = "InputMap")]
+pub struct Input {
+	bindings: [Vec<Binding>; ActionId::SIZE],
+	states: [BindingState; ActionId::SIZE],
+	editing_binding: Option<(ActionId, usize, BindingEdit)>,
+}
+
+#[derive(Clone, Debug)]
+enum BindingEdit {
+	Init,
+	Adding(Binding),
+	Releasing(Binding),
+}
+
+impl Input {
+	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();
+		}
+
+		let buttons_x = 220;
+		let binding_text_x = buttons_x + 135;
+
+		for action_index in 0..ActionId::SIZE {
+			let action = ActionId::from_usize(action_index).unwrap();
+
+			d.draw_text(&format!("{action:?}"), 16, y, 20, Color::ORANGE);
+			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);
+					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);
+				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);
+				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,
+					);
+				}
+				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));
+			}
+			y += 45;
+		}
+
+		if let Some((action, binding_index, edit_state)) = &mut self.editing_binding {
+			globals.mouse.update(d);
+			let border = screen_centered_rect(d, 408, 128);
+			d.draw_rectangle_rec(border, BG_LIGHT);
+			let bounds = screen_centered_rect(d, 400, 120);
+			d.draw_rectangle_rec(bounds, BG_DARK);
+			let x = bounds.x as i32;
+			let y = bounds.y as i32;
+			d.draw_text(
+				&format!("editing binding for {action:?}"),
+				x + 10,
+				y + 5,
+				20,
+				Color::WHITE,
+			);
+			let y = y + 30;
+			let ok_btn_x = x + 10;
+			let ok_btn_y = y + 40;
+			let ok_btn_width = 80;
+			let ok_btn_rect = rect(ok_btn_x, ok_btn_y, ok_btn_width, 30);
+
+			for key_index in 0..Button::SIZE {
+				let key = Button::from_usize(key_index).unwrap();
+				match edit_state {
+					BindingEdit::Init => {
+						if key.just_pressed(d) {
+							*edit_state = BindingEdit::Adding(Binding {
+								modifiers: Vec::new(),
+								trigger: key,
+							});
+						}
+					}
+					BindingEdit::Adding(binding) => {
+						if key.just_pressed(d) {
+							if key != binding.trigger && !binding.modifiers.contains(&key) {
+								binding.modifiers.push(binding.trigger);
+								binding.trigger = key;
+							}
+						} else if key.released(d) {
+							if let Some(i) = binding.modifiers.iter().position(|&k| k == key) {
+								binding.modifiers.remove(i);
+								binding.modifiers.push(binding.trigger);
+								binding.trigger = key;
+							}
+							*edit_state = BindingEdit::Releasing(binding.clone());
+						}
+					}
+					BindingEdit::Releasing(_binding) => {
+						let clicking_ok =
+							globals.mouse.is_over(ok_btn_rect) && key == Button::MouseLeft;
+						if key.just_pressed(d) && !clicking_ok {
+							*edit_state = BindingEdit::Adding(Binding {
+								modifiers: Vec::new(),
+								trigger: key,
+							});
+						}
+					}
+				}
+			}
+
+			if let BindingEdit::Adding(b) | BindingEdit::Releasing(b) = &edit_state {
+				let colour = if matches!(edit_state, BindingEdit::Releasing(_)) {
+					Color::GREEN
+				} else {
+					Color::ORANGE
+				};
+				let text = format!("{:?} + {:?}", b.modifiers, b.trigger);
+				d.draw_text(&text, x + 5, y + 5, 20, colour);
+
+				let conflicts = conflicts(&self.bindings, b, *action);
+				if !conflicts.is_empty() {
+					d.draw_text(
+						&format!("conflicts: {conflicts:?}"),
+						x + 200,
+						y + 40,
+						20,
+						Color::ORANGERED,
+					);
+				}
+			}
+			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];
+					if *binding_index < binding_list.len() {
+						binding_list[*binding_index] = binding.clone();
+					} else {
+						binding_list.push(binding.clone());
+					}
+					self.editing_binding = None;
+				}
+			}
+			if text_button(d, &globals.mouse, x + 100, y + 40, 80, "cancel") {
+				self.editing_binding = None;
+			}
+		}
+	}
+
+	pub fn update(&mut self, rl: &RaylibHandle) {
+		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,
+				}
+			} else {
+				match state {
+					BindingState::Off | BindingState::Released => BindingState::Off,
+					BindingState::Pressed | BindingState::Held => BindingState::Released,
+				}
+			}
+		}
+	}
+
+	pub fn is_pressed(&self, action: ActionId) -> bool {
+		self.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
+	}
+
+	pub fn is_released(&self, action: ActionId) -> bool {
+		self.states[action as usize] == BindingState::Released
+	}
+}
+
+fn conflicts(
+	bindings: &[Vec<Binding>; ActionId::SIZE],
+	search: &Binding,
+	skip: ActionId,
+) -> Vec<ActionId> {
+	let mut matches = Vec::new();
+
+	for i in 0..ActionId::SIZE {
+		if skip as usize == i {
+			continue;
+		}
+		let bindings = &bindings[i];
+		for binding in bindings {
+			if binding == search {
+				matches.push(ActionId::from_usize(i).unwrap());
+				break;
+			}
+		}
+	}
+
+	matches
+}
+
+impl ActionId {
+	pub const SIZE: usize = Self::_EnumSize as usize;
+
+	fn from_usize(val: usize) -> Option<Self> {
+		if val < Self::SIZE {
+			Some(unsafe { transmute::<u8, Self>(val as u8) })
+		} else {
+			None
+		}
+	}
+}
+
+#[derive(Clone, Debug, Serialize, Deserialize, PartialEq)]
+pub struct Binding {
+	modifiers: Vec<Button>,
+	trigger: Button,
+}
+
+impl From<InputMap> for Input {
+	fn from(value: InputMap) -> Self {
+		let mut new = Self::default();
+		for (action, loaded_bindings) in value {
+			new.bindings[action as usize] = loaded_bindings;
+		}
+		new
+	}
+}
+
+impl From<Input> for InputMap {
+	fn from(value: Input) -> Self {
+		value
+			.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()))
+			.collect()
+	}
+}
+
+#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq)]
+#[repr(u8)]
+enum Button {
+	MouseLeft,
+	MouseRight,
+	MouseMiddle,
+	Mouse3,
+	Mouse4,
+	Mouse5,
+	Mouse6,
+	Apostrophe,
+	Comma,
+	Minus,
+	Period,
+	Slash,
+	Zero,
+	One,
+	Two,
+	Three,
+	Four,
+	Five,
+	Six,
+	Seven,
+	Eight,
+	Nine,
+	Semicolon,
+	Equal,
+	A,
+	B,
+	C,
+	D,
+	E,
+	F,
+	G,
+	H,
+	I,
+	J,
+	K,
+	L,
+	M,
+	N,
+	O,
+	P,
+	Q,
+	R,
+	S,
+	T,
+	U,
+	V,
+	W,
+	X,
+	Y,
+	Z,
+	LeftBracket,
+	Backslash,
+	RightBracket,
+	Grave,
+	Space,
+	Escape,
+	Enter,
+	Tab,
+	Backspace,
+	Insert,
+	Delete,
+	Right,
+	Left,
+	Down,
+	Up,
+	PageUp,
+	PageDown,
+	Home,
+	End,
+	CapsLock,
+	ScrollLock,
+	NumLock,
+	PrintScreen,
+	Pause,
+	F1,
+	F2,
+	F3,
+	F4,
+	F5,
+	F6,
+	F7,
+	F8,
+	F9,
+	F10,
+	F11,
+	F12,
+	LShift,
+	LCtrl,
+	LAlt,
+	LeftSuper,
+	RShift,
+	RCtrl,
+	RAlt,
+	RightSuper,
+	Menu,
+	Kp0,
+	Kp1,
+	Kp2,
+	Kp3,
+	Kp4,
+	Kp5,
+	Kp6,
+	Kp7,
+	Kp8,
+	Kp9,
+	KpDecimal,
+	KpDivide,
+	KpMultiply,
+	KpSubtract,
+	KpAdd,
+	KpEnter,
+	KpEqual,
+	Back,
+	VolumeUp,
+	VolumeDown,
+	//
+	_EnumSize,
+}
+
+enum RlInput {
+	Key(KeyboardKey),
+	Mouse(MouseButton),
+}
+
+impl Button {
+	const SIZE: usize = Self::_EnumSize as usize;
+
+	fn from_usize(val: usize) -> Option<Self> {
+		if val < Self::SIZE {
+			Some(unsafe { transmute::<u8, Self>(val as u8) })
+		} else {
+			None
+		}
+	}
+
+	fn is_down(self, rl: &RaylibHandle) -> bool {
+		match self.to_raylib() {
+			RlInput::Key(key) => rl.is_key_down(key),
+			RlInput::Mouse(btn) => rl.is_mouse_button_down(btn),
+		}
+	}
+
+	fn just_pressed(self, rl: &RaylibHandle) -> bool {
+		match self.to_raylib() {
+			RlInput::Key(key) => rl.is_key_pressed(key),
+			RlInput::Mouse(btn) => rl.is_mouse_button_pressed(btn),
+		}
+	}
+
+	fn released(self, rl: &RaylibHandle) -> bool {
+		match self.to_raylib() {
+			RlInput::Key(key) => rl.is_key_released(key),
+			RlInput::Mouse(btn) => rl.is_mouse_button_released(btn),
+		}
+	}
+
+	fn to_raylib(self) -> RlInput {
+		use KeyboardKey::*;
+		use RlInput::*;
+		match self {
+			Button::MouseLeft => Mouse(MouseButton::MOUSE_BUTTON_LEFT),
+			Button::MouseRight => Mouse(MouseButton::MOUSE_BUTTON_RIGHT),
+			Button::MouseMiddle => Mouse(MouseButton::MOUSE_BUTTON_MIDDLE),
+			Button::Mouse3 => Mouse(MouseButton::MOUSE_BUTTON_SIDE),
+			Button::Mouse4 => Mouse(MouseButton::MOUSE_BUTTON_EXTRA),
+			Button::Mouse5 => Mouse(MouseButton::MOUSE_BUTTON_FORWARD),
+			Button::Mouse6 => Mouse(MouseButton::MOUSE_BUTTON_BACK),
+			Button::Apostrophe => Key(KEY_APOSTROPHE),
+			Button::Comma => Key(KEY_COMMA),
+			Button::Minus => Key(KEY_MINUS),
+			Button::Period => Key(KEY_PERIOD),
+			Button::Slash => Key(KEY_SLASH),
+			Button::Zero => Key(KEY_ZERO),
+			Button::One => Key(KEY_ONE),
+			Button::Two => Key(KEY_TWO),
+			Button::Three => Key(KEY_THREE),
+			Button::Four => Key(KEY_FOUR),
+			Button::Five => Key(KEY_FIVE),
+			Button::Six => Key(KEY_SIX),
+			Button::Seven => Key(KEY_SEVEN),
+			Button::Eight => Key(KEY_EIGHT),
+			Button::Nine => Key(KEY_NINE),
+			Button::Semicolon => Key(KEY_SEMICOLON),
+			Button::Equal => Key(KEY_EQUAL),
+			Button::A => Key(KEY_A),
+			Button::B => Key(KEY_B),
+			Button::C => Key(KEY_C),
+			Button::D => Key(KEY_D),
+			Button::E => Key(KEY_E),
+			Button::F => Key(KEY_F),
+			Button::G => Key(KEY_G),
+			Button::H => Key(KEY_H),
+			Button::I => Key(KEY_I),
+			Button::J => Key(KEY_J),
+			Button::K => Key(KEY_K),
+			Button::L => Key(KEY_L),
+			Button::M => Key(KEY_M),
+			Button::N => Key(KEY_N),
+			Button::O => Key(KEY_O),
+			Button::P => Key(KEY_P),
+			Button::Q => Key(KEY_Q),
+			Button::R => Key(KEY_R),
+			Button::S => Key(KEY_S),
+			Button::T => Key(KEY_T),
+			Button::U => Key(KEY_U),
+			Button::V => Key(KEY_V),
+			Button::W => Key(KEY_W),
+			Button::X => Key(KEY_X),
+			Button::Y => Key(KEY_Y),
+			Button::Z => Key(KEY_Z),
+			Button::LeftBracket => Key(KEY_LEFT_BRACKET),
+			Button::Backslash => Key(KEY_BACKSLASH),
+			Button::RightBracket => Key(KEY_RIGHT_BRACKET),
+			Button::Grave => Key(KEY_GRAVE),
+			Button::Space => Key(KEY_SPACE),
+			Button::Escape => Key(KEY_ESCAPE),
+			Button::Enter => Key(KEY_ENTER),
+			Button::Tab => Key(KEY_TAB),
+			Button::Backspace => Key(KEY_BACKSPACE),
+			Button::Insert => Key(KEY_INSERT),
+			Button::Delete => Key(KEY_DELETE),
+			Button::Right => Key(KEY_RIGHT),
+			Button::Left => Key(KEY_LEFT),
+			Button::Down => Key(KEY_DOWN),
+			Button::Up => Key(KEY_UP),
+			Button::PageUp => Key(KEY_PAGE_UP),
+			Button::PageDown => Key(KEY_PAGE_DOWN),
+			Button::Home => Key(KEY_HOME),
+			Button::End => Key(KEY_END),
+			Button::CapsLock => Key(KEY_CAPS_LOCK),
+			Button::ScrollLock => Key(KEY_SCROLL_LOCK),
+			Button::NumLock => Key(KEY_NUM_LOCK),
+			Button::PrintScreen => Key(KEY_PRINT_SCREEN),
+			Button::Pause => Key(KEY_PAUSE),
+			Button::F1 => Key(KEY_F1),
+			Button::F2 => Key(KEY_F2),
+			Button::F3 => Key(KEY_F3),
+			Button::F4 => Key(KEY_F4),
+			Button::F5 => Key(KEY_F5),
+			Button::F6 => Key(KEY_F6),
+			Button::F7 => Key(KEY_F7),
+			Button::F8 => Key(KEY_F8),
+			Button::F9 => Key(KEY_F9),
+			Button::F10 => Key(KEY_F10),
+			Button::F11 => Key(KEY_F11),
+			Button::F12 => Key(KEY_F12),
+			Button::LShift => Key(KEY_LEFT_SHIFT),
+			Button::LCtrl => Key(KEY_LEFT_CONTROL),
+			Button::LAlt => Key(KEY_LEFT_ALT),
+			Button::LeftSuper => Key(KEY_LEFT_SUPER),
+			Button::RShift => Key(KEY_RIGHT_SHIFT),
+			Button::RCtrl => Key(KEY_RIGHT_CONTROL),
+			Button::RAlt => Key(KEY_RIGHT_ALT),
+			Button::RightSuper => Key(KEY_RIGHT_SUPER),
+			Button::Menu => Key(KEY_KB_MENU),
+			Button::Kp0 => Key(KEY_KP_0),
+			Button::Kp1 => Key(KEY_KP_1),
+			Button::Kp2 => Key(KEY_KP_2),
+			Button::Kp3 => Key(KEY_KP_3),
+			Button::Kp4 => Key(KEY_KP_4),
+			Button::Kp5 => Key(KEY_KP_5),
+			Button::Kp6 => Key(KEY_KP_6),
+			Button::Kp7 => Key(KEY_KP_7),
+			Button::Kp8 => Key(KEY_KP_8),
+			Button::Kp9 => Key(KEY_KP_9),
+			Button::KpDecimal => Key(KEY_KP_DECIMAL),
+			Button::KpDivide => Key(KEY_KP_DIVIDE),
+			Button::KpMultiply => Key(KEY_KP_MULTIPLY),
+			Button::KpSubtract => Key(KEY_KP_SUBTRACT),
+			Button::KpAdd => Key(KEY_KP_ADD),
+			Button::KpEnter => Key(KEY_KP_ENTER),
+			Button::KpEqual => Key(KEY_KP_EQUAL),
+			Button::Back => Key(KEY_BACK),
+			Button::VolumeUp => Key(KEY_VOLUME_UP),
+			Button::VolumeDown => Key(KEY_VOLUME_DOWN),
+			Button::_EnumSize => unreachable!(),
+		}
+	}
+}
--- a/src/level.rs
+++ b/src/level.rs
@ -1,5 +1,7 @@
 use serde::Deserialize;

+use crate::board::Board;
+
 #[derive(Debug, Deserialize)]
 pub struct Chapter {
 	pub title: String,
@ -12,7 +14,7 @@ pub struct Level {
 	name: String,
 	description: String,
 	#[serde(default)]
-	init_board: Option<String>,
+	init_board: Option<Board>,
 	/// no stages means sandbox
 	#[serde(default)]
 	stages: Vec<Stage>,
@ -61,7 +63,7 @@ impl Level {
 		self.stages.is_empty()
 	}

-	pub fn init_board(&self) -> Option<String> {
+	pub fn init_board(&self) -> Option<Board> {
 		self.init_board.clone()
 	}

--- a/src/lib.rs
+++ b/src/lib.rs
@ -0,0 +1,74 @@
+pub mod blueprint;
+pub mod board;
+pub mod config;
+pub mod editor;
+pub mod input;
+pub mod level;
+pub mod marble_engine;
+pub mod solution;
+pub mod theme;
+pub mod ui;
+pub mod util;
+
+use std::fs;
+
+use arboard::Clipboard;
+use config::Config;
+use input::ActionId;
+use raylib::{texture::Texture2D, RaylibHandle};
+use util::{userdata_dir, MouseInput, Textures};
+// use util::MouseInput;
+
+pub const CONFIG_FILE_NAME: &str = "config.json";
+
+pub struct Globals {
+	pub clipboard: Option<Clipboard>,
+	pub config: Config,
+	textures: Textures,
+	pub mouse: MouseInput,
+}
+
+impl Globals {
+	pub fn new(rl: &mut RaylibHandle, thread: &raylib::prelude::RaylibThread) -> Self {
+		let mut textures = Textures::default();
+		textures.load_dir("assets", rl, thread);
+		textures.load_dir("assets/tiles", rl, thread);
+		textures.load_dir("assets/digits", rl, thread);
+
+		let config_path = userdata_dir().join(CONFIG_FILE_NAME);
+		let config = fs::read_to_string(config_path)
+			.ok()
+			.and_then(|s| serde_json::from_str(&s).ok())
+			.unwrap_or_default();
+
+		Self {
+			clipboard: Clipboard::new()
+				.map_err(|e| eprintln!("System clipboard error: {e}"))
+				.ok(),
+			config,
+			textures,
+			mouse: MouseInput::default(),
+		}
+	}
+
+	pub fn update(&mut self, rl: &RaylibHandle) {
+		self.config.input.update(rl);
+		self.mouse.update(rl);
+	}
+
+	pub fn is_pressed(&self, action: ActionId) -> bool {
+		self.config.input.is_pressed(action)
+	}
+
+	pub fn is_held(&self, action: ActionId) -> bool {
+		self.config.input.is_held(action)
+	}
+
+	pub fn is_released(&self, action: ActionId) -> bool {
+		self.config.input.is_released(action)
+	}
+
+	pub fn get_tex(&self, name: &str) -> &Texture2D {
+		self.textures.get(name)
+	}
+}
--- a/src/main.rs
+++ b/src/main.rs
@ -1,19 +1,14 @@
 use std::{
 	collections::HashMap,
-	fs::{read_dir, read_to_string},
+	fs::{read_dir, read_to_string, File},
+	io::Write,
 };

 use raylib::prelude::*;

-mod blueprint;
-mod editor;
-mod level;
-mod marble_engine;
-mod solution;
-mod theme;
-mod ui;
-mod util;
+use marble_machinations::*;

+use config::Config;
 use editor::{Editor, ExitState};
 use level::{Chapter, Level};
 use solution::Solution;
@ -23,19 +18,18 @@ use util::*;

 const TITLE_TEXT: &str = concat!("Marble Machinations v", env!("CARGO_PKG_VERSION"));

-pub const TILE_TEXTURE_SIZE: f32 = 16.0;
-
 struct Game {
 	levels: Vec<LevelListEntry>,
 	level_scroll: usize,
 	solutions: HashMap<String, Vec<Solution>>,
 	open_editor: Option<Editor>,
-	textures: Textures,
 	selected_level: usize,
 	selected_solution: usize,
 	delete_solution: Option<usize>,
 	editing_solution_name: bool,
 	level_desc_text: ShapedText,
+	globals: Globals,
+	edit_settings: Option<Config>,
 }

 #[derive(Debug)]
@ -58,41 +52,37 @@ fn main() {

 impl Game {
 	fn new(rl: &mut RaylibHandle, thread: &RaylibThread) -> Self {
-		let mut textures = Textures::default();
-		textures.load_dir("assets", rl, thread);
-		textures.load_dir("assets/tiles", rl, thread);
-		textures.load_dir("assets/digits", rl, thread);
-
 		let levels = get_levels();
 		let solutions = get_solutions();
-		let selected_solution = 0;

 		Self {
 			levels,
 			level_scroll: 0,
 			solutions,
 			open_editor: None,
-			textures,
 			selected_level: 0,
-			selected_solution,
+			selected_solution: 0,
 			delete_solution: None,
 			editing_solution_name: false,
 			level_desc_text: ShapedText::new(20),
+			globals: Globals::new(rl, thread),
+			edit_settings: None,
 		}
 	}

 	fn run(&mut self, rl: &mut RaylibHandle, thread: &RaylibThread) {
 		while !rl.window_should_close() {
 			let mut d = rl.begin_drawing(thread);
+			self.globals.update(&d);
 			if let Some(editor) = &mut self.open_editor {
-				editor.update(&d);
-				editor.draw(&mut d, &self.textures);
+				editor.update(&d, &mut self.globals);
+				editor.draw(&mut d, &mut self.globals);
 				match editor.get_exit_state() {
 					ExitState::Dont => (),
 					ExitState::ExitAndSave => {
 						let solution = &mut self.solutions.get_mut(editor.level_id()).unwrap()
 							[self.selected_solution];
-						solution.board = editor.source_board().serialize();
+						solution.board = editor.source_board().clone();
 						solution.score = editor.score();
 						solution.save();
 						self.open_editor = None;
@ -100,11 +90,26 @@ impl Game {
 					ExitState::Save => {
 						let solution = &mut self.solutions.get_mut(editor.level_id()).unwrap()
 							[self.selected_solution];
-						solution.board = editor.source_board().serialize();
+						solution.board = editor.source_board().clone();
 						solution.score = editor.score();
 						solution.save();
 					}
 				}
+			} else if let Some(config) = &mut self.edit_settings {
+				d.clear_background(BG_DARK);
+				match config.draw_edit(&mut d, &mut self.globals) {
+					config::MenuReturn::Stay => (),
+					config::MenuReturn::StaySave => {
+						self.globals.config = config.clone();
+						self.save_config();
+					}
+					config::MenuReturn::ReturnSave => {
+						self.globals.config = config.clone();
+						self.save_config();
+						self.edit_settings = None;
+					}
+					config::MenuReturn::ReturnCancel => self.edit_settings = None,
+				}
 			} else {
 				self.draw(&mut d);
 			}
@ -128,16 +133,26 @@ impl Game {
 		let level_list_width = (d.get_screen_width() / 3).min(400);
 		let screen_height = d.get_screen_height();
 		d.draw_rectangle(0, 0, level_list_width, screen_height, BG_MEDIUM);
-		let mouse = MouseInput::get(d);
+
+		if text_button(
+			d,
+			&self.globals.mouse,
+			d.get_screen_width() - 100,
+			d.get_screen_height() - 70,
+			90,
+			"settings",
+		) {
+			self.edit_settings = Some(self.globals.config.clone());
+		}

 		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);
-		if mouse.pos().x < level_list_width as f32 {
-			if mouse.scroll() == Some(Scroll::Down) && self.level_scroll < max_scroll {
+		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;
 			}
-			if mouse.scroll() == Some(Scroll::Up) && self.level_scroll > 0 {
+			if self.globals.mouse.scroll() == Some(Scroll::Up) && self.level_scroll > 0 {
 				self.level_scroll -= 1;
 			}
 		}
@ -151,7 +166,8 @@ impl Game {
 				width: level_list_width as f32 - 10.,
 				height: ENTRY_SPACING as f32 - 5.,
 			};
-			let clicked_this = mouse.left_click() && mouse.is_over(bounds);
+			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);
@ -212,7 +228,7 @@ impl Game {
 				let mut solution_y = y;
 				for (solution_index, solution) in solutions.iter().enumerate() {
 					if simple_option_button(
-						(d, &mouse),
+						(d, &self.globals.mouse),
 						rect(
 							level_list_width + 10,
 							solution_y,
@ -244,9 +260,9 @@ impl Game {
 						Color::WHITE,
 					);
 					if tex32_button(
-						(d, &mouse),
+						(d, &self.globals.mouse),
 						(level_list_width + entry_width + 15, solution_y + 4),
-						self.textures.get("cancel"),
+						self.globals.get_tex("cancel"),
 						(&mut tooltip, "delete"),
 					) {
 						self.delete_solution = Some(solution_index);
@ -257,7 +273,7 @@ impl Game {
 				let next_id = get_free_id(solutions, Solution::id);
 				if text_button(
 					d,
-					&mouse,
+					&self.globals.mouse,
 					level_list_width + 10,
 					solution_y,
 					entry_width,
@ -272,12 +288,12 @@ impl Game {
 					let y = (solution_y + 40).max(240);
 					let x = level_list_width + 10;
 					d.draw_text(&text, x, y, 20, Color::ORANGE);
-					if text_button(d, &mouse, x, y + 30, 100, "yes") {
+					if text_button(d, &self.globals.mouse, x, y + 30, 100, "yes") {
 						solutions[i].remove_file();
 						solutions.remove(i);
 						self.delete_solution = None;
 					}
-					if text_button(d, &mouse, x + 110, y + 30, 100, "no") {
+					if text_button(d, &self.globals.mouse, x + 110, y + 30, 100, "no") {
 						self.delete_solution = None;
 					}
 				}
@ -287,7 +303,7 @@ impl Game {
 					let bounds = Rectangle::new(column_x as f32, y as f32, 220., 30.);
 					if text_input(
 						d,
-						&mouse,
+						&self.globals.mouse,
 						bounds,
 						&mut solution.name,
 						&mut self.editing_solution_name,
@ -299,14 +315,14 @@ impl Game {
 					let id_text = format!("{}", solution.id());
 					d.draw_text(&id_text, column_x, y + 35, 10, Color::GRAY);

-					if text_button(d, &mouse, column_x, y + 50, 220, "clone") {
+					if text_button(d, &self.globals.mouse, column_x, y + 50, 220, "clone") {
 						let cloned = solution.new_copy(next_id);
 						self.selected_solution = solutions.len();
 						solutions.push(cloned);
 						return;
 					}

-					if text_button(d, &mouse, column_x, y + 85, 220, "edit") {
+					if text_button(d, &self.globals.mouse, column_x, y + 85, 220, "edit") {
 						let mut editor = Editor::new(solution.clone(), level.clone());
 						editor.center_view(d);
 						self.open_editor = Some(editor);
@ -318,6 +334,13 @@ impl Game {
 		}
 		tooltip.draw(d);
 	}
+
+	fn save_config(&self) {
+		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();
+	}
 }

 fn get_levels() -> Vec<LevelListEntry> {
--- a/src/marble_engine.rs
+++ b/src/marble_engine.rs
@ -1,35 +1,44 @@
 use raylib::prelude::*;

-pub mod board;
+pub mod grid;
 pub mod pos;
 pub mod tile;
-use board::Board;
+use crate::{theme::TILE_TEXTURE_SIZE, ui::draw_usize_small, util::Textures};
+use grid::Grid;
 use pos::*;
 use tile::*;

-use crate::{ui::draw_usize_small, Textures, TILE_TEXTURE_SIZE};
-
 #[derive(Debug)]
 pub struct Machine {
-	board: Board,
+	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>,
+}
+
+#[derive(Debug)]
+pub struct DebugSubTick {
+	pub grid: Grid,
+	pub pos: Option<Pos>,
 }

 impl Machine {
 	pub fn new_empty() -> Self {
 		Self {
-			board: Board::new_empty(5, 5),
+			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(),
 		}
 	}

@ -38,16 +47,18 @@ impl Machine {
 		self.input_index = 0;
 		self.output.clear();
 		self.powered.clear();
+		self.debug_subticks.clear();
+		self.subtick_index = 0;
 	}

-	pub fn set_board(&mut self, board: Board) {
+	pub fn set_grid(&mut self, board: Grid) {
 		self.marbles = board.get_marbles();
 		self.powered.clear();
-		self.board = board;
+		self.grid = board;
 	}

-	pub fn board(&self) -> &Board {
-		&self.board
+	pub fn grid(&self) -> &Grid {
+		&self.grid
 	}

 	pub fn output(&self) -> &[u8] {
@ -82,7 +93,7 @@ impl Machine {
 		for marble in &self.marbles {
 			let x = marble.x;
 			let y = marble.y;
-			if let Some(tile) = self.board.get(*marble) {
+			if let Some(tile) = self.grid.get(*marble) {
 				let px = x as i32 * tile_size + offset.x as i32;
 				let py = y as i32 * tile_size + offset.y as i32;
 				if let Tile::Marble { value, dir } = tile {
@ -98,40 +109,46 @@ impl Machine {

 	pub fn step(&mut self) {
 		self.steps += 1;
+		#[cfg(debug_assertions)]
+		{
+			self.subtick_index = 0;
+			self.debug_subticks.clear();
+			self.debug_subticks.push(DebugSubTick {
+				grid: self.grid.clone(),
+				pos: None,
+			});
+		}

 		let old_marbles = self.marbles.len();

 		let mut new_marbles = Vec::new();
 		// activate all powered machines
 		for &pos in &self.powered {
-			match self.board.get_mut(pos) {
-				Some(Tile::Powerable(machine, state)) => {
-					*state = false;
+			match self.grid.get_mut(pos) {
+				Some(Tile::Powerable(PTile::Comparator(_), board_power_state)) => {
+					// already handled at the power propagation stage (end of sim step)
+					*board_power_state = Power::OFF;
+				}
+				Some(Tile::Powerable(machine, board_power_state)) => {
+					let state = *board_power_state;
+					*board_power_state = Power::OFF;
 					let machine = *machine;
 					for dir in Direction::ALL {
-						let front_pos = dir.step(pos);
-						let source_pos = dir.opposite().step(pos);
-						match self.board.get(source_pos) {
-							Some(Tile::Wire(wiretype, true)) => {
-								if !wiretype.has_output(dir) {
+						if !state.get_dir(dir) {
 							continue;
 						}
-							}
-							Some(Tile::Button(true)) => (),
-							_ => continue,
-						}
-						let Some(front_tile) = self.board.get_mut(front_pos) else {
+						let front_pos = dir.step(pos);
+						let Some(front_tile) = self.grid.get_mut(front_pos) else {
 							continue;
 						};
-						// `machine`` is being powered, in direction `dir``
+						// `machine` is being powered, in direction `dir`
 						match machine {
-							PTile::Comparator(_) => (), // handled at the power propagation stage (end of step)
 							PTile::Math(op) => {
 								if front_tile.is_blank() {
 									let pos_a = dir.left().step(pos);
 									let pos_b = dir.right().step(pos);
-									let val_a = self.board.get_or_blank(pos_a).read_value();
-									let val_b = self.board.get_or_blank(pos_b).read_value();
+									let val_a = self.grid.get_or_blank(pos_a).read_value();
+									let val_b = self.grid.get_or_blank(pos_b).read_value();

 									let value = match op {
 										MathOp::Add => val_a.wrapping_add(val_b),
@ -170,24 +187,16 @@ impl Machine {
 									_ => (),
 								};
 							}
+							PTile::Comparator(_) => unreachable!(),
 						}
 					}
 				}
-				Some(Tile::Button(_state)) => (),
-				Some(Tile::Wire(_, _state)) => (),
-				_ => unreachable!(),
+				Some(Tile::Button(state) | Tile::Wire(_, state)) => {
+					*state = false;
+				}
+				_ => unreachable!("non-powerable tile at {pos:?} in self.powered"),
 			};
 		}
-
-		// old wires have to be reset after machine processing,
-		// so they can figure out which directions they are powered from
-		for &p in &self.powered {
-			match self.board.get_mut(p) {
-				Some(Tile::Button(state)) => *state = false,
-				Some(Tile::Wire(_, state)) => *state = false,
-				_ => (),
-			}
-		}
 		self.powered.clear();

 		if self.marbles.is_empty() {
@ -200,18 +209,17 @@ impl Machine {
 			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
 		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.board.get(pos) else {
+			let Some(Tile::Marble { value: _, dir }) = self.grid.get(pos) else {
 				unreachable!()
 			};
 			let front_pos = dir.step(pos);
-			let Some(front_tile) = self.board.get(front_pos) else {
+			let Some(front_tile) = self.grid.get(front_pos) else {
 				continue;
 			};
 			match front_tile {
@ -244,7 +252,7 @@ impl Machine {
 		}
 		// #### apply all direct bounces ####
 		for (i, &pos) in self.marbles.iter().enumerate() {
-			let Some(Tile::Marble { value: _, dir }) = self.board.get_mut(pos) else {
+			let Some(Tile::Marble { value: _, dir }) = self.grid.get_mut(pos) else {
 				unreachable!()
 			};
 			if will_reverse_direction[i] {
@ -255,49 +263,41 @@ impl Machine {
 		}

 		// #### new marbles ####
+		let mut claim_positions = Vec::new();
 		// prepare creating the new marbles
 		for &(pos, _val, _dir) in &new_marbles {
-			let Some(Tile::Open(OpenTile::Blank, claim)) = self.board.get_mut(pos) else {
+			let Some(Tile::Open(OpenTile::Blank, claim)) = self.grid.get_mut(pos) else {
 				unreachable!()
 			};
-			*claim = match claim {
-				Claim::Free => Claim::Claimed,
-				Claim::Claimed | Claim::Blocked => Claim::Blocked,
-				_ => unreachable!(),
+			if claim.claim_indirect() {
+				claim_positions.push(pos);
 			}
 		}
 		// create new marbles
 		// new marbles are past old_marbles index, so will not move this step
 		for (pos, value, dir) in new_marbles {
-			let Some(Tile::Open(OpenTile::Blank, Claim::Claimed)) = self.board.get_mut(pos) else {
+			let Some(Tile::Open(OpenTile::Blank, Claim::ClaimedIndirect)) = self.grid.get_mut(pos)
+			else {
 				continue;
 			};
-			self.board.set(pos, Tile::Marble { value, dir });
+			self.grid.set(pos, Tile::Marble { value, dir });
 			self.marbles.push(pos);
 		}

 		// #### movement ####
-		let mut claim_positions = Vec::new();
 		// 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.board.get(pos) else {
+			let Some(Tile::Marble { value: _, dir }) = self.grid.get(pos) else {
 				unreachable!()
 			};
 			let front_pos = dir.step(pos);
-			let Some(front_tile) = self.board.get_mut(front_pos) else {
+			let Some(front_tile) = self.grid.get_mut(front_pos) else {
 				continue;
 			};
 			if let Tile::Open(_type, claim) = front_tile {
-				*claim = match claim {
-					Claim::Free => {
+				if claim.claim() {
 					claim_positions.push(front_pos);
-						Claim::Claimed
 				}
-					Claim::ClaimedIndirect => Claim::Claimed,
-					Claim::BlockedIndirect => Claim::Claimed,
-					Claim::Claimed => Claim::Blocked,
-					Claim::Blocked => Claim::Blocked,
-				};
 			} else {
 				let target_pos = match front_tile {
 					Tile::Arrow(d) => d.step(front_pos),
@ -305,20 +305,13 @@ impl Machine {
 					Tile::Button(_) => dir.step(front_pos),
 					_ => continue,
 				};
-				let Some(target_tile) = self.board.get_mut(target_pos) else {
+				let Some(target_tile) = self.grid.get_mut(target_pos) else {
 					continue;
 				};
 				if let Tile::Open(_type, claim) = target_tile {
-					*claim = match claim {
-						Claim::Free => {
+					if claim.claim_indirect() {
 						claim_positions.push(front_pos);
-							Claim::ClaimedIndirect
 					}
-						Claim::ClaimedIndirect => Claim::BlockedIndirect,
-						Claim::BlockedIndirect => Claim::BlockedIndirect,
-						Claim::Claimed => Claim::Claimed,
-						Claim::Blocked => Claim::Blocked,
-					};
 				}
 			}
 		}
@ -326,15 +319,15 @@ impl Machine {
 		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.board.get(*pos) else {
+			let Some(Tile::Marble { value, dir }) = self.grid.get(*pos) else {
 				unreachable!()
 			};
 			let front_pos = dir.step(*pos);
-			let Some(front_tile) = self.board.get_mut(front_pos) else {
+			let Some(front_tile) = self.grid.get_mut(front_pos) else {
 				continue;
 			};

-			let mut move_to = |tile, target_pos, dir, board: &mut Board| {
+			let mut move_to = |tile, target_pos, dir, board: &mut Grid| {
 				let value = match tile {
 					OpenTile::Blank => value,
 					OpenTile::Digit(n) => value.wrapping_mul(10).wrapping_add(n as MarbleValue),
@ -346,11 +339,11 @@ impl Machine {

 			if let Tile::Open(space_type, claim_state) = front_tile {
 				if *claim_state == Claim::Claimed {
-					move_to(*space_type, front_pos, dir, &mut self.board);
+					move_to(*space_type, front_pos, dir, &mut self.grid);
 				} else if *claim_state != Claim::Free {
 					// (Free means a marble was just here but moved earlier this tick)
 					// bounce on failed direct movement
-					self.board.set(
+					self.grid.set(
 						*pos,
 						Tile::Marble {
 							value,
@ -386,11 +379,11 @@ impl Machine {
 					}
 					_ => continue,
 				}
-				let Some(target_tile) = self.board.get_mut(target_pos) else {
+				let Some(target_tile) = self.grid.get_mut(target_pos) else {
 					continue;
 				};
 				if let Tile::Open(space_type, Claim::ClaimedIndirect) = target_tile {
-					move_to(*space_type, target_pos, new_dir, &mut self.board);
+					move_to(*space_type, target_pos, new_dir, &mut self.grid);
 					if is_button {
 						self.powered.push(front_pos);
 					}
@ -399,14 +392,14 @@ impl Machine {
 		}

 		for pos in claim_positions {
-			if let Some(Tile::Open(_, claim_state)) = self.board.get_mut(pos) {
+			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.board.set(self.marbles[i], Tile::BLANK);
+			self.grid.set(self.marbles[i], Tile::BLANK);
 			self.marbles.swap_remove(i);
 		}

@ -414,7 +407,7 @@ impl Machine {
 		let mut i = 0;
 		while i < self.powered.len() {
 			let pos = self.powered[i];
-			let Some(tile) = self.board.get_mut(pos) else {
+			let Some(tile) = self.grid.get_mut(pos) else {
 				unreachable!()
 			};
 			match tile {
@ -422,10 +415,10 @@ impl Machine {
 					*state = true;
 					for dir in Direction::ALL {
 						let target_pos = dir.step(pos);
-						match self.board.get_mut(target_pos) {
+						match self.grid.get_mut(target_pos) {
 							Some(Tile::Powerable(_, state)) => {
-								if !*state {
-									*state = true;
+								if !state.get_dir(dir) {
+									state.add_dir(dir);
 									self.powered.push(target_pos);
 								}
 							}
@ -439,15 +432,20 @@ impl Machine {
 							_ => (),
 						}
 					}
+					#[cfg(debug_assertions)]
+					self.debug_subticks.push(DebugSubTick {
+						grid: self.grid.clone(),
+						pos: Some(pos),
+					});
 				}
 				Tile::Wire(wiretype, state) => {
 					*state = true;
 					for dir in wiretype.directions() {
 						let target_pos = dir.step(pos);
-						match self.board.get_mut(target_pos) {
+						match self.grid.get_mut(target_pos) {
 							Some(Tile::Powerable(_, state)) => {
-								if !*state {
-									*state = true;
+								if !state.get_dir(*dir) {
+									state.add_dir(*dir);
 									self.powered.push(target_pos);
 								}
 							}
@ -461,30 +459,28 @@ impl Machine {
 							_ => (),
 						}
 					}
+					#[cfg(debug_assertions)]
+					self.debug_subticks.push(DebugSubTick {
+						grid: self.grid.clone(),
+						pos: Some(pos),
+					});
 				}
 				Tile::Powerable(PTile::Comparator(comp), state) => {
-					*state = true;
 					let comp = *comp;
+					let state = *state;
 					for dir in Direction::ALL {
-						let front_pos = dir.step(pos);
-						let source_pos = dir.opposite().step(pos);
-						match self.board.get(source_pos) {
-							Some(Tile::Wire(wiretype, true)) => {
-								if !wiretype.has_output(dir) {
+						if !state.get_dir(dir) {
 							continue;
 						}
-							}
-							Some(Tile::Button(true)) => (),
-							_ => continue,
-						}
-						let Some(front_tile) = self.board.get_mut(front_pos) else {
+						let front_pos = dir.step(pos);
+						let Some(front_tile) = self.grid.get_mut(front_pos) else {
 							continue;
 						};
 						if matches!(front_tile, Tile::Wire(_, _) | Tile::Powerable(_, _)) {
 							let pos_a = dir.left().step(pos);
 							let pos_b = dir.right().step(pos);
-							let val_a = self.board.get_or_blank(pos_a).read_value();
-							let val_b = self.board.get_or_blank(pos_b).read_value();
+							let val_a = self.grid.get_or_blank(pos_a).read_value();
+							let val_b = self.grid.get_or_blank(pos_b).read_value();

 							let result = match comp {
 								Comparison::LessThan => val_a < val_b,
@ -493,13 +489,37 @@ impl Machine {
 								Comparison::NotEqual => val_a != val_b,
 							};
 							if result {
+								match self.grid.get_mut(front_pos) {
+									Some(Tile::Powerable(_, state)) => {
+										if !state.get_dir(dir) {
+											state.add_dir(dir);
 											self.powered.push(front_pos);
 										}
 									}
+									Some(Tile::Wire(_, state)) => {
+										if !*state {
+											*state = true;
+											self.powered.push(front_pos);
 										}
 									}
-				// state may be false if it was powered by a machine in earlier step
-				Tile::Powerable(_, state) => *state = true,
+									_ => (),
+								}
+							}
+						}
+					}
+					#[cfg(debug_assertions)]
+					self.debug_subticks.push(DebugSubTick {
+						grid: self.grid.clone(),
+						pos: Some(pos),
+					});
+				}
+				Tile::Powerable(_, _state) => {
+					#[cfg(debug_assertions)]
+					self.debug_subticks.push(DebugSubTick {
+						grid: self.grid.clone(),
+						pos: Some(pos),
+					});
+				}
 				_ => {
 					dbg!(tile);
 					unreachable!()
@ -507,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;
+		}
 	}
 }
--- a/src/marble_engine/board.rs
+++ b/src/marble_engine/board.rs
@ -1,13 +1,15 @@
-use crate::TILE_TEXTURE_SIZE;
-use crate::{draw_scaled_texture, Textures};
-
-use super::tile::*;
-use super::Pos;
-use super::PosInt;
 use raylib::prelude::*;
+use serde::{Deserialize, Serialize};

-#[derive(Debug, Clone, PartialEq)]
-pub struct Board {
+use super::{tile::*, Pos, PosInt};
+use crate::{
+	theme::TILE_TEXTURE_SIZE,
+	util::{draw_scaled_texture, Textures},
+};
+
+#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
+#[serde(into = "String", from = "String")]
+pub struct Grid {
 	tiles: Vec<Tile>,
 	width: usize,
 	height: usize,
@ -21,8 +23,37 @@ pub struct ResizeDeltas {
 	pub y_neg: usize,
 }

-impl Board {
-	pub fn parse(source: &str) -> Self {
+impl ResizeDeltas {
+	pub fn new(
+		margin: usize,
+		(width, height): (usize, usize),
+		pos: Pos,
+		(new_width, new_height): (usize, usize),
+	) -> Self {
+		let margin = margin as PosInt;
+		let width = width as PosInt;
+		let height = height as PosInt;
+		let new_width = new_width as PosInt;
+		let new_height = new_height as PosInt;
+		Self {
+			x_pos: if (pos.x + margin + new_width) > width {
+				pos.x + margin + new_width - width
+			} else {
+				0
+			} as usize,
+			x_neg: if pos.x < margin { margin - pos.x } else { 0 } as usize,
+			y_pos: if (pos.y + margin + new_height) > height {
+				pos.y + margin + new_height - height
+			} else {
+				0
+			} as usize,
+			y_neg: if pos.y < margin { margin - pos.y } else { 0 } as usize,
+		}
+	}
+}
+
+impl Grid {
+	pub fn from_ascii(source: &str) -> Self {
 		let mut rows = Vec::new();

 		let mut width = 0;
@ -48,13 +79,18 @@ impl Board {
 		}
 	}

-	pub fn serialize(&self) -> String {
+	pub fn to_ascii(&self) -> String {
 		let mut out = String::new();
 		for y in 0..self.height {
 			for x in 0..self.width {
 				let tile = self.get((x, y).into()).unwrap();
 				out.push(tile.to_char());
 			}
+			if y > 0 {
+				while out.as_bytes().last() == Some(&b' ') {
+					out.pop();
+				}
+			}
 			out.push('\n');
 		}
 		out
@ -87,6 +123,48 @@ impl Board {
 		sum
 	}

+	pub fn used_bounds_area(&self) -> usize {
+		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;
+				}
+			}
+			true
+		};
+		let mut height = self.height;
+		for y in 0..self.height {
+			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, self.width, |y, x| (x, y)) {
+				height -= 1;
+			} else {
+				break;
+			}
+		}
+		let mut width = self.width;
+		for x in 0..self.width {
+			if row_clear(x, self.height, |x, y| (x, y)) {
+				width -= 1;
+			} else {
+				break;
+			}
+		}
+		for x in (0..self.width).rev() {
+			if row_clear(x, self.width, |x, y| (x, y)) {
+				width -= 1;
+			} else {
+				break;
+			}
+		}
+		width * height
+	}
+
 	fn in_bounds(&self, p: Pos) -> bool {
 		p.x >= 0 && p.y >= 0 && p.x < self.width as PosInt && p.y < self.height as PosInt
 	}
@ -125,7 +203,7 @@ impl Board {
 		}
 	}

-	pub fn paste_board(&mut self, pos: Pos, source: &Board) {
+	pub fn paste_grid(&mut self, pos: Pos, source: &Grid) {
 		for x in 0..source.width() {
 			for y in 0..source.height() {
 				let offset = (x, y).into();
@ -136,8 +214,8 @@ impl Board {
 		}
 	}

-	pub fn get_rect(&self, pos: Pos, width: usize, height: usize) -> Board {
-		let mut out = Board::new_empty(width, height);
+	pub fn get_rect(&self, pos: Pos, width: usize, height: usize) -> Grid {
+		let mut out = Grid::new_empty(width, height);
 		for x in 0..width {
 			for y in 0..height {
 				let offset = (x, y).into();
@ -152,27 +230,27 @@ impl Board {
 	pub fn grow(&mut self, deltas: &ResizeDeltas) {
 		let new_width = self.width + deltas.x_neg + deltas.x_pos;
 		let new_height = self.height + deltas.y_neg + deltas.y_pos;
-		let mut new_board = Board::new_empty(new_width, new_height);
+		let mut new_grid = Grid::new_empty(new_width, new_height);
 		for x in 0..self.width {
 			for y in 0..self.height {
 				let tile = self.get_unchecked((x, y).into());
-				new_board.set((x + deltas.x_neg, y + deltas.y_neg).into(), tile);
+				new_grid.set((x + deltas.x_neg, y + deltas.y_neg).into(), tile);
 			}
 		}
-		*self = new_board;
+		*self = new_grid;
 	}

 	pub fn shrink(&mut self, deltas: &ResizeDeltas) {
 		let new_width = self.width - deltas.x_neg - deltas.x_pos;
 		let new_height = self.height - deltas.y_neg - deltas.y_pos;
-		let mut new_board = Board::new_empty(new_width, new_height);
+		let mut new_grid = Grid::new_empty(new_width, new_height);
 		for x in 0..new_width {
 			for y in 0..new_height {
 				let tile = self.get_unchecked((x + deltas.x_neg, y + deltas.y_neg).into());
-				new_board.set((x, y).into(), tile);
+				new_grid.set((x, y).into(), tile);
 			}
 		}
-		*self = new_board;
+		*self = new_grid;
 	}

 	pub fn width(&self) -> usize {
@ -183,6 +261,10 @@ impl Board {
 		self.height
 	}

+	pub fn size(&self) -> (usize, usize) {
+		(self.width, self.height)
+	}
+
 	pub fn get_marbles(&self) -> Vec<Pos> {
 		let mut out = Vec::new();
 		for y in 0..self.height {
@ -214,6 +296,16 @@ impl Board {
 					}
 					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 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 {
 					d.draw_rectangle(px, py, tile_size, tile_size, Color::new(0, 0, 0, 80));
 				}
@ -221,3 +313,15 @@ impl Board {
 		}
 	}
 }
+
+impl From<String> for Grid {
+	fn from(value: String) -> Self {
+		Self::from_ascii(&value)
+	}
+}
+
+impl From<Grid> for String {
+	fn from(val: Grid) -> String {
+		val.to_ascii()
+	}
+}
--- a/src/marble_engine/pos.rs
+++ b/src/marble_engine/pos.rs
@ -1,10 +1,11 @@
 use std::ops::Add;

 use raylib::prelude::*;
+use serde::{Deserialize, Serialize};

 pub type PosInt = i16;

-#[derive(Debug, Default, Clone, Copy, PartialEq)]
+#[derive(Debug, Default, Clone, Copy, PartialEq, Serialize, Deserialize)]
 pub struct Pos {
 	pub x: PosInt,
 	pub y: PosInt,
--- a/src/marble_engine/tile.rs
+++ b/src/marble_engine/tile.rs
@ -11,7 +11,7 @@ pub enum Tile {
 	Arrow(Direction),
 	Button(bool),
 	Wire(WireType, bool),
-	Powerable(PTile, bool),
+	Powerable(PTile, Power),
 }

 #[derive(Debug, Clone, Copy, PartialEq)]
@ -38,6 +38,11 @@ pub enum PTile {
 	IO,
 }

+#[derive(Debug, Clone, Copy, PartialEq)]
+pub struct Power {
+	directions: u8,
+}
+
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum MirrorType {
 	Forward,
@ -94,18 +99,18 @@ impl Tile {
 			'v' => Tile::Arrow(Direction::Down),
 			'<' => Tile::Arrow(Direction::Left),
 			'>' => Tile::Arrow(Direction::Right),
-			'=' => Tile::Powerable(PTile::Comparator(Comparison::Equal), false),
-			'!' => Tile::Powerable(PTile::Comparator(Comparison::NotEqual), false),
-			'L' => Tile::Powerable(PTile::Comparator(Comparison::LessThan), false),
-			'G' => Tile::Powerable(PTile::Comparator(Comparison::GreaterThan), false),
-			'I' | 'P' => Tile::Powerable(PTile::IO, false),
-			'F' => Tile::Powerable(PTile::Flipper, false),
-			'A' => Tile::Powerable(PTile::Math(MathOp::Add), false),
-			'S' => Tile::Powerable(PTile::Math(MathOp::Sub), false),
-			'M' => Tile::Powerable(PTile::Math(MathOp::Mul), false),
-			'D' => Tile::Powerable(PTile::Math(MathOp::Div), false),
-			'R' => Tile::Powerable(PTile::Math(MathOp::Rem), false),
-			'B' => Tile::Powerable(PTile::Silo, false),
+			'=' => Tile::Powerable(PTile::Comparator(Comparison::Equal), Power::OFF),
+			'!' => Tile::Powerable(PTile::Comparator(Comparison::NotEqual), Power::OFF),
+			'L' => Tile::Powerable(PTile::Comparator(Comparison::LessThan), Power::OFF),
+			'G' => Tile::Powerable(PTile::Comparator(Comparison::GreaterThan), Power::OFF),
+			'I' | 'P' => Tile::Powerable(PTile::IO, Power::OFF),
+			'F' => Tile::Powerable(PTile::Flipper, Power::OFF),
+			'A' => Tile::Powerable(PTile::Math(MathOp::Add), Power::OFF),
+			'S' => Tile::Powerable(PTile::Math(MathOp::Sub), Power::OFF),
+			'M' => Tile::Powerable(PTile::Math(MathOp::Mul), Power::OFF),
+			'D' => Tile::Powerable(PTile::Math(MathOp::Div), Power::OFF),
+			'R' => Tile::Powerable(PTile::Math(MathOp::Rem), Power::OFF),
+			'B' => Tile::Powerable(PTile::Silo, Power::OFF),
 			d @ '0'..='9' => Tile::Open(OpenTile::Digit(d as u8 - b'0'), Claim::Free),
 			'#' => Tile::Block,
 			_ => Tile::Open(OpenTile::Blank, Claim::Free),
@ -200,7 +205,7 @@ impl Tile {
 				wire.texture_name_off()
 			}
 			Tile::Powerable(tile, state) => {
-				if state {
+				if state.any() {
 					return match tile {
 						PTile::Comparator(comp) => comp.texture_name_on(),
 						PTile::Math(math_op) => math_op.texture_name_on(),
@ -270,6 +275,15 @@ impl Direction {
 		}
 	}

+	pub const fn debug_arrow_texture_name(self) -> &'static str {
+		match self {
+			Direction::Up => "debug_arrow_up",
+			Direction::Down => "debug_arrow_down",
+			Direction::Left => "debug_arrow_left",
+			Direction::Right => "debug_arrow_right",
+		}
+	}
+
 	pub const fn arrow_tile_human_name(self) -> &'static str {
 		match self {
 			Direction::Up => "Up Arrow",
@ -485,3 +499,54 @@ impl Comparison {
 		}
 	}
 }
+
+impl Claim {
+	#[must_use]
+	/// returns `was_free`
+	pub fn claim(&mut self) -> bool {
+		let mut was_free = false;
+		*self = match self {
+			Claim::Free => {
+				was_free = true;
+				Claim::Claimed
+			}
+			Claim::ClaimedIndirect | Claim::BlockedIndirect => Claim::Claimed,
+			Claim::Claimed | Claim::Blocked => Claim::Blocked,
+		};
+		was_free
+	}
+
+	#[must_use]
+	/// returns `was_free`
+	pub fn claim_indirect(&mut self) -> bool {
+		let mut was_free = false;
+		*self = match self {
+			Claim::Free => {
+				was_free = true;
+				Claim::ClaimedIndirect
+			}
+			Claim::ClaimedIndirect => Claim::BlockedIndirect,
+			_ => *self,
+		};
+		was_free
+	}
+}
+
+impl Power {
+	pub const OFF: Self = Self { directions: 0 };
+
+	#[inline]
+	pub fn any(self) -> bool {
+		self.directions != 0
+	}
+
+	#[inline]
+	pub fn get_dir(self, dir: Direction) -> bool {
+		self.directions & (1 << (dir as u8)) != 0
+	}
+
+	#[inline]
+	pub fn add_dir(&mut self, dir: Direction) {
+		self.directions |= 1 << (dir as u8)
+	}
+}
--- a/src/solution.rs
+++ b/src/solution.rs
@ -6,14 +6,14 @@ use std::{

 use serde::{Deserialize, Serialize};

-use crate::{level::Level, userdata_dir};
+use crate::{board::Board, level::Level, util::userdata_dir};

 #[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Solution {
 	solution_id: usize,
 	level_id: String,
 	pub name: String,
-	pub board: String,
+	pub board: Board,
 	#[serde(default)]
 	pub score: Option<Score>,
 }
@ -22,6 +22,8 @@ pub struct Solution {
 pub struct Score {
 	pub cycles: usize,
 	pub tiles: usize,
+	#[serde(default)]
+	pub bounds_area: usize,
 }

 impl Solution {
@ -30,7 +32,7 @@ impl Solution {
 			solution_id: id,
 			level_id: level.id().to_owned(),
 			name: format!("Unnamed {id}"),
-			board: level.init_board().unwrap_or(String::from(" ")),
+			board: level.init_board().unwrap_or_default(),
 			score: None,
 		}
 	}
@ -68,7 +70,10 @@ impl Solution {

 	pub fn score_text(&self) -> String {
 		if let Some(score) = &self.score {
-			format!("C: {}   T: {}", score.cycles, score.tiles)
+			format!(
+				"C: {}  T: {}  B: {}",
+				score.cycles, score.tiles, score.bounds_area
+			)
 		} else {
 			"unsolved".into()
 		}
--- a/src/theme.rs
+++ b/src/theme.rs
@ -1,5 +1,7 @@
 use raylib::prelude::*;

+pub const TILE_TEXTURE_SIZE: f32 = 16.0;
+
 pub const BG_WORLD: Color = gray(48);
 pub const FG_GRID: Color = gray(64);

--- a/src/ui.rs
+++ b/src/ui.rs
@ -1,6 +1,6 @@
 use std::ops::Range;

-use crate::{draw_scaled_texture, theme::*, MouseInput, Scroll, Textures};
+use crate::{theme::*, util::draw_scaled_texture, util::MouseInput, util::Scroll, util::Textures};
 use raylib::prelude::*;

 #[derive(Debug)]
@ -38,7 +38,6 @@ impl ShapedText {
 		}
 		self.max_width = width;
 		self.lines.clear();
-		// todo remove leading space on broken lines
 		// todo fix splitting very long words
 		let mut line_start = 0;
 		let mut line_end = 0;
@ -305,6 +304,7 @@ pub fn scrollable_texture_option_button<T>(
 	option: T,
 	current: &mut T,
 	border: f32,
+	clicked_override: bool,
 ) -> Option<Scroll>
 where
 	T: PartialEq,
@ -330,7 +330,9 @@ where
 		32. / texture.width as f32,
 		Color::WHITE,
 	);
-	if mouse.is_over(bounds) {
+	if clicked_override {
+		*current = option;
+	} else if mouse.is_over(bounds) {
 		if mouse.left_click() {
 			*current = option;
 		}
--- a/src/util.rs
+++ b/src/util.rs
@ -84,15 +84,13 @@ pub struct MouseInput {
 }

 impl MouseInput {
-	pub fn get(rl: &RaylibHandle) -> Self {
-		Self {
-			pos: rl.get_mouse_position(),
-			left_click: rl.is_mouse_button_pressed(MouseButton::MOUSE_BUTTON_LEFT),
-			left_hold: rl.is_mouse_button_down(MouseButton::MOUSE_BUTTON_LEFT),
-			left_release: rl.is_mouse_button_released(MouseButton::MOUSE_BUTTON_LEFT),
-			right_hold: rl.is_mouse_button_down(MouseButton::MOUSE_BUTTON_RIGHT),
-			scroll: get_scroll(rl),
-		}
+	pub fn update(&mut self, rl: &RaylibHandle) {
+		self.pos = rl.get_mouse_position();
+		self.left_click = rl.is_mouse_button_pressed(MouseButton::MOUSE_BUTTON_LEFT);
+		self.left_hold = rl.is_mouse_button_down(MouseButton::MOUSE_BUTTON_LEFT);
+		self.left_release = rl.is_mouse_button_released(MouseButton::MOUSE_BUTTON_LEFT);
+		self.right_hold = rl.is_mouse_button_down(MouseButton::MOUSE_BUTTON_RIGHT);
+		self.scroll = get_scroll(rl);
 	}

 	pub fn is_over(&self, rect: Rectangle) -> bool {
--- a/tests/main.rs
+++ b/tests/main.rs
@ -0,0 +1,27 @@
+use marble_machinations::marble_engine::{grid::Grid, Machine};
+
+#[test]
+fn creating_marbles_cause_indirect_claim() {
+	let mut eng = Machine::new_empty();
+	eng.set_grid(Grid::from_ascii(
+		"
+  I
+o 2
+   B-        o
+  B |      |-*-|
+  |-+o     |   |
+*-| |*     -B B-
+
+     1       3
+
+
+
+
+     I       I
+",
+	));
+	for _ in 0..9 {
+		eng.step();
+	}
+	assert_eq!(eng.output(), [1, 2, 3]);
+}
Author	SHA1	Message	Date
CrispyPin	157ee0de51	add bounding area score to solution results	2025-04-03 16:05:08 +02:00
CrispyPin	997297ab68	add selection cut button and binding	2025-04-03 15:39:25 +02:00
CrispyPin	11fd29c9c6	show input conflicts in binding menu	2025-04-03 14:25:00 +02:00
CrispyPin	3fdcb50694	cleanup	2025-04-03 14:02:12 +02:00
CrispyPin	7800e8d5fe	update raylib to 5.5	2025-04-03 13:53:15 +02:00
CrispyPin	6a8bc840b4	add bindings (default qwerty + asdfgh) for the tile tools	2025-04-03 13:45:49 +02:00
CrispyPin	04e7e4090d	cleanup config ui	2025-04-03 13:15:50 +02:00
CrispyPin	d62dbe3462	add scrolling to config menu, use new input system for tile group cycling	2025-04-03 00:44:34 +02:00
CrispyPin	8d81f94b70	implement keybinding editing	2025-04-03 00:19:05 +02:00
CrispyPin	7a4c9014c8	replace raylib key and mouse button types with own enum	2025-04-02 23:12:19 +02:00
CrispyPin	1bb29b5f75	add edit mode popup for keybindings	2025-04-02 22:48:08 +02:00
CrispyPin	14edee5a53	list bindings in settings menu, allow deleting bindings	2025-03-30 21:27:21 +02:00
CrispyPin	be699aa0ec	cleanup todo comments, tweak default board for incrementer level	2025-03-30 17:33:49 +02:00
CrispyPin	c20fea4f86	store textures in global struct	2025-03-30 17:29:27 +02:00
CrispyPin	031736bea6	wrap input bindings in config struct	2025-03-30 17:13:33 +02:00
CrispyPin	3548679bbb	make [copy, paste, menu, start, stop] use new input system	2025-03-30 15:23:37 +02:00
CrispyPin	70fd50d3bc	implement key binding system	2025-03-30 03:14:45 +02:00
CrispyPin	57512a4c6b	add support for system clipboard copy and paste	2025-03-29 19:44:44 +01:00
CrispyPin	fc1670f97d	refresh intro levels 2-4, making them more like a tutorial	2025-03-29 12:23:15 +01:00
CrispyPin	f5b5356139	center first line of comments vertically in the grid	2025-03-29 12:21:41 +01:00
CrispyPin	c4378c85f5	auto-strip trailing whitespace in serialized grids	2025-03-29 11:53:58 +01:00
CrispyPin	c2babaa674	render comments when pasting or placing blueprints	2025-03-29 01:14:38 +01:00
CrispyPin	6b8b2e6e6e	make comments disappear when pasting over them, but not when placing single tiles	2025-03-29 01:10:02 +01:00
CrispyPin	ae42cd10a4	fix comment line spacing, add comments to first level	2025-03-29 00:48:14 +01:00
CrispyPin	cd51c4b47a	include final tick state in debug subticks	2025-03-29 00:41:58 +01:00
CrispyPin	e2df4f4bff	implement comment rendering and positioning after resizes	2025-03-29 00:37:49 +01:00
CrispyPin	ad360ed96e	add cover image and example screenshot	2025-03-28 23:13:31 +01:00
CrispyPin	5c48b531f6	add comment storage to boards	2025-03-28 23:06:27 +01:00
CrispyPin	0b9f41cbf6	add benchmark executable	2025-03-27 19:21:10 +01:00
CrispyPin	d27c019cc4	update readme	2025-03-27 18:14:52 +01:00
CrispyPin	a793896af1	update readme	2025-03-27 18:07:14 +01:00
CrispyPin	d5bb0f7ba0	include changelog in releases	2025-03-27 15:38:29 +01:00
CrispyPin	1d3841fb6d	update changelog	2025-03-26 23:02:58 +01:00
CrispyPin	d3a3471fcb	add sub-tick debugging, add direction information to state of powerable tiles	2025-03-26 23:02:31 +01:00
CrispyPin	181f76a341	add changelog	2025-03-26 22:51:46 +01:00
CrispyPin	7574ec20f5	restructure to allow cargo tests	2025-03-15 21:00:20 +01:00
CrispyPin	fa10b38f99	make marble creation a weak claim	2025-03-15 20:13:48 +01:00
CrispyPin	e7f424aadc	bump version to 0.2.1	2025-03-14 22:22:12 +01:00
CrispyPin	bb2b1fea7c	fix tiles not being unclaimed after multiple marble creations block each other	2025-03-14 22:20:48 +01:00
CrispyPin	ce2e7c252a	add intro level for comparator	2024-12-26 23:45:38 +01:00